Add terra example contract (#31)

* Add terra example contract

Author: ali-behjati

.github/workflows/pyth-sdk-example-terra-contract.yml

@@ -0,0 +1,60 @@
+name: Pyth SDK Example Terra Contract
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+
+jobs:
+  test:
+    name: Build
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./examples/terra-contract
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+
+      - name: Install stable toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: 1.58.1
+          target: wasm32-unknown-unknown
+          override: true
+
+      - name: Compile WASM contract
+        run: cargo build --release --target wasm32-unknown-unknown
+        env:
+          RUSTFLAGS: "-C link-arg=-s"
+
+  lints:
+    name: Lints
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./examples/terra-contract
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+
+      - name: Install stable toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: 1.58.1
+          override: true
+          components: clippy
+
+      - name: Generate Schema
+        run: cargo run --example schema
+
+      - name: Schema Changes
+        # fails if any changes not committed
+        run: git diff --exit-code schema

.gitignore

@@ -2,7 +2,8 @@
 debug
 target
 Cargo.lock
+artifacts/
 
 # IntelliJ temp files
 .idea
-*.iml
+*.iml

Cargo.toml

@@ -5,4 +5,5 @@ members = [
     "pyth-sdk-solana",
     "pyth-sdk-solana/test-contract",
     "pyth-sdk-terra",
+    "examples/terra-contract",
 ]

examples/terra-contract/Cargo.toml

@@ -0,0 +1,40 @@
+[package]
+name = "example-terra-contract"
+version = "0.1.0"
+authors = ["Ali Behjati <[email protected]>"]
+edition = "2018"
+
+exclude = [
+  # Those files are rust-optimizer artifacts. You might want to commit them for convenience but they should not be part of the source code publication.
+  "contract.wasm",
+  "hash.txt",
+]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[features]
+# for more explicit tests, cargo test --features=backtraces
+backtraces = ["cosmwasm-std/backtraces"]
+# use library feature to disable all instantiate/execute/query exports
+library = []
+
+[package.metadata.scripts]
+optimize = """docker run --rm -v "$(pwd)":/code \
+  --mount type=volume,source="$(basename "$(pwd)")_cache",target=/code/target \
+  --mount type=volume,source=registry_cache,target=/usr/local/cargo/registry \
+  cosmwasm/rust-optimizer:0.12.5
+"""
+
+[dependencies]
+cosmwasm-std = { version = "0.16.2" }
+cosmwasm-storage = { version = "0.16.0" }
+cw-storage-plus = "0.8.0"
+schemars = "0.8"
+serde = { version = "1.0", default-features = false, features = ["derive"] }
+pyth-sdk-terra = { version = "0.1.0", path = "../../pyth-sdk-terra" } # Remove path and use version only when you use this example on your own.
+
+[dev-dependencies]
+cosmwasm-schema = { version = "0.16.0" }

examples/terra-contract/Developing.md

@@ -0,0 +1,85 @@
+# Developing
+
+This document contains guidance regarding building, testing and preparing your contracts for production.
+
+## Prerequisites
+
+Before starting, make sure you have [rustup](https://rustup.rs/) along with a
+recent `rustc` and `cargo` version installed. Rust version 1.58.1 or above is required.
+
+And you need to have the `wasm32-unknown-unknown` target installed as well.
+
+You can check that via:
+
+```sh
+rustc --version
+cargo --version
+rustup target list --installed
+# if wasm32 is not listed above, run this
+rustup target add wasm32-unknown-unknown
+```
+
+## Compiling
+
+After changing the contract, make sure you can compile and run it before
+making any changes. Go into the repository and do:
+
+```sh
+# this will produce a wasm build in ./target/wasm32-unknown-unknown/release/exxamle_terra_contract.wasm
+cargo build --release --target wasm32-unknown-unknown
+```
+## Generating JSON Schema
+
+While the Wasm calls (`instantiate`, `execute`, `query`) accept JSON, this is not enough
+information to use it. You need to expose the schema for the expected messages to the
+clients. You can generate this schema by calling `cargo run --example schema`, which will output
+4 files in `./schema`, corresponding to the 3 message types the contract accepts,
+as well as the internal `State`.
+
+These files are in standard json-schema format, which should be usable by various
+client side tools, either to auto-generate codecs, or just to validate incoming
+json wrt. the defined schema.
+
+## Preparing the Wasm bytecode for production
+
+Before you upload it to a chain, you need to ensure the smallest output size possible,
+as this will be included in the body of a transaction. You also want to have a
+reproducible build process, so third parties can verify that the uploaded Wasm
+code did indeed come from the claimed rust code.
+
+To solve both these issues, CosmWasm have produced `rust-optimizer`, a docker image to
+produce an extremely small build output in a consistent manner. The suggested way
+to run it is this:
+
+```sh
+docker run --rm -v "$(pwd)":/code \
+  --mount type=volume,source="$(basename "$(pwd)")_cache",target=/code/target \
+  --mount type=volume,source=registry_cache,target=/usr/local/cargo/registry \
+  cosmwasm/rust-optimizer:0.12.4
+```
+
+Or, If you're on an arm64 machine, you should use a docker image built with arm64.
+```sh
+docker run --rm -v "$(pwd)":/code \
+  --mount type=volume,source="$(basename "$(pwd)")_cache",target=/code/target \
+  --mount type=volume,source=registry_cache,target=/usr/local/cargo/registry \
+  cosmwasm/rust-optimizer-arm64:0.12.4
+```
+
+You must mount the contract code to `/code`. You can use a absolute path instead
+of `$(pwd)` if you don't want to `cd` to the directory first. The other two
+volumes are nice for speedup. Mounting `/code/target` in particular is useful
+to avoid docker overwriting your local dev files with root permissions.
+Note the `/code/target` cache is unique for each contract being compiled to limit
+interference, while the registry cache is global.
+
+This is rather slow compared to local compilations, especially the first compile
+of a given contract. The use of the two volume caches is very useful to speed up
+following compiles of the same contract.
+
+This produces an `artifacts` directory with a `PROJECT_NAME.wasm`, as well as
+`checksums.txt`, containing the Sha256 hash of the wasm file.
+The wasm file is compiled deterministically (anyone else running the same
+docker on the same git commit should get the identical file with the same Sha256 hash).
+It is also stripped and minimized for upload to a blockchain (it is also compressed using
+gzip in the uploading process to make it even smaller).

examples/terra-contract/README.md

@@ -0,0 +1,126 @@
+# Pyth SDK Example contract for Terra
+
+This is an example contract that demonstrates reading the Pyth price from the Pyth on-chain contract. It is created using
+[cw-template](https://github.com/InterWasm/cw-template) which is a standard template for developing Terra contracts.
+
+## Development
+
+Visit [Developing](./Developing.md) to learn more on how to compile and develop the contract.
+
+## Deploy and Query
+The javascript package in `tools` directory contains scripts for querying and deploying the example contract.
+
+If this is the first time running the code, run the below command to install required packages in the `tools` directory: 
+
+```
+npm install
+```
+
+### Testnet Demo
+In order to query the contract you can call:
+
+```sh
+npm run query -- --network testnet --contract terra1fm4ssxq39m355pdv2wzxggf5uxs2ase4vga9qs
+```
+
+If successful the output should look like:
+```
+{
+  current_price: { price: 8704350000, conf: 3150000, expo: -8 },
+  ema_price: { price: 8665158600, conf: 2965370, expo: -8 }
+}
+```
+
+If the price is not available you will get:
+```
+rpc error: code = Unknown desc = Generic error: Current price is not available: contract query failed
+```
+
+`terra1fm4ssxq39m355pdv2wzxggf5uxs2ase4vga9qs` is a live deployment of the example contract in testnet network. This contract
+is configured to return price of `Crypto.LUNA/USD` if it is available. If you have deployed your contract you can replace the 
+address with your contract address.
+### Deployment
+
+Deploying a contract in terra consists of two steps:
+1. Uploading the code. This step will give you a code id.
+2. Optionally create a new contract or migrate an existing one:
+    1. Creating a new contract which has an address with a code id as its program.
+    2. Migrating an existing contract code id to the new code id.
+
+This script can do both steps at the same time. Read below for the details.
+
+#### Uploading the code
+
+First build the contracts as mentioned in [Developing](../Developing.md).
+
+This command will builds and saves all the contracts in the `artifact` directory.
+
+Then, for example, to deploy `example_terra_contract.wasm`, run in the `tools` directory:
+
+``` sh
+npm run deploy -- --network testnet --artifact ../artifacts/example_terra_contract.wasm --mnemonic "..."
+```
+
+which will print something along the lines of:
+
+``` sh
+Storing WASM: ../artifacts/example_terra_contract.wasm (367689 bytes)
+Deploy fee:  88446uluna
+Code ID:  2435
+```
+
+If you do not pass any additional arguments to the script it will only upload the code and returns the code id. If you want to create a 
+new contract or upgrade an existing contract you should pass more arguments that are described below.
+
+#### Instantiating a new contract
+If you want instantiate a new contract after your deployment pass `--instantiate` argument to the above command.
+It will upload the code and with the resulting code id instantiates a new example contract:
+
+``` sh
+npm run deploy -- --network testnet --artifact ../artifacts/example_terra_contract.wasm --mnemonic "..." --instantiate
+```
+
+If successful, the output should look like:
+```
+Storing WASM: ../artifacts/example_terra_contract.wasm (183749 bytes)
+Deploy fee:  44682uluna
+Code ID:  53199
+Instantiating a contract
+Sleeping for 10 seconds for store transaction to finalize.
+Instantiated Pyth Example at terra123456789yelw23uh22nadqlyjvtl7s5527er97 (0x0000000000000000000000001234567896267ee5479752a7d683e49317ff4294)
+Deployed pyth example contract at terra123456789yelw23uh22nadqlyjvtl7s5527er97
+```
+
+This scripts currently set the example contract price to `Crypto.LUNA/USD` but you can change it within `deploy.js`.
+
+#### Migrating an existing contract
+If you want to upgrade an existing contract pass `--migrate --contract terra123456xyzqwe..` arguments to the above command.
+It will upload the code and with the resulting code id migrates the existing contract to the new one:
+
+``` sh
+npm run deploy -- --network testnet --artifact ../artifacts/example_terra_contract.wasm --mnemonic "..." --migrate --contract "terra123..."
+```
+
+If successful, the output should look like:
+```
+Storing WASM: ../artifacts/example_terra_contract.wasm (183749 bytes)
+Deploy fee:  44682uluna
+Code ID:  53227
+Sleeping for 10 seconds for store transaction to finalize.
+Migrating contract terra1rhjej5gkyelw23uh22nadqlyjvtl7s5527er97 to 53227
+Contract terra1rhjej5gkyelw23uh22nadqlyjvtl7s5527er97 code_id successfully updated to 53227
+```
+
+#### Notes
+
+You might encounter gateway timeout or account sequence mismatch in errors. In is good to double check with terra finder as sometimes
+transactions succeed despite being timed out.
+
+If that happens in the middle of an instantiation or migration. You can avoid re-uploading the code and use the resulting Code Id 
+by passing `--code-id <codeId>` instead of `--artifact` and it will only do the instantiation/migration part.
+
+An example is:
+
+``` sh
+npm run deploy -- --network testnet --code-id 50123 --mnemonic "..." --migrate --contract "terra123..."
+```

examples/terra-contract/examples/schema.rs

@@ -0,0 +1,29 @@
+use std::env::current_dir;
+use std::fs::create_dir_all;
+
+use cosmwasm_schema::{
+    export_schema,
+    remove_schemas,
+    schema_for,
+};
+
+use example_terra_contract::msg::{
+    ExecuteMsg,
+    FetchPriceResponse,
+    InstantiateMsg,
+    QueryMsg,
+};
+use example_terra_contract::state::State;
+
+fn main() {
+    let mut out_dir = current_dir().unwrap();
+    out_dir.push("schema");
+    create_dir_all(&out_dir).unwrap();
+    remove_schemas(&out_dir).unwrap();
+
+    export_schema(&schema_for!(InstantiateMsg), &out_dir);
+    export_schema(&schema_for!(ExecuteMsg), &out_dir);
+    export_schema(&schema_for!(QueryMsg), &out_dir);
+    export_schema(&schema_for!(State), &out_dir);
+    export_schema(&schema_for!(FetchPriceResponse), &out_dir);
+}

examples/terra-contract/schema/execute_msg.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "ExecuteMsg",
+  "type": "string",
+  "enum": []
+}