Fixing TrackingCopy caching mechanism so it doesn't return Some(_) when a key was pruned. Fixing Vector implementation.

zajko · zajko · commit 84c5668aa48e · 2025-12-04T12:31:11.000+01:00
diff --git a/executor/wasm/tests/collections.rs b/executor/wasm/tests/collections.rs
@@ -152,11 +152,11 @@ fn inserting_into_non_existing_vec_index_fails() {
         .expect("should build");
     let res = run_wasm_session(&mut executor, &global_state, state_root_hash, run_method);
     assert!(res.is_ok());
+
     if let Ok(res) = res {
-        let host_error = res.host_error;
-        assert!(host_error.is_some());
-        if let Some(err) = host_error {
-            println!("XXX {:?}", err);
-        }
+        assert!(matches!(
+            res.host_error,
+            Some(casper_executor_wasm_common::error::CallError::NotCallable)
+        ));
     }
 }
diff --git a/executor/wasm_host/src/host/global_state.rs b/executor/wasm_host/src/host/global_state.rs
@@ -354,6 +354,7 @@ pub(crate) fn host_write<S: GlobalStateReader + 'static>(
         Keyspace::EntryPoint(_) => return Ok(HOST_ERROR_INVALID_INPUT),
     };
 
+    error!("XXXX2");
     metered_write(caller, global_state_key, stored_value)?;
 
     Ok(HOST_ERROR_SUCCESS)
diff --git a/smart_contracts/contracts/vm2/vm2-collections-test/src/vector/assert.rs b/smart_contracts/contracts/vm2/vm2-collections-test/src/vector/assert.rs
@@ -1,4 +1,4 @@
-use core::{panic, ptr::NonNull};
+use core::ptr::NonNull;
 
 use alloc::{vec, vec::Vec};
 use casper_contract_sdk::{
@@ -54,7 +54,21 @@ pub(crate) fn should_retain_assert(vec: &mut Vector<u64>) {
     assert_eq!(vec, vec![2, 4]);
 }
 
-pub(crate) fn test_vec_assert(vec: &mut Vector<u64>) {
+// Assert for scenario in which deletes happen in previous
+// state hash
+pub(crate) fn test_vec_1_assert() {
+    assert_eq!(
+        get_vec_elements_from_storage("test_vec_1"),
+        vec![41, 43, 42, 111, 222, 333]
+    );
+
+    let vec2 = Vector::<u64>::new("test1");
+    assert_eq!(vec2.get(0), None);
+
+    assert_eq!(get_vec_elements_from_storage("test1"), Vec::<u64>::new());
+}
+
+pub(crate) fn test_vec_2_assert(vec: &mut Vector<u64>) {
     assert_eq!(vec.remove(5), Some(334));
     assert_eq!(vec.remove(55), None);
 
@@ -81,7 +95,7 @@ pub(crate) fn test_vec_assert(vec: &mut Vector<u64>) {
     }
 
     assert_eq!(
-        get_vec_elements_from_storage("test_vec"),
+        get_vec_elements_from_storage("test_vec_2"),
         vec![41, 43, 42, 111, 222, 333]
     );
 
diff --git a/smart_contracts/contracts/vm2/vm2-collections-test/src/vector/mod.rs b/smart_contracts/contracts/vm2/vm2-collections-test/src/vector/mod.rs
@@ -9,9 +9,10 @@ use prepare::*;
 
 #[casper]
 pub(crate) struct VectorTestData {
-    should_not_panic_with_empty: Vector<u64>,
     should_retain: Vector<u64>,
-    test_vec: Vector<u64>,
+    should_not_panic_with_empty: Vector<u64>,
+    test_vec_1: Vector<u64>,
+    test_vec_2: Vector<u64>,
     test_pop: Vector<u64>,
     test_contains: Vector<u64>,
     test_clear: Vector<u64>,
@@ -26,9 +27,10 @@ pub(crate) struct VectorTestData {
 impl VectorTestData {
     pub(crate) fn new() -> Self {
         Self {
-            should_not_panic_with_empty: should_not_panic_with_empty_prepare(),
             should_retain: should_retain_prepare(),
-            test_vec: test_vec_prepare(),
+            should_not_panic_with_empty: should_not_panic_with_empty_prepare(),
+            test_vec_1: test_vec_1_prepare(),
+            test_vec_2: test_vec_2_prepare(),
             test_pop: test_pop_prepare(),
             test_contains: test_contains_prepare(),
             test_clear: test_clear_prepare(),
@@ -44,7 +46,7 @@ impl VectorTestData {
     pub(crate) fn do_assertions(&mut self) {
         let should_not_panic_with_empty = &mut self.should_not_panic_with_empty;
         let should_retain = &mut self.should_retain;
-        let test_vec = &mut self.test_vec;
+        let test_vec_2 = &mut self.test_vec_2;
         let test_pop = &mut self.test_pop;
         let test_contains = &mut self.test_contains;
         let test_clear = &mut self.test_clear;
@@ -56,7 +58,8 @@ impl VectorTestData {
         let test_remove_invalid_index = &mut self.test_remove_invalid_index;
         should_not_panic_with_empty_assert(should_not_panic_with_empty);
         should_retain_assert(should_retain);
-        test_vec_assert(test_vec);
+        test_vec_1_assert();
+        test_vec_2_assert(test_vec_2);
         test_pop_assert(test_pop);
         test_contains_assert(test_contains);
         test_clear_assert(test_clear);
diff --git a/smart_contracts/contracts/vm2/vm2-collections-test/src/vector/prepare.rs b/smart_contracts/contracts/vm2/vm2-collections-test/src/vector/prepare.rs
@@ -1,4 +1,4 @@
-use casper_contract_sdk::{casper, collections::Vector};
+use casper_contract_sdk::collections::Vector;
 
 use crate::types::VectorTestStruct;
 
@@ -22,8 +22,51 @@ pub(crate) fn should_retain_prepare() -> Vector<u64> {
     vec
 }
 
-pub(crate) fn test_vec_prepare() -> Vector<u64> {
-    let mut vec = Vector::new("test_vec");
+pub(crate) fn test_vec_1_prepare() -> Vector<u64> {
+    let mut vec = Vector::new("test_vec_1");
+
+    assert!(vec.get(0).is_none());
+    vec.push(111);
+    assert_eq!(vec.get(0), Some(111));
+    vec.push(222);
+    assert_eq!(vec.get(1), Some(222));
+
+    vec.insert(0, 42);
+    vec.insert(0, 41);
+    vec.insert(1, 43);
+    vec.insert(5, 333);
+    vec.insert(5, 334);
+    assert_eq!(vec.remove(5), Some(334));
+    assert_eq!(vec.remove(55), None);
+
+    /*let to_return = vec.clone();
+        let mut iter = (&vec).iter();
+        assert_eq!(iter.next(), Some(41));
+        assert_eq!(iter.next(), Some(43));
+        assert_eq!(iter.next(), Some(42));
+        assert_eq!(iter.next(), Some(111));
+        assert_eq!(iter.next(), Some(222));
+        assert_eq!(iter.next(), Some(333));
+        assert_eq!(iter.next(), None);
+    */
+    {
+        let ser = borsh::to_vec(&vec).unwrap();
+        let deser: Vector<u64> = borsh::from_slice(&ser).unwrap();
+        let mut iter = deser.iter();
+        assert_eq!(iter.next(), Some(41));
+        assert_eq!(iter.next(), Some(43));
+        assert_eq!(iter.next(), Some(42));
+        assert_eq!(iter.next(), Some(111));
+        assert_eq!(iter.next(), Some(222));
+        assert_eq!(iter.next(), Some(333));
+        assert_eq!(iter.next(), None);
+    }
+
+    vec
+}
+
+pub(crate) fn test_vec_2_prepare() -> Vector<u64> {
+    let mut vec = Vector::new("test_vec_2");
 
     assert!(vec.get(0).is_none());
     vec.push(111);
diff --git a/smart_contracts/vm2/sdk/src/casper.rs b/smart_contracts/vm2/sdk/src/casper.rs
@@ -368,7 +368,7 @@ pub enum GetEnvInfoError {
 
 thread_local! {
     /// Env info cache for the current execution
-    static ENV_INFO: RefCell<Option<EnvInfo>> = RefCell::new(None);
+    static ENV_INFO: RefCell<Option<EnvInfo>> = const {RefCell::new(None)};
 }
 
 /// Get the environment info.
diff --git a/smart_contracts/vm2/sdk/src/casper/native.rs b/smart_contracts/vm2/sdk/src/casper/native.rs
@@ -149,6 +149,17 @@ pub struct ExpectedCall {
     result_code: u32,
 }
 
+type CreateInputExpectationTuple<'a> = (
+    Option<&'a [u8]>,
+    u64,
+    Option<&'a str>,
+    Option<&'a [u8]>,
+    Option<&'a [u8; 32]>,
+    Option<&'a [u8]>,
+);
+
+type UpgradeInputExpectationTuple<'a> = (&'a [u8], Option<&'a str>, Option<&'a [u8]>);
+
 impl ExpectedCall {
     pub fn new(
         input_match: Option<Vec<u8>>,
@@ -362,33 +373,22 @@ impl ExpectedCall {
         )
     }
 
-    pub fn expect_read(key: Option<&Keyspace>, output: &[u8]) -> Self {
-        Self::expect_read_with_result_code(key, output, HOST_ERROR_SUCCESS)
-    }
-
-    pub fn expect_read_with_result_code(
+    pub fn expect_read(
         input_expectation: Option<&Keyspace>,
-        output: &[u8],
+        maybe_output: Option<&[u8]>,
         result_code: u32,
     ) -> Self {
         let input_data = input_expectation.map(|x| x.to_host_input_data().unwrap());
         Self::new(
             input_data,
             Some(GlobalStateFunctionOption::Read as u32),
-            Some(output.to_vec()),
+            maybe_output.map(|x| x.to_vec()),
             result_code,
         )
     }
 
     pub fn expect_create(
-        input_expectation: Option<(
-            Option<&[u8]>,
-            u64,
-            Option<&str>,
-            Option<&[u8]>,
-            Option<&[u8; 32]>,
-            Option<&[u8]>,
-        )>,
+        input_expectation: Option<CreateInputExpectationTuple>,
         output: Option<CreateResult>,
         result_code: u32,
     ) -> Self {
@@ -469,7 +469,7 @@ impl ExpectedCall {
     }
 
     pub fn expect_upgrade(
-        input_expectation: Option<(&[u8], Option<&str>, Option<&[u8]>)>,
+        input_expectation: Option<UpgradeInputExpectationTuple>,
         return_code: u32,
     ) -> Self {
         Self::new(
@@ -573,13 +573,12 @@ impl Environment for EnvironmentMock {
         alloc: extern "C" fn(usize, *mut core::ffi::c_void) -> *mut u8,
         alloc_ctx: *const core::ffi::c_void,
     ) -> u32 {
-        let expectation = self.deque_expectation().expect(
-            format!(
+        let expectation = self.deque_expectation().unwrap_or_else(|| {
+            panic!(
                 "Trying to call `casper_ffi` (ffi_opt={}) without enqueued mock results",
                 ffi_opt
             )
-            .as_str(),
-        );
+        });
         if let Some(expected_ffi_opt) = expectation.ffi_opt_match {
             assert_eq!(
                 expected_ffi_opt, ffi_opt,
@@ -674,11 +673,10 @@ where
 {
     use std::panic;
     let call_result = panic::catch_unwind(func);
-    let res = match call_result {
+    match call_result {
         Ok(t) => Ok(t),
         Err(error) => Err(NativeTrap::Panic(error)),
-    };
-    res
+    }
 }
 
 pub fn set_env<T: Environment + 'static>(stub: Arc<T>) {
@@ -736,12 +734,28 @@ mod tests {
         );
 
         let key_3 = Keyspace::NamedKey("abc");
-        env.add_expectation(ExpectedCall::expect_read(Some(&key_3), b"value 2"));
+        env.add_expectation(ExpectedCall::expect_read(
+            Some(&key_3),
+            Some(b"value 2"),
+            HOST_ERROR_SUCCESS,
+        ));
         assert_eq!(casper::read_into_vec(key_3), Ok(Some(b"value 2".to_vec())));
 
-        let key_3 = Keyspace::NamedKey("abc");
-        env.add_expectation(ExpectedCall::expect_read(Some(&key_3), &[]));
-        assert_eq!(casper::read_into_vec(key_3), Err(HostResult::InvalidInput));
+        let key_4 = Keyspace::NamedKey("abc2");
+        env.add_expectation(ExpectedCall::expect_read(
+            Some(&key_4),
+            Some(&[5]),
+            HOST_ERROR_SUCCESS,
+        ));
+        assert_eq!(casper::read_into_vec(key_4), Ok(Some(vec![5])));
+
+        let key_5 = Keyspace::NamedKey("abc3");
+        env.add_expectation(ExpectedCall::expect_read(
+            Some(&key_5),
+            None,
+            HOST_ERROR_INVALID_INPUT,
+        ));
+        assert_eq!(casper::read_into_vec(key_5), Err(HostResult::InvalidInput));
 
         env.add_expectation(ExpectedCall::expect_get_info(Some(EnvInfo {
             protocol_version_major: 2,
diff --git a/smart_contracts/vm2/sdk/src/collections/vector.rs b/smart_contracts/vm2/sdk/src/collections/vector.rs
diff --git a/storage/src/tracking_copy/mod.rs b/storage/src/tracking_copy/mod.rs
diff --git a/storage/src/tracking_copy/tests.rs b/storage/src/tracking_copy/tests.rs

Original file line number	Diff line number	Diff line change
`@@ -368,7 +368,7 @@ pub enum GetEnvInfoError {`
`368`	`368`
`369`	`369`	`thread_local! {`
`370`	`370`	`/// Env info cache for the current execution`
`371`		`- static ENV_INFO: RefCell<Option<EnvInfo>> = RefCell::new(None);`
	`371`	`+ static ENV_INFO: RefCell<Option<EnvInfo>> = const {RefCell::new(None)};`
`372`	`372`	`}`
`373`	`373`
`374`	`374`	`/// Get the environment info.`