Implement S/T Storage getters/setters and call_data_load, return_data_copy hostfns

CHANGELOG.md

@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 [Unreleased]
 
 ### Added
+- Implements the API for the `pallet-revive` host functions `set_storage_or_clear`, `get_storage_or_zero`, `call_data_load`, `return_data_copy` - [#2739](https://github.com/use-ink/ink/pull/2739)
 - Implements the API for the `pallet-revive` host functions `chain_id`, `balance_of`, `base_fee`, `origin`, `code_size`, `block_hash`, `block_author` - [#2719](https://github.com/use-ink/ink/pull/2719)
 - Implement `From<ink::Address>` for "ink-as-dependency" contract refs - [#2728](https://github.com/use-ink/ink/pull/2728)
 

crates/env/src/api.rs

@@ -170,6 +170,61 @@ pub fn block_author() -> Address {
     <EnvInstance as OnInstance>::on_instance(TypedEnvBackend::block_author)
 }
 
+/// Returns the U256 value at the given offset from the input passed by the caller,
+/// akin to the EVM [CALLDATALOAD](https://www.evm.codes/?fork=cancun#35) opcode.
+///
+/// # Note
+///
+/// - If `offset` is out of bounds, a value of zero will be returned.
+/// - If `offset` is in bounds but there is not enough call data, the available data is
+///   right-padded in order to fill a whole U256 value.
+/// - The data returned is a little endian U256 integer value.
+pub fn call_data_load(offset: u32) -> U256 {
+    <EnvInstance as OnInstance>::on_instance(|instance| {
+        TypedEnvBackend::call_data_load(instance, offset)
+    })
+}
+
+/// Sets the storage entry for a fixed 256-bit key with a fixed 256-bit value,
+/// akin to the EVM [SSTORE](https://www.evm.codes/?fork=cancun#55) opcode.
+///
+/// If the provided value is all zeros then the key is cleared (i.e. deleted).
+/// Returns the size (in bytes) of the pre-existing value at the specified key, if any.
+pub fn set_storage(key: U256, value: &[u8; 32]) -> Option<u32> {
+    <EnvInstance as OnInstance>::on_instance(|instance| {
+        TypedEnvBackend::set_storage(instance, key, value)
+    })
+}
+
+/// Sets the transient storage entry for a fixed 256-bit key with a fixed 256-bit value,
+/// akin to the EVM [TSTORE](https://www.evm.codes/?fork=cancun#5D) opcode.
+///
+/// If the provided value is all zeros then the key is cleared (i.e. deleted).
+/// Returns the size (in bytes) of the pre-existing value at the specified key, if any.
+pub fn set_transient_storage(key: U256, value: &[u8; 32]) -> Option<u32> {
+    <EnvInstance as OnInstance>::on_instance(|instance| {
+        TypedEnvBackend::set_transient_storage(instance, key, value)
+    })
+}
+
+/// Retrieves the storage entry for a fixed 256-bit key.
+/// If the key does not exist, it returns 32 zero bytes.
+/// This is akin to the EVM [SLOAD](https://www.evm.codes/?fork=cancun#54) opcode.
+pub fn get_storage(key: U256) -> [u8; 32] {
+    <EnvInstance as OnInstance>::on_instance(|instance| {
+        TypedEnvBackend::get_storage(instance, key)
+    })
+}
+
+/// Retrieves the transient storage entry for a fixed 256-bit key.
+/// If the key does not exist, it returns 32 zero bytes.
+/// This is akin to the EVM [TLOAD](https://www.evm.codes/?fork=cancun#5C) opcode.
+pub fn get_transient_storage(key: U256) -> [u8; 32] {
+    <EnvInstance as OnInstance>::on_instance(|instance| {
+        TypedEnvBackend::get_transient_storage(instance, key)
+    })
+}
+
 /// Returns the transferred value for the contract execution.
 ///
 /// # Errors

crates/env/src/backend.rs

@@ -369,6 +369,57 @@ pub trait TypedEnvBackend: EnvBackend {
     /// For more details visit: [`block_author`][`crate::block_author`]
     fn block_author(&mut self) -> Address;
 
+    /// Returns the U256 value at given `offset` from the input passed by the caller.
+    /// This is akin to the EVM [CALLDATALOAD](https://www.evm.codes/?fork=cancun#35) opcode.
+    ///
+    /// # Note
+    ///
+    /// - If `offset` is out of bounds, a value of zero will be returned.
+    /// - If `offset` is in bounds but there is not enough call data, the available data
+    /// is right-padded in order to fill a whole U256 value.
+    /// - The data returned is a little endian U256 integer value.
+    ///
+    /// For more details visit: [`call_data_load`][`crate::call_data_load`]
+    fn call_data_load(&mut self, offset: u32) -> U256;
+
+    /// Sets the storage entry for a fixed 256‑bit key with a fixed 256‑bit value.
+    /// If the provided 32‑byte value is all zeros then the key is cleared (i.e. deleted).
+    /// Returns the size (in bytes) of the pre‑existing value at the specified key, if
+    /// any. This is akin to the EVM [SSTORE](https://www.evm.codes/?fork=cancun#55) opcode.
+    ///
+    /// # Note
+    ///
+    /// For more details visit: [`set_storage`][`crate::set_storage`]
+    fn set_storage(&mut self, key: U256, value: &[u8; 32]) -> Option<u32>;
+
+    /// Sets the transient storage entry for a fixed 256‑bit key with a fixed 256‑bit
+    /// value. If the provided 32‑byte value is all zeros then the key is cleared
+    /// (i.e. deleted). Returns the size (in bytes) of the pre‑existing value at the
+    /// specified key, if any. This is akin to the EVM [TSTORE](https://www.evm.codes/?fork=cancun#5D) opcode.
+    ///
+    /// # Note
+    ///
+    /// For more details visit: [`set_transient_storage`][`crate::set_transient_storage`]
+    fn set_transient_storage(&mut self, key: U256, value: &[u8; 32]) -> Option<u32>;
+
+    /// Retrieves the storage entry for a fixed 256‑bit key.
+    /// If the key does not exist, it returns 32 zero bytes.
+    /// This is akin to the EVM [SLOAD](https://www.evm.codes/?fork=cancun#54) opcode.
+    ///
+    /// # Note
+    ///
+    /// For more details visit: [`get_storage`][`crate::get_storage`]
+    fn get_storage(&mut self, key: U256) -> [u8; 32];
+
+    /// Retrieves the transient storage entry for a fixed 256‑bit key.
+    /// If the key does not exist, it returns 32 zero bytes.
+    /// This is akin to the EVM [TLOAD](https://www.evm.codes/?fork=cancun#5C) opcode.
+    ///
+    /// # Note
+    ///
+    /// For more details visit: [`get_transient_storage`][`crate::get_transient_storage`]
+    fn get_transient_storage(&mut self, key: U256) -> [u8; 32];
+
     /// Returns the transferred value for the contract execution.
     ///
     /// # Note

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

@@ -616,6 +616,26 @@ impl TypedEnvBackend for EnvInstance {
         unimplemented!("not implemented, the off-chain environment will be removed");
     }
 
+    fn call_data_load(&mut self, _offset: u32) -> U256 {
+        unimplemented!("not implemented, the off-chain environment will be removed");
+    }
+
+    fn set_storage(&mut self, _key: U256, _value: &[u8; 32]) -> Option<u32> {
+        unimplemented!("not implemented, the off-chain environment will be removed");
+    }
+
+    fn set_transient_storage(&mut self, _key: U256, _value: &[u8; 32]) -> Option<u32> {
+        unimplemented!("not implemented, the off-chain environment will be removed");
+    }
+
+    fn get_storage(&mut self, _key: U256) -> [u8; 32] {
+        unimplemented!("not implemented, the off-chain environment will be removed");
+    }
+
+    fn get_transient_storage(&mut self, _key: U256) -> [u8; 32] {
+        unimplemented!("not implemented, the off-chain environment will be removed");
+    }
+
     fn transferred_value(&mut self) -> U256 {
         self.get_property(Engine::value_transferred)
             .unwrap_or_else(|error| {

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

@@ -647,6 +647,7 @@ fn decode_bytes(input: &[u8], out: &mut [u8]) -> usize {
 }
 
 const STORAGE_FLAGS: StorageFlags = StorageFlags::empty();
+const TRANSIENT_STORAGE_FLAGS: StorageFlags = StorageFlags::TRANSIENT;
 
 impl EnvBackend for EnvInstance {
     fn set_contract_storage<K, V>(&mut self, key: &K, value: &V) -> Option<u32>
@@ -1093,6 +1094,42 @@ impl TypedEnvBackend for EnvInstance {
         h160.into()
     }
 
+    fn call_data_load(&mut self, offset: u32) -> U256 {
+        let mut scope = self.scoped_buffer();
+        let u256: &mut [u8; 32] = scope.take(32).try_into().unwrap();
+
+        ext::call_data_load(u256, offset);
+        U256::from_le_bytes(*u256)
+    }
+
+    fn set_storage(&mut self, key: U256, value: &[u8; 32]) -> Option<u32> {
+        let mut scope = self.scoped_buffer();
+        let key: &mut [u8; 32] = scope.take_encoded(&key).try_into().unwrap();
+        ext::set_storage_or_clear(STORAGE_FLAGS, key, value)
+    }
+
+    fn set_transient_storage(&mut self, key: U256, value: &[u8; 32]) -> Option<u32> {
+        let mut scope = self.scoped_buffer();
+        let key: &mut [u8; 32] = scope.take_encoded(&key).try_into().unwrap();
+        ext::set_storage_or_clear(TRANSIENT_STORAGE_FLAGS, key, value)
+    }
+
+    fn get_storage(&mut self, key: U256) -> [u8; 32] {
+        let mut scope = self.scoped_buffer();
+        let key: &mut [u8; 32] = scope.take_encoded(&key).try_into().unwrap();
+        let value: &mut [u8; 32] = scope.take(32).try_into().unwrap();
+        ext::get_storage_or_zero(STORAGE_FLAGS, key, value);
+        *value
+    }
+
+    fn get_transient_storage(&mut self, key: U256) -> [u8; 32] {
+        let mut scope = self.scoped_buffer();
+        let key: &mut [u8; 32] = scope.take_encoded(&key).try_into().unwrap();
+        let value: &mut [u8; 32] = scope.take(32).try_into().unwrap();
+        ext::get_storage_or_zero(TRANSIENT_STORAGE_FLAGS, key, value);
+        *value
+    }
+
     fn transferred_value(&mut self) -> U256 {
         let mut scope = self.scoped_buffer();
         let u256: &mut [u8; 32] = scope.take(32).try_into().unwrap();

crates/ink/src/env_access.rs

@@ -274,6 +274,188 @@ where
         ink_env::return_data_size()
     }
 
+    /// Returns the U256 value at the given offset from the input passed by the caller,
+    /// akin to the EVM [CALLDATALOAD](https://www.evm.codes/?fork=cancun#35) opcode.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// #[ink::contract]
+    /// mod my_contract {
+    ///     use ink::U256;
+    ///
+    ///     #[ink(storage)]
+    ///     pub struct MyContract;
+    ///
+    ///     impl MyContract {
+    ///         #[ink(constructor)]
+    ///         pub fn new() -> Self {
+    ///             Self {}
+    ///         }
+    ///
+    ///         #[ink(message)]
+    ///         pub fn get_call_data_at_offset(&self, offset: u32) -> U256 {
+    ///             self.env().call_data_load(offset)
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// # Note
+    ///
+    /// For more details visit: [`ink_env::call_data_load`]
+    pub fn call_data_load(self, offset: u32) -> U256 {
+        ink_env::call_data_load(offset)
+    }
+
+    /// Sets the storage entry for a fixed 256-bit key with a fixed 256-bit value.
+    /// If the provided 32-byte value is all zeros then the key is cleared (i.e. deleted).
+    /// Returns the size (in bytes) of the pre-existing value at the specified key, if
+    /// any. This is akin to the EVM [SSTORE](https://www.evm.codes/?fork=cancun#55) opcode.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// #[ink::contract]
+    /// mod my_contract {
+    ///     use ink::U256;
+    ///
+    ///     #[ink(storage)]
+    ///     pub struct MyContract;
+    ///
+    ///     impl MyContract {
+    ///         #[ink(constructor)]
+    ///         pub fn new() -> Self {
+    ///             Self {}
+    ///         }
+    ///
+    ///         #[ink(message)]
+    ///         pub fn store_value(&self) {
+    ///             let key = U256::from(42u32);
+    ///             let value = [0xDEu8; 32];
+    ///             self.env().set_storage(key, &value);
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// # Note
+    ///
+    /// For more details visit: [`ink_env::set_storage`]
+    pub fn set_storage(self, key: U256, value: &[u8; 32]) -> Option<u32> {
+        ink_env::set_storage(key, value)
+    }
+
+    /// Sets the transient storage entry for a fixed 256-bit key with a fixed 256-bit
+    /// value. If the provided 32-byte value is all zeros then the key is cleared
+    /// (i.e. deleted). Returns the size (in bytes) of the pre-existing value at the
+    /// specified key, if any. This is akin to the EVM [TSTORE](https://www.evm.codes/?fork=cancun#5D) opcode.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// #[ink::contract]
+    /// mod my_contract {
+    ///     use ink::U256;
+    ///
+    ///     #[ink(storage)]
+    ///     pub struct MyContract;
+    ///
+    ///     impl MyContract {
+    ///         #[ink(constructor)]
+    ///         pub fn new() -> Self {
+    ///             Self {}
+    ///         }
+    ///
+    ///         #[ink(message)]
+    ///         pub fn store_transient(&self) {
+    ///             let key = U256::from(42u32);
+    ///             let value = [0xABu8; 32];
+    ///             self.env().set_transient_storage(key, &value);
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// # Note
+    ///
+    /// For more details visit: [`ink_env::set_transient_storage`]
+    pub fn set_transient_storage(self, key: U256, value: &[u8; 32]) -> Option<u32> {
+        ink_env::set_transient_storage(key, value)
+    }
+
+    /// Retrieves the storage entry for a fixed 256-bit key.
+    /// If the key does not exist, it returns 32 zero bytes.
+    /// This is akin to the EVM [SLOAD](https://www.evm.codes/?fork=cancun#54) opcode.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// #[ink::contract]
+    /// mod my_contract {
+    ///     use ink::U256;
+    ///
+    ///     #[ink(storage)]
+    ///     pub struct MyContract;
+    ///
+    ///     impl MyContract {
+    ///         #[ink(constructor)]
+    ///         pub fn new() -> Self {
+    ///             Self {}
+    ///         }
+    ///
+    ///         #[ink(message)]
+    ///         pub fn load_value(&self) -> [u8; 32] {
+    ///             let key = U256::from(42u32);
+    ///             self.env().get_storage(key)
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// # Note
+    ///
+    /// For more details visit: [`ink_env::get_storage`]
+    pub fn get_storage(self, key: U256) -> [u8; 32] {
+        ink_env::get_storage(key)
+    }
+
+    /// Retrieves the transient storage entry for a fixed 256-bit key.
+    /// If the key does not exist, it returns 32 zero bytes.
+    /// This is akin to the EVM [TLOAD](https://www.evm.codes/?fork=cancun#5C) opcode.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// #[ink::contract]
+    /// mod my_contract {
+    ///     use ink::U256;
+    ///
+    ///     #[ink(storage)]
+    ///     pub struct MyContract;
+    ///
+    ///     impl MyContract {
+    ///         #[ink(constructor)]
+    ///         pub fn new() -> Self {
+    ///             Self {}
+    ///         }
+    ///
+    ///         #[ink(message)]
+    ///         pub fn load_transient(&self) -> [u8; 32] {
+    ///             let key = U256::from(42u32);
+    ///             self.env().get_transient_storage(key)
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// # Note
+    ///
+    /// For more details visit: [`ink_env::get_transient_storage`]
+    pub fn get_transient_storage(self, key: U256) -> [u8; 32] {
+        ink_env::get_transient_storage(key)
+    }
+
     /// Returns the [EIP-155](https://eips.ethereum.org/EIPS/eip-155) chain ID,
     /// akin to the EVM [CHAINID](https://www.evm.codes/?fork=cancun#46) opcode.
     ///