Terra Rust API

A rust API for Terrad's LCD system.

Warning

This is a WIP.

No security audit has been performed.

Randomness

The API is currently using random numbers via
let mut rng = rand::thread_rng();

Disclaimer

This may steal your money.

This is not investment advice.

Do you own research

Help ?

There is a CLI that uses this, which may be helpful

If you think this was useful, feel free to delegate to the PFC validator. It will help defray the costs.

PFC - Terra/Luna is Pretty Freaking Cool right... feel free to drop me a line

An Example

use terra_rust_api::{Terra, GasOptions, PrivateKey};
use terra_rust_api::core_types::{Coin, Msg, StdSignMsg, StdSignature};
use terra_rust_api::messages::MsgSend;
use terra_rust_api::auth_types::AuthAccountResult;

// set up the LCD client
let gas_opts = GasOptions::create_with_gas_estimate("50ukrw",1.4);
let t = Terra::lcd_client("https://tequila-lcd.terra.dev/", "tequila-0004", &gas_opts).await?;
// generate a private key
let secp = Secp256k1::new();
let from_key = PrivateKey::from_words(&secp,"your secret words");
let from_public_key = from_key.public_key(&secp);
// generate the message SEND 1000 uluna from your private key to someone else
let coin: Coin = Coin::parse("1000uluna")?.unwrap();
let from_account = from_public_key.account()?;
let send: MsgSend = MsgSend::create(from_account, "terra1usws7c2c6cs7nuc8vma9qzaky5pkgvm2uag6rh", vec![coin]);
// generate the transaction & calc fees
let messages: Vec<Box<dyn Msg>> = vec![Box::new(send)];
let std_fee = terra.calc_fees(&messages).await?;
let auth_result: AuthAccountResult =
               terra.auth().account(&from_public_key.account()?).await?;
let account_number = auth_result.result.value.account_number;
let std_sign_msg = StdSignMsg {
                chain_id: terra.chain_id.to_string(),
                account_number,
                sequence: auth_result.result.value.sequence,
                fee: std_fee,
                msgs: messages,
                memo: "Luna to the Moon!".to_string(),
 };

// Sign it
 let js = serde_json::to_string(&std_sign_msg)?;
 let sig = from_key.sign(&secp, &js)?;
 let sigs: Vec<StdSignature> = vec![sig];

// send it out
 let resp = terra.tx().broadcast_sync(&std_sign_msg, &sigs).await?;
 match resp.code {
     Some(code) => {
         log::error!("{}", serde_json::to_string(&resp)?);
         eprintln!("Transaction returned a {} {}", code, resp.txhash)
     }
     None => {
         println!("{}", resp.txhash)
     }
 }