multiversx_sdk_http/gateway_http_proxy/
http_tx.rs

1use anyhow::Result;
2use multiversx_sdk::{
3    chain_core::types::Address,
4    data::{
5        network_config::NetworkConfig,
6        sdk_address::SdkAddress,
7        transaction::{
8            ArgCreateTransaction, Transaction, TransactionOnNetwork, TxCostResponseData,
9        },
10        vm::{VMQueryInput, VmValuesResponseData},
11    },
12    gateway::{
13        GetTxCost, GetTxInfo, GetTxProcessStatus, GetTxStatus, SendMultiTxRequest, SendTxRequest,
14        VMQueryRequest,
15    },
16};
17
18use super::GatewayHttpProxy;
19
20impl GatewayHttpProxy {
21    // request_transaction_cost retrieves how many gas a transaction will consume
22    pub async fn request_transaction_cost(&self, tx: &Transaction) -> Result<TxCostResponseData> {
23        self.http_request(GetTxCost(tx)).await
24    }
25
26    // get_transaction_info retrieves a transaction's details from the network
27    pub async fn get_transaction_info(&self, hash: &str) -> Result<TransactionOnNetwork> {
28        self.http_request(GetTxInfo::new(hash)).await
29    }
30
31    // get_transaction_info_with_results retrieves a transaction's details from the network with events
32    pub async fn get_transaction_info_with_results(
33        &self,
34        hash: &str,
35    ) -> Result<TransactionOnNetwork> {
36        self.http_request(GetTxInfo::new(hash).with_results()).await
37    }
38
39    // get_transaction_status retrieves a transaction's status from the network
40    pub async fn get_transaction_status(&self, hash: &str) -> Result<String> {
41        self.http_request(GetTxStatus::new(hash)).await
42    }
43
44    // get_transaction_process_status retrieves a transaction's status from the network using process-status API
45    pub async fn get_transaction_process_status(&self, hash: &str) -> Result<(String, String)> {
46        self.http_request(GetTxProcessStatus::new(hash)).await
47    }
48
49    // get_default_transaction_arguments will prepare the transaction creation argument by querying the account's info
50    pub async fn get_default_transaction_arguments(
51        &self,
52        address: &Address,
53        network_configs: &NetworkConfig,
54    ) -> Result<ArgCreateTransaction> {
55        let account = self.get_account(address).await?;
56
57        Ok(ArgCreateTransaction {
58            nonce: account.nonce,
59            value: "".to_string(),
60            rcv_addr: SdkAddress(address.clone()),
61            snd_addr: SdkAddress(address.clone()),
62            gas_price: network_configs.min_gas_price,
63            gas_limit: network_configs.min_gas_limit,
64            data: None,
65            signature: "".to_string(),
66            chain_id: network_configs.chain_id.clone(),
67            version: network_configs.min_transaction_version,
68            options: 0,
69            available_balance: account.balance,
70        })
71    }
72
73    pub async fn send_transaction(&self, tx: &Transaction) -> Result<String> {
74        self.http_request(SendTxRequest(tx)).await
75    }
76
77    #[allow(clippy::ptr_arg)]
78    pub async fn send_transactions(&self, txs: &Vec<Transaction>) -> Result<Vec<String>> {
79        self.http_request(SendMultiTxRequest(txs)).await
80    }
81
82    // execute_vmquery retrieves data from existing SC trie through the use of a VM
83    pub async fn execute_vmquery(&self, vm_request: &VMQueryInput) -> Result<VmValuesResponseData> {
84        self.http_request(VMQueryRequest(vm_request)).await
85    }
86}