Migration to terra 2: A perfect guide

This article aims to bring the necessary guidelines for migrating from origin or classic Terra to new


Terra or Terra2. This migrating includes the updates in main-net, test-net, exchanges, functions,


dApps, starting a node, faucets and everything that help the developers update their scripts with


the new Terra chain. It is important to mention that the classic or origin Terra still works the way it


used to. But in Terra2 we have some modifications that solve the problem related to the classic


Terra.


Of course this guide is not meant to create a full tutorial on how to interact with Terra2 main-net or


test-net and other interactions, but to continue the detailed guidelines that we provided for the


original Terra (Terra1), with the difference that they are going to be used for the new Terra chain.

What is terra?

Terra is a DeFi protocol on the Blockchain that powers the universal payment


systems which is based on fiat currencies using the fiat-based stablecoins. This


protocol uses a mixture of wide adoption of stable coins and at the same time


censorship resistance of Bitcoin. Terra is built on Cosmos SDK and Tendermint. The


main language that the Terra smart contracts are written in, is Rust. However, there


are SDKs for python and JavaScript and creating the smart contracts called WASM


Contracts.

What does terra2 look like?

Most of what we know about the original Terra Or Terra Classic is true about Terra2


as well. Although the differences that Terra2 has with Terra Classic, is the main focus


of this article and you need to read it fully until the end to understand the differences,


we can summarize them here in the beginning.


The new Terra chain is also a Cosmos chain with the difference that it doesn’t have


oracle, stable coins (such as UST, KRT, EUT, etc), treasury and the market modules


as opposed to the original chain. Moreover, Luna will be the main staking asset of


the chain (notice that this Luna is the related to the new Terra chain and the token of


the Terra Classic will be named LUNC). And last but not the least, the official name


that is considered for the new Terra chain is Terra without any post or pre phrases.


These are the main features of Terra2 mentioned by Terra official documentation


website.

Changes made on the original Terra:

The only changes that have been made on the Terra Classic is the names of tokens


and the new conventions set for calling them. Consequently, we have no changes in


the back-end and codes behind the scenes except that the market swaps have been


disabled as well as the minting and burning functions. The new naming changes


include:


1. Luna has become Luna Classic (LUNC).


2. Terra stable coins have been renamed from ( UST, KRT, EUT, etc) to ( USTC,


KRTC, EUTC, etc)


Arashtad.com Design and development solutions


arashtad

Terra 2 main-net and test-net:

The new Terra chain has a new main-net and test-net name. If you have read our


articles about the Terra Classic which was called Terra at the time, you can


remember that the main-net used for it was called Columbus-5 and the test-net


named Bombay-12. With the new Terra chain, we have a new main-net called


Phoenix-1 and the test-net with the name of Pisco-1.. It is important to notice that for


Terra2 main-net Phoenix -1 the LCD changes from (https://lcd.terra.dev) which was


used to for Columbus-5 to (https://phoenix-lcd.terra.dev). Also the FCD changes


from (https://fcd.terra.dev) to (https://phoenix-fcd.terra.dev).


Now, let’s see if the new settings works for our recent Terra Classic scripts.


Before you run the codes, you should reinstall the Terra Python SDK, as there are


new updates made on the SDK. To do so enter the following command in the


terminal to perform the installation:

Coppied to clipboard.

pip install -U terra_sdk

And then create a file called test.py and paste the below scripts in it:

from terra_sdk.key.mnemonic import MnemonicKey


from terra_sdk.client.lcd import LCDClient


terra = LCDClient(


url="https://pisco-lcd.terra.dev/",


chain_id="pisco-1"


)


mk = MnemonicKey().__dict__


wallet = terra.wallet(mk)


print(mk)

To run the above script, paste the following command in the terminal:

Coppied to clipboard.

Python test.py

Result:

Coppied to clipboard.

{'public_key': SimplePublicKey(key=b'x02sxf0xcax8c$Ax86;


xbcxbeExff8xf3x96x98xdb/Rx1fx89x11r xf7xc5O|xe3#


x1ex98'), 'raw_address': b'xb3^^xdexfcexe1xa5x97&x1f


x88x85xa4x95}xc7x1aPx8d', 'raw_pubkey': b'xebZxe9


x87!x02sxf0xcax8c$Ax86;xbcxbeExff8xf3x96x98xdb/R


x1fx89x11r xf7xc5O|xe3#x1ex98', 'private_key': b'x89


tqxe5xeex14kx82xd0xe5xd4x85x9aWx1ex98xf5Exd2


xa4]xedx99x9fxd9Ox8bxe9n? x98', 'mnemonic': 'tube have


blanket praise panther popular owner brand brick arena combine


follow refuse frog normal seed alarm awkward spend vicious


inject solution soul artwork', 'coin_type': 330, 'account': 0,


'index': 0}

Using the mnemonic key given above, we can get some test ULUNAs from Terra


Faucet (The way we did on our Python Terra SDK article) and also create another


account. Finally, we can create and sign the transaction of transferring money from


account 1 to account 2.

Estimating Gas fees on Terra2:

On all the blockchains, the transactions need efforts from computational resources.


In the proof of work architectures, the computational resources are the miners and in


other mechanisms, there are other resources. The computational processing applied


for transactions is quantified in the units called gas.


To estimate the gas fee for a transaction, we use the very same script that we


used when

import requests


import json


gas_price_dict = requests.get("prices").json()


print(gas_price_dict)

Result:

Coppied to clipboard.

5.665

Migrating CosmWasm contracts on Terra:

The CosmWasm smart contracts in Local Terra remain the same but with a little bit


of difference. If you can remember from the article of Local Terra, we had some .rs


files including msg.rs and contract.rs. We also had 3 kinds of messages in the


Local Terra:


1. Instantiate


2. Execute


3. Query


Now, in the new Terra chain, we have also got the Migrate message added. We will


add this migrate method to the msg.rs like below:

#


pub struct MigrateMsg {}

Also, in the contract.rs file we have 2 changes for adding the migration:

#


pub fn migrate(_deps: DepsMut, _env: Env, _msg: MigrateMsg) -> StdResult {


Ok(Response::default())


}

And

use crate::msg::{CountResponse, ExecuteMsg, InstantiateMsg, QueryMsg, MigrateMsg};

Deprecated functionalities on terra2:

On the new Terra chain, we will see that some of the functions are deprecated.


Meaning that they cannot be used anymore. Some of these functions are as follows:


1. oracle functions:

const oracleParams = await lcd.oracle.parameters();


const marketParams = await lcd.market.parameters();

2. swap function used in Python Terra SDK:

const swap = new MsgSwap('terra...9fj',new Coin('uluna','1000000'),'uusd')

We used the MsgSwap function to swap tokens on Terra Classic Network. With the


expiration of the stablecoins on Terra2, the MsgSwap function is deprecated as well


3.compute tax function:

pub fn compute_tax(deps: Deps, coin: &Coin) -> StdResult {


let terra_querier = TerraQuerier::new(&deps.querier);


let tax_rate = Decimal256::from((terra_querier.query_tax_rate()?).rate);


let tax_cap = Uint256::from((terra_querier.query_tax_cap(coin.denom.to_string())?).cap);


let amount = Uint256::from(coin.amount);


Ok(std::cmp::min(amount * Decimal256::one() - amount / (Decimal256::one() + tax_rate),tax_cap,))


}

Conclusion

In this article, we have got familiar with Terra Network, what it is doing, how it


does what it does, and the distinctions of this chain. Furthermore, we have got to


know the new features of Terra2 with the new updates that have been made on this


new fork of the original Terra or Terra Classic. In addition to that, we have taken a


look at the Terra network's new names from the Terra Classic tokens to the Terra2.


The other thing that we have done is to run the Terra2 Pisco-1 test-net to see if


works properly.


Moreover, we have seen what scripts have been added to the CosmWasm smart


contracts and how to update them. And last but not the least, we have taken a


look at the deprecated functions that can no more be used in the new Terra chain


such as the swap function, oracles, and taxes.

Download this Article in PDF format

Arashtad Custom Services

In Arashtad, we have gathered a professional team of developers who are working in fields such as 3D websites, 3D games, metaverses, and other types of WebGL and 3D applications as well as blockchain developemnet.

Visit Our Services

Arashtad Serivces

Drop us a message and tell us about your ideas.

Fill in the Form

Blockchain Development
https://blog.arashtad.com/blog/migration-to-terra-2-a-perfect-guide/