Mapping::insert_return_size is back, having now both seal1 and `sea…

…l0` seal_set_storage versions used

crates/engine/src/ext.rs

@@ -227,8 +227,8 @@ impl Engine {
         });
     }
 
-    /// Writes the encoded value into the storage at the given key.
-    pub fn set_storage(&mut self, key: &[u8; 32], encoded_value: &[u8]) {
+    /// Silently writes the encoded value into the storage at the given key.
+    pub fn set_storage_silent(&mut self, key: &[u8; 32], encoded_value: &[u8]) {
         let callee = self.get_callee();
         let account_id = AccountId::from_bytes(&callee[..]);
 
@@ -244,6 +244,21 @@ impl Engine {
         );
     }
 
+    /// Writes the encoded value into the storage at the given key.
+    /// Returns the size of the previously stored value at the key if any.
+    pub fn set_storage(&mut self, key: &[u8; 32], encoded_value: &[u8]) -> Option<u32> {
+        let callee = self.get_callee();
+        let account_id = AccountId::from_bytes(&callee[..]);
+
+        self.debug_info.inc_writes(account_id.clone());
+        self.debug_info
+            .record_cell_for_account(account_id, key.to_vec());
+
+        self.database
+            .insert_into_contract_storage(&callee, key, encoded_value.to_vec())
+            .map(|v| <u32>::try_from(v.len()).expect("usize to u32 conversion failed"))
+    }
+
     /// Returns the decoded contract storage at the key if any.
     pub fn get_storage(&mut self, key: &[u8; 32], output: &mut &mut [u8]) -> Result {
         let callee = self.get_callee();

crates/env/src/api.rs

@@ -183,12 +183,27 @@ where
     })
 }
 
+/// The elder version of the function which is equivalent to the new one
+/// but returns nothing.
+///
+/// # Panics
+///
+/// - If the encode length of value exceeds the configured maximum value length of a storage entry.
+pub fn set_contract_storage_silent<V>(key: &Key, value: &V)
+where
+    V: scale::Encode,
+{
+    <EnvInstance as OnInstance>::on_instance(|instance| {
+        EnvBackend::set_contract_storage_silent::<V>(instance, key, value)
+    });
+}
+
 /// Writes the value to the contract storage under the given key.
 ///
 /// # Panics
 ///
 /// - If the encode length of value exceeds the configured maximum value length of a storage entry.
-pub fn set_contract_storage<V>(key: &Key, value: &V)
+pub fn set_contract_storage<V>(key: &Key, value: &V) -> Option<u32>
 where
     V: scale::Encode,
 {

crates/env/src/backend.rs

@@ -162,8 +162,13 @@ impl CallFlags {
 
 /// Environmental contract functionality that does not require `Environment`.
 pub trait EnvBackend {
+    /// Eqivalent to the newer version but returns nothing.
+    fn set_contract_storage_silent<V>(&mut self, key: &Key, value: &V)
+    where
+        V: scale::Encode;
+
     /// Writes the value to the contract storage under the given key.
-    fn set_contract_storage<V>(&mut self, key: &Key, value: &V)
+    fn set_contract_storage<V>(&mut self, key: &Key, value: &V) -> Option<u32>
     where
         V: scale::Encode;
 

crates/env/src/engine/off_chain/impls.rs

@@ -184,12 +184,20 @@ impl EnvInstance {
 }
 
 impl EnvBackend for EnvInstance {
-    fn set_contract_storage<V>(&mut self, key: &Key, value: &V)
+    fn set_contract_storage_silent<V>(&mut self, key: &Key, value: &V)
     where
         V: scale::Encode,
     {
         let v = scale::Encode::encode(value);
-        self.engine.set_storage(key.as_ref(), &v[..]);
+        self.engine.set_storage_silent(key.as_ref(), &v[..]);
+    }
+
+    fn set_contract_storage<V>(&mut self, key: &Key, value: &V) -> Option<u32>
+    where
+        V: scale::Encode,
+    {
+        let v = scale::Encode::encode(value);
+        self.engine.set_storage(key.as_ref(), &v[..])
     }
 
     fn get_contract_storage<R>(&mut self, key: &Key) -> Result<Option<R>>

crates/env/src/engine/on_chain/ext.rs

@@ -231,7 +231,8 @@ mod sys {
             data_len: u32,
         );
 
-        pub fn seal_set_storage(
+        #[link_name = "seal_set_storage"]
+        pub fn seal_set_storage_silent(
             key_ptr: Ptr32<[u8]>,
             value_ptr: Ptr32<[u8]>,
             value_len: u32,
@@ -380,6 +381,12 @@ mod sys {
             output_ptr: Ptr32Mut<[u8]>,
             output_len_ptr: Ptr32Mut<u32>,
         ) -> ReturnCode;
+
+        pub fn seal_set_storage(
+            key_ptr: Ptr32<[u8]>,
+            value_ptr: Ptr32<[u8]>,
+            value_len: u32,
+        ) -> ReturnCode;
     }
 }
 
@@ -495,16 +502,27 @@ pub fn deposit_event(topics: &[u8], data: &[u8]) {
     }
 }
 
-pub fn set_storage(key: &[u8], encoded_value: &[u8]) {
+pub fn set_storage_silent(key: &[u8], encoded_value: &[u8]) {
     unsafe {
-        sys::seal_set_storage(
+        sys::seal_set_storage_silent(
             Ptr32::from_slice(key),
             Ptr32::from_slice(encoded_value),
             encoded_value.len() as u32,
         )
     }
 }
 
+pub fn set_storage(key: &[u8], encoded_value: &[u8]) -> Option<u32> {
+    let ret_code = unsafe {
+        sys::seal_set_storage(
+            Ptr32::from_slice(key),
+            Ptr32::from_slice(encoded_value),
+            encoded_value.len() as u32,
+        )
+    };
+    ret_code.into()
+}
+
 pub fn clear_storage(key: &[u8]) {
     unsafe { sys::seal_clear_storage(Ptr32::from_slice(key)) }
 }

crates/env/src/engine/on_chain/impls.rs

@@ -219,12 +219,20 @@ impl EnvInstance {
 }
 
 impl EnvBackend for EnvInstance {
-    fn set_contract_storage<V>(&mut self, key: &Key, value: &V)
+    fn set_contract_storage_silent<V>(&mut self, key: &Key, value: &V)
     where
         V: scale::Encode,
     {
         let buffer = self.scoped_buffer().take_encoded(value);
-        ext::set_storage(key.as_ref(), buffer);
+        ext::set_storage_silent(key.as_ref(), buffer);
+    }
+
+    fn set_contract_storage<V>(&mut self, key: &Key, value: &V) -> Option<u32>
+    where
+        V: scale::Encode,
+    {
+        let buffer = self.scoped_buffer().take_encoded(value);
+        ext::set_storage(key.as_ref(), buffer)
     }
 
     fn get_contract_storage<R>(&mut self, key: &Key) -> Result<Option<R>>
@@ -241,6 +249,10 @@ impl EnvBackend for EnvInstance {
         Ok(Some(decoded))
     }
 
+    fn contract_storage_contains(&mut self, key: &Key) -> Option<u32> {
+        ext::storage_contains(key.as_ref())
+    }
+
     fn clear_contract_storage(&mut self, key: &Key) {
         ext::clear_storage(key.as_ref())
     }

crates/storage/src/lazy/mapping.rs

@@ -134,6 +134,18 @@ where
         push_packed_root(value, &self.storage_key(&key));
     }
 
+    /// Insert the given `value` to the contract storage.
+    ///
+    /// Returns the size of the pre-existing value at the specified key if any.
+    #[inline]
+    pub fn insert_return_size<Q, R>(&mut self, key: Q, value: &R) -> Option<u32>
+    where
+        Q: scale::EncodeLike<K>,
+        R: scale::EncodeLike<V> + PackedLayout,
+    {
+        push_packed_root(value, &self.storage_key(&key))
+    }
+
     /// Get the `value` at `key` from the contract storage.
     ///
     /// Returns `None` if no `value` exists at the given `key`.

crates/storage/src/traits/impls/mod.rs

@@ -100,7 +100,7 @@ use super::{
     allocate_packed_root,
     clear_packed_root,
     pull_packed_root,
-    push_packed_root,
+    push_packed_root_silent,
     PackedAllocate,
     PackedLayout,
 };
@@ -162,7 +162,7 @@ pub fn forward_push_packed<T>(entity: &T, ptr: &mut KeyPtr)
 where
     T: PackedLayout,
 {
-    push_packed_root::<T>(entity, ptr.next_for::<T>())
+    push_packed_root_silent::<T>(entity, ptr.next_for::<T>());
 }
 
 /// Clears an instance of type `T` in packed fashion from the contract storage.

crates/storage/src/traits/mod.rs

@@ -187,6 +187,18 @@ where
 
 /// Pushes the entity to the contract storage using packed layout.
 ///
+/// This is the silent equivalent to the newer version.
+pub fn push_packed_root_silent<T>(entity: &T, root_key: &Key)
+where
+    T: PackedLayout,
+{
+    <T as PackedLayout>::push_packed(entity, root_key);
+    ink_env::set_contract_storage_silent(root_key, entity);
+}
+
+/// Pushes the entity to the contract storage using packed layout and
+/// returns the size of the pre-existing value if any.
+///
 /// The root key denotes the offset into the contract storage where the
 /// instance of type `T` is being pushed to.
 ///
@@ -196,12 +208,12 @@ where
 ///   packed layout.
 /// - Users should prefer using this function directly instead of using the
 ///   trait methods on [`PackedLayout`].
-pub fn push_packed_root<T>(entity: &T, root_key: &Key)
+pub fn push_packed_root<T>(entity: &T, root_key: &Key) -> Option<u32>
 where
     T: PackedLayout,
 {
     <T as PackedLayout>::push_packed(entity, root_key);
-    ink_env::set_contract_storage(root_key, entity);
+    ink_env::set_contract_storage(root_key, entity)
 }
 
 /// Clears the entity from the contract storage using packed layout.