Reading chain state

let block = provider.get_now_block().await?;
println!("number    : {}", block.number);
println!("timestamp : {} ms", block.timestamp);
println!("hash      : {:#x}", block.hash);

let account = provider.get_account(address).await?;
 
println!("balance   : {} TRX", account.balance);
println!("name      : {}", account.name);
println!("activated : {}", account.is_activated);
 
// Stake 2.0 frozen balances
for f in &account.frozen_v2 {
    println!("staked {} for {:?}", f.amount, f.resource);
}

let res = provider.get_account_resource(address).await?;
 
println!("bandwidth : {}/{}", res.bandwidth_used, res.bandwidth_limit);
println!("energy    : {}/{}", res.energy_used, res.energy_limit);
println!("tron power: {}", res.tron_power_used);

use tronz::primitives::ResourceCode;
 
// Who is this account delegating to / receiving from?
let idx = provider.get_delegated_resource_index(address).await?;
println!("delegating to  : {} accounts", idx.to_accounts.len());
println!("receiving from : {} accounts", idx.from_accounts.len());
 
// Max still delegatable, per resource.
let max_energy = provider.get_can_delegate_max(address, ResourceCode::Energy).await?;
 
// Unclaimed staking rewards.
let reward = provider.get_reward(address).await?;
println!("pending reward : {}", reward);

let tx = provider
    .get_transaction(tx_id)
    .await?
    .ok_or_else(|| anyhow::anyhow!("transaction not found"))?;
 
// `get_transaction_info` returns `None` until the node has indexed the tx.
let info = provider
    .get_transaction_info(tx_id)
    .await?
    .ok_or_else(|| anyhow::anyhow!("transaction not found or not yet confirmed"))?;
 
println!("block  : {}", info.block_number);
println!("status : {:?}", info.status);
println!("energy : {}", info.receipt.energy_usage);