Hackathon feat

contracts/feature-tests/rust-testing-framework-tester/scenarios/test.scen.json

@@ -35,6 +35,7 @@
             "step": "checkState",
             "accounts": {
                 "0x0000000000000000fb1397e8225ea85e0f0e6e8c7b126d0016ccbde0e667151e": {
+                    "nonce": "*",
                     "balance": "0",
                     "esdt": {},
                     "storage": {
@@ -62,13 +63,15 @@
             "expect": {
                 "out": [],
                 "status": "0",
-                "message": "str:"
+                "message": "str:",
+                "refund": "*"
             }
         },
         {
             "step": "checkState",
             "accounts": {
                 "0x0000000000000000fb1397e8225ea85e0f0e6e8c7b126d0016ccbde0e667151e": {
+                    "nonce": "*",
                     "balance": "0",
                     "esdt": {},
                     "storage": {
@@ -95,7 +98,8 @@
                     "0x33"
                 ],
                 "status": "0",
-                "message": "str:"
+                "message": "str:",
+                "refund": "*"
             }
         }
     ]

contracts/feature-tests/rust-testing-framework-tester/scenarios/test_esdt_generation.scen.json

@@ -36,6 +36,7 @@
             "step": "checkState",
             "accounts": {
                 "0x00000000000000006c8fc18b8e9f8e20089714856ee233b3902a591d0d5f2925": {
+                    "nonce": "*",
                     "balance": "0",
                     "esdt": {
                         "str:COOL-123456": {

framework/scenario/src/facade/scenario_world.rs

@@ -96,7 +96,7 @@ impl ScenarioWorld {
         }
     }
 
-    pub(crate) fn get_state(&self) -> &BlockchainState {
+    pub fn get_state(&self) -> &BlockchainState {
         &self.get_debugger_backend().vm_runner.blockchain_mock.state
     }
 
@@ -113,6 +113,11 @@ impl ScenarioWorld {
         self
     }
 
+    pub fn start_trace_with(&mut self, trace: ScenarioTrace) -> &mut Self {
+        self.get_mut_debugger_backend().trace = Some(trace);
+        self
+    }
+
     /// Tells the tests where the crate lies relative to the workspace.
     /// This ensures that the paths are set correctly, including in debug mode.
     pub fn set_current_dir_from_workspace(&mut self, relative_path: &str) -> &mut Self {

framework/scenario/src/scenario/model/account_data/account.rs

@@ -21,6 +21,7 @@ pub struct Account {
     pub code: Option<BytesValue>,
     pub owner: Option<AddressValue>,
     pub developer_rewards: Option<BigUintValue>,
+    pub update: Option<bool>,
 }
 
 impl Account {
@@ -176,6 +177,11 @@ impl Account {
         self.owner = Some(AddressValue::from(owner_expr));
         self
     }
+
+    pub fn update(mut self, update: bool) -> Self {
+        self.update = Some(update);
+        self
+    }
 }
 
 impl InterpretableFrom<AccountRaw> for Account {
@@ -214,6 +220,7 @@ impl InterpretableFrom<AccountRaw> for Account {
             developer_rewards: from
                 .developer_rewards
                 .map(|b| BigUintValue::interpret_from(b, context)),
+            update: from.update,
         }
     }
 }
@@ -238,6 +245,7 @@ impl IntoRaw<AccountRaw> for Account {
             code: self.code.map(|n| n.original),
             owner: self.owner.map(|n| n.original),
             developer_rewards: self.developer_rewards.map(|n| n.original),
+            update: self.update,
         }
     }
 }

framework/scenario/src/scenario/model/account_data/account_check.rs

@@ -11,7 +11,7 @@ use crate::{
     },
     scenario_model::CheckEsdtData,
 };
-use std::collections::BTreeMap;
+use std::collections::{btree_map, BTreeMap};
 
 #[derive(Debug, Default, Clone)]
 pub struct CheckAccount {
@@ -86,7 +86,10 @@ impl CheckAccount {
                 self.esdt = CheckEsdtMap::Equal(new_check_esdt_map);
             },
             CheckEsdtMap::Equal(check_esdt_map) => {
-                if check_esdt_map.contents.contains_key(&token_id) {
+                if let btree_map::Entry::Vacant(e) = check_esdt_map.contents.entry(token_id.clone())
+                {
+                    e.insert(CheckEsdt::Short(balance));
+                } else {
                     let prev_entry = check_esdt_map.contents.get_mut(&token_id).unwrap();
                     match prev_entry {
                         CheckEsdt::Short(prev_balance_check) => *prev_balance_check = balance,
@@ -115,35 +118,105 @@ impl CheckAccount {
         BigUintValue: From<V>,
         T: TopEncode,
     {
-        let token_id = BytesKey::from(token_id_expr);
+        let insert_check_esdt = |map: &mut CheckEsdtMapContents| {
+            let token_id = BytesKey::from(token_id_expr);
+            let attributes_expr = if let Some(attributes_expr) = attributes_expr {
+                top_encode_to_vec_u8_or_panic(&attributes_expr)
+            } else {
+                Vec::<u8>::new()
+            };
 
-        if let CheckEsdtMap::Unspecified = &self.esdt {
             let mut check_esdt = CheckEsdt::Full(CheckEsdtData::default());
+            check_esdt.add_balance_and_attributes_check(nonce_expr, balance_expr, attributes_expr);
 
-            if let Some(attributes_expr) = attributes_expr {
-                check_esdt.add_balance_and_attributes_check(
-                    nonce_expr,
-                    balance_expr,
-                    top_encode_to_vec_u8_or_panic(&attributes_expr),
-                );
-            } else {
-                check_esdt.add_balance_and_attributes_check(
-                    nonce_expr,
-                    balance_expr,
-                    Vec::<u8>::new(),
-                );
-            }
-
-            let mut new_esdt_map = BTreeMap::new();
-            let _ = new_esdt_map.insert(token_id, check_esdt);
-
-            let new_check_esdt_map = CheckEsdtMapContents {
-                contents: new_esdt_map,
-                other_esdts_allowed: true,
-            };
+            map.contents.insert(token_id, check_esdt)
+        };
 
-            self.esdt = CheckEsdtMap::Equal(new_check_esdt_map);
-        }
+        match &mut self.esdt {
+            CheckEsdtMap::Equal(map) => {
+                insert_check_esdt(map);
+            },
+            _ => {
+                let mut new_map = CheckEsdtMapContents {
+                    contents: BTreeMap::new(),
+                    other_esdts_allowed: true,
+                };
+
+                insert_check_esdt(&mut new_map);
+
+                self.esdt = CheckEsdtMap::Equal(new_map);
+            },
+        };
+
+        self
+    }
+
+    pub fn esdt_roles<K>(mut self, token_id_expr: K, roles: Vec<String>) -> Self
+    where
+        BytesKey: From<K>,
+    {
+        let insert_check_esdt = |map: &mut CheckEsdtMapContents| {
+            let token_id = BytesKey::from(token_id_expr);
+
+            map.contents
+                .entry(token_id)
+                .and_modify(|check_esdt| check_esdt.add_roles_check(roles.clone()))
+                .or_insert(CheckEsdt::Full(CheckEsdtData {
+                    roles,
+                    ..Default::default()
+                }));
+        };
+
+        match &mut self.esdt {
+            CheckEsdtMap::Equal(map) => {
+                insert_check_esdt(map);
+            },
+            _ => {
+                let mut new_map = CheckEsdtMapContents {
+                    contents: BTreeMap::new(),
+                    other_esdts_allowed: true,
+                };
+
+                insert_check_esdt(&mut new_map);
+
+                self.esdt = CheckEsdtMap::Equal(new_map);
+            },
+        };
+
+        self
+    }
+
+    pub fn esdt_nft_last_nonce<K>(mut self, token_id_expr: K, last_nonce: u64) -> Self
+    where
+        BytesKey: From<K>,
+    {
+        let insert_check_esdt = |map: &mut CheckEsdtMapContents| {
+            let token_id = BytesKey::from(token_id_expr);
+
+            map.contents
+                .entry(token_id)
+                .and_modify(|check_esdt| check_esdt.add_last_nonce_check(last_nonce))
+                .or_insert(CheckEsdt::Full(CheckEsdtData {
+                    last_nonce: CheckValue::Equal(last_nonce.into()),
+                    ..Default::default()
+                }));
+        };
+
+        match &mut self.esdt {
+            CheckEsdtMap::Equal(map) => {
+                insert_check_esdt(map);
+            },
+            _ => {
+                let mut new_map = CheckEsdtMapContents {
+                    contents: BTreeMap::new(),
+                    other_esdts_allowed: true,
+                };
+
+                insert_check_esdt(&mut new_map);
+
+                self.esdt = CheckEsdtMap::Equal(new_map);
+            },
+        };
 
         self
     }
@@ -192,7 +265,7 @@ impl IntoRaw<CheckAccountRaw> for CheckAccount {
     fn into_raw(self) -> CheckAccountRaw {
         CheckAccountRaw {
             comment: self.comment,
-            nonce: self.nonce.into_raw(),
+            nonce: self.nonce.into_raw_explicit(),
             balance: self.balance.into_raw(),
             esdt: self.esdt.into_raw(),
             username: self.username.into_raw(),

framework/scenario/src/scenario/model/esdt_data/esdt_check.rs

@@ -62,6 +62,27 @@ impl CheckEsdt {
         }
     }
 
+    pub fn add_roles_check(&mut self, roles: Vec<String>) {
+        self.convert_to_full();
+
+        if let CheckEsdt::Full(prev_esdt_check) = self {
+            prev_esdt_check.roles = roles;
+        }
+    }
+
+    pub fn add_last_nonce_check<N>(&mut self, nonce_expr: N)
+    where
+        U64Value: From<N>,
+    {
+        let last_nonce = U64Value::from(nonce_expr);
+
+        self.convert_to_full();
+
+        if let CheckEsdt::Full(prev_esdt_check) = self {
+            prev_esdt_check.last_nonce = CheckValue::Equal(last_nonce);
+        }
+    }
+
     pub fn add_balance_check<N, V>(&mut self, nonce_expr: N, balance_expr: V)
     where
         U64Value: InterpretableFrom<N>,

framework/scenario/src/scenario/model/esdt_data/esdt_data_check.rs

@@ -13,6 +13,7 @@ pub struct CheckEsdtData {
     pub instances: CheckEsdtInstances,
     pub last_nonce: CheckValue<U64Value>,
     pub frozen: CheckValue<U64Value>,
+    pub roles: Vec<String>
 }
 
 impl InterpretableFrom<CheckEsdtDataRaw> for CheckEsdtData {
@@ -21,6 +22,7 @@ impl InterpretableFrom<CheckEsdtDataRaw> for CheckEsdtData {
             instances: CheckEsdtInstances::interpret_from(from.instances, context),
             last_nonce: CheckValue::<U64Value>::interpret_from(from.last_nonce, context),
             frozen: CheckValue::<U64Value>::interpret_from(from.frozen, context),
+            roles: from.roles
         }
     }
 }
@@ -30,7 +32,7 @@ impl IntoRaw<CheckEsdtDataRaw> for CheckEsdtData {
         CheckEsdtDataRaw {
             instances: self.instances.into_raw(),
             last_nonce: self.last_nonce.into_raw(),
-            roles: Vec::new(),
+            roles: self.roles,
             frozen: self.frozen.into_raw(),
         }
     }

framework/scenario/src/scenario/model/transaction/tx_expect.rs

@@ -150,7 +150,7 @@ impl IntoRaw<TxExpectRaw> for TxExpect {
             message: self.message.into_raw(),
             logs: self.logs.into_raw(),
             gas: self.gas.into_raw(),
-            refund: self.refund.into_raw(),
+            refund: self.refund.into_raw_explicit(),
         }
     }
 }

framework/scenario/src/scenario/run_vm/check_state.rs

@@ -124,8 +124,10 @@ pub fn check_account_esdt(address: &AddressKey, expected: &CheckEsdtMap, actual:
                 match expected_value {
                     CheckEsdt::Short(expected_balance) => {
                         if expected_balance.value.is_zero() {
+                            let actual_value_is_empty =
+                                actual_value.is_empty() || actual_value.is_empty_with_roles();
                             assert!(
-                                actual_value.is_empty(),
+                                actual_value_is_empty,
                                 "No balance expected for ESDT token address: {}. token name: {}. nonce: {}.",
                                 address,
                                 bytes_to_string(key.value.as_slice()),