Struct GatewayHttpProxy 

pub struct GatewayHttpProxy { /* private fields */ }

Allows communication with the MultiversX gateway API.

Implementations

impl GatewayHttpProxy

pub async fn get_account(&self, address: &Bech32Address) -> Result<Account>

Examples found in repository

examples/account.rs (line 11)

async fn main() {
    let addr = Bech32Address::from_bech32_string(
        "erd1qqqqqqqqqqqqqpgqfzydqmdw7m2vazsp6u5p95yxz76t2p9rd8ss0zp9ts".to_owned(),
    );

    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let account = blockchain.get_account(&addr).await.unwrap();

    println!("account: {account:#?}");
}

pub async fn get_account_esdt_roles( &self, address: &Bech32Address, ) -> Result<HashMap<String, Vec<String>>>

pub async fn get_account_esdt_tokens( &self, address: &Bech32Address, ) -> Result<HashMap<String, EsdtBalance>>

Examples found in repository

examples/get_esdt_tokens.rs (line 11)

async fn main() {
    let addr = Bech32Address::from_bech32_string(
        "erd1pdv0h3ddqyzlraek02y5rhmjnwwapjyhqm983kfcdfzmr6axqhdsfg4akx".to_owned(),
    );

    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let balances = blockchain.get_account_esdt_tokens(&addr).await.unwrap();

    assert!(!balances.is_empty());
    println!("{balances:#?}");
}

pub async fn get_account_storage_keys( &self, address: &Bech32Address, ) -> Result<HashMap<String, String>>

Examples found in repository

examples/account_storage.rs (line 11)

async fn main() {
    let addr = Bech32Address::from_bech32_string(
        "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th".to_owned(),
    );

    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let account_storage = blockchain.get_account_storage_keys(&addr).await.unwrap();

    assert!(!account_storage.is_empty());
    println!("Account Storage: {account_storage:#?}");
}

impl GatewayHttpProxy

pub async fn get_hyper_block_by_hash(&self, hash: &str) -> Result<HyperBlock>

Examples found in repository

examples/get_hyper_block_by_hash.rs (line 7)

async fn main() {
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let result = blockchain
        .get_hyper_block_by_hash("d59e0dc7d407b1175655357cb8056ec3bb77961192753cddda2fb700c6ce71c6")
        .await;

    assert!(result.is_ok());
    println!("block by hash result: {result:#?}");
}

pub async fn get_hyper_block_by_nonce(&self, nonce: u64) -> Result<HyperBlock>

Examples found in repository

examples/get_hyper_block_by_nonce.rs (line 6)

async fn main() {
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let result = blockchain.get_hyper_block_by_nonce(7468).await;

    assert!(result.is_ok());
    println!("block by nonce result: {result:#?}")
}

pub async fn get_latest_hyper_block_nonce(&self) -> Result<u64>

Examples found in repository

examples/get_hyper_block_latest.rs (line 6)

async fn main() {
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let result = blockchain.get_latest_hyper_block_nonce().await;

    assert!(result.is_ok());
    println!("latest block result: {result:?}")
}

impl GatewayHttpProxy

pub async fn send_user_funds( &self, receiver: &Bech32Address, ) -> Result<String, Error>

pub async fn generate_blocks(&self, num_blocks: u64) -> Result<String, Error>

pub async fn generate_blocks_until_epoch( &self, epoch_number: u64, ) -> Result<String, Error>

pub async fn generate_blocks_until_tx_processed( &self, tx_hash: &str, ) -> Result<String, Error>

impl GatewayHttpProxy

pub async fn get_network_config(&self) -> Result<NetworkConfig>

Examples found in repository

examples/get_network_config.rs (line 6)

async fn main() {
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let network_config = blockchain.get_network_config().await.unwrap();

    assert!(!network_config.chain_id.is_empty());
    println!("network_config: {network_config:#?}")
}

examples/tx_default_args.rs (line 7)

async fn main() {
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let network_config = blockchain.get_network_config().await.unwrap();
    let addr = Bech32Address::from_bech32_string(
        "erd1qqqqqqqqqqqqqpgqfzydqmdw7m2vazsp6u5p95yxz76t2p9rd8ss0zp9ts".to_owned(),
    );

    let arg = blockchain
        .get_default_transaction_arguments(&addr.address, &network_config)
        .await
        .unwrap();

    let _ = arg.rcv_addr.to_bech32_string();
    println!("default tx arg: {arg:#?}");
}

examples/sign_tx.rs (line 12)

async fn main() {
    let wl = Wallet::from_private_key(
        "1648ad209d6b157a289884933e3bb30f161ec7113221ec16f87c3578b05830b0",
    )
    .unwrap();
    let addr = wl.to_address();
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let network_config = blockchain.get_network_config().await.unwrap();

    let arg = blockchain
        .get_default_transaction_arguments(&addr, &network_config)
        .await
        .unwrap();

    let mut unsign_tx = Transaction {
        nonce: arg.nonce,
        value: "0".to_string(),
        receiver: addr.to_bech32(&network_config.address_hrp),
        sender: addr.to_bech32(&network_config.address_hrp),
        gas_price: arg.gas_price,
        gas_limit: arg.gas_limit,
        data: arg.data,
        signature: None,
        chain_id: arg.chain_id,
        version: arg.version,
        options: arg.options,
    };

    let signature = wl.sign_tx(&unsign_tx);
    unsign_tx.signature = Some(hex::encode(signature));
    let tx_hash = blockchain.send_transaction(&unsign_tx).await.unwrap();

    assert!(!tx_hash.is_empty());
    println!("tx_hash {tx_hash}");
}

examples/sign_txs.rs (line 12)

async fn main() {
    let wl = Wallet::from_private_key(
        "1648ad209d6b157a289884933e3bb30f161ec7113221ec16f87c3578b05830b0",
    )
    .unwrap();
    let addr = wl.to_address();
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let network_config = blockchain.get_network_config().await.unwrap();

    let arg = blockchain
        .get_default_transaction_arguments(&addr, &network_config)
        .await
        .unwrap();

    let mut unsign_tx = Transaction {
        nonce: arg.nonce,
        value: "1000000000000000000".to_string(),
        receiver: addr.to_bech32(&network_config.address_hrp),
        sender: addr.to_bech32(&network_config.address_hrp),
        gas_price: arg.gas_price,
        gas_limit: arg.gas_limit,
        data: arg.data,
        signature: None,
        chain_id: arg.chain_id,
        version: arg.version,
        options: arg.options,
    };

    let mut txs: Vec<Transaction> = vec![];

    let signature = wl.sign_tx(&unsign_tx);
    unsign_tx.signature = Some(hex::encode(signature));
    txs.push(unsign_tx.clone());

    unsign_tx.version = 2;
    unsign_tx.options = 1;
    unsign_tx.nonce += 1;

    let signature = wl.sign_tx(&unsign_tx);
    unsign_tx.signature = Some(hex::encode(signature));
    txs.push(unsign_tx.clone());

    let tx_hash = blockchain.send_transactions(&txs).await.unwrap();

    assert!(!tx_hash.is_empty());
    println!("tx_hashes {tx_hash:?}");
}

pub async fn get_network_economics(&self) -> Result<NetworkEconomics>

Examples found in repository

examples/get_network_economics.rs (line 6)

async fn main() {
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let network_economics = blockchain.get_network_economics().await.unwrap();

    assert!(!network_economics.dev_rewards.is_empty());
    println!("network_economics: {network_economics:#?}")
}

impl GatewayHttpProxy

pub async fn request_transaction_cost( &self, tx: &Transaction, ) -> Result<TxCostResponseData>

Examples found in repository

examples/tx_cost.rs (line 27)

async fn main() {
    let tx = Transaction {
        nonce: 1,
        value: "50".to_string(),
        receiver: Bech32Address::from_bech32_string(
            "erd1rh5ws22jxm9pe7dtvhfy6j3uttuupkepferdwtmslms5fydtrh5sx3xr8r".to_owned(),
        ),
        sender: Bech32Address::from_bech32_string(
            "erd1rh5ws22jxm9pe7dtvhfy6j3uttuupkepferdwtmslms5fydtrh5sx3xr8r".to_owned(),
        ),
        data: Some(base64_encode("hello")),
        chain_id: "1".to_string(),
        version: 1,
        options: 0,
        gas_limit: 0,
        gas_price: 0,
        signature: None,
    };

    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let cost = blockchain.request_transaction_cost(&tx).await.unwrap();

    println!("tx cost: {cost:#?}");

    assert_eq!(
        cost.tx_gas_units, 57500,
        "receive cost {}",
        cost.tx_gas_units
    );
}

pub async fn get_transaction_info( &self, hash: &str, ) -> Result<TransactionOnNetwork>

Examples found in repository

examples/tx_info.rs (line 12)

async fn main() {
    let tx_hash = "fd21782ddb9e2217a3239e849e39d1d2c8fa74142a73f2dda3adb3028c0514e9";
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());

    let status = blockchain.get_transaction_status(tx_hash).await;
    assert!(status.is_ok());
    println!("tx status: {status:?}");

    let tx = blockchain.get_transaction_info(tx_hash).await;
    assert!(tx.is_ok());
    println!("tx: {tx:#?}");

    let tx = blockchain.get_transaction_info_with_results(tx_hash).await;
    assert!(tx.is_ok());
    println!("tx with results: {tx:#?}");
}

pub async fn get_transaction_info_with_results( &self, hash: &str, ) -> Result<TransactionOnNetwork>

Examples found in repository

examples/tx_info.rs (line 16)

async fn main() {
    let tx_hash = "fd21782ddb9e2217a3239e849e39d1d2c8fa74142a73f2dda3adb3028c0514e9";
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());

    let status = blockchain.get_transaction_status(tx_hash).await;
    assert!(status.is_ok());
    println!("tx status: {status:?}");

    let tx = blockchain.get_transaction_info(tx_hash).await;
    assert!(tx.is_ok());
    println!("tx: {tx:#?}");

    let tx = blockchain.get_transaction_info_with_results(tx_hash).await;
    assert!(tx.is_ok());
    println!("tx with results: {tx:#?}");
}

pub async fn get_transaction_status(&self, hash: &str) -> Result<String>

Examples found in repository

examples/tx_info.rs (line 8)

async fn main() {
    let tx_hash = "fd21782ddb9e2217a3239e849e39d1d2c8fa74142a73f2dda3adb3028c0514e9";
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());

    let status = blockchain.get_transaction_status(tx_hash).await;
    assert!(status.is_ok());
    println!("tx status: {status:?}");

    let tx = blockchain.get_transaction_info(tx_hash).await;
    assert!(tx.is_ok());
    println!("tx: {tx:#?}");

    let tx = blockchain.get_transaction_info_with_results(tx_hash).await;
    assert!(tx.is_ok());
    println!("tx with results: {tx:#?}");
}

pub async fn get_transaction_process_status( &self, hash: &str, ) -> Result<(String, String)>

pub async fn get_default_transaction_arguments( &self, address: &Address, network_configs: &NetworkConfig, ) -> Result<ArgCreateTransaction>

Examples found in repository

examples/tx_default_args.rs (line 13)

async fn main() {
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let network_config = blockchain.get_network_config().await.unwrap();
    let addr = Bech32Address::from_bech32_string(
        "erd1qqqqqqqqqqqqqpgqfzydqmdw7m2vazsp6u5p95yxz76t2p9rd8ss0zp9ts".to_owned(),
    );

    let arg = blockchain
        .get_default_transaction_arguments(&addr.address, &network_config)
        .await
        .unwrap();

    let _ = arg.rcv_addr.to_bech32_string();
    println!("default tx arg: {arg:#?}");
}

examples/sign_tx.rs (line 15)

async fn main() {
    let wl = Wallet::from_private_key(
        "1648ad209d6b157a289884933e3bb30f161ec7113221ec16f87c3578b05830b0",
    )
    .unwrap();
    let addr = wl.to_address();
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let network_config = blockchain.get_network_config().await.unwrap();

    let arg = blockchain
        .get_default_transaction_arguments(&addr, &network_config)
        .await
        .unwrap();

    let mut unsign_tx = Transaction {
        nonce: arg.nonce,
        value: "0".to_string(),
        receiver: addr.to_bech32(&network_config.address_hrp),
        sender: addr.to_bech32(&network_config.address_hrp),
        gas_price: arg.gas_price,
        gas_limit: arg.gas_limit,
        data: arg.data,
        signature: None,
        chain_id: arg.chain_id,
        version: arg.version,
        options: arg.options,
    };

    let signature = wl.sign_tx(&unsign_tx);
    unsign_tx.signature = Some(hex::encode(signature));
    let tx_hash = blockchain.send_transaction(&unsign_tx).await.unwrap();

    assert!(!tx_hash.is_empty());
    println!("tx_hash {tx_hash}");
}

examples/sign_txs.rs (line 15)

async fn main() {
    let wl = Wallet::from_private_key(
        "1648ad209d6b157a289884933e3bb30f161ec7113221ec16f87c3578b05830b0",
    )
    .unwrap();
    let addr = wl.to_address();
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let network_config = blockchain.get_network_config().await.unwrap();

    let arg = blockchain
        .get_default_transaction_arguments(&addr, &network_config)
        .await
        .unwrap();

    let mut unsign_tx = Transaction {
        nonce: arg.nonce,
        value: "1000000000000000000".to_string(),
        receiver: addr.to_bech32(&network_config.address_hrp),
        sender: addr.to_bech32(&network_config.address_hrp),
        gas_price: arg.gas_price,
        gas_limit: arg.gas_limit,
        data: arg.data,
        signature: None,
        chain_id: arg.chain_id,
        version: arg.version,
        options: arg.options,
    };

    let mut txs: Vec<Transaction> = vec![];

    let signature = wl.sign_tx(&unsign_tx);
    unsign_tx.signature = Some(hex::encode(signature));
    txs.push(unsign_tx.clone());

    unsign_tx.version = 2;
    unsign_tx.options = 1;
    unsign_tx.nonce += 1;

    let signature = wl.sign_tx(&unsign_tx);
    unsign_tx.signature = Some(hex::encode(signature));
    txs.push(unsign_tx.clone());

    let tx_hash = blockchain.send_transactions(&txs).await.unwrap();

    assert!(!tx_hash.is_empty());
    println!("tx_hashes {tx_hash:?}");
}

pub async fn send_transaction(&self, tx: &Transaction) -> Result<String>

Examples found in repository

examples/sign_tx.rs (line 35)

async fn main() {
    let wl = Wallet::from_private_key(
        "1648ad209d6b157a289884933e3bb30f161ec7113221ec16f87c3578b05830b0",
    )
    .unwrap();
    let addr = wl.to_address();
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let network_config = blockchain.get_network_config().await.unwrap();

    let arg = blockchain
        .get_default_transaction_arguments(&addr, &network_config)
        .await
        .unwrap();

    let mut unsign_tx = Transaction {
        nonce: arg.nonce,
        value: "0".to_string(),
        receiver: addr.to_bech32(&network_config.address_hrp),
        sender: addr.to_bech32(&network_config.address_hrp),
        gas_price: arg.gas_price,
        gas_limit: arg.gas_limit,
        data: arg.data,
        signature: None,
        chain_id: arg.chain_id,
        version: arg.version,
        options: arg.options,
    };

    let signature = wl.sign_tx(&unsign_tx);
    unsign_tx.signature = Some(hex::encode(signature));
    let tx_hash = blockchain.send_transaction(&unsign_tx).await.unwrap();

    assert!(!tx_hash.is_empty());
    println!("tx_hash {tx_hash}");
}

pub async fn send_transactions( &self, txs: &Vec<Transaction>, ) -> Result<Vec<String>>

Examples found in repository

examples/sign_txs.rs (line 47)

async fn main() {
    let wl = Wallet::from_private_key(
        "1648ad209d6b157a289884933e3bb30f161ec7113221ec16f87c3578b05830b0",
    )
    .unwrap();
    let addr = wl.to_address();
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let network_config = blockchain.get_network_config().await.unwrap();

    let arg = blockchain
        .get_default_transaction_arguments(&addr, &network_config)
        .await
        .unwrap();

    let mut unsign_tx = Transaction {
        nonce: arg.nonce,
        value: "1000000000000000000".to_string(),
        receiver: addr.to_bech32(&network_config.address_hrp),
        sender: addr.to_bech32(&network_config.address_hrp),
        gas_price: arg.gas_price,
        gas_limit: arg.gas_limit,
        data: arg.data,
        signature: None,
        chain_id: arg.chain_id,
        version: arg.version,
        options: arg.options,
    };

    let mut txs: Vec<Transaction> = vec![];

    let signature = wl.sign_tx(&unsign_tx);
    unsign_tx.signature = Some(hex::encode(signature));
    txs.push(unsign_tx.clone());

    unsign_tx.version = 2;
    unsign_tx.options = 1;
    unsign_tx.nonce += 1;

    let signature = wl.sign_tx(&unsign_tx);
    unsign_tx.signature = Some(hex::encode(signature));
    txs.push(unsign_tx.clone());

    let tx_hash = blockchain.send_transactions(&txs).await.unwrap();

    assert!(!tx_hash.is_empty());
    println!("tx_hashes {tx_hash:?}");
}

pub async fn execute_vmquery( &self, vm_request: &VMQueryInput, ) -> Result<VmValuesResponseData>

Examples found in repository

examples/vm_query.rs (line 15)

async fn main() {
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let sc_address = Bech32Address::from_bech32_string(
        "erd1qqqqqqqqqqqqqpgq5dvvkmka7sujfsx7cfmygnx0n7luv8k0d8sskpqcec".to_owned(),
    );
    let req = VMQueryInput {
        sc_address: sc_address.clone(),
        func_name: "empty".to_string(),
        args: vec![],
    };
    let result = blockchain.execute_vmquery(&req).await;
    assert!(result.is_ok());
    println!("{result:#?}");
}

impl GatewayHttpProxy

pub fn new(proxy_uri: String) -> Self

Examples found in repository

examples/get_hyper_block_latest.rs (line 5)

async fn main() {
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let result = blockchain.get_latest_hyper_block_nonce().await;

    assert!(result.is_ok());
    println!("latest block result: {result:?}")
}

examples/get_hyper_block_by_nonce.rs (line 5)

async fn main() {
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let result = blockchain.get_hyper_block_by_nonce(7468).await;

    assert!(result.is_ok());
    println!("block by nonce result: {result:#?}")
}

examples/get_network_config.rs (line 5)

async fn main() {
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let network_config = blockchain.get_network_config().await.unwrap();

    assert!(!network_config.chain_id.is_empty());
    println!("network_config: {network_config:#?}")
}

examples/get_network_economics.rs (line 5)

async fn main() {
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let network_economics = blockchain.get_network_economics().await.unwrap();

    assert!(!network_economics.dev_rewards.is_empty());
    println!("network_economics: {network_economics:#?}")
}

examples/get_hyper_block_by_hash.rs (line 5)

async fn main() {
    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let result = blockchain
        .get_hyper_block_by_hash("d59e0dc7d407b1175655357cb8056ec3bb77961192753cddda2fb700c6ce71c6")
        .await;

    assert!(result.is_ok());
    println!("block by hash result: {result:#?}");
}

examples/account.rs (line 10)

async fn main() {
    let addr = Bech32Address::from_bech32_string(
        "erd1qqqqqqqqqqqqqpgqfzydqmdw7m2vazsp6u5p95yxz76t2p9rd8ss0zp9ts".to_owned(),
    );

    let blockchain = GatewayHttpProxy::new(DEVNET_GATEWAY.to_string());
    let account = blockchain.get_account(&addr).await.unwrap();

    println!("account: {account:#?}");
}

Additional examples can be found in:

• examples/get_esdt_tokens.rs
• examples/account_storage.rs
• examples/vm_query.rs
• examples/tx_default_args.rs
• examples/tx_info.rs
• examples/tx_cost.rs
• examples/sign_tx.rs
• examples/sign_txs.rs

pub async fn http_request<G>(&self, request: G) -> Result<G::Result>

where G: GatewayRequest,

Performs a request to the gateway. Can be either GET or POST, depending on the argument.

Trait Implementations

impl Clone for GatewayHttpProxy

fn clone(&self) -> GatewayHttpProxy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GatewayHttpProxy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl GatewayAsyncService for GatewayHttpProxy

type Instant = Instant

Keeps track of elapsed time.

fn from_uri(uri: &str) -> Self

fn request<G>(&self, request: G) -> impl Future<Output = Result<G::Result>>

where G: GatewayRequest,

fn sleep(&self, millis: u64) -> impl Future<Output = ()>

fn now(&self) -> Self::Instant

fn elapsed_seconds(&self, instant: &Self::Instant) -> f32