Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

redesign idea for more customizability #1754

Closed
wants to merge 1 commit into from
Closed

redesign idea for more customizability #1754

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
148 changes: 76 additions & 72 deletions contracts/examples/adder/interact/src/basic_interact.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,6 +10,7 @@
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");

Check warning on line 13 in contracts/examples/adder/interact/src/basic_interact.rs

View workflow job for this annotation

GitHub Actions / clippy

[clippy] contracts/examples/adder/interact/src/basic_interact.rs#L13 

warning: constant `ERROR_NOT_OWNER` is never used
  --> contracts/examples/adder/interact/src/basic_interact.rs:13:7
   |
13 | const ERROR_NOT_OWNER: ExpectError = ExpectError(4u64, "upgrade is allowed only for owner");
   |       ^^^^^^^^^^^^^^^
   |
   = note: `#[warn(dead_code)]` on by default
Raw output 
contracts/examples/adder/interact/src/basic_interact.rs:13:7:w:warning: constant `ERROR_NOT_OWNER` is never used
  --> contracts/examples/adder/interact/src/basic_interact.rs:13:7
   |
13 | const ERROR_NOT_OWNER: ExpectError = ExpectError(4u64, "upgrade is allowed only for owner");
   |       ^^^^^^^^^^^^^^^
   |
   = note: `#[warn(dead_code)]` on by default


__END__

const ADDER_CODE_PATH: MxscPath = MxscPath::new("../output/adder.mxsc.json");

Expand All @@ -18,32 +19,41 @@
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 => {},
Expand All @@ -53,19 +63,16 @@
#[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"
Expand All @@ -79,31 +86,44 @@
);

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)
Expand All @@ -118,19 +138,18 @@
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)
Expand All @@ -151,14 +170,13 @@
}
}

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)
Expand All @@ -171,21 +189,21 @@
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()
.run()
.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)
Expand Down Expand Up @@ -216,40 +234,25 @@
&mut self,
new_value: u32,
sender: &Bech32Address,
expected_result: Option<(u64, &str)>,
expected_result: Option<ExpectError<'_>>,
) {
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
Expand All @@ -272,25 +275,26 @@
#[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
Expand Down
Loading