multiversx_sc_snippets/interactor/interactor_scenario/
interactor_transfer.rs

1use std::process;
2
3use super::error_message::{simulate_gas_transfer_err_message, transfer_err_message};
4use crate::InteractorBase;
5use log::info;
6use multiversx_sc_scenario::{scenario::ScenarioRunner, scenario_model::TransferStep};
7use multiversx_sdk::{
8    data::transaction::Transaction,
9    gateway::{GatewayAsyncService, SendTxRequest, SimulateTxRequest},
10    retrieve_tx_on_network,
11};
12
13impl<GatewayProxy> InteractorBase<GatewayProxy>
14where
15    GatewayProxy: GatewayAsyncService,
16{
17    pub async fn transfer(&mut self, transfer_step: TransferStep) -> String {
18        let transaction = self.launch_transfer(&transfer_step).await;
19
20        let tx_hash = match self.proxy.request(SendTxRequest(&transaction)).await {
21            Ok(hash) => hash,
22            Err(err) => {
23                transfer_err_message(&err);
24                process::exit(1);
25            }
26        };
27        self.generate_blocks_until_tx_processed(&tx_hash)
28            .await
29            .unwrap();
30
31        println!("transfer tx hash: {tx_hash}");
32        info!("transfer tx hash: {}", tx_hash);
33
34        retrieve_tx_on_network(&self.proxy, tx_hash.clone()).await;
35
36        self.post_runners.run_transfer_step(&transfer_step);
37
38        tx_hash
39    }
40
41    pub async fn simulate_gas_transfer(&mut self, transfer_step: TransferStep) -> u64 {
42        let transaction = self.launch_transfer(&transfer_step).await;
43
44        let tx_gas_units = match self.proxy.request(SimulateTxRequest(&transaction)).await {
45            Ok(gas) => {
46                println!("Gas simulation for the SC transfer: {gas} units.");
47                log::info!("Gas simulation for the SC transfer: {gas} units.");
48                gas
49            }
50            Err(err) => {
51                simulate_gas_transfer_err_message(&err);
52                process::exit(1);
53            }
54        };
55
56        tx_gas_units
57    }
58
59    async fn launch_transfer(&mut self, transfer_step: &TransferStep) -> Transaction {
60        self.pre_runners.run_transfer_step(transfer_step);
61
62        let sender_address = &transfer_step.tx.from.value;
63        let mut transaction = self.tx_call_to_blockchain_tx(&transfer_step.tx.to_tx_call());
64        self.set_tx_nonce_update_sender(sender_address, &mut transaction)
65            .await;
66        self.sign_tx(sender_address, &mut transaction);
67
68        transaction
69    }
70}