How to Set Up the Dependencies For Running Local Terra: All You Need to Know

In this tutorial-based article, we are going to set up the dependencies for running Local Terra. So, you will be guided through all the installations and commands necessary to start your interaction with local Terra smart contracts. Installing Go, Docker, Terrad, and git cloning local Terra, as well as terra-core repositories, are some of the main steps we are going to take in this tutorial.

Installing the Dependencies

For running local terra the main step is to install all of the dependencies required. The first step is to install go. You need to be careful that the version should be higher than 1.17.5.

The Dependencies for Running Local Terra #1: Go

To install Go, you should find the latest version for your operating system using this link. Then, the next step is to check the version to make sure it meets the requirement of our version (higher than 1.17.5). To do so, enter the following command in the terminal:

Result:

If you see a result like the above, your installation has been successful. You should also have the Rust programming language installed using the below command (Notice that this command is used for Linux OS) in the terminal:

For other operating systems, follow the instructions on this link. Now, it is time to git clone the terra-core repository. In the terminal, enter the following command:

After that, change the directory to the terra-core folder by entering the below command in the terminal:

To install the downloaded repository, enter the following in the terminal:

The Dependencies for Running Local Terra #2: Docker

One of the required dependencies for running local Terra is Docker. You should also have docker installed on your operating system. Here we explain the process for Linux:
For the installation guide in other operating systems than Linux, follow the instructions on the Docker.

Installation Guide on Linux

This process consists of 5 steps that are described in the followings.

1. Dependencies:

At first, update the system to get the list of available packages and their version numbers. To do so, enter the following command in the terminal:

To prepare for the installation run these commands in the terminal one after the other:

2. Add Docker’s Official GPG Key:

Also run the following commands in the terminal:

3. Add the Docker Repository to Linux:

To add the Docker repository for Linux, enter the following commands in the terminal:

4. Install the Docker Engine and the Docker Compose:

And finally, It is time to install docker by running these 2 commands in the terminal one after the other.

5. Checking the Installation:

To start with checking the installation, use the command below:

To make sure the installation has been successful, run the following command in the terminal:

Result:

After installation for every use, you need to first sign in and run the following commands in the terminal:

Run the above commands in the local Terra directory terminal.
Result:

For the following command in the terminal, instead of YourProjectName, you can enter any name you want for your project to be created (make sure you run this command in the directory of local Terra you have just git cloned):

Result:

CosmWasm Smart Contracts on Local Terra

In this section, we are going to get familiar with CosmWasm smart contracts written inRust programming language for interacting with local Terra through Python or JavaScript. These smart contracts have different functions that we need to send specific JSON messages to interact with them. In the end, we are going to create the artifacts folder containing the necessary binary files to interact with local Terra.

If you open the YourProjectName folder and in its src folder, the Msg.rs and contract.rs alongside with other Rust script files are found. The Msg.rs contract is related to the 3 kinds of messages we can send to our contract and it is composed of 3 main parts:

1. InstantiateMsg struct:

2. ExecuteMsg enum:

3. QueryMsg Query Msg:

use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct InstantiateMsg {
     pub count: i32,
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
     Increment {},
     Reset { count: i32 },
}
#[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 {},
}
// We define a custom struct for each query response
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct CountResponse {
     pub count: i32,
}

On Dependencies for Running Local Terra: What is Inside the Contract.rs File?

Another important Rust file is Contract.rs. In the next part, we are going to refer to the functions of this contract and use them in python. The important functions that we are going to interact with later using the python scripts are instantiated, execute, try increment, try_reset, and query_count. We will later see how we can interact with these functions with the JSON messages sent to them through python codes. As you can see the programming language that these smart contracts are written in is Rust.

use cosmwasm_std::entry_point;
use cosmwasm_std::{to_binary, Binary, Deps, DepsMut, Env, MessageInfo, Response, StdResult};
use cw2::set_contract_version;
use crate::error::ContractError;
use crate::msg::{CountResponse, ExecuteMsg, InstantiateMsg, QueryMsg};
use crate::state::{State, STATE};
// version info for migration info
const CONTRACT_NAME: &str = "crates.io:my-project";
const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION");
#[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()))
}

#[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),
     }
}

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"))
}

#[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 })
}

#[cfg(test)]
mod tests {
     use super::*;
     use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
     use cosmwasm_std::{coins, from_binary};
     #[test]
     fn proper_initialization() {
          let mut deps = mock_dependencies(&[]);
          let msg = InstantiateMsg { count: 17 };
          let info = mock_info("creator", &coins(1000, "earth"));
          // we can just call .unwrap() to assert this was a success
          let res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
          assert_eq!(0, res.messages.len());
          // it worked, let's query the state
          let res = query(deps.as_ref(), mock_env(), QueryMsg::GetCount {}).unwrap();
          let value: CountResponse = from_binary(&res).unwrap();
          assert_eq!(17, value.count);
     }
     #[test]
     fn increment() {
          let mut deps = mock_dependencies(&coins(2, "token"));
          let msg = InstantiateMsg { count: 17 };
          let info = mock_info("creator", &coins(2, "token"));
          let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
          // beneficiary can release it
          let info = mock_info("anyone", &coins(2, "token"));
          let msg = ExecuteMsg::Increment {};
          let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
          // should increase counter by 1
          let res = query(deps.as_ref(), mock_env(), QueryMsg::GetCount {}).unwrap();
          let value: CountResponse = from_binary(&res).unwrap();
          assert_eq!(18, value.count);
     }
     #[test]
     fn reset() {
          let mut deps = mock_dependencies(&coins(2, "token"));
          let msg = InstantiateMsg { count: 17 };
          let info = mock_info("creator", &coins(2, "token"));
          let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
          // beneficiary can release it
          let unauth_info = mock_info("anyone", &coins(2, "token"));
          let msg = ExecuteMsg::Reset { count: 5 };
          let res = execute(deps.as_mut(), mock_env(), unauth_info, msg);
          match res {
               Err(ContractError::Unauthorized {}) => {}
                    _ => panic!("Must return unauthorized error"),
          }
          // only the original creator can reset the counter
          let auth_info = mock_info("creator", &coins(2, "token"));
          let msg = ExecuteMsg::Reset { count: 5 };
          let _res = execute(deps.as_mut(), mock_env(), auth_info, msg).unwrap();
          // should now be 5
          let res = query(deps.as_ref(), mock_env(), QueryMsg::GetCount {}).unwrap();
          let value: CountResponse = from_binary(&res).unwrap();
          assert_eq!(5, value.count);
     }
}

Creating a project folder using cargo

Now, let’s run the following command in the terminal to create binaries and other dependency files so that we can eventually interact with local Terra using python Terra SDK.

Result:

And in the project name folder, we are going to see that a new folder has been created called artifacts. Now, we are ready to write our python codes to interact with local Terra and use CosmWasm based contracts written in Rust.

In this tutorial, we have managed to install the dependencies required to run local Terra, such as GO and Rust programming languages, Docker, Cargo, and some Github repositories like terra-core and local-terra. We have also connected to Local Terra network using the docker-compose up command. In the end, we have created our project folder and files using the cargo generate command.
Moreover, we have taken a quick look at some of the important smart contracts written in Rust programming language and got familiar with their functions so that we can interact with them later using our python scripts. We also created the artifacts folder using the cargo command to have everything set up for interacting with the local Terra.

Download this Article in PDF format

Need More Rust Learning?

To fully take advantage of this article, you’d better get familiar with Rust Language applied to CosmWasm smart contracts. And the good news is that we have a complete tutorial for it.

See Our Rust Learning Tutorial

Arashtad Services

Drop us a message and tell us about your ideas.

Request a Quote

Blockchain Development