Terra Luna – Python Guide

What is the Terra Blockchain?

Terra Blockchain is one of the most known protocols that specializes in the deployment of stablecoins that allows cryptocurrency users mass access to DeFi. Terra Blockchain is built on the Cosmos SDK and Tendermint.

What is the Terra Blockchain used for?

The Terra Blockchain is mainly used for obtaining and utilizing various stablecoins and DeFi. The most known projects on the Terra Blockchain that allow for this are Anchor, Mirror, Astroport, Pylon, Valkyrie, and more.

What is Luna?

Luna is the native cryptocurrency to the Terra blockchain ecosystem.

What programming languages does the Terra Blockchain support?

Rust programming language is the main language used throughout the Terra Blockchain and the blockchain itself is built upon it. Terra also supports the use of Python and JavaScript with their respective SDKs.

Why should I use the Terra Blockchain?

• You should use the Terra Blockchain to promote decentralization
• Terra Blockchain allows you to be in charge of your money
• To participate in DeFi
• To obtain monetary rewards through delegating, staking, borrowing, lending, burning, bonding, providing liquidity, and more.
• To support the Blockchain narrative
• To avoid the use of a CEX
• Has low fees
• Allows for interoperability
• Has fast transactions
• Has decent development activity

Why shouldn’t I use the Terra Blockchain?

• Terra Blockchain currently has limited nodes
• Terra Blockchain, like the rest of the crypto space, will be addressed by regulators
• The development documentation is currently scatterred
• Needs more adoption outside of Asia

Does the Terra Blockchain have an API?

What is the FCD and LCD on the Terra Blockchain?

The Full Client Deamon (FCD) and the Light Client Deamon (LCD) are REST-based adapters to the Remote Procedure Call (RPC) endpoints and are used for decoding the Amino-encoded blockchain data into parseable JSON.

The LCD is a “light” client while the FCD isn’t as it pulls data from the LCD to its own database. When using the LCD or FCD, we are basically connecting to a Terra node so that we can broadcast our transaction or query.

You can think of this as analogous to using a basic API for an exchange but it is on a blockchain and decentralized.

Is the Terra Blockchain API free?

Yes, everything on Terra is open-sourced and free to use. You also have access to a testnet where you can play with the Terra Network. You can also run a test node locally.

What are the alternatives to the Terra Blockchain?

Main Terra alternatives are other Layer 1 protocols like:

• Ethereum
• Fantom
• Tezos
• Algorand
• Solana
• Avalanche
• EOS and more

How to get started with Python on the Terra Blockchain?

To get started with Python on the Terra Blockchain, you will need to install the Python SDK. This can be done with the following command:

pip install terra_sdk

How to connect to the Terra Blockchain with Python?

To connect to the Terra Blockchain, you will want to load the terra LCD module and provide it with the blockchain address and client that you want to connect with. In our case, we will connect to the testnet with the Terra LCD.

from terra_sdk.client.lcd import LCDClient

terra = LCDClient(
    chain_id="bombay-12", 
    url="https://bombay-lcd.terra.dev"
    )
terra

<terra_sdk.client.lcd.lcdclient.LCDClient at 0x7f10f6ec0390>

How to create a wallet on the Terra Blockchain with Python?

A Terra Blockchain Wallet can be created with Python by issuing your own mnemonic key. This can be done by just calling the MnemonicKey module without any parameters. The result will be a randomly generated mnemonic.

from terra_sdk.key.mnemonic import MnemonicKey

mk = MnemonicKey()
mk.mnemonic

warm photo twenty series memory law range bonus shallow tent remove bone country chunk civil device harvest level lunar maid mom glad wood sight

Now, you can easily check your newly created wallet/account and also access the private key that is used for signing transactions.

print(mk.acc_address, '\n')
print(mk.private_key)

terra1sjvvhcvaqeg4x05dgn8avhwe56hr739ps8qnzp 

b'\x8e\x1d\r\x15\xda\x9c\xe6\xe4\xa4\xfc\x81x,\xbeM\xad\\\x87r\x18\x96_i\x96K$P\xf2j\xfe\xfe_'

I suggest using the newly generated mnemonic and passing it into the MnemonicKey as a parameter so that your test wallet is saved and that you don’t create a new one each time you want to do something.

If you want to use an existing Terra wallet (not advised when learning), you will pass the mnemonic into the MnemonicKey as a string parameter.

How to send test tokens from the Terra Blockchain with Python?

What are Terra Blockchain native tokens?

Terra Blockchain native tokens are the following: uluna, usdr, ukrw, uusd, umnt, ueur, ucny, ujpy, ugbp, uinr, ucad, uchf, uhkd, uaud, usgd, uthb, usek, unok, udkk, uidr, and uphp. Each currency has an “u” added in front of it.

What are Terra Blockchain CW-20 tokens?

Terra Blockchain CRW-20 tokens are fungible tokens based on CosmWasm. Their design is conceptually similar to the Ethereum ERC20 standard but they are quite manipulated and changed from them.

Some examples of these tokens are bLUNA, ANC, MINE, VKR, ASTRO, MIR, ORION, TWD, and more.

How to obtain data about the Terra Blockchain with Python?

To obtain Terra Blockchain data you can query many of the endpoints that are well explained in the Terra Python SDK documentation. These endpoints belong to their own groups like treasury, oracle, bank, and more.

For example, to get the tax rate we run the following command:

terra.treasury.tax_rate()

To get the oracle parameters we do this:

terra.oracle.parameters()

To get the last request high:

terra.last_request_height()

Take note that some of these calls might not give you a result due to the fact that we are using the testnet for the purpose of this article.

How to obtain price data from the Terra Blockchain with Python?

To obtain price data from the Terra Blockchain you can do things like previewing swap rates, parsing the block information, querying an external price API, or obtaining historical price data.

To preview the swap rate you will use the market swap rate endpoint and provide the amount of the offered coin and the crypto that is your ask. For example, let’s provide $100 and see how much Luna we can get:

terra.market.swap_rate('100000000uusd', 'uluna')

Coin(denom='uluna', amount=1259909)

We can obtain 1.25 LUNA for $100. Now, let us take in the historical prices by sending an API request to the FCD:

import requests

requests.get('https://fcd.terra.dev/v1/market/price?denom=uusd&interval=1h').json()

How to perform a native swap on the Terra Blockchain with Python?

To perform a native on the Terra Blockchain with Python, you will need to use the MsgSwap module with a specified transaction message and account address that you will use to sign the transaction.

The Python SDK allows shortening the amount of code you would need to write in order to perform a swap. The first thing that we want to do is to import the MsgSwap module and create the message that will swap 100 UST for Luna.

from terra_sdk.core.market import MsgSwap

# Swap 100 UST for Luna
msg = MsgSwap(mk.acc_address, "100000000uusd", "uluna")

Now we initialize our wallet that will do the signing and broadcasting of the transaction:

# Initialize the wallet
wallet = terra.wallet(mk)

The next step is to build the transaction message itself and sign it by passing it the message and addressing several optional parameters:

# Create and sign the transaction
tx = wallet.create_and_sign_tx(
    msgs=[msg],
    memo = "Algotrading101", # Optional
    gas_prices = "1uluna", # Optional
    gas_adjustment = "1.3", # Optional
    fee_denoms = ["uluna", "uusd"] # Optional
)

tx

StdTx(msg=[MsgSwap(trader='terra1sjvvhcvaqeg4x05dgn8avhwe56hr739ps8qnzp', offer_coin=Coin(denom='uusd', amount=100000000), ask_denom='uluna')], fee=StdFee(gas=134045, amount=Coins('134045uluna')), signatures=[StdSignature(signature='n+hJUQn0sT5zFS3JKQq7Tgqks5Fl6v+1RZ5439Ja/7hDeGoWXvBhh+fMwK17mq7HxVo46YabA4tpeMV6eBEqag==', pub_key=PublicKey(type='tendermint/PubKeySecp256k1', value='AlAdv8psEHZm56S9nzleTMhaEyEQmqR/UqACtRP8BnR9'))], memo='Algotrading101')

Now, let us go over some of these optional parameters:

• memo – this is a simple message you might want to pass in order to mark your transaction or greet someone if you are sending him crypto
• gas_prices – gas prices that are used for fee estimation
• gas_adjustment – how much of a buffer you might want to have so that you don’t run out of gas
• fee_denoms – what currency you want to use to pay for gas

Now that we have a simple transaction message ready, we will broadcast it on the testnet:

result = terra.tx.broadcast(tx)
result

On a side note, if you are ever unsure of all the available parameters for a specific module, you can write help(Module_Name) to see what you can use and what the model does exactly.

How to check if the transaction was successful on the Terra Blockchain with Python?

How to estimate fees on the Terra Blockchain with Python?

To estimate fees on the Terra Blockchain you can either query the FCD to obtain the current gas prices or simulate the transaction you wish to make to obtain the precise amount of fees you might need. Let’s cover both ways.

Update: As of lately, there was a “silent” update to the SDK where the example below is outdated (v1.0.2). Now, the StdFee module doesn’t exist anymore and is replaced by the Fee module. Also, if you don’t pass the fee, it will be automatically estimated by the node for you. I advise letting the node do the job for you.

To obtain the fees by querying the FCD we do the following:

fees = requests.get(
        "https://fcd.terra.dev/v1/txs/gas_prices"
    ).json()
fees

{'uaud': '0.19',
 'ucad': '0.19',
 'uchf': '0.14',
 'ucny': '0.98',
 'udkk': '0.9',
 'ueur': '0.125',
 'ugbp': '0.11',
 'uhkd': '1.17',
 'uidr': '2180.0',
 'uinr': '10.88',
 'ujpy': '16.37',
 'ukrw': '169.77',
 'uluna': '0.01133',
 'umnt': '428.571',
 'unok': '1.25',
 'uphp': '7.6',
 'usdr': '0.104938',
 'usek': '1.25',
 'usgd': '0.2',
 'uthb': '4.62',
 'uusd': '0.15'}

The above values are the current mean fee estimations for the Terra Blockchain per 1 transaction. Now, let us imagine that we want to pay our fees in uusd.

We can simply insert the fee estimation into our transaction like this:

from terra_sdk.core.auth import StdFee

denominator = 1000000

fee = str(int(float(fees["uusd"]) * denominator)) + "uusd"

# Send tx
sendtx = wallet.create_and_sign_tx(
    msgs=[msg],
    fee=StdFee(denominator, fee),
    fee_denoms=['uusd']
)

fee

150000uusd

To estimate how much a transaction might take in terms of UST fees we do the following:

terra.tx.estimate_fee(
    sender=mk.acc_address, 
    msgs=[msg], 
    fee_denoms=['uusd']
    )

StdFee(gas=99535, amount=Coins())

How to send crypto from one wallet to another on the Terra Blockchain with Python?

To send crypto from one wallet to another on the Terra Blockchain, you will want to utilize the MsgSend module and provide it with your account address, the account address you want to send crypto to, and the crypto.

from terra_sdk.core.bank import MsgSend

# Send a third of coins to another account
send = MsgSend(
    mk.acc_address,
    'RECEIVER-ADDRESS-HERE',
    terra.bank.balance(mk.acc_address)/3
    )

The code above will send a third of the sender account balance to the receiver account. All you need to do for this to work is to broadcast the transaction like in the previous swap example.

For practice, try creating a new wallet and send funds to it. You can juggle multiple wallets at the same time easily.

How to perform a non-native swap on the Terra Blockchain with Python?

To perform a non-native swap on the Terra Blockchain with Python, you will need to create a bit different transaction message that can accommodate a non-native token.

Let us start with an example of swapping LUNA for bLUNA step-by-step. The first thing we need to import are several modules and specify the amount we wish to swap, the LUNA-bLUNA testnet address and bLUNA contract:

from terra_sdk.core.coins import Coins
from terra_sdk.core.coins import Coin
from terra_sdk.core.wasm import MsgExecuteContract

# Specify the amount of Luna to swap
amount = 10000000

# Populate the address and contact variables
luna_bluna_pair_address = "terra13e4jmcjnwrauvl2fnjdwex0exuzd8zrh5xk29v"
bluna_contract = "terra1u0t35drzyy0mujj8rkdyzhe264uls4ug3wdp3x"

Now we create a coins object that specifies how much LUNA are we offering to perform the swap. This object is required each time you offer a native asset:

# Specify how much LUNA you're sending 
coin = Coin("uluna", amount).to_data()
coins = Coins.from_data([coin])

The next thing that we want to do is to create the swap message. When swapping to a non-native asset you must point to the LUNA-bLUNA pair contract and specify the address it should go to:

# Create the message
send = (
    MsgExecuteContract(
        sender=mk.acc_address,
        contract=luna_bluna_pair_address,
        execute_msg={
            "swap": {
                "offer_asset": {
                    "max_spread":"0.005", # Optional
                    "info": {"native_token": {"denom": "uluna"}},
                    "amount": str(int(amount)),
                },
                "to": mk.acc_address,
            }
        },
        coins=coins,
    ),
)

Now, we simply obtain the fees and broadcast the transaction as shown in our previous examples. Be sure to inspect your transaction hash to see if you did everything correctly. Here is my transaction hash:

D3288A99A9861D57F91F050291C9E95251C7106C661DDF77CFF67C0C4455E244

If you want to swap back from a non-native asset to LUNA, you write the message like the following:

send = (
        MsgExecuteContract(
            sender=mk.acc_address,
            contract=bluna_contract,
            execute_msg={
                "send": {
                    "contract": luna_bluna_pair_address,
                    "amount": str(5000000),
                    "msg": "eyJzd2FwIjoge319",
                }
            },
            coins=Coins(),
        ),
  )

B229B2A24DF9E5F07B0292C36FCE207A3E74F9E039C8C397DE0F2DFDF7928474

How to obtain the CW-20 token balance on the Terra Blockchain with Python?

To obtain the CW-20 token balance on the Terra Blockchain with Python, you will need to issue a query to the store endpoint. For example, let us obtain the amount of bLUNA that we have in our test wallet:

query_msg = '{"balance":{"address":"' + mk.acc_address + '"}}'
response = requests.get(
    "https://bombay-lcd.terra.dev/wasm/contracts/" + bluna_contract + "/store",
    params={"query_msg": query_msg},
).json()

response

{'height': '7422940', 'result': {'balance': '5020394'}}

How to simulate a swap on the Terra Blockchain with Python?

To simulate a swap on the Terra Blockchain with Python, you will want to issue a query to the LCD that will do the simulation and show you the results of the swap as if it happened for real. Let’s simulate LUNA->bLUNA.

query_msg = (
    '{"simulation":{"offer_asset":{"amount":"'
    + str(50000000)
    + '","info":{"token":{"contract_addr":"terra1u0t35drzyy0mujj8rkdyzhe264uls4ug3wdp3x"}}}}}'
)


response = requests.get(
    "https://bombay-lcd.terra.dev/wasm/contracts/" + luna_bluna_pair_address + "/store",
    params={"query_msg": query_msg},
).json()

response

{'height': '7423219',
 'result': {'commission_amount': '149085',
  'return_amount': '49546156',
  'spread_amount': '53341'}}

If you wish to simulate the reverse of the above transaction, you do the following:

# Reverse
query_msg = (
    '{"reverse_simulation":{"ask_asset":{"amount":"'
    + str(50000000)
    + '","info":{"token":{"contract_addr":"terra1u0t35drzyy0mujj8rkdyzhe264uls4ug3wdp3x"}}}}}'
)


response = requests.get(
    "https://bombay-lcd.terra.dev/wasm/contracts/" + luna_bluna_pair_address + "/store",
    params={"query_msg": query_msg},
).json()

response

{'height': '7423233',
 'result': {'commission_amount': '150451',
  'offer_amount': '49952055',
  'spread_amount': '54049'}}

How to find adequate contract and token addresses for the Terra Blockchain?

How to create your own smart contract on the Terra Blockchain with Python?

Where can I learn more about the Terra Blockchain?

Full code