From 13e283f67684aea27ec98be067854eae947094c0 Mon Sep 17 00:00:00 2001 From: Mihai Calin Luca Date: Thu, 11 Apr 2024 17:53:09 +0200 Subject: [PATCH] scenario test contract added in feature tests --- Cargo.lock | 16 ++ Cargo.toml | 3 + .../feature-tests/scenario-tester/.gitignore | 10 + .../feature-tests/scenario-tester/Cargo.toml | 17 ++ .../feature-tests/scenario-tester/README.md | 3 + .../scenario-tester/interact/.gitignore | 8 + .../scenario-tester/interact/Cargo.toml | 22 +++ .../scenario-tester/interact/config.toml | 1 + .../interact/src/basic_interact.rs | 172 ++++++++++++++++++ .../interact/src/basic_interact_cli.rs | 39 ++++ .../interact/src/basic_interact_config.rs | 26 +++ .../interact/src/basic_interact_state.rs | 50 +++++ .../interaction/devnet.snippets.sh | 25 +++ .../interaction/testnet.snippets.sh | 26 +++ .../scenario-tester/meta/Cargo.toml | 13 ++ .../scenario-tester/meta/src/main.rs | 3 + .../scenario-tester/multiversx.json | 3 + .../scenario-tester/mxsc-template.toml | 24 +++ .../scenario-tester/sc-config.toml | 4 + .../scenario-tester/scenarios/adder.scen.json | 99 ++++++++++ .../scenarios/interactor_trace.scen.json | 76 ++++++++ .../feature-tests/scenario-tester/src/lib.rs | 30 +++ .../src/scenario_tester_proxy.rs | 110 +++++++++++ .../tests/adder_blackbox_chained_test.rs | 64 +++++++ .../tests/adder_blackbox_legacy_proxy_test.rs | 77 ++++++++ .../tests/adder_blackbox_raw_steps_test.rs | 53 ++++++ .../tests/adder_blackbox_test.rs | 72 ++++++++ .../tests/adder_blackbox_upgrade_test.rs | 50 +++++ .../tests/adder_scenario_go_test.rs | 15 ++ .../tests/adder_scenario_rs_test.rs | 19 ++ .../scenario-tester/tests/adder_unit_test.rs | 17 ++ .../tests/adder_whitebox_test.rs | 50 +++++ .../scenario-tester/wasm/Cargo.lock | 170 +++++++++++++++++ .../scenario-tester/wasm/Cargo.toml | 32 ++++ .../scenario-tester/wasm/src/lib.rs | 30 +++ 35 files changed, 1429 insertions(+) create mode 100644 contracts/feature-tests/scenario-tester/.gitignore create mode 100644 contracts/feature-tests/scenario-tester/Cargo.toml create mode 100644 contracts/feature-tests/scenario-tester/README.md create mode 100644 contracts/feature-tests/scenario-tester/interact/.gitignore create mode 100644 contracts/feature-tests/scenario-tester/interact/Cargo.toml create mode 100644 contracts/feature-tests/scenario-tester/interact/config.toml create mode 100644 contracts/feature-tests/scenario-tester/interact/src/basic_interact.rs create mode 100644 contracts/feature-tests/scenario-tester/interact/src/basic_interact_cli.rs create mode 100644 contracts/feature-tests/scenario-tester/interact/src/basic_interact_config.rs create mode 100644 contracts/feature-tests/scenario-tester/interact/src/basic_interact_state.rs create mode 100644 contracts/feature-tests/scenario-tester/interaction/devnet.snippets.sh create mode 100644 contracts/feature-tests/scenario-tester/interaction/testnet.snippets.sh create mode 100644 contracts/feature-tests/scenario-tester/meta/Cargo.toml create mode 100644 contracts/feature-tests/scenario-tester/meta/src/main.rs create mode 100644 contracts/feature-tests/scenario-tester/multiversx.json create mode 100644 contracts/feature-tests/scenario-tester/mxsc-template.toml create mode 100644 contracts/feature-tests/scenario-tester/sc-config.toml create mode 100644 contracts/feature-tests/scenario-tester/scenarios/adder.scen.json create mode 100644 contracts/feature-tests/scenario-tester/scenarios/interactor_trace.scen.json create mode 100644 contracts/feature-tests/scenario-tester/src/lib.rs create mode 100644 contracts/feature-tests/scenario-tester/src/scenario_tester_proxy.rs create mode 100644 contracts/feature-tests/scenario-tester/tests/adder_blackbox_chained_test.rs create mode 100644 contracts/feature-tests/scenario-tester/tests/adder_blackbox_legacy_proxy_test.rs create mode 100644 contracts/feature-tests/scenario-tester/tests/adder_blackbox_raw_steps_test.rs create mode 100644 contracts/feature-tests/scenario-tester/tests/adder_blackbox_test.rs create mode 100644 contracts/feature-tests/scenario-tester/tests/adder_blackbox_upgrade_test.rs create mode 100644 contracts/feature-tests/scenario-tester/tests/adder_scenario_go_test.rs create mode 100644 contracts/feature-tests/scenario-tester/tests/adder_scenario_rs_test.rs create mode 100644 contracts/feature-tests/scenario-tester/tests/adder_unit_test.rs create mode 100644 contracts/feature-tests/scenario-tester/tests/adder_whitebox_test.rs create mode 100755 contracts/feature-tests/scenario-tester/wasm/Cargo.lock create mode 100644 contracts/feature-tests/scenario-tester/wasm/Cargo.toml create mode 100644 contracts/feature-tests/scenario-tester/wasm/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index a63206b567..9ad27741d0 100755 --- a/Cargo.lock +++ b/Cargo.lock @@ -2755,6 +2755,22 @@ dependencies = [ "winapi-util", ] +[[package]] +name = "scenario-tester-meta" +version = "0.0.0" +dependencies = [ + "multiversx-sc-meta", + "scenario_tester", +] + +[[package]] +name = "scenario_tester" +version = "0.0.0" +dependencies = [ + "multiversx-sc", + "multiversx-sc-scenario", +] + [[package]] name = "schannel" version = "0.1.23" diff --git a/Cargo.toml b/Cargo.toml index d97f1292e0..459624af85 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -178,4 +178,7 @@ members = [ "contracts/feature-tests/exchange-features", "contracts/feature-tests/exchange-features/meta", + "contracts/feature-tests/scenario-tester", + "contracts/feature-tests/scenario-tester/meta" + ] diff --git a/contracts/feature-tests/scenario-tester/.gitignore b/contracts/feature-tests/scenario-tester/.gitignore new file mode 100644 index 0000000000..dd49a95243 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/.gitignore @@ -0,0 +1,10 @@ +# Generated by Cargo +# will have compiled files and executables +/target/ +*/target/ + +# The mxpy output +/output*/ + +# Mandos test trace +trace*.scen.json diff --git a/contracts/feature-tests/scenario-tester/Cargo.toml b/contracts/feature-tests/scenario-tester/Cargo.toml new file mode 100644 index 0000000000..a8faf14f1c --- /dev/null +++ b/contracts/feature-tests/scenario-tester/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "scenario_tester" +version = "0.0.0" +authors = ["Andrei Marinica "] +edition = "2021" +publish = false + +[lib] +path = "src/lib.rs" + +[dependencies.multiversx-sc] +version = "0.49.0-alpha.2" +path = "../../../framework/base" + +[dev-dependencies.multiversx-sc-scenario] +version = "0.49.0-alpha.2" +path = "../../../framework/scenario" diff --git a/contracts/feature-tests/scenario-tester/README.md b/contracts/feature-tests/scenario-tester/README.md new file mode 100644 index 0000000000..4538caeca9 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/README.md @@ -0,0 +1,3 @@ +# Adder + +`Adder` is a simple Smart Contract. diff --git a/contracts/feature-tests/scenario-tester/interact/.gitignore b/contracts/feature-tests/scenario-tester/interact/.gitignore new file mode 100644 index 0000000000..ea1b920080 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/interact/.gitignore @@ -0,0 +1,8 @@ +# Pem files are used for interactions, but shouldn't be committed +*.pem + +# Temporary storage of deployed contract address, so we can preserve the context between executions. +state.toml + +# Trace file of interactor tooling +interactor_trace.scen.json diff --git a/contracts/feature-tests/scenario-tester/interact/Cargo.toml b/contracts/feature-tests/scenario-tester/interact/Cargo.toml new file mode 100644 index 0000000000..dc6a5533ea --- /dev/null +++ b/contracts/feature-tests/scenario-tester/interact/Cargo.toml @@ -0,0 +1,22 @@ +[package] +name = "basic-interact" +version = "0.0.0" +authors = ["Ovidiu Stinga "] +edition = "2021" +publish = false + +[[bin]] +name = "basic-interact" +path = "src/basic_interact.rs" + +[dependencies] +clap = { version = "4.4.7", features = ["derive"] } +serde = { version = "1.0", features = ["derive"] } +toml = "0.8.6" + +[dependencies.adder] +path = ".." + +[dependencies.multiversx-sc-snippets] +version = "0.49.0-alpha.2" +path = "../../../../framework/snippets" diff --git a/contracts/feature-tests/scenario-tester/interact/config.toml b/contracts/feature-tests/scenario-tester/interact/config.toml new file mode 100644 index 0000000000..61ac8dbf87 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/interact/config.toml @@ -0,0 +1 @@ +gateway = 'https://devnet-gateway.multiversx.com' diff --git a/contracts/feature-tests/scenario-tester/interact/src/basic_interact.rs b/contracts/feature-tests/scenario-tester/interact/src/basic_interact.rs new file mode 100644 index 0000000000..8a8a6c22fd --- /dev/null +++ b/contracts/feature-tests/scenario-tester/interact/src/basic_interact.rs @@ -0,0 +1,172 @@ +mod basic_interact_cli; +mod basic_interact_config; +mod basic_interact_state; + +use adder::adder_proxy; +use basic_interact_config::Config; +use basic_interact_state::State; +use clap::Parser; + +use multiversx_sc_snippets::imports::*; + +const INTERACTOR_SCENARIO_TRACE_PATH: &str = "interactor_trace.scen.json"; + +#[tokio::main] +async fn main() { + env_logger::init(); + + let mut basic_interact = AdderInteract::init().await; + + let cli = basic_interact_cli::InteractCli::parse(); + match &cli.command { + Some(basic_interact_cli::InteractCliCommand::Add(args)) => { + basic_interact.add(args.value).await; + }, + Some(basic_interact_cli::InteractCliCommand::Deploy) => { + basic_interact.deploy().await; + }, + Some(basic_interact_cli::InteractCliCommand::Feed) => { + basic_interact.feed_contract_egld().await; + }, + Some(basic_interact_cli::InteractCliCommand::MultiDeploy(args)) => { + basic_interact.multi_deploy(&args.count).await; + }, + Some(basic_interact_cli::InteractCliCommand::Sum) => { + basic_interact.print_sum().await; + }, + None => {}, + } +} + +#[allow(unused)] +struct AdderInteract { + interactor: Interactor, + wallet_address: Bech32Address, + adder_code: BytesValue, + 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; + let wallet_address = interactor.register_wallet(test_wallets::mike()); + let adder_code = BytesValue::interpret_from( + "mxsc:../output/adder.mxsc.json", + &InterpreterContext::default(), + ); + + Self { + interactor, + wallet_address: wallet_address.into(), + adder_code, + state: State::load_state(), + } + } + + async fn set_state(&mut self) { + println!("wallet address: {}", &self.wallet_address); + let scenario_raw = retrieve_account_as_scenario_set_state( + Config::load_config().gateway().to_string(), + self.wallet_address.to_bech32_string(), + true, + ) + .await; + + let scenario = Scenario::interpret_from(scenario_raw, &InterpreterContext::default()); + + self.interactor.pre_runners.run_scenario(&scenario); + self.interactor.post_runners.run_scenario(&scenario); + } + + async fn deploy(&mut self) { + self.set_state().await; + + let new_address = self + .interactor + .tx() + .from(&self.wallet_address) + .typed(adder_proxy::AdderProxy) + .init(0u32) + .code(&self.adder_code) + .returns(ReturnsNewBech32Address) + .prepare_async() + .run() + .await; + + println!("new address: {new_address}"); + self.state.set_adder_address(new_address); + } + + async fn multi_deploy(&mut self, count: &u8) { + 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) + .typed(adder_proxy::AdderProxy) + .init(0u32) + .code(&self.adder_code) + .gas(NumExpr("70,000,000")) + .returns(ReturnsNewBech32Address) + }); + } + + let results = buffer.run().await; + for new_address in results { + println!("new address: {new_address}"); + + self.state.set_adder_address(new_address); + } + } + + async fn feed_contract_egld(&mut self) { + self.interactor + .tx() + .from(&self.wallet_address) + .to(self.state.current_adder_address()) + .egld(NumExpr("0,050000000000000000")) + .prepare_async() + .run() + .await; + } + + async fn add(&mut self, value: u64) { + self.interactor + .tx() + .from(&self.wallet_address) + .to(self.state.current_adder_address()) + .typed(adder_proxy::AdderProxy) + .add(value) + .prepare_async() + .run() + .await; + + println!("successfully performed add"); + } + + async fn print_sum(&mut self) { + let sum = self + .interactor + .query() + .to(self.state.current_adder_address()) + .typed(adder_proxy::AdderProxy) + .sum() + .returns(ReturnsResultConv::::new()) + .prepare_async() + .run() + .await; + + println!("sum: {sum}"); + } +} diff --git a/contracts/feature-tests/scenario-tester/interact/src/basic_interact_cli.rs b/contracts/feature-tests/scenario-tester/interact/src/basic_interact_cli.rs new file mode 100644 index 0000000000..8818c1bb60 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/interact/src/basic_interact_cli.rs @@ -0,0 +1,39 @@ +use clap::{Args, Parser, Subcommand}; + +/// Adder Interact CLI +#[derive(Default, PartialEq, Eq, Debug, Parser)] +#[command(version, about)] +#[command(propagate_version = true)] +pub struct InteractCli { + #[command(subcommand)] + pub command: Option, +} + +/// Adder Interact CLI Commands +#[derive(Clone, PartialEq, Eq, Debug, Subcommand)] +pub enum InteractCliCommand { + #[command(name = "add", about = "Add value")] + Add(AddArgs), + #[command(name = "deploy", about = "Deploy contract")] + Deploy, + #[command(name = "feed", about = "Feed contract EGLD")] + Feed, + #[command(name = "multi-deploy", about = "Multiple deploy contracts")] + MultiDeploy(MultiDeployArgs), + #[command(name = "sum", about = "Print sum")] + Sum, +} + +#[derive(Default, Clone, PartialEq, Eq, Debug, Args)] +pub struct AddArgs { + /// The value to add + #[arg(short = 'v', long = "value", verbatim_doc_comment)] + pub value: u64, +} + +#[derive(Default, Clone, PartialEq, Eq, Debug, Args)] +pub struct MultiDeployArgs { + /// The number of contracts to deploy + #[arg(short = 'c', long = "count", verbatim_doc_comment)] + pub count: u8, +} diff --git a/contracts/feature-tests/scenario-tester/interact/src/basic_interact_config.rs b/contracts/feature-tests/scenario-tester/interact/src/basic_interact_config.rs new file mode 100644 index 0000000000..e17d0cbe65 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/interact/src/basic_interact_config.rs @@ -0,0 +1,26 @@ +use serde::Deserialize; +use std::io::Read; + +/// Config file +const CONFIG_FILE: &str = "config.toml"; + +/// Adder Interact configuration +#[derive(Debug, Deserialize)] +pub struct Config { + gateway: String, +} + +impl Config { + // Deserializes config from file + pub fn load_config() -> Self { + let mut file = std::fs::File::open(CONFIG_FILE).unwrap(); + let mut content = String::new(); + file.read_to_string(&mut content).unwrap(); + toml::from_str(&content).unwrap() + } + + // Returns the gateway + pub fn gateway(&self) -> &str { + &self.gateway + } +} diff --git a/contracts/feature-tests/scenario-tester/interact/src/basic_interact_state.rs b/contracts/feature-tests/scenario-tester/interact/src/basic_interact_state.rs new file mode 100644 index 0000000000..41453e36fd --- /dev/null +++ b/contracts/feature-tests/scenario-tester/interact/src/basic_interact_state.rs @@ -0,0 +1,50 @@ +use multiversx_sc_snippets::imports::*; +use serde::{Deserialize, Serialize}; +use std::{ + io::{Read, Write}, + path::Path, +}; + +/// State file +const STATE_FILE: &str = "state.toml"; + +/// Multisig Interact state +#[derive(Debug, Default, Serialize, Deserialize)] +pub struct State { + adder_address: Option, +} + +impl State { + // Deserializes state from file + pub fn load_state() -> Self { + if Path::new(STATE_FILE).exists() { + let mut file = std::fs::File::open(STATE_FILE).unwrap(); + let mut content = String::new(); + file.read_to_string(&mut content).unwrap(); + toml::from_str(&content).unwrap() + } else { + Self::default() + } + } + + /// Sets the adder address + pub fn set_adder_address(&mut self, address: Bech32Address) { + self.adder_address = Some(address); + } + + /// Returns the adder contract + pub fn current_adder_address(&self) -> &Bech32Address { + self.adder_address + .as_ref() + .expect("no known adder contract, deploy first") + } +} + +impl Drop for State { + // Serializes state to file + fn drop(&mut self) { + let mut file = std::fs::File::create(STATE_FILE).unwrap(); + file.write_all(toml::to_string(self).unwrap().as_bytes()) + .unwrap(); + } +} diff --git a/contracts/feature-tests/scenario-tester/interaction/devnet.snippets.sh b/contracts/feature-tests/scenario-tester/interaction/devnet.snippets.sh new file mode 100644 index 0000000000..1966381cde --- /dev/null +++ b/contracts/feature-tests/scenario-tester/interaction/devnet.snippets.sh @@ -0,0 +1,25 @@ +ALICE="${USERS}/alice.pem" +ADDRESS=$(mxpy data load --key=address-devnet) +DEPLOY_TRANSACTION=$(mxpy data load --key=deployTransaction-devnet) + +deploy() { + mxpy --verbose contract deploy --project=${PROJECT} --recall-nonce --pem=${ALICE} --gas-limit=50000000 --arguments 0 --send --outfile="deploy-devnet.interaction.json" || return + + TRANSACTION=$(mxpy data parse --file="deploy-devnet.interaction.json" --expression="data['emittedTransactionHash']") + ADDRESS=$(mxpy data parse --file="deploy-devnet.interaction.json" --expression="data['contractAddress']") + + mxpy data store --key=address-devnet --value=${ADDRESS} + mxpy data store --key=deployTransaction-devnet --value=${TRANSACTION} + + echo "" + echo "Smart contract address: ${ADDRESS}" +} + +add() { + read -p "Enter number: " NUMBER + mxpy --verbose contract call ${ADDRESS} --recall-nonce --pem=${ALICE} --gas-limit=50000000 --function="add" --arguments ${NUMBER} --send +} + +getSum() { + mxpy --verbose contract query ${ADDRESS} --function="getSum" +} diff --git a/contracts/feature-tests/scenario-tester/interaction/testnet.snippets.sh b/contracts/feature-tests/scenario-tester/interaction/testnet.snippets.sh new file mode 100644 index 0000000000..06bb13e3ba --- /dev/null +++ b/contracts/feature-tests/scenario-tester/interaction/testnet.snippets.sh @@ -0,0 +1,26 @@ +ALICE="${USERS}/alice.pem" +ADDRESS=$(mxpy data load --key=address-testnet) +DEPLOY_TRANSACTION=$(mxpy data load --key=deployTransaction-testnet) +PROXY=https://testnet-api.multiversx.com + +deploy() { + mxpy --verbose contract deploy --project=${PROJECT} --recall-nonce --pem=${ALICE} --gas-limit=50000000 --arguments 0 --send --outfile="deploy-testnet.interaction.json" --proxy=${PROXY} --chain=T || return + + TRANSACTION=$(mxpy data parse --file="deploy-testnet.interaction.json" --expression="data['emittedTransactionHash']") + ADDRESS=$(mxpy data parse --file="deploy-testnet.interaction.json" --expression="data['contractAddress']") + + mxpy data store --key=address-testnet --value=${ADDRESS} + mxpy data store --key=deployTransaction-testnet --value=${TRANSACTION} + + echo "" + echo "Smart contract address: ${ADDRESS}" +} + +add() { + read -p "Enter number: " NUMBER + mxpy --verbose contract call ${ADDRESS} --recall-nonce --pem=${ALICE} --gas-limit=5000000 --function="add" --arguments ${NUMBER} --send --proxy=${PROXY} --chain=T +} + +getSum() { + mxpy --verbose contract query ${ADDRESS} --function="getSum" --proxy=${PROXY} +} diff --git a/contracts/feature-tests/scenario-tester/meta/Cargo.toml b/contracts/feature-tests/scenario-tester/meta/Cargo.toml new file mode 100644 index 0000000000..5962cb3d93 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/meta/Cargo.toml @@ -0,0 +1,13 @@ +[package] +name = "scenario-tester-meta" +version = "0.0.0" +edition = "2021" +publish = false + +[dependencies.scenario_tester] +path = ".." + +[dependencies.multiversx-sc-meta] +version = "0.49.0-alpha.2" +path = "../../../../framework/meta" +default-features = false diff --git a/contracts/feature-tests/scenario-tester/meta/src/main.rs b/contracts/feature-tests/scenario-tester/meta/src/main.rs new file mode 100644 index 0000000000..d88f5e7545 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/meta/src/main.rs @@ -0,0 +1,3 @@ +fn main() { + multiversx_sc_meta::cli_main::(); +} diff --git a/contracts/feature-tests/scenario-tester/multiversx.json b/contracts/feature-tests/scenario-tester/multiversx.json new file mode 100644 index 0000000000..7365539625 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/multiversx.json @@ -0,0 +1,3 @@ +{ + "language": "rust" +} \ No newline at end of file diff --git a/contracts/feature-tests/scenario-tester/mxsc-template.toml b/contracts/feature-tests/scenario-tester/mxsc-template.toml new file mode 100644 index 0000000000..f7a17bd7a8 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/mxsc-template.toml @@ -0,0 +1,24 @@ +name = "scenario_tester" +contract_trait = "Adder" +src_file = "adder.rs" +rename_pairs = [ + [ + "blockchain.set_current_dir_from_workspace(\"contracts/examples/adder\");", + "// blockchain.set_current_dir_from_workspace(\"relative path to your workspace, if applicable\");", + ], +] +files_include = [ + "meta", + "scenarios", + "src", + "tests", + "Cargo.toml", + "README.md", + "sc-config.toml", + "multiversx.json", + "interact/Cargo.toml", + "interact/config.toml", + "interact/.gitignore", + "interact/src", +] +has_interactor = true diff --git a/contracts/feature-tests/scenario-tester/sc-config.toml b/contracts/feature-tests/scenario-tester/sc-config.toml new file mode 100644 index 0000000000..b56f82b429 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/sc-config.toml @@ -0,0 +1,4 @@ +[settings] + +[[proxy]] +path = "src/adder_proxy.rs" diff --git a/contracts/feature-tests/scenario-tester/scenarios/adder.scen.json b/contracts/feature-tests/scenario-tester/scenarios/adder.scen.json new file mode 100644 index 0000000000..08ecb79e3f --- /dev/null +++ b/contracts/feature-tests/scenario-tester/scenarios/adder.scen.json @@ -0,0 +1,99 @@ +{ + "name": "adder", + "comment": "add then check", + "gasSchedule": "v3", + "steps": [ + { + "step": "setState", + "accounts": { + "address:owner": { + "nonce": "1", + "balance": "0" + } + }, + "newAddresses": [ + { + "creatorAddress": "address:owner", + "creatorNonce": "1", + "newAddress": "sc:adder" + } + ] + }, + { + "step": "scDeploy", + "id": "1", + "tx": { + "from": "address:owner", + "contractCode": "mxsc:../output/adder.mxsc.json", + "arguments": [ + "5" + ], + "gasLimit": "5,000,000", + "gasPrice": "0" + }, + "expect": { + "out": [], + "status": "", + "logs": "*", + "gas": "*", + "refund": "*" + } + }, + { + "step": "scQuery", + "id": "2", + "tx": { + "to": "sc:adder", + "function": "getSum", + "arguments": [] + }, + "expect": { + "out": [ + "5" + ], + "status": "", + "logs": [] + } + }, + { + "step": "scCall", + "id": "3", + "tx": { + "from": "address:owner", + "to": "sc:adder", + "function": "add", + "arguments": [ + "3" + ], + "gasLimit": "5,000,000", + "gasPrice": "0" + }, + "expect": { + "out": [], + "status": "", + "logs": "*", + "gas": "*", + "refund": "*" + } + }, + { + "step": "checkState", + "accounts": { + "address:owner": { + "nonce": "*", + "balance": "0", + "storage": {}, + "code": "" + }, + "sc:adder": { + "nonce": "0", + "balance": "0", + "storage": { + "str:sum": "8" + }, + "code": "mxsc:../output/adder.mxsc.json" + } + } + } + ] +} diff --git a/contracts/feature-tests/scenario-tester/scenarios/interactor_trace.scen.json b/contracts/feature-tests/scenario-tester/scenarios/interactor_trace.scen.json new file mode 100644 index 0000000000..e0824697fe --- /dev/null +++ b/contracts/feature-tests/scenario-tester/scenarios/interactor_trace.scen.json @@ -0,0 +1,76 @@ +{ + "steps": [ + { + "step": "setState", + "accounts": { + "0xe32afedc904fe1939746ad973beb383563cf63642ba669b3040f9b9428a5ed60": { + "nonce": "481", + "balance": "106274669842530000003", + "esdt": { + "str:CAN-14dc0a": "1000", + "str:CAN-2abf4b": "1000", + "str:CAN-6d39e6": "1000", + "str:CAN-ac1592": "1000" + } + } + } + }, + { + "step": "setState", + "newAddresses": [ + { + "creatorAddress": "0xe32afedc904fe1939746ad973beb383563cf63642ba669b3040f9b9428a5ed60", + "creatorNonce": "481", + "newAddress": "0x0000000000000000050028600ceb73ac22ec0b6f257aff7bed74dffa3ebfed60" + } + ] + }, + { + "step": "scDeploy", + "tx": { + "from": "0xe32afedc904fe1939746ad973beb383563cf63642ba669b3040f9b9428a5ed60", + "contractCode": "mxsc:../output/adder.mxsc.json", + "arguments": [ + "0x00" + ], + "gasLimit": "70,000,000" + }, + "expect": { + "out": [], + "status": "0" + } + }, + { + "step": "scCall", + "tx": { + "from": "0xe32afedc904fe1939746ad973beb383563cf63642ba669b3040f9b9428a5ed60", + "to": "0x0000000000000000050028600ceb73ac22ec0b6f257aff7bed74dffa3ebfed60", + "function": "add", + "arguments": [ + "0x07" + ], + "gasLimit": "70,000,000" + }, + "expect": { + "out": [], + "status": "0" + } + }, + { + "step": "scCall", + "tx": { + "from": "0xe32afedc904fe1939746ad973beb383563cf63642ba669b3040f9b9428a5ed60", + "to": "0x0000000000000000050028600ceb73ac22ec0b6f257aff7bed74dffa3ebfed60", + "function": "add", + "arguments": [ + "0x05" + ], + "gasLimit": "70,000,000" + }, + "expect": { + "out": [], + "status": "0" + } + } + ] +} diff --git a/contracts/feature-tests/scenario-tester/src/lib.rs b/contracts/feature-tests/scenario-tester/src/lib.rs new file mode 100644 index 0000000000..015b3e82c2 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/src/lib.rs @@ -0,0 +1,30 @@ +#![no_std] + +use multiversx_sc::imports::*; + +pub mod scenario_tester_proxy; + +/// One of the simplest smart contracts possible, +/// it holds a single variable in storage, which anyone can increment. +#[multiversx_sc::contract] +pub trait ScenarioTester { + #[view(getSum)] + #[storage_mapper("sum")] + fn sum(&self) -> SingleValueMapper; + + #[init] + fn init(&self, initial_value: BigUint) { + self.sum().set(initial_value); + } + + #[upgrade] + fn upgrade(&self, initial_value: BigUint) { + self.init(initial_value); + } + + /// Add desired amount to the storage variable. + #[endpoint] + fn add(&self, value: BigUint) { + self.sum().update(|sum| *sum += value); + } +} diff --git a/contracts/feature-tests/scenario-tester/src/scenario_tester_proxy.rs b/contracts/feature-tests/scenario-tester/src/scenario_tester_proxy.rs new file mode 100644 index 0000000000..d3abf4b9b7 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/src/scenario_tester_proxy.rs @@ -0,0 +1,110 @@ +// Code generated by the multiversx-sc proxy generator. DO NOT EDIT. + +//////////////////////////////////////////////////// +////////////////// AUTO-GENERATED ////////////////// +//////////////////////////////////////////////////// + +#![allow(dead_code)] +#![allow(clippy::all)] + +use multiversx_sc::proxy_imports::*; + +pub struct ScenarioTesterProxy; + +impl TxProxyTrait for ScenarioTesterProxy +where + Env: TxEnv, + From: TxFrom, + To: TxTo, + Gas: TxGas, +{ + type TxProxyMethods = ScenarioTesterProxyMethods; + + fn proxy_methods(self, tx: Tx) -> Self::TxProxyMethods { + ScenarioTesterProxyMethods { wrapped_tx: tx } + } +} + +pub struct ScenarioTesterProxyMethods +where + Env: TxEnv, + From: TxFrom, + To: TxTo, + Gas: TxGas, +{ + wrapped_tx: Tx, +} + +#[rustfmt::skip] +impl ScenarioTesterProxyMethods +where + Env: TxEnv, + Env::Api: VMApi, + From: TxFrom, + Gas: TxGas, +{ + pub fn init< + Arg0: CodecInto>, + >( + self, + initial_value: Arg0, + ) -> TxProxyDeploy { + self.wrapped_tx + .raw_deploy() + .argument(&initial_value) + .original_result() + } +} + +#[rustfmt::skip] +impl ScenarioTesterProxyMethods +where + Env: TxEnv, + Env::Api: VMApi, + From: TxFrom, + To: TxTo, + Gas: TxGas, +{ + pub fn upgrade< + Arg0: CodecInto>, + >( + self, + initial_value: Arg0, + ) -> TxProxyUpgrade { + self.wrapped_tx + .raw_upgrade() + .argument(&initial_value) + .original_result() + } +} + +#[rustfmt::skip] +impl ScenarioTesterProxyMethods +where + Env: TxEnv, + Env::Api: VMApi, + From: TxFrom, + To: TxTo, + Gas: TxGas, +{ + pub fn sum( + self, + ) -> TxProxyCall> { + self.wrapped_tx + .raw_call("getSum") + .original_result() + } + + /// Add desired amount to the storage variable. + pub fn add< + Arg0: CodecInto>, + >( + self, + value: Arg0, + ) -> TxProxyCall { + self.wrapped_tx + .raw_call("add") + .argument(&value) + .original_result() + } +} diff --git a/contracts/feature-tests/scenario-tester/tests/adder_blackbox_chained_test.rs b/contracts/feature-tests/scenario-tester/tests/adder_blackbox_chained_test.rs new file mode 100644 index 0000000000..b10b3e3a54 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/tests/adder_blackbox_chained_test.rs @@ -0,0 +1,64 @@ +use multiversx_sc_scenario::imports::*; +use num_bigint::BigUint; + +use adder::*; + +const ADDER_PATH_EXPR: &str = "mxsc:output/adder.mxsc.json"; + +fn world() -> ScenarioWorld { + let mut blockchain = ScenarioWorld::new(); + blockchain.set_current_dir_from_workspace("contracts/examples/adder"); + + blockchain.register_contract(ADDER_PATH_EXPR, adder::ContractBuilder); + blockchain +} + +#[test] +fn adder_blackbox_chained() { + let mut world = world(); + let owner_address = "address:owner"; + let adder_contract = ContractInfo::>::new("sc:adder"); + + world + .start_trace() + .set_state_step( + SetStateStep::new() + .put_account(owner_address, Account::new().nonce(1)) + .new_address(owner_address, 1, "sc:adder"), + ) + .chain_deploy(|tx| { + tx.from(AddressExpr("owner")) + .typed(adder_proxy::AdderProxy) + .init(5u32) + .code(MxscExpr("output/adder.mxsc.json")) + .with_result(WithNewAddress::new(|new_address| { + assert_eq!(new_address.to_address(), adder_contract.to_address()); + })) + }) + .chain_query(|tx| { + tx.to(ScExpr("adder")) + .typed(adder_proxy::AdderProxy) + .sum() + .with_result(WithResultConv::new(|value: BigUint| { + assert_eq!(value, BigUint::from(5u32)); + })) + }) + .chain_call(|tx| { + tx.from(AddressExpr("owner")) + .to(ScExpr("adder")) + .typed(adder_proxy::AdderProxy) + .add(3u32) + .with_result(WithRawTxResponse(|response| { + assert!(response.tx_error.is_success()); + })) + }) + .check_state_step( + CheckStateStep::new() + .put_account(owner_address, CheckAccount::new()) + .put_account( + &adder_contract, + CheckAccount::new().check_storage("str:sum", "8"), + ), + ) + .write_scenario_trace("trace2.scen.json"); +} diff --git a/contracts/feature-tests/scenario-tester/tests/adder_blackbox_legacy_proxy_test.rs b/contracts/feature-tests/scenario-tester/tests/adder_blackbox_legacy_proxy_test.rs new file mode 100644 index 0000000000..e3a2540386 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/tests/adder_blackbox_legacy_proxy_test.rs @@ -0,0 +1,77 @@ +use multiversx_sc_scenario::imports::*; +use num_bigint::BigUint; + +use adder::*; + +const ADDER_PATH_EXPR: &str = "mxsc:output/adder.mxsc.json"; + +const OWNER: AddressExpr = AddressExpr("owner"); +const CODE_EXPR: MxscExpr = MxscExpr("output/adder.mxsc.json"); + +fn world() -> ScenarioWorld { + let mut blockchain = ScenarioWorld::new(); + blockchain.set_current_dir_from_workspace("contracts/examples/adder"); + + blockchain.register_contract(ADDER_PATH_EXPR, adder::ContractBuilder); + blockchain +} + +#[test] +fn adder_blackbox_legacy_proxy() { + let mut world = world(); + let owner_address = "address:owner"; + let mut adder_contract = ContractInfo::>::new("sc:adder"); + + world.start_trace(); + + world.set_state_step( + SetStateStep::new() + .put_account(owner_address, Account::new().nonce(1)) + .new_address(owner_address, 1, "sc:adder"), + ); + + world + .tx() + .from(OWNER) + .typed(adder_proxy::AdderProxy) + .init(5u32) + .code(CODE_EXPR) + .with_result(WithNewAddress::new(|new_address| { + assert_eq!(new_address.to_address(), adder_contract.to_address()); + })) + .run(); + + world.sc_query( + ScQueryStep::new() + .to(&adder_contract) + .call(adder_contract.sum()) + .expect_value(SingleValue::from(BigUint::from(5u32))), + ); + + let value = world + .query() + .call(adder_contract.sum()) + .returns(ReturnsResultConv::>::new()) + .run(); + assert_eq!(value.into(), BigUint::from(5u32)); + + world + .tx() + .from(OWNER) + .call(adder_contract.add(3u32)) + .with_result(WithRawTxResponse(|response| { + assert!(response.tx_error.is_success()); + })) + .run(); + + world.check_state_step( + CheckStateStep::new() + .put_account(owner_address, CheckAccount::new()) + .put_account( + &adder_contract, + CheckAccount::new().check_storage("str:sum", "8"), + ), + ); + + world.write_scenario_trace("trace1.scen.json"); +} diff --git a/contracts/feature-tests/scenario-tester/tests/adder_blackbox_raw_steps_test.rs b/contracts/feature-tests/scenario-tester/tests/adder_blackbox_raw_steps_test.rs new file mode 100644 index 0000000000..fc6b5d02a0 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/tests/adder_blackbox_raw_steps_test.rs @@ -0,0 +1,53 @@ +use multiversx_sc_scenario::imports::*; + +const SCENARIO_TESTER_PATH_EXPR: &str = "mxsc:output/scenario-tester.mxsc.json"; + +fn world() -> ScenarioWorld { + let mut blockchain = ScenarioWorld::new(); + blockchain.set_current_dir_from_workspace("contracts/feature-tests/scenario-tester"); + + blockchain.register_contract(SCENARIO_TESTER_PATH_EXPR, scenario_tester::ContractBuilder); + blockchain +} + +#[test] +fn scenario_tester_blackbox_raw() { + let mut world = world(); + let scenario_tester_code = world.code_expression(SCENARIO_TESTER_PATH_EXPR); + + world + .set_state_step( + SetStateStep::new() + .put_account("address:owner", Account::new().nonce(1)) + .new_address("address:owner", 1, "sc:scenario-tester"), + ) + .sc_deploy( + ScDeployStep::new() + .from("address:owner") + .code(scenario_tester_code) + .argument("5") + .expect(TxExpect::ok().no_result()), + ) + .sc_query( + ScQueryStep::new() + .to("sc:scenario-tester") + .function("getSum") + .expect(TxExpect::ok().result("5")), + ) + .sc_call( + ScCallStep::new() + .from("address:owner") + .to("sc:scenario-tester") + .function("add") + .argument("3") + .expect(TxExpect::ok().no_result()), + ) + .check_state_step( + CheckStateStep::new() + .put_account("address:owner", CheckAccount::new()) + .put_account( + "sc:scenario-tester", + CheckAccount::new().check_storage("str:sum", "8"), + ), + ); +} diff --git a/contracts/feature-tests/scenario-tester/tests/adder_blackbox_test.rs b/contracts/feature-tests/scenario-tester/tests/adder_blackbox_test.rs new file mode 100644 index 0000000000..9149a25e3b --- /dev/null +++ b/contracts/feature-tests/scenario-tester/tests/adder_blackbox_test.rs @@ -0,0 +1,72 @@ +use multiversx_sc_scenario::imports::*; +use num_bigint::BigUint; + +use scenario_tester::*; + +const ADDER_PATH_EXPR: &str = "mxsc:output/scenario-tester.mxsc.json"; + +const OWNER: AddressExpr = AddressExpr("owner"); +const SC_ADDER: ScExpr = ScExpr("scenario-tester"); +const CODE_EXPR: MxscExpr = MxscExpr("output/scenario-tester.mxsc.json"); + +fn world() -> ScenarioWorld { + let mut blockchain = ScenarioWorld::new(); + blockchain.set_current_dir_from_workspace("contracts/examples/scenario-tester"); + + blockchain.register_contract(ADDER_PATH_EXPR, scenario_tester::ContractBuilder); + blockchain +} + +#[test] +fn adder_blackbox() { + let mut world = world(); + let owner_address = "address:owner"; + let adder_contract = ContractInfo::>::new("sc:scenario-tester"); + + world.start_trace(); + + world.set_state_step( + SetStateStep::new() + .put_account(owner_address, Account::new().nonce(1)) + .new_address(owner_address, 1, "sc:scenario-tester"), + ); + + let new_address = world + .tx() + .from(OWNER) + .typed(scenario_tester_proxy::ScenarioTesterProxy) + .init(5u32) + .code(CODE_EXPR) + .returns(ReturnsNewAddress) + .run(); + + assert_eq!(new_address, adder_contract.to_address()); + + let value = world + .query() + .to(SC_ADDER) + .typed(scenario_tester_proxy::ScenarioTesterProxy) + .sum() + .returns(ReturnsResultConv::::new()) + .run(); + assert_eq!(value, BigUint::from(5u32)); + + world + .tx() + .from(OWNER) + .to(SC_ADDER) + .typed(scenario_tester_proxy::ScenarioTesterProxy) + .add(1u32) + .run(); + + world.check_state_step( + CheckStateStep::new() + .put_account(owner_address, CheckAccount::new()) + .put_account( + &adder_contract, + CheckAccount::new().check_storage("str:sum", "6"), + ), + ); + + world.write_scenario_trace("trace1.scen.json"); +} diff --git a/contracts/feature-tests/scenario-tester/tests/adder_blackbox_upgrade_test.rs b/contracts/feature-tests/scenario-tester/tests/adder_blackbox_upgrade_test.rs new file mode 100644 index 0000000000..5a38f7c5df --- /dev/null +++ b/contracts/feature-tests/scenario-tester/tests/adder_blackbox_upgrade_test.rs @@ -0,0 +1,50 @@ +use multiversx_sc_scenario::imports::*; + +const ADDER_PATH_EXPR: &str = "mxsc:output/adder.mxsc.json"; + +fn world() -> ScenarioWorld { + let mut blockchain = ScenarioWorld::new(); + blockchain.set_current_dir_from_workspace("contracts/examples/adder"); + + blockchain.register_contract("mxsc:output/adder.mxsc.json", adder::ContractBuilder); + blockchain +} + +#[test] +fn adder_blackbox_upgrade() { + let mut world = world(); + let adder_code = world.code_expression(ADDER_PATH_EXPR); + + world + .set_state_step( + SetStateStep::new() + .put_account("address:owner", Account::new().nonce(1)) + .new_address("address:owner", 1, "sc:adder"), + ) + .sc_deploy( + ScDeployStep::new() + .from("address:owner") + .code(&adder_code) + .argument("5") + .gas_limit("5,000,000") + .expect(TxExpect::ok().no_result()), + ) + .sc_call( + ScCallStep::new() + .from("address:owner") + .to("sc:adder") + .function("upgradeContract") + .argument(&adder_code) + .argument("0x0502") // codeMetadata + .argument("8") // contract argument + .expect(TxExpect::ok().no_result()), + ) + .check_state_step( + CheckStateStep::new() + .put_account("address:owner", CheckAccount::new()) + .put_account( + "sc:adder", + CheckAccount::new().check_storage("str:sum", "8"), + ), + ); +} diff --git a/contracts/feature-tests/scenario-tester/tests/adder_scenario_go_test.rs b/contracts/feature-tests/scenario-tester/tests/adder_scenario_go_test.rs new file mode 100644 index 0000000000..bed4ae016d --- /dev/null +++ b/contracts/feature-tests/scenario-tester/tests/adder_scenario_go_test.rs @@ -0,0 +1,15 @@ +use multiversx_sc_scenario::*; + +fn world() -> ScenarioWorld { + ScenarioWorld::vm_go() +} + +#[test] +fn adder_go() { + world().run("scenarios/adder.scen.json"); +} + +#[test] +fn interactor_trace_go() { + world().run("scenarios/interactor_trace.scen.json"); +} diff --git a/contracts/feature-tests/scenario-tester/tests/adder_scenario_rs_test.rs b/contracts/feature-tests/scenario-tester/tests/adder_scenario_rs_test.rs new file mode 100644 index 0000000000..c467100633 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/tests/adder_scenario_rs_test.rs @@ -0,0 +1,19 @@ +use multiversx_sc_scenario::*; + +fn world() -> ScenarioWorld { + let mut blockchain = ScenarioWorld::new(); + blockchain.set_current_dir_from_workspace("contracts/examples/adder"); + + blockchain.register_contract("mxsc:output/adder.mxsc.json", adder::ContractBuilder); + blockchain +} + +#[test] +fn adder_rs() { + world().run("scenarios/adder.scen.json"); +} + +#[test] +fn interactor_trace_rs() { + world().run("scenarios/interactor_trace.scen.json"); +} diff --git a/contracts/feature-tests/scenario-tester/tests/adder_unit_test.rs b/contracts/feature-tests/scenario-tester/tests/adder_unit_test.rs new file mode 100644 index 0000000000..3839382866 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/tests/adder_unit_test.rs @@ -0,0 +1,17 @@ +use adder::*; +use multiversx_sc::types::BigUint; +use multiversx_sc_scenario::api::SingleTxApi; + +#[test] +fn adder_unit_test() { + let adder = adder::contract_obj::(); + + adder.init(BigUint::from(5u32)); + assert_eq!(BigUint::from(5u32), adder.sum().get()); + + adder.add(BigUint::from(7u32)); + assert_eq!(BigUint::from(12u32), adder.sum().get()); + + adder.add(BigUint::from(1u32)); + assert_eq!(BigUint::from(13u32), adder.sum().get()); +} diff --git a/contracts/feature-tests/scenario-tester/tests/adder_whitebox_test.rs b/contracts/feature-tests/scenario-tester/tests/adder_whitebox_test.rs new file mode 100644 index 0000000000..50ad95faa6 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/tests/adder_whitebox_test.rs @@ -0,0 +1,50 @@ +use adder::*; +use multiversx_sc_scenario::imports::*; + +const ADDER_PATH_EXPR: &str = "mxsc:output/adder.mxsc.json"; + +fn world() -> ScenarioWorld { + let mut blockchain = ScenarioWorld::new(); + blockchain.set_current_dir_from_workspace("contracts/examples/adder"); + + blockchain.register_contract("mxsc:output/adder.mxsc.json", adder::ContractBuilder); + blockchain +} + +#[test] +fn adder_whitebox() { + let mut world = world(); + let adder_whitebox = WhiteboxContract::new("sc:adder", adder::contract_obj); + let adder_code = world.code_expression(ADDER_PATH_EXPR); + + world + .set_state_step( + SetStateStep::new() + .put_account("address:owner", Account::new().nonce(1)) + .new_address("address:owner", 1, "sc:adder"), + ) + .whitebox_deploy( + &adder_whitebox, + ScDeployStep::new().from("address:owner").code(adder_code), + |sc| { + sc.init(5u32.into()); + }, + ) + .whitebox_query(&adder_whitebox, |sc| { + let sum_value = sc.sum(); + assert_eq!(sum_value.get(), 5u32); + }) + .whitebox_call( + &adder_whitebox, + ScCallStep::new().from("address:owner"), + |sc| sc.add(3u32.into()), + ) + .check_state_step( + CheckStateStep::new() + .put_account("address:owner", CheckAccount::new()) + .put_account( + "sc:adder", + CheckAccount::new().check_storage("str:sum", "8"), + ), + ); +} diff --git a/contracts/feature-tests/scenario-tester/wasm/Cargo.lock b/contracts/feature-tests/scenario-tester/wasm/Cargo.lock new file mode 100755 index 0000000000..9bc1e41879 --- /dev/null +++ b/contracts/feature-tests/scenario-tester/wasm/Cargo.lock @@ -0,0 +1,170 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "arrayvec" +version = "0.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711" + +[[package]] +name = "autocfg" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80" + +[[package]] +name = "bitflags" +version = "2.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed570934406eb16438a4e976b1b4500774099c13b8cb96eec99f620f05090ddf" + +[[package]] +name = "endian-type" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d" + +[[package]] +name = "hex" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" + +[[package]] +name = "hex-literal" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6fe2267d4ed49bc07b63801559be28c718ea06c4738b7a03c94df7386d2cde46" + +[[package]] +name = "multiversx-sc" +version = "0.49.0-alpha.2" +dependencies = [ + "bitflags", + "hex-literal", + "multiversx-sc-codec", + "multiversx-sc-derive", + "num-traits", +] + +[[package]] +name = "multiversx-sc-codec" +version = "0.18.6" +dependencies = [ + "arrayvec", + "multiversx-sc-codec-derive", +] + +[[package]] +name = "multiversx-sc-codec-derive" +version = "0.18.6" +dependencies = [ + "hex", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "multiversx-sc-derive" +version = "0.49.0-alpha.2" +dependencies = [ + "hex", + "proc-macro2", + "quote", + "radix_trie", + "syn", +] + +[[package]] +name = "multiversx-sc-wasm-adapter" +version = "0.49.0-alpha.2" +dependencies = [ + "multiversx-sc", +] + +[[package]] +name = "nibble_vec" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77a5d83df9f36fe23f0c3648c6bbb8b0298bb5f1939c8f2704431371f4b84d43" +dependencies = [ + "smallvec", +] + +[[package]] +name = "num-traits" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39e3200413f237f41ab11ad6d161bc7239c84dcb631773ccd7de3dfe4b5c267c" +dependencies = [ + "autocfg", +] + +[[package]] +name = "proc-macro2" +version = "1.0.78" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2422ad645d89c99f8f3e6b88a9fdeca7fabeac836b1002371c4367c8f984aae" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "radix_trie" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c069c179fcdc6a2fe24d8d18305cf085fdbd4f922c041943e203685d6a1c58fd" +dependencies = [ + "endian-type", + "nibble_vec", +] + +[[package]] +name = "scenario_tester" +version = "0.0.0" +dependencies = [ + "multiversx-sc", +] + +[[package]] +name = "scenario_tester-wasm" +version = "0.0.0" +dependencies = [ + "multiversx-sc-wasm-adapter", + "scenario_tester", +] + +[[package]] +name = "smallvec" +version = "1.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67" + +[[package]] +name = "syn" +version = "2.0.48" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "unicode-ident" +version = "1.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" diff --git a/contracts/feature-tests/scenario-tester/wasm/Cargo.toml b/contracts/feature-tests/scenario-tester/wasm/Cargo.toml new file mode 100644 index 0000000000..6de4181a2b --- /dev/null +++ b/contracts/feature-tests/scenario-tester/wasm/Cargo.toml @@ -0,0 +1,32 @@ +# Code generated by the multiversx-sc build system. DO NOT EDIT. + +# ########################################## +# ############## AUTO-GENERATED ############# +# ########################################## + +[package] +name = "scenario_tester-wasm" +version = "0.0.0" +edition = "2021" +publish = false + +[lib] +crate-type = ["cdylib"] + +[profile.release] +codegen-units = 1 +opt-level = "z" +lto = true +debug = false +panic = "abort" +overflow-checks = false + +[dependencies.scenario_tester] +path = ".." + +[dependencies.multiversx-sc-wasm-adapter] +version = "0.49.0-alpha.2" +path = "../../../../framework/wasm-adapter" + +[workspace] +members = ["."] diff --git a/contracts/feature-tests/scenario-tester/wasm/src/lib.rs b/contracts/feature-tests/scenario-tester/wasm/src/lib.rs new file mode 100644 index 0000000000..e4a29325bf --- /dev/null +++ b/contracts/feature-tests/scenario-tester/wasm/src/lib.rs @@ -0,0 +1,30 @@ +// Code generated by the multiversx-sc build system. DO NOT EDIT. + +//////////////////////////////////////////////////// +////////////////// AUTO-GENERATED ////////////////// +//////////////////////////////////////////////////// + +// Init: 1 +// Upgrade: 1 +// Endpoints: 2 +// Async Callback (empty): 1 +// Total number of exported functions: 4 + +#![no_std] +#![allow(internal_features)] +#![feature(lang_items)] + +multiversx_sc_wasm_adapter::allocator!(); +multiversx_sc_wasm_adapter::panic_handler!(); + +multiversx_sc_wasm_adapter::endpoints! { + scenario_tester + ( + init => init + upgrade => upgrade + getSum => sum + add => add + ) +} + +multiversx_sc_wasm_adapter::async_callback_empty! {}