How to Write Terra Smart Contracts: A Complete Tutorial

This article explains the connections between the python codes we wrote earlier (same for JavaScript) and the pre-built functions inside the src folder created with the cargo generate–git command. Reading this article will give you a deeper insight into what actually happens when we instantiate, execute or query a state of Terra smart contracts in python code and how it communicates with the CosmWasm libraries written in Rust.Being familiar with Rust programming language can help you better understand the steps we are going to take to interact with the CosmWasm smart contracts on the Terra network. We have provided a small Rust tutorial to make you more familiar with Rust scripts at CosmWasm Smart Contracts – learning Rust series.

What Are Terra Smart Contracts?

1. Instantiate(): a constructor which is used during contract instantiation to set the initial state.

2. Execute(): it is used when a user wants to invoke a method on the smart contract.

3. Query(): it is used when a user wants to get data out of a smart contract.

Creating the Template to Write Terra Smart Contracts

use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use cosmwasm_std::Addr;
use cw_storage_plus::Item;
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct State {
     pub count: i32,
     pub owner: Addr,
}
pub const STATE: Item = Item::new("state");

Serialization & Deserialization

1. Serialize: for providing serialization

2. Deserialize: for deserialization

3. Clone: makes the struct copyable

4. Debug: enables the struct to be printed to string

5. PartialEq: provides equality comparison

6. JsonSchema: automatically creates a JSON schema

InstantiateMsg

use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct InstantiateMsg {
     pub count: i32,
}

{
     "count": 100
}

contract_address = instantiate_contract(code_id,{"count": 15})

#[cfg_attr(not(feature = "library"), entry_point)]
pub fn instantiate(
               deps: DepsMut,
               _env: Env,
               info: MessageInfo,
               msg: InstantiateMsg,
          ) -> Result {
     let state = State {
     count: msg.count,
     owner: info.sender.clone(),
     };
     set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;
     STATE.save(deps.storage, &state)?;
     Ok(Response::new()
     .add_attribute("method", "instantiate")
     .add_attribute("owner", info.sender)
     .add_attribute("count", msg.count.to_string()))
}

ExecuteMsg

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
     Increment {},
     Reset { count: i32 },
}

ExecuteMsg::Increment {} => try_increment(deps)
Increment {} => try_increment(deps),

#[cfg_attr(not(feature = "library"), entry_point)]
pub fn execute(
               deps: DepsMut,
               _env: Env,
               info: MessageInfo,
               msg: ExecuteMsg,
          ) -> Result {
     match msg {
          ExecuteMsg::Increment {} => try_increment(deps),
          ExecuteMsg::Reset { count } => try_reset(deps, info, count),
     }
}

{
     "increment": {}
}

{
     "reset": {"count": 5}
}

execute = execute_contract(deployer,contract_address,{"increment":{}})

pub fn try_increment(deps: DepsMut) -> Result {
     STATE.update(deps.storage, |mut state| -> Result<_, ContractError> {
          state.count += 1;
          Ok(state)
     })?;
     Ok(Response::new().add_attribute("method", "try_increment"))
}

pub fn try_reset(deps: DepsMut, info: MessageInfo, count: i32) -> Result {
     STATE.update(deps.storage, |mut state| -> Result<_, ContractError> {
          if info.sender != state.owner {
               return Err(ContractError::Unauthorized {});
          }
          state.count = count;
          Ok(state)
     })?;
     Ok(Response::new().add_attribute("method", "reset"))
}

How to Interact with Terra Smart Contracts

1. A format of receiving defined in the request GetCount {} inside the QueryMsg enum.

2. And a variable pub count: i32 to respond to the query request which is defined inside the CountResponse struct. The scripts below can be found in the src folder inside the file called msg.rs

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
     // GetCount returns the current count as a json-encoded number
     GetCount {},
}
// Define a custom struct for each query response
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct CountResponse {
     pub count: i32,
}

#[cfg_attr(not(feature = "library"), entry_point)]
pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult {
     match msg {
          QueryMsg::GetCount {} => to_binary(&query_count(deps)?),
     }
}

fn query_count(deps: Deps) -> StdResult {
     let state = STATE.load(deps.storage)?;
     Ok(CountResponse { count: state.count })
}

{
     "get_count": {}
}

{
     "count": 5
}

Building Terra Smart Contract

), &out_dir); you can see the registration in the examples folder, inside the file called schema.rs:

use std::env::current_dir;
use std::fs::create_dir_all;
use cosmwasm_schema::{export_schema, remove_schemas, schema_for};
use my_first_contract::msg::{CountResponse, HandleMsg, InitMsg, QueryMsg};
use my_first_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!(CountResponse), &out_dir);
}

Now, using the following commands, you can create these data structure JSON files inside schema folder: Coppied to clipboard. cd examples Cargo schema Result: Coppied to clipboard. Finished dev [unoptimized + debuginfo] target(s) in 0.37s Running `/home/mohamad/LocalTerra/my-first-contract.wasm/target/debug/examples/schema` Created /home/mohamad/LocalTerra/my-first-contract.wasm/examples/schema/instantiate_msg.json Created /home/mohamad/LocalTerra/my-first-contract.wasm/examples/schema/execute_msg.json Created /home/mohamad/LocalTerra/my-first-contract.wasm/examples/schema/ query_msg.json Created /home/mohamad/LocalTerra/my-first-contract.wasm/examples/schema/ state.json Created /home/mohamad/LocalTerra/my-first-contract.wasm/examples/schema/ count_response.json Inside the schema folder, you should be able to see all the requested data structures JSON files.

count_response.json
execute_msg.json
instantiate_msg.json
query_msg.json
state.json

Inside the state.json, you can see different sections of the .json file, the most important of which is the requires containing the “count” and the “owner”. Coppied to clipboard. { "$schema": "http://json-schema.org/draft-07/schema#", "title": "State", "type": "object", "required": [ "count", "owner" ], "properties": { "count": { "type": "integer", "format": "int32" }, "owner": { "$ref": "#/definitions/Addr" } }, "definitions": { "Addr": { "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Re- ally? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.", "type": "string" } } } Besides, you can see 2 required sections inside the execute_msg.json: Coppied to clipboard. 1. "increment" 2. "reset" { "$schema": "http://json-schema.org/draft-07/schema#", "title": "ExecuteMsg", "anyOf": [ { "type": "object", "required": [ "increment" ], "properties": { "increment": { "type": "object" } }, "additionalProperties": false }, { "type": "object", "required": [ "reset" ], "properties": { "reset": { "type": "object", "required": [ "count" ], "properties": { "count": { "type": "integer", "format": "int32" } } } }, "additionalProperties": false } ] }

Summing Up

we dived deep into the details of the local Terra smart contracts written in Rust or in other words the CosmWasm smart contracts. This type of understanding from scratch helps us interact and communicate better with local Terra and understand what actually happens behind the scenes when we send JSON messages with python scripts to instantiate or execute a smart contract or query data from it. Firstly, we showed how to create a template for initiating state. Then, we created a smart contract and learned how to interact with it. Besides, we learned how to use the QueryMsg function and build a Terra smart contract.

Download this Article in PDF format

Curious about What We’re Up To?

In Arashtad, we provide custom services in various design and development fields. 3D websites, 3D games, metaverses, and other types of WebGL and 3D applications are just some of our expertise.

Check Out Our Services

Arashtad Services

Drop us a message and tell us about your ideas.

Request a Quote

ThreeJS Development