From af917db5993010b446b9a395cdbc802e7bf440b0 Mon Sep 17 00:00:00 2001 From: Mihai Calin Luca Date: Thu, 29 Aug 2024 15:00:18 +0300 Subject: [PATCH] refactor --- .../adder/interact/src/basic_interact.rs | 148 +++++++++--------- 1 file changed, 76 insertions(+), 72 deletions(-) diff --git a/contracts/examples/adder/interact/src/basic_interact.rs b/contracts/examples/adder/interact/src/basic_interact.rs index 93a00d4079..873cfd752a 100644 --- a/contracts/examples/adder/interact/src/basic_interact.rs +++ b/contracts/examples/adder/interact/src/basic_interact.rs @@ -10,6 +10,7 @@ use clap::Parser; use multiversx_sc_snippets::{imports::*, sdk::data::keystore::InsertPassword}; const INTERACTOR_SCENARIO_TRACE_PATH: &str = "interactor_trace.scen.json"; +const ERROR_NOT_OWNER: ExpectError = ExpectError(4u64, "upgrade is allowed only for owner"); const ADDER_CODE_PATH: MxscPath = MxscPath::new("../output/adder.mxsc.json"); @@ -18,32 +19,41 @@ async fn main() { env_logger::init(); let mut basic_interact = AdderInteract::init().await; + let accounts = Accounts::init(&mut basic_interact.interactor).await; + basic_interact.set_state(&accounts).await; let cli = basic_interact_cli::InteractCli::parse(); match &cli.command { Some(basic_interact_cli::InteractCliCommand::Add(args)) => { if args.count == 1 { - basic_interact.add(args.value).await; + basic_interact + .add(args.value, &accounts.adder_owner_address) + .await; } else { - basic_interact.multi_add(args.value, args.count).await; + basic_interact + .multi_add(args.value, args.count, &accounts.adder_owner_address) + .await; } }, Some(basic_interact_cli::InteractCliCommand::Deploy) => { - basic_interact.deploy().await; + basic_interact.deploy(&accounts.adder_owner_address).await; }, Some(basic_interact_cli::InteractCliCommand::Feed) => { - basic_interact.feed_contract_egld().await; + basic_interact + .feed_contract_egld(&accounts.adder_owner_address) + .await; }, Some(basic_interact_cli::InteractCliCommand::MultiDeploy(args)) => { - basic_interact.multi_deploy(args.count).await; + basic_interact + .multi_deploy(args.count, &accounts.adder_owner_address) + .await; }, Some(basic_interact_cli::InteractCliCommand::Sum) => { basic_interact.print_sum().await; }, Some(basic_interact_cli::InteractCliCommand::Upgrade(args)) => { - let owner_address = basic_interact.adder_owner_address.clone(); basic_interact - .upgrade(args.value, &owner_address, None) + .upgrade(args.value, &accounts.adder_owner_address, None) .await }, None => {}, @@ -53,19 +63,16 @@ async fn main() { #[allow(unused)] struct AdderInteract { interactor: Interactor, - adder_owner_address: Bech32Address, - wallet_address: Bech32Address, state: State, } -impl AdderInteract { - async fn init() -> Self { - let config = Config::load_config(); - let mut interactor = Interactor::new(config.gateway()) - .await - .with_tracer(INTERACTOR_SCENARIO_TRACE_PATH) - .await; +struct Accounts { + adder_owner_address: Bech32Address, + wallet_address: Bech32Address, +} +impl Accounts { + async fn init(interactor: &mut Interactor) -> Self { let adder_owner_address = interactor.register_wallet(Wallet::from_pem_file("adder-owner.pem").unwrap()); // PASSWORD: "alice" @@ -79,31 +86,44 @@ impl AdderInteract { ); Self { - interactor, adder_owner_address: adder_owner_address.into(), wallet_address: wallet_address.into(), + } + } +} + +impl AdderInteract { + async fn init() -> Self { + let config = Config::load_config(); + let interactor = Interactor::new(config.gateway()) + .await + .with_tracer(INTERACTOR_SCENARIO_TRACE_PATH) + .await; + + Self { + interactor, state: State::load_state(), } } - async fn set_state(&mut self) { - println!("wallet address: {}", self.wallet_address); + async fn set_state(&mut self, accounts: &Accounts) { + println!("wallet address: {}", accounts.wallet_address); self.interactor - .retrieve_account(&self.adder_owner_address) + .retrieve_account(&accounts.adder_owner_address) + .await; + self.interactor + .retrieve_account(&accounts.wallet_address) .await; - self.interactor.retrieve_account(&self.wallet_address).await; } - async fn deploy(&mut self) { + async fn deploy(&mut self, from: &Bech32Address) { // warning: multi deploy not yet fully supported // only works with last deployed address - self.set_state().await; - let new_address = self .interactor .tx() - .from(&self.adder_owner_address) + .from(from) .gas(6_000_000) .typed(adder_proxy::AdderProxy) .init(0u32) @@ -118,19 +138,18 @@ impl AdderInteract { self.state.set_adder_address(new_address); } - async fn multi_deploy(&mut self, count: usize) { + async fn multi_deploy(&mut self, count: usize, from: &Bech32Address) { if count == 0 { println!("count must be greater than 0"); return; } - self.set_state().await; println!("deploying {count} contracts..."); let mut buffer = self.interactor.homogenous_call_buffer(); for _ in 0..count { buffer.push_tx(|tx| { - tx.from(&self.wallet_address) + tx.from(from) .typed(adder_proxy::AdderProxy) .init(0u32) .code(ADDER_CODE_PATH) @@ -151,14 +170,13 @@ impl AdderInteract { } } - async fn multi_add(&mut self, value: u32, count: usize) { - self.set_state().await; + async fn multi_add(&mut self, value: u32, count: usize, from: &Bech32Address) { println!("calling contract {count} times..."); let mut buffer = self.interactor.homogenous_call_buffer(); for _ in 0..count { buffer.push_tx(|tx| { - tx.from(&self.wallet_address) + tx.from(from) .to(self.state.current_adder_address()) .typed(adder_proxy::AdderProxy) .add(value) @@ -171,10 +189,10 @@ impl AdderInteract { println!("successfully performed add {count} times"); } - async fn feed_contract_egld(&mut self) { + async fn feed_contract_egld(&mut self, from: &Bech32Address) { self.interactor .tx() - .from(&self.wallet_address) + .from(from) .to(self.state.current_adder_address()) .egld(NumExpr("0,050000000000000000")) .prepare_async() @@ -182,10 +200,10 @@ impl AdderInteract { .await; } - async fn add(&mut self, value: u32) { + async fn add(&mut self, value: u32, from: &Bech32Address) { self.interactor .tx() - .from(&self.wallet_address) + .from(from) .to(self.state.current_adder_address()) .gas(6_000_000) .typed(adder_proxy::AdderProxy) @@ -216,40 +234,25 @@ impl AdderInteract { &mut self, new_value: u32, sender: &Bech32Address, - expected_result: Option<(u64, &str)>, + expected_result: Option>, ) { - match expected_result { - Some((code, msg)) => { - let response = self - .interactor - .tx() - .from(sender) - .to(self.state.current_adder_address()) - .gas(6_000_000) - .typed(adder_proxy::AdderProxy) - .upgrade(BigUint::from(new_value)) - .code_metadata(CodeMetadata::UPGRADEABLE) - .code(ADDER_CODE_PATH) - .returns(ExpectError(code, msg)) - .prepare_async() - .run() - .await; + let transaction = self + .interactor + .tx() + .from(sender) + .to(self.state.current_adder_address()) + .gas(6_000_000) + .typed(adder_proxy::AdderProxy) + .upgrade(BigUint::from(new_value)) + .code_metadata(CodeMetadata::UPGRADEABLE) + .code(ADDER_CODE_PATH); - println!("response: {response:?}"); + match expected_result { + Some(error) => { + transaction.returns(error).prepare_async().run().await; }, None => { - self.interactor - .tx() - .from(sender) - .to(self.state.current_adder_address()) - .gas(6_000_000) - .typed(adder_proxy::AdderProxy) - .upgrade(BigUint::from(new_value)) - .code_metadata(CodeMetadata::UPGRADEABLE) - .code(ADDER_CODE_PATH) - .prepare_async() - .run() - .await; + transaction.prepare_async().run().await; let sum = self .interactor @@ -272,25 +275,26 @@ impl AdderInteract { #[ignore = "run on demand"] async fn upgrade_test() { let mut basic_interact = AdderInteract::init().await; - let wallet_address = basic_interact.wallet_address.clone(); - let adder_owner_address = basic_interact.adder_owner_address.clone(); - let error_not_owner = (4, "upgrade is allowed only for owner"); + let accounts = Accounts::init(&mut basic_interact.interactor).await; + basic_interact.set_state(&accounts).await; - basic_interact.deploy().await; - basic_interact.add(1u32).await; + basic_interact.deploy(&accounts.adder_owner_address).await; + basic_interact + .add(1u32, &accounts.adder_owner_address) + .await; // Sum will be 1 basic_interact.print_sum().await; basic_interact - .upgrade(7u32, &adder_owner_address, None) + .upgrade(7u32, &accounts.adder_owner_address, None) .await; // Sum will be the updated value of 7 basic_interact.print_sum().await; basic_interact - .upgrade(10u32, &wallet_address, Some(error_not_owner)) + .upgrade(10u32, &accounts.wallet_address, Some(ERROR_NOT_OWNER)) .await; // Sum will remain 7