refactor interactor retrieve_account

contracts/examples/adder/interact/src/basic_interact.rs

@@ -68,18 +68,8 @@ impl AdderInteract {
     }
 
     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);
+        println!("wallet address: {}", self.wallet_address);
+        self.interactor.retrieve_account(&self.wallet_address).await;
     }
 
     async fn deploy(&mut self) {

contracts/examples/multisig/interact/src/multisig_interact.rs

@@ -119,17 +119,9 @@ impl MultisigInteract {
                 "board member address: {}",
                 bech32::encode(board_member_address)
             );
-            let scenario_raw = retrieve_account_as_scenario_set_state(
-                Config::load_config().gateway().to_string(),
-                bech32::encode(board_member_address),
-                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);
+            self.interactor
+                .retrieve_account(&board_member_address.into())
+                .await;
         }
 
         self.wegld_swap_set_state().await;

contracts/examples/multisig/interact/src/multisig_interact_wegld.rs

@@ -35,17 +35,11 @@ impl MultisigInteract {
     }
 
     pub async fn wegld_swap_set_state(&mut self) {
-        let scenario_raw = retrieve_account_as_scenario_set_state(
-            Config::load_config().gateway().to_string(),
-            WEGLD_SWAP_SC_BECH32.to_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);
+        self.interactor
+            .retrieve_account(&Bech32Address::from_bech32_string(
+                WEGLD_SWAP_SC_BECH32.to_owned(),
+            ))
+            .await;
     }
 
     async fn propose_wrap_egld(&mut self) -> usize {

contracts/feature-tests/basic-features/interact/src/bf_interact.rs

@@ -73,17 +73,9 @@ impl BasicFeaturesInteract {
 
     async fn set_state(&mut self) {
         println!("wallet address: {}", bech32::encode(&self.wallet_address));
-        let scenario_raw = retrieve_account_as_scenario_set_state(
-            Config::load_config().gateway().to_string(),
-            bech32::encode(&self.wallet_address),
-            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);
+        self.interactor
+            .retrieve_account(&Bech32Address::from(&self.wallet_address))
+            .await;
     }
 
     async fn deploy(&mut self) {

framework/scenario/src/facade/expr/bech32_address.rs

@@ -32,6 +32,16 @@ impl From<Address> for Bech32Address {
     }
 }
 
+impl From<&Address> for Bech32Address {
+    fn from(value: &Address) -> Self {
+        let bech32 = bech32::encode(value);
+        Bech32Address {
+            address: value.clone(),
+            bech32,
+        }
+    }
+}
+
 impl Bech32Address {
     pub fn from_bech32_string(bech32: String) -> Self {
         let address = bech32::decode(&bech32);

framework/scenario/src/standalone/account_tool.rs

@@ -1,142 +1,97 @@
-use super::scenario_cli::AccountArgs;
-use multiversx_chain_scenario_format::serde_raw::{
-    AccountRaw, EsdtFullRaw, EsdtInstanceRaw, EsdtRaw, ScenarioRaw, StepRaw, ValueSubTree,
+use crate::{
+    imports::Bech32Address,
+    scenario_model::{Account, BytesKey, BytesValue, Scenario, SetStateStep},
 };
+
+use multiversx_chain_scenario_format::interpret_trait::IntoRaw;
 use multiversx_sdk::{
     blockchain::CommunicationProxy,
     data::{address::Address, esdt::EsdtBalance},
 };
 use std::collections::{BTreeMap, HashMap};
 
-pub async fn print_account_as_scenario_set_state(api: String, args: &AccountArgs) {
-    let scenario_raw =
-        retrieve_account_as_scenario_set_state(api, args.address.clone(), false).await;
-    println!("{}", scenario_raw.to_json_string());
+pub async fn print_account_as_scenario_set_state(
+    api: &CommunicationProxy,
+    address: &Bech32Address,
+) {
+    let set_state = retrieve_account_as_scenario_set_state(api, address).await;
+    let scenario = build_scenario(set_state);
+    println!("{}", scenario.into_raw().to_json_string());
+}
+
+fn build_scenario(set_state: SetStateStep) -> Scenario {
+    Scenario {
+        name: None,
+        comment: None,
+        check_gas: None,
+        steps: vec![crate::scenario_model::Step::SetState(set_state)],
+    }
 }
 
 pub async fn retrieve_account_as_scenario_set_state(
-    api: String,
-    addr: String,
-    hex_encoded: bool,
-) -> ScenarioRaw {
-    let address = Address::from_bech32_string(&addr).unwrap();
-    let blockchain = CommunicationProxy::new(api);
-    let account = blockchain.get_account(&address).await.unwrap();
+    api: &CommunicationProxy,
+    address: &Bech32Address,
+) -> SetStateStep {
+    let sdk_address = Address::from_bech32_string(address.to_bech32_str()).unwrap();
+    let sdk_account = api.get_account(&sdk_address).await.unwrap();
 
-    let account_esdt = blockchain
-        .get_account_esdt_tokens(&address)
+    let account_esdt = api
+        .get_account_esdt_tokens(&sdk_address)
         .await
-        .unwrap_or_else(|err| panic!("failed to retrieve ESDT tokens for address {addr}: {err}"));
-    let account_esdt_roles = blockchain
-        .get_account_esdt_roles(&address)
+        .unwrap_or_else(|err| {
+            panic!("failed to retrieve ESDT tokens for address {address}: {err}")
+        });
+    let account_esdt_roles = api
+        .get_account_esdt_roles(&sdk_address)
         .await
-        .unwrap_or_else(|err| panic!("failed to retrieve ESDT roles for address {addr}: {err}"));
-    let account_storage = blockchain
-        .get_account_storage_keys(&address)
+        .unwrap_or_else(|err| panic!("failed to retrieve ESDT roles for address {address}: {err}"));
+    let account_storage = api
+        .get_account_storage_keys(&sdk_address)
         .await
-        .unwrap_or_else(|err| panic!("failed to retrieve storage for address {addr}: {err}"));
+        .unwrap_or_else(|err| panic!("failed to retrieve storage for address {address}: {err}"));
 
-    let addr_pretty = if !hex_encoded {
-        if account.code.is_empty() {
-            format!("address:{addr}")
-        } else {
-            format!("sc:{addr}")
-        }
-    } else {
-        format!("0x{}", hex::encode(address.to_bytes()))
-    };
-
-    let mut accounts = BTreeMap::new();
-    accounts.insert(
-        addr_pretty,
-        AccountRaw {
-            nonce: Some(ValueSubTree::Str(account.nonce.to_string())),
-            balance: Some(ValueSubTree::Str(account.balance.to_string())),
-            esdt: convert_esdt(account_esdt, account_esdt_roles),
-            username: Some(ValueSubTree::Str(account.username.to_string())),
-            storage: convert_storage(account_storage),
-            comment: None,
-            code: retrieve_code(account.code),
-            code_metadata: None, // TODO: retrieve code metadata
-            owner: None,
-            developer_rewards: None,
-        },
+    let account_state = set_account(
+        sdk_account,
+        account_storage,
+        account_esdt,
+        account_esdt_roles,
     );
 
-    ScenarioRaw {
-        check_gas: None,
-        comment: None,
-        gas_schedule: None,
-        name: None,
-        steps: vec![StepRaw::SetState {
-            accounts,
-            block_hashes: Vec::new(),
-            new_addresses: Vec::new(),
-            new_token_identifiers: Vec::new(),
-            comment: None,
-            current_block_info: None,
-            previous_block_info: None,
-        }],
-    }
+    let set_state_step = SetStateStep::new();
+    set_state_step.put_account(address, account_state)
 }
 
-fn retrieve_code(code: String) -> Option<ValueSubTree> {
-    if code.is_empty() {
-        None
-    } else {
-        Some(ValueSubTree::Str(format!("0x{code}")))
-    }
-}
-
-fn convert_storage(account_storage: HashMap<String, String>) -> BTreeMap<String, ValueSubTree> {
-    account_storage
-        .into_iter()
-        .filter(|(k, _)| !k.starts_with("454c524f4e44"))
-        .map(|(k, v)| (format!("0x{k}"), ValueSubTree::Str(format!("0x{v}"))))
-        .collect()
-}
+pub fn set_account(
+    account: multiversx_sdk::data::account::Account,
+    account_storage: HashMap<String, String>,
+    account_esdt: HashMap<String, EsdtBalance>,
+    account_esdt_roles: HashMap<String, Vec<String>>,
+) -> Account {
+    let mut account_state = Account::new()
+        .nonce(account.nonce)
+        .balance(account.balance.as_str())
+        .code(account.code);
+    account_state.username = Some(account.username.as_str().into());
+    account_state.storage = convert_storage(account_storage);
 
-fn convert_esdt(
-    sdk_esdt: HashMap<String, EsdtBalance>,
-    sdk_esdt_roles: HashMap<String, Vec<String>>,
-) -> BTreeMap<String, EsdtRaw> {
-    let mut result = BTreeMap::new();
-    for (key, value) in sdk_esdt.into_iter() {
-        let (token_identifier, nonce) = split_token_identifer_nonce(key);
-        let esdt_raw = result
-            .entry(format!("str:{}", token_identifier.clone()))
-            .or_insert(EsdtRaw::Full(EsdtFullRaw::default()));
-        if let EsdtRaw::Full(esdt_full_raw) = esdt_raw {
-            esdt_full_raw.instances.push(EsdtInstanceRaw {
-                nonce: Some(ValueSubTree::Str(nonce.to_string())),
-                balance: Some(ValueSubTree::Str(value.balance)),
-                // TODO: add creator, royalties, etc ...
-                ..Default::default()
-            });
-        }
+    for (_, esdt_balance) in account_esdt.iter() {
+        account_state = account_state.esdt_balance(
+            esdt_balance.token_identifier.as_str(),
+            esdt_balance.balance.as_str(),
+        );
     }
 
-    for (key, roles) in sdk_esdt_roles.into_iter() {
-        let (token_identifier, _) = split_token_identifer_nonce(key);
-        let esdt_raw = result
-            .entry(format!("str:{}", token_identifier.clone()))
-            .or_insert(EsdtRaw::Full(EsdtFullRaw::default()));
-        if let EsdtRaw::Full(esdt_full_raw) = esdt_raw {
-            esdt_full_raw.roles = roles;
-        }
+    for (token_id, esdt_roles) in account_esdt_roles {
+        account_state = account_state.esdt_roles(token_id.as_str(), esdt_roles);
     }
 
-    result
+    account_state
 }
 
-fn split_token_identifer_nonce(full_identifier: String) -> (String, u64) {
-    let tokens = full_identifier.split('-').collect::<Vec<_>>();
-    match tokens.len() {
-        2 => (full_identifier, 0),
-        3 => (
-            format!("{}-{}", tokens[0], tokens[1]),
-            u64::from_str_radix(tokens[2], 16).unwrap(),
-        ),
-        _ => panic!("could not process token identifier: {full_identifier}"),
-    }
+fn convert_storage(account_storage: HashMap<String, String>) -> BTreeMap<BytesKey, BytesValue> {
+    account_storage
+        .into_iter()
+        .filter(|(k, _)| !k.starts_with("454c524f4e44"))
+        .map(|(k, v)| (BytesKey::from(k.as_str()), BytesValue::from(v)))
+        .collect()
 }

framework/scenario/src/standalone/scenario_cli.rs

@@ -1,4 +1,7 @@
 use clap::{Args, Parser, Subcommand};
+use multiversx_sdk::blockchain::CommunicationProxy;
+
+use crate::imports::Bech32Address;
 
 use super::account_tool;
 
@@ -34,10 +37,14 @@ pub struct AccountArgs {
 /// Entry point in the program when calling it as a standalone tool.
 pub async fn cli_main() {
     let cli_args = ScenarioCliArgs::parse();
-    let api = cli_args.api.expect("API needs tp be specified");
+    let api = CommunicationProxy::new(cli_args.api.expect("API needs tp be specified"));
     match &cli_args.command {
         Some(ScenarioCliAction::Account(args)) => {
-            account_tool::print_account_as_scenario_set_state(api, args).await;
+            account_tool::print_account_as_scenario_set_state(
+                &api,
+                &Bech32Address::from_bech32_string(args.address.to_string()),
+            )
+            .await;
         },
         None => {},
     }

framework/snippets/src/interactor.rs

@@ -1,4 +1,5 @@
 use multiversx_sc_scenario::{
+    imports::{retrieve_account_as_scenario_set_state, Bech32Address, ScenarioRunner},
     mandos_system::{run_list::ScenarioRunnerList, run_trace::ScenarioTraceFile},
     multiversx_sc::types::Address,
     scenario_model::AddressValue,
@@ -67,6 +68,12 @@ impl Interactor {
         self.post_runners.push(ScenarioTraceFile::new(path));
         self
     }
+
+    pub async fn retrieve_account(&mut self, wallet_address: &Bech32Address) {
+        let set_state = retrieve_account_as_scenario_set_state(&self.proxy, wallet_address).await;
+        self.pre_runners.run_set_state_step(&set_state);
+        self.post_runners.run_set_state_step(&set_state);
+    }
 }
 
 pub(crate) fn mandos_to_erdrs_address(mandos_address: &AddressValue) -> ErdrsAddress {