Implemented contract instantiation and invocation for integration tests

CHANGELOG.md

@@ -6,6 +6,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 [Unreleased]
 
+- Implement contract invokation in off-chain environment engine - [#1957](https://github.com/paritytech/ink/pull/1988)
+
 ## Changed
 - Restrict which `cfg` attributes can be used ‒ [#2313](https://github.com/use-ink/ink/pull/2313)
 

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] {
@@ -27,6 +30,31 @@ pub fn balance_of_key(who: &[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
+}
+
 /// Returns the database key under which to find the balance for account `who`.
 pub fn storage_of_contract_key(who: &[u8], key: &[u8]) -> [u8; 32] {
     let keyed = who.to_vec().to_keyed_vec(key).to_keyed_vec(STORAGE_OF);
@@ -42,13 +70,15 @@ pub fn storage_of_contract_key(who: &[u8], key: &[u8]) -> [u8; 32] {
 #[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.as_slice()).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/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

@@ -71,6 +71,7 @@ ink = { path = "../ink" }
 default = [ "std" ]
 std = [
 	"blake2",
+    "ink/std",
 	"ink_allocator/std",
 	"ink_prelude/std",
 	"ink_primitives/std",
@@ -92,6 +93,7 @@ std = [
 	"xcm/std",
 	"derive_more/std"
 ]
+test_instantiate = []
 
 # Enable contract debug messages via `debug_print!` and `debug_println!`.
 ink-debug = []

crates/env/src/api.rs

@@ -42,8 +42,10 @@ use crate::{
         CryptoHash,
         HashOutput,
     },
-    types::Gas,
-    Environment,
+    types::{
+        Environment,
+        Gas,
+    },
     Result,
 };
 use ink_storage_traits::Storable;
@@ -383,7 +385,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>,
@@ -512,6 +516,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,
@@ -521,6 +526,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

@@ -32,7 +32,7 @@ use crate::{
         CryptoHash,
         HashOutput,
     },
-    Environment,
+    types::Environment,
     Result,
 };
 use ink_storage_traits::Storable;
@@ -121,10 +121,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
@@ -363,7 +378,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/call.rs

@@ -26,9 +26,11 @@ use crate::{
         CallParams,
         ExecutionInput,
     },
-    Environment,
+    types::{
+        Environment,
+        Gas,
+    },
     Error,
-    Gas,
 };
 use num_traits::Zero;
 #[cfg(not(feature = "revive"))]

crates/env/src/call/call_builder/call_v1.rs

@@ -24,9 +24,11 @@ use crate::{
         CallBuilder,
         ExecutionInput,
     },
-    Environment,
+    types::{
+        Environment,
+        Gas,
+    },
     Error,
-    Gas,
 };
 use num_traits::Zero;
 #[cfg(not(feature = "revive"))]

crates/env/src/call/call_builder/delegate.rs

@@ -24,7 +24,7 @@ use crate::{
         CallParams,
         ExecutionInput,
     },
-    Environment,
+    types::Environment,
     Error,
 };
 #[cfg(not(feature = "revive"))]

crates/env/src/call/call_builder/mod.rs

@@ -33,7 +33,7 @@ use crate::{
         Execution,
         ExecutionInput,
     },
-    Environment,
+    types::Environment,
 };
 use core::marker::PhantomData;
 

crates/env/src/call/create_builder.rs

@@ -24,7 +24,7 @@ use crate::{
         Selector,
     },
     ContractEnv,
-    Environment,
+    types::Environment,
     Error,
 };
 use core::marker::PhantomData;
@@ -293,7 +293,11 @@ impl<E, ContractRef, Args, Salt, R>
     CreateParams<E, ContractRef, LimitParamsV2<E>, 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>,
@@ -883,7 +887,11 @@ impl<E, ContractRef, 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,
     Args: scale::Encode,
     Salt: AsRef<[u8]>,
     RetType: ConstructorReturnType<ContractRef>,

crates/env/src/engine/mod.rs

@@ -81,7 +81,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>,
 {
@@ -106,7 +106,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>,
 {