Test commit

.config/cargo_spellcheck.dic

@@ -38,6 +38,7 @@ defragmentation
 deploy
 dereferencing
 deserialize/S
+deserialization
 dispatchable/S
 encodable
 evaluable

crates/engine/src/ext.rs

@@ -229,7 +229,7 @@ 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> {
+    pub fn set_storage(&mut self, key: &[u8], encoded_value: &[u8]) -> Option<u32> {
         let callee = self.get_callee();
         let account_id = AccountId::from_bytes(&callee[..]);
 
@@ -243,7 +243,7 @@ impl Engine {
     }
 
     /// Returns the decoded contract storage at the key if any.
-    pub fn get_storage(&mut self, key: &[u8; 32], output: &mut &mut [u8]) -> Result {
+    pub fn get_storage(&mut self, key: &[u8], output: &mut &mut [u8]) -> Result {
         let callee = self.get_callee();
         let account_id = AccountId::from_bytes(&callee[..]);
 
@@ -258,7 +258,7 @@ impl Engine {
     }
 
     /// Returns the size of the value stored in the contract storage at the key if any.
-    pub fn contains_storage(&mut self, key: &[u8; 32]) -> Option<u32> {
+    pub fn contains_storage(&mut self, key: &[u8]) -> Option<u32> {
         let callee = self.get_callee();
         let account_id = AccountId::from_bytes(&callee[..]);
 
@@ -269,14 +269,16 @@ impl Engine {
     }
 
     /// Removes the storage entries at the given key.
-    pub fn clear_storage(&mut self, key: &[u8; 32]) {
+    pub fn clear_storage(&mut self, key: &[u8]) -> Option<u32> {
         let callee = self.get_callee();
         let account_id = AccountId::from_bytes(&callee[..]);
         self.debug_info.inc_writes(account_id.clone());
         let _ = self
             .debug_info
             .remove_cell_for_account(account_id, key.to_vec());
-        let _ = self.database.remove_contract_storage(&callee, key);
+        self.database
+            .remove_contract_storage(&callee, key)
+            .map(|val| val.len() as u32)
     }
 
     /// Remove the calling account and transfer remaining balance.

crates/env/src/api.rs

@@ -39,7 +39,6 @@ use crate::{
     Environment,
     Result,
 };
-use ink_primitives::Key;
 
 /// Returns the address of the caller of the executed contract.
 ///
@@ -183,49 +182,56 @@ where
     })
 }
 
-/// Writes the value to the contract storage under the given key and returns
-/// the size of pre-existing value at the specified key if any.
+/// Writes the value to the contract storage under the given storage key and returns the size
+/// of pre-existing value if any.
 ///
 /// # 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) -> Option<u32>
+pub fn set_contract_storage<K, V>(key: &K, value: &V) -> Option<u32>
 where
+    K: scale::Encode,
     V: scale::Encode,
 {
     <EnvInstance as OnInstance>::on_instance(|instance| {
-        EnvBackend::set_contract_storage::<V>(instance, key, value)
+        EnvBackend::set_contract_storage::<K, V>(instance, key, value)
     })
 }
 
-/// Returns the value stored under the given key in the contract's storage if any.
+/// Returns the value stored under the given storage key in the contract's storage if any.
 ///
 /// # Errors
 ///
 /// - If the decoding of the typed value failed (`KeyNotFound`)
-pub fn get_contract_storage<R>(key: &Key) -> Result<Option<R>>
+pub fn get_contract_storage<K, R>(key: &K) -> Result<Option<R>>
 where
+    K: scale::Encode,
     R: scale::Decode,
 {
     <EnvInstance as OnInstance>::on_instance(|instance| {
-        EnvBackend::get_contract_storage::<R>(instance, key)
+        EnvBackend::get_contract_storage::<K, R>(instance, key)
     })
 }
 
-/// Checks whether there is a value stored under the given key in
-/// the contract's storage.
+/// Checks whether there is a value stored under the given storage key in the contract's storage.
 ///
 /// If a value is stored under the specified key, the size of the value is returned.
-pub fn contract_storage_contains(key: &Key) -> Option<u32> {
+pub fn contains_contract_storage<K>(key: &K) -> Option<u32>
+where
+    K: scale::Encode,
+{
     <EnvInstance as OnInstance>::on_instance(|instance| {
-        EnvBackend::contract_storage_contains(instance, key)
+        EnvBackend::contains_contract_storage::<K>(instance, key)
     })
 }
 
-/// Clears the contract's storage key entry.
-pub fn clear_contract_storage(key: &Key) {
+/// Clears the contract's storage entry under the given storage key.
+pub fn clear_contract_storage<K>(key: &K) -> Option<u32>
+where
+    K: scale::Encode,
+{
     <EnvInstance as OnInstance>::on_instance(|instance| {
-        EnvBackend::clear_contract_storage(instance, key)
+        EnvBackend::clear_contract_storage::<K>(instance, key)
     })
 }
 

crates/env/src/backend.rs

@@ -27,7 +27,6 @@ use crate::{
     Environment,
     Result,
 };
-use ink_primitives::Key;
 
 /// The flags to indicate further information about the end of a contract execution.
 #[derive(Default)]
@@ -162,26 +161,33 @@ impl CallFlags {
 
 /// Environmental contract functionality that does not require `Environment`.
 pub trait EnvBackend {
-    /// Writes the value to the contract storage under the given key and returns
-    /// the size of the pre-existing value at the specified key if any.
-    fn set_contract_storage<V>(&mut self, key: &Key, value: &V) -> Option<u32>
+    /// Writes the value to the contract storage under the given storage key.
+    ///
+    /// Returns the size of the pre-existing value at the specified key if any.
+    fn set_contract_storage<K, V>(&mut self, key: &K, value: &V) -> Option<u32>
     where
+        K: scale::Encode,
         V: scale::Encode;
 
-    /// Returns the value stored under the given key in the contract's storage if any.
+    /// Returns the value stored under the given storage key in the contract's storage if any.
     ///
     /// # Errors
     ///
     /// - If the decoding of the typed value failed
-    fn get_contract_storage<R>(&mut self, key: &Key) -> Result<Option<R>>
+    fn get_contract_storage<K, R>(&mut self, key: &K) -> Result<Option<R>>
     where
+        K: scale::Encode,
         R: scale::Decode;
 
-    /// Returns the size of a value stored under the specified key is returned if any.
-    fn contract_storage_contains(&mut self, key: &Key) -> Option<u32>;
+    /// Returns the size of a value stored under the given storage key is returned if any.
+    fn contains_contract_storage<K>(&mut self, key: &K) -> Option<u32>
+    where
+        K: scale::Encode;
 
-    /// Clears the contract's storage key entry.
-    fn clear_contract_storage(&mut self, key: &Key);
+    /// Clears the contract's storage key entry under the given storage key.
+    fn clear_contract_storage<K>(&mut self, key: &K) -> Option<u32>
+    where
+        K: scale::Encode;
 
     /// Returns the execution input to the executed contract and decodes it as `T`.
     ///

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

@@ -44,7 +44,6 @@ use ink_engine::{
     ext,
     ext::Engine,
 };
-use ink_primitives::Key;
 
 /// The capacity of the static buffer.
 /// This is the same size as the ink! on-chain environment. We chose to use the same size
@@ -184,20 +183,22 @@ impl EnvInstance {
 }
 
 impl EnvBackend for EnvInstance {
-    fn set_contract_storage<V>(&mut self, key: &Key, value: &V) -> Option<u32>
+    fn set_contract_storage<K, V>(&mut self, key: &K, value: &V) -> Option<u32>
     where
+        K: scale::Encode,
         V: scale::Encode,
     {
         let v = scale::Encode::encode(value);
-        self.engine.set_storage(key.as_ref(), &v[..])
+        self.engine.set_storage(&key.encode(), &v[..])
     }
 
-    fn get_contract_storage<R>(&mut self, key: &Key) -> Result<Option<R>>
+    fn get_contract_storage<K, R>(&mut self, key: &K) -> Result<Option<R>>
     where
+        K: scale::Encode,
         R: scale::Decode,
     {
         let mut output: [u8; 9600] = [0; 9600];
-        match self.engine.get_storage(key.as_ref(), &mut &mut output[..]) {
+        match self.engine.get_storage(&key.encode(), &mut &mut output[..]) {
             Ok(_) => (),
             Err(ext::Error::KeyNotFound) => return Ok(None),
             Err(_) => panic!("encountered unexpected error"),
@@ -206,12 +207,18 @@ impl EnvBackend for EnvInstance {
         Ok(Some(decoded))
     }
 
-    fn contract_storage_contains(&mut self, key: &Key) -> Option<u32> {
-        self.engine.contains_storage(key.as_ref())
+    fn contains_contract_storage<K>(&mut self, key: &K) -> Option<u32>
+    where
+        K: scale::Encode,
+    {
+        self.engine.contains_storage(&key.encode())
     }
 
-    fn clear_contract_storage(&mut self, key: &Key) {
-        self.engine.clear_storage(key.as_ref())
+    fn clear_contract_storage<K>(&mut self, key: &K) -> Option<u32>
+    where
+        K: scale::Encode,
+    {
+        self.engine.clear_storage(&key.encode())
     }
 
     fn decode_input<T>(&mut self) -> Result<T>

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

@@ -33,12 +33,14 @@ impl StaticBuffer {
 impl core::ops::Index<core::ops::RangeFull> for StaticBuffer {
     type Output = [u8];
 
+    #[inline(always)]
     fn index(&self, index: core::ops::RangeFull) -> &Self::Output {
         core::ops::Index::index(&self.buffer[..], index)
     }
 }
 
 impl core::ops::IndexMut<core::ops::RangeFull> for StaticBuffer {
+    #[inline(always)]
     fn index_mut(&mut self, index: core::ops::RangeFull) -> &mut Self::Output {
         core::ops::IndexMut::index_mut(&mut self.buffer[..], index)
     }
@@ -47,7 +49,7 @@ impl core::ops::IndexMut<core::ops::RangeFull> for StaticBuffer {
 /// Utility to allow for non-heap allocating encoding into a static buffer.
 ///
 /// Required by `ScopedBuffer` internals.
-struct EncodeScope<'a> {
+pub struct EncodeScope<'a> {
     buffer: &'a mut [u8],
     len: usize,
 }
@@ -154,6 +156,7 @@ impl<'a> ScopedBuffer<'a> {
 
     /// Encode the given value into the scoped buffer and return the sub slice
     /// containing all the encoded bytes.
+    #[inline(always)]
     pub fn take_encoded<T>(&mut self, value: &T) -> &'a mut [u8]
     where
         T: scale::Encode,
@@ -172,6 +175,7 @@ impl<'a> ScopedBuffer<'a> {
     /// Does not return the buffer immediately so that other values can be appended
     /// afterwards. The [`take_appended`] method shall be used to return the buffer
     /// that includes all appended encodings as a single buffer.
+    #[inline(always)]
     pub fn append_encoded<T>(&mut self, value: &T)
     where
         T: scale::Encode,