drt_sc_snippets/interactor_scenario/
interactor_sc_call.rs

1use crate::{address_h256_to_moars, denali_to_moars_address, network_response, Interactor};
2use log::info;
3use drt_sc_scenario::{
4    api::StaticApi,
5    scenario::ScenarioRunner,
6    scenario_model::{ScCallStep, SetStateStep, TxCall},
7};
8use drt_sdk::{data::transaction::Transaction, utils::base64_encode};
9
10impl Interactor {
11    pub async fn sc_call<S>(&mut self, mut sc_call_step: S)
12    where
13        S: AsMut<ScCallStep>,
14    {
15        let sc_call_step = sc_call_step.as_mut();
16        let tx_hash = self.launch_sc_call(sc_call_step).await;
17        let tx = self.proxy.retrieve_tx_on_network(tx_hash.clone()).await;
18
19        sc_call_step.save_response(network_response::parse_tx_response(tx));
20
21        if let Some(token_identifier) = sc_call_step.response().new_issued_token_identifier.clone()
22        {
23            println!("token identifier: {}", token_identifier);
24            let set_state_step = SetStateStep::new().new_token_identifier(token_identifier);
25
26            self.pre_runners.run_set_state_step(&set_state_step);
27            self.post_runners.run_set_state_step(&set_state_step);
28        }
29
30        self.post_runners.run_sc_call_step(sc_call_step);
31    }
32
33    async fn launch_sc_call(&mut self, sc_call_step: &mut ScCallStep) -> String {
34        self.pre_runners.run_sc_call_step(sc_call_step);
35
36        let sender_address = &sc_call_step.tx.from.value;
37        let mut transaction = self.tx_call_to_blockchain_tx(&sc_call_step.tx);
38        self.set_nonce_and_sign_tx(sender_address, &mut transaction)
39            .await;
40        let tx_hash = self.proxy.send_transaction(&transaction).await.unwrap();
41        println!("sc call tx hash: {tx_hash}");
42        info!("sc call tx hash: {}", tx_hash);
43
44        tx_hash
45    }
46
47    #[allow(deprecated)] // TODO
48    pub(crate) fn tx_call_to_blockchain_tx(&self, tx_call: &TxCall) -> Transaction {
49        let contract_call = tx_call.to_contract_call();
50        let contract_call_tx_data = contract_call_to_tx_data(&contract_call);
51        let data = if contract_call_tx_data.is_empty() {
52            None
53        } else {
54            Some(String::from_utf8(base64_encode(contract_call_tx_data).into()).unwrap())
55        };
56
57        Transaction {
58            nonce: 0,
59            value: contract_call.rewa_payment.to_alloc().to_string(),
60            sender: denali_to_moars_address(&tx_call.from),
61            receiver: address_h256_to_moars(&contract_call.basic.to.to_address()),
62            gas_price: self.network_config.min_gas_price,
63            gas_limit: tx_call.gas_limit.value,
64            data,
65            signature: None,
66            chain_id: self.network_config.chain_id.clone(),
67            version: self.network_config.min_transaction_version,
68            options: 0,
69        }
70    }
71}
72
73#[allow(deprecated)] // TODO
74fn contract_call_to_tx_data(
75    contract_call: &drt_sc_scenario::imports::ContractCallWithRewa<StaticApi, ()>,
76) -> String {
77    let mut result = String::from_utf8(
78        contract_call
79            .basic
80            .function_call
81            .function_name
82            .to_boxed_bytes()
83            .into_vec(),
84    )
85    .unwrap();
86    for argument in contract_call.basic.function_call.arg_buffer.raw_arg_iter() {
87        result.push('@');
88        result.push_str(hex::encode(argument.to_boxed_bytes().as_slice()).as_str());
89    }
90    result
91}