Caller is origin implementation

CHANGELOG.md

@@ -9,6 +9,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - [E2E] Call builders and extra gas margin option - [#1917](https://github.com/paritytech/ink/pull/1917)
 - Make `set_code_hash` generic - [#1906](https://github.com/paritytech/ink/pull/1906)
 - Clean E2E configuration parsing - [#1922](https://github.com/paritytech/ink/pull/1922)
+- Implement contract invokation in off-chain environment engine - [#1957](https://github.com/paritytech/ink/pull/1988)
+- Implement `caller_is_origin()` in off-chain environment engine - [#1991](https://github.com/paritytech/ink/pull/1991)
 
 ### Changed
 - Fail when decoding from storage and not all bytes consumed - [#1897](https://github.com/paritytech/ink/pull/1897)

crates/engine/src/database.rs

@@ -18,6 +18,9 @@ use std::collections::HashMap;
 
 const BALANCE_OF: &[u8] = b"balance:";
 const STORAGE_OF: &[u8] = b"contract-storage:";
+const CONTRACT_PREFIX: &[u8] = b"contract:";
+const MSG_HANDLER_OF: &[u8] = b"message-handler:";
+const CODE_HASH_OF: &[u8] = b"code-hash:";
 
 /// Returns the database key under which to find the balance for account `who`.
 pub fn balance_of_key(who: &[u8]) -> [u8; 32] {
@@ -35,20 +38,47 @@ pub fn storage_of_contract_key(who: &[u8], key: &[u8]) -> [u8; 32] {
     hashed_key
 }
 
+pub type MessageHandler = fn(Vec<u8>) -> Vec<u8>;
+
+pub fn contract_key(f: MessageHandler) -> [u8; 32] {
+    let f = f as usize;
+    let f = f.to_le_bytes();
+    let keyed = f.to_vec().to_keyed_vec(CONTRACT_PREFIX);
+    let mut ret: [u8; 32] = [0; 32];
+    super::hashing::blake2b_256(&keyed[..], &mut ret);
+    ret
+}
+
+pub fn message_handler_of_contract_key(key: &[u8]) -> [u8; 32] {
+    let keyed = key.to_vec().to_keyed_vec(MSG_HANDLER_OF);
+    let mut hashed_key: [u8; 32] = [0; 32];
+    super::hashing::blake2b_256(&keyed[..], &mut hashed_key);
+    hashed_key
+}
+
+pub fn code_hash_of_key(key: &Vec<u8>) -> [u8; 32] {
+    let keyed = key.to_keyed_vec(CODE_HASH_OF);
+    let mut hashed_key: [u8; 32] = [0; 32];
+    super::hashing::blake2b_256(&keyed[..], &mut hashed_key);
+    hashed_key
+}
+
 /// The chain database.
 ///
 /// Everything is stored in here: accounts, balances, contract storage, etc..
 /// Just like in Substrate a prefix hash is computed for every contract.
 #[derive(Default)]
 pub struct Database {
     hmap: HashMap<Vec<u8>, Vec<u8>>,
+    fmap: HashMap<Vec<u8>, MessageHandler>,
 }
 
 impl Database {
     /// Creates a new database instance.
     pub fn new() -> Self {
         Database {
             hmap: HashMap::new(),
+            fmap: HashMap::new(),
         }
     }
 
@@ -128,6 +158,34 @@ impl Database {
             .and_modify(|v| *v = encoded_balance.clone())
             .or_insert(encoded_balance);
     }
+
+    pub fn set_contract_message_handler(&mut self, handler: MessageHandler) -> [u8; 32] {
+        let key = contract_key(handler);
+        let hashed_key = message_handler_of_contract_key(&key);
+        self.fmap
+            .entry(hashed_key.to_vec())
+            .and_modify(|x| *x = handler)
+            .or_insert(handler);
+        key
+    }
+
+    pub fn get_contract_message_handler(&mut self, key: &[u8]) -> MessageHandler {
+        let hashed_key = message_handler_of_contract_key(key);
+        *self.fmap.get(&hashed_key.to_vec()).unwrap()
+    }
+
+    pub fn set_code_hash(&mut self, account: &Vec<u8>, code_hash: &[u8]) {
+        let hashed_key = code_hash_of_key(account);
+        self.hmap
+            .entry(hashed_key.to_vec())
+            .and_modify(|x| *x = code_hash.to_vec())
+            .or_insert(code_hash.to_vec());
+    }
+
+    pub fn get_code_hash(&self, account: &Vec<u8>) -> Option<Vec<u8>> {
+        let hashed_key = code_hash_of_key(account);
+        self.get(&hashed_key).cloned()
+    }
 }
 
 #[cfg(test)]

crates/engine/src/exec_context.rs

@@ -45,6 +45,8 @@ pub struct ExecContext {
     pub block_timestamp: BlockTimestamp,
     /// Known contract accounts
     pub contracts: Vec<Vec<u8>>,
+    /// This value is used to know the origin of the contract calls.
+    pub depth: u8,
 }
 
 impl ExecContext {

crates/engine/src/ext.rs

@@ -505,6 +505,10 @@ impl Engine {
             Err(_) => Err(Error::EcdsaRecoveryFailed),
         }
     }
+
+    pub fn caller_is_origin(&self) -> bool {
+        self.exec_context.depth == 0
+    }
 }
 
 /// Copies the `slice` into `output`.

crates/engine/src/lib.rs

@@ -23,7 +23,7 @@ pub mod test_api;
 mod chain_extension;
 mod database;
 mod exec_context;
-mod hashing;
+pub mod hashing;
 mod types;
 
 #[cfg(test)]

crates/env/Cargo.toml

@@ -60,6 +60,7 @@ ink = { path = "../ink" }
 [features]
 default = ["std"]
 std = [
+    "ink/std",
     "ink_allocator/std",
     "ink_prelude/std",
     "ink_primitives/std",
@@ -77,6 +78,7 @@ std = [
     "sha3",
     "blake2",
 ]
+test_instantiate = []
 
 # Enable contract debug messages via `debug_print!` and `debug_println!`.
 ink-debug = []

crates/env/src/api.rs

@@ -37,8 +37,10 @@ use crate::{
         CryptoHash,
         HashOutput,
     },
-    types::Gas,
-    Environment,
+    types::{
+        Environment,
+        Gas,
+    },
     Result,
 };
 use ink_storage_traits::Storable;
@@ -336,7 +338,9 @@ pub fn instantiate_contract<E, ContractRef, Args, Salt, R>(
 >
 where
     E: Environment,
-    ContractRef: FromAccountId<E>,
+    ContractRef: FromAccountId<E> + crate::ContractReverseReference,
+    <ContractRef as crate::ContractReverseReference>::Type:
+        crate::reflect::ContractConstructorDecoder,
     Args: scale::Encode,
     Salt: AsRef<[u8]>,
     R: ConstructorReturnType<ContractRef>,
@@ -426,6 +430,7 @@ where
 /// # Note
 ///
 /// This function  stops the execution of the contract immediately.
+#[cfg(not(feature = "test_instantiate"))]
 pub fn return_value<R>(return_flags: ReturnFlags, return_value: &R) -> !
 where
     R: scale::Encode,
@@ -435,6 +440,22 @@ where
     })
 }
 
+/// Returns the value back to the caller of the executed contract.
+///
+/// # Note
+///
+/// When the test_instantiate feature is used, the contract is allowed to
+/// return normally. This feature should only be used for integration tests.
+#[cfg(feature = "test_instantiate")]
+pub fn return_value<R>(return_flags: ReturnFlags, return_value: &R)
+where
+    R: scale::Encode,
+{
+    <EnvInstance as OnInstance>::on_instance(|instance| {
+        EnvBackend::return_value::<R>(instance, return_flags, return_value)
+    })
+}
+
 /// Appends the given message to the debug message buffer.
 pub fn debug_message(message: &str) {
     <EnvInstance as OnInstance>::on_instance(|instance| {

crates/env/src/backend.rs

@@ -26,7 +26,7 @@ use crate::{
         CryptoHash,
         HashOutput,
     },
-    Environment,
+    types::Environment,
     Result,
 };
 use ink_storage_traits::Storable;
@@ -247,10 +247,25 @@ pub trait EnvBackend {
     ///
     /// The `flags` parameter can be used to revert the state changes of the
     /// entire execution if necessary.
+    #[cfg(not(feature = "test_instantiate"))]
     fn return_value<R>(&mut self, flags: ReturnFlags, return_value: &R) -> !
     where
         R: scale::Encode;
 
+    /// Returns the value back to the caller of the executed contract.
+    ///
+    /// # Note
+    ///
+    /// When the test_instantiate feature is used, the contract is allowed to
+    /// return normally. This feature should only be used for integration tests.
+    ///
+    /// The `flags` parameter can be used to revert the state changes of the
+    /// entire execution if necessary.
+    #[cfg(feature = "test_instantiate")]
+    fn return_value<R>(&mut self, flags: ReturnFlags, return_value: &R)
+    where
+        R: scale::Encode;
+
     /// Emit a custom debug message.
     ///
     /// The message is appended to the debug buffer which is then supplied to the calling
@@ -469,7 +484,9 @@ pub trait TypedEnvBackend: EnvBackend {
     >
     where
         E: Environment,
-        ContractRef: FromAccountId<E>,
+        ContractRef: FromAccountId<E> + crate::ContractReverseReference,
+        <ContractRef as crate::ContractReverseReference>::Type:
+            crate::reflect::ContractConstructorDecoder,
         Args: scale::Encode,
         Salt: AsRef<[u8]>,
         R: ConstructorReturnType<ContractRef>;

crates/env/src/call/call_builder.rs

@@ -23,8 +23,10 @@ use crate::{
         },
         ExecutionInput,
     },
-    types::Gas,
-    Environment,
+    types::{
+        Environment,
+        Gas,
+    },
     Error,
 };
 use core::marker::PhantomData;

crates/env/src/call/create_builder.rs

@@ -24,8 +24,8 @@ use crate::{
         ExecutionInput,
         Selector,
     },
+    types::Environment,
     ContractEnv,
-    Environment,
     Error,
 };
 use core::marker::PhantomData;
@@ -240,7 +240,11 @@ where
 impl<E, ContractRef, Args, Salt, R> CreateParams<E, ContractRef, Args, Salt, R>
 where
     E: Environment,
-    ContractRef: FromAccountId<E>,
+    ContractRef: FromAccountId<E> + crate::ContractReverseReference,
+    <ContractRef as crate::ContractReverseReference>::Type:
+        crate::reflect::ContractConstructorDecoder,
+    <ContractRef as crate::ContractReverseReference>::Type:
+        crate::reflect::ContractMessageDecoder,
     Args: scale::Encode,
     Salt: AsRef<[u8]>,
     R: ConstructorReturnType<ContractRef>,
@@ -721,7 +725,11 @@ impl<E, ContractRef, GasLimit, Args, Salt, RetType>
     >
 where
     E: Environment,
-    ContractRef: FromAccountId<E>,
+    ContractRef: FromAccountId<E> + crate::ContractReverseReference,
+    <ContractRef as crate::ContractReverseReference>::Type:
+        crate::reflect::ContractConstructorDecoder,
+    <ContractRef as crate::ContractReverseReference>::Type:
+        crate::reflect::ContractMessageDecoder,
     GasLimit: Unwrap<Output = u64>,
     Args: scale::Encode,
     Salt: AsRef<[u8]>,

crates/env/src/engine/mod.rs

@@ -77,7 +77,7 @@ pub(crate) fn decode_instantiate_result<I, E, ContractRef, R>(
 ) -> EnvResult<ConstructorResult<<R as ConstructorReturnType<ContractRef>>::Output>>
 where
     I: scale::Input,
-    E: crate::Environment,
+    E: crate::types::Environment,
     ContractRef: FromAccountId<E>,
     R: ConstructorReturnType<ContractRef>,
 {
@@ -102,7 +102,7 @@ fn decode_instantiate_err<I, E, ContractRef, R>(
 ) -> EnvResult<ConstructorResult<<R as ConstructorReturnType<ContractRef>>::Output>>
 where
     I: scale::Input,
-    E: crate::Environment,
+    E: crate::types::Environment,
     ContractRef: FromAccountId<E>,
     R: ConstructorReturnType<ContractRef>,
 {