Storage rework

crates/env/src/api.rs

@@ -39,7 +39,10 @@ use crate::{
     Environment,
     Result,
 };
-use ink_primitives::Key;
+use ink_primitives::{
+    Key,
+    StorageKey,
+};
 
 /// Returns the address of the caller of the executed contract.
 ///
@@ -229,6 +232,41 @@ pub fn clear_contract_storage(key: &Key) {
     })
 }
 
+/// 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_storage_value<V>(key: &StorageKey, value: &V) -> Option<u32>
+where
+    V: scale::Encode,
+{
+    <EnvInstance as OnInstance>::on_instance(|instance| {
+        EnvBackend::set_storage_value::<V>(instance, key, value)
+    })
+}
+
+/// Returns the value stored under the given key in the contract's storage if any.
+///
+/// # Errors
+///
+/// - If the decoding of the typed value failed (`KeyNotFound`)
+pub fn get_storage_value<R>(key: &StorageKey) -> Result<Option<R>>
+where
+    R: scale::Decode,
+{
+    <EnvInstance as OnInstance>::on_instance(|instance| {
+        EnvBackend::get_storage_value::<R>(instance, key)
+    })
+}
+
+/// Clears the contract's storage key entry.
+pub fn clear_storage_value(key: &StorageKey) {
+    <EnvInstance as OnInstance>::on_instance(|instance| {
+        EnvBackend::clear_storage_value(instance, key)
+    })
+}
+
 /// Invokes a contract message and returns its result.
 ///
 /// # Note

crates/env/src/backend.rs

@@ -27,7 +27,10 @@ use crate::{
     Environment,
     Result,
 };
-use ink_primitives::Key;
+use ink_primitives::{
+    Key,
+    StorageKey,
+};
 
 /// The flags to indicate further information about the end of a contract execution.
 #[derive(Default)]
@@ -183,6 +186,16 @@ pub trait EnvBackend {
     /// Clears the contract's storage key entry.
     fn clear_contract_storage(&mut self, key: &Key);
 
+    fn set_storage_value<V>(&mut self, key: &StorageKey, value: &V) -> Option<u32>
+    where
+        V: scale::Encode;
+
+    fn get_storage_value<R>(&mut self, key: &StorageKey) -> Result<Option<R>>
+    where
+        R: scale::Decode;
+
+    fn clear_storage_value(&mut self, key: &StorageKey);
+
     /// Returns the execution input to the executed contract and decodes it as `T`.
     ///
     /// # Note

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

@@ -44,7 +44,11 @@ use ink_engine::{
     ext,
     ext::Engine,
 };
-use ink_primitives::Key;
+use ink_primitives::{
+    Key,
+    StorageKey,
+    StorageKeyComposer,
+};
 
 /// The capacity of the static buffer.
 /// This is the same size as the ink! on-chain environment. We chose to use the same size
@@ -214,6 +218,24 @@ impl EnvBackend for EnvInstance {
         self.engine.clear_storage(key.as_ref())
     }
 
+    fn set_storage_value<V>(&mut self, key: &StorageKey, value: &V) -> Option<u32>
+    where
+        V: scale::Encode,
+    {
+        self.set_contract_storage(&StorageKeyComposer::old_key(key), value)
+    }
+
+    fn get_storage_value<R>(&mut self, key: &StorageKey) -> Result<Option<R>>
+    where
+        R: scale::Decode,
+    {
+        self.get_contract_storage(&StorageKeyComposer::old_key(key))
+    }
+
+    fn clear_storage_value(&mut self, key: &StorageKey) {
+        self.clear_contract_storage(&StorageKeyComposer::old_key(key))
+    }
+
     fn decode_input<T>(&mut self) -> Result<T>
     where
         T: scale::Decode,

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

@@ -47,7 +47,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 +154,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 +173,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,

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

@@ -386,12 +386,14 @@ mod sys {
     }
 }
 
+#[inline(always)]
 fn extract_from_slice(output: &mut &mut [u8], new_len: usize) {
     debug_assert!(new_len <= output.len());
     let tmp = core::mem::take(output);
     *output = &mut tmp[..new_len];
 }
 
+#[inline(always)]
 pub fn instantiate(
     code_hash: &[u8],
     gas_limit: u64,
@@ -425,6 +427,7 @@ pub fn instantiate(
     ret_code.into()
 }
 
+#[inline(always)]
 pub fn call(
     flags: u32,
     callee: &[u8],
@@ -452,6 +455,7 @@ pub fn call(
     ret_code.into()
 }
 
+#[inline(always)]
 pub fn delegate_call(
     flags: u32,
     code_hash: &[u8],
@@ -513,6 +517,7 @@ pub fn clear_storage(key: &[u8]) {
     unsafe { sys::seal_clear_storage(Ptr32::from_slice(key)) }
 }
 
+#[inline(always)]
 pub fn get_storage(key: &[u8], output: &mut &mut [u8]) -> Result {
     let mut output_len = output.len() as u32;
     let ret_code = {
@@ -537,6 +542,7 @@ pub fn terminate(beneficiary: &[u8]) -> ! {
     unsafe { sys::seal_terminate(Ptr32::from_slice(beneficiary)) }
 }
 
+#[inline(always)]
 pub fn call_chain_extension(func_id: u32, input: &[u8], output: &mut &mut [u8]) -> u32 {
     let mut output_len = output.len() as u32;
     let ret_code = {
@@ -554,6 +560,7 @@ pub fn call_chain_extension(func_id: u32, input: &[u8], output: &mut &mut [u8])
     ret_code.into_u32()
 }
 
+#[inline(always)]
 pub fn input(output: &mut &mut [u8]) {
     let mut output_len = output.len() as u32;
     {
@@ -580,6 +587,7 @@ pub fn return_value(flags: ReturnFlags, return_value: &[u8]) -> ! {
 macro_rules! impl_seal_wrapper_for {
     ( $( ($name:ident => $seal_name:ident), )* ) => {
         $(
+            #[inline(always)]
             pub fn $name(output: &mut &mut [u8]) {
                 let mut output_len = output.len() as u32;
                 {
@@ -590,7 +598,8 @@ macro_rules! impl_seal_wrapper_for {
                         )
                     };
                 }
-                extract_from_slice(output, output_len as usize);
+                // We don't need `extract_from_slice` here because it is stored in the own array
+                // in `get_property_little_endian` and `get_property_inplace`
             }
         )*
     }
@@ -606,6 +615,7 @@ impl_seal_wrapper_for! {
     (minimum_balance => seal_minimum_balance),
 }
 
+#[inline(always)]
 pub fn weight_to_fee(gas: u64, output: &mut &mut [u8]) {
     let mut output_len = output.len() as u32;
     {
@@ -620,6 +630,7 @@ pub fn weight_to_fee(gas: u64, output: &mut &mut [u8]) {
     extract_from_slice(output, output_len as usize);
 }
 
+#[inline(always)]
 pub fn random(subject: &[u8], output: &mut &mut [u8]) {
     let mut output_len = output.len() as u32;
     {

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

@@ -14,6 +14,7 @@
 
 use super::{
     ext,
+    EncodeScope,
     EnvInstance,
     Error as ExtError,
     ScopedBuffer,
@@ -46,7 +47,11 @@ use crate::{
     ReturnFlags,
     TypedEnvBackend,
 };
-use ink_primitives::Key;
+use ink_primitives::{
+    Key,
+    StorageKey,
+    StorageKeyComposer,
+};
 
 impl CryptoHash for Blake2x128 {
     fn hash(input: &[u8], output: &mut <Self as HashOutput>::Type) {
@@ -174,6 +179,7 @@ where
 }
 
 impl EnvInstance {
+    #[inline(always)]
     /// Returns a new scoped buffer for the entire scope of the static 16 kB buffer.
     fn scoped_buffer(&mut self) -> ScopedBuffer {
         ScopedBuffer::from(&mut self.buffer[..])
@@ -184,6 +190,7 @@ impl EnvInstance {
     /// # Note
     ///
     /// This skips the potentially costly decoding step that is often equivalent to a `memcpy`.
+    #[inline(always)]
     fn get_property_inplace<T>(&mut self, ext_fn: fn(output: &mut &mut [u8])) -> T
     where
         T: Default + AsMut<[u8]>,
@@ -198,6 +205,7 @@ impl EnvInstance {
     /// # Note
     ///
     /// This skips the potentially costly decoding step that is often equivalent to a `memcpy`.
+    #[inline(always)]
     fn get_property_little_endian<T>(&mut self, ext_fn: fn(output: &mut &mut [u8])) -> T
     where
         T: FromLittleEndian,
@@ -208,6 +216,7 @@ impl EnvInstance {
     }
 
     /// Returns the contract property value.
+    #[inline(always)]
     fn get_property<T>(&mut self, ext_fn: fn(output: &mut &mut [u8])) -> Result<T>
     where
         T: scale::Decode,
@@ -249,6 +258,24 @@ impl EnvBackend for EnvInstance {
         ext::clear_storage(key.as_ref())
     }
 
+    fn set_storage_value<V>(&mut self, key: &StorageKey, value: &V) -> Option<u32>
+    where
+        V: scale::Encode,
+    {
+        self.set_contract_storage(&StorageKeyComposer::old_key(key), value)
+    }
+
+    fn get_storage_value<R>(&mut self, key: &StorageKey) -> Result<Option<R>>
+    where
+        R: scale::Decode,
+    {
+        self.get_contract_storage(&StorageKeyComposer::old_key(key))
+    }
+
+    fn clear_storage_value(&mut self, key: &StorageKey) {
+        self.clear_contract_storage(&StorageKeyComposer::old_key(key))
+    }
+
     fn decode_input<T>(&mut self) -> Result<T>
     where
         T: scale::Decode,
@@ -260,9 +287,10 @@ impl EnvBackend for EnvInstance {
     where
         R: scale::Encode,
     {
-        let mut scope = self.scoped_buffer();
-        let enc_return_value = scope.take_encoded(return_value);
-        ext::return_value(flags, enc_return_value);
+        let mut scope = EncodeScope::from(&mut self.buffer[..]);
+        return_value.encode_to(&mut scope);
+        let len = scope.len();
+        ext::return_value(flags, &self.buffer[..][..len]);
     }
 
     fn debug_message(&mut self, content: &str) {

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

@@ -18,6 +18,7 @@ mod impls;
 
 use self::{
     buffer::{
+        EncodeScope,
         ScopedBuffer,
         StaticBuffer,
     },

crates/lang/codegen/Cargo.toml

@@ -18,6 +18,7 @@ include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE"]
 name = "ink_lang_codegen"
 
 [dependencies]
+ink_primitives = { version = "3.1.0", path = "../../primitives" }
 ir = { version = "3.1.0", package = "ink_lang_ir", path = "../ir", default-features = false }
 quote = "1"
 syn = { version = "1.0", features = ["parsing", "full", "extra-traits"] }

crates/lang/codegen/src/generator/as_dependency/call_builder.rs

@@ -82,16 +82,9 @@ impl CallBuilder<'_> {
             /// Implements the underlying on-chain calling of the ink! smart contract
             /// messages and trait implementations in a type safe way.
             #[repr(transparent)]
-            #[cfg_attr(feature = "std", derive(
-                ::scale_info::TypeInfo,
-                ::ink_storage::traits::StorageLayout,
-            ))]
+            #[::ink_lang::storage_item]
             #[derive(
                 ::core::fmt::Debug,
-                ::ink_storage::traits::SpreadLayout,
-                ::ink_storage::traits::PackedLayout,
-                ::scale::Encode,
-                ::scale::Decode,
                 ::core::hash::Hash,
                 ::core::cmp::PartialEq,
                 ::core::cmp::Eq,

crates/lang/codegen/src/generator/as_dependency/contract_ref.rs

@@ -86,16 +86,9 @@ impl ContractRef<'_> {
         let storage_ident = self.contract.module().storage().ident();
         let ref_ident = self.generate_contract_ref_ident();
         quote_spanned!(span=>
-            #[cfg_attr(feature = "std", derive(
-                ::scale_info::TypeInfo,
-                ::ink_storage::traits::StorageLayout,
-            ))]
+            #[::ink_lang::storage_item]
             #[derive(
                 ::core::fmt::Debug,
-                ::ink_storage::traits::SpreadLayout,
-                ::ink_storage::traits::PackedLayout,
-                ::scale::Encode,
-                ::scale::Decode,
                 ::core::hash::Hash,
                 ::core::cmp::PartialEq,
                 ::core::cmp::Eq,