Advanced test environment

crates/engine/src/exec_context.rs

@@ -43,6 +43,10 @@ pub struct ExecContext {
     pub block_number: BlockNumber,
     /// The current block timestamp.
     pub block_timestamp: BlockTimestamp,
+    /// The input of the call.
+    pub input: Vec<u8>,
+    /// The output buffer of the call.
+    pub output: Vec<u8>,
 }
 
 impl ExecContext {

crates/engine/src/ext.rs

@@ -32,7 +32,12 @@ use crate::{
     },
 };
 use scale::Encode;
-use std::panic::panic_any;
+use std::{
+    cell::RefCell,
+    collections::HashMap,
+    panic::panic_any,
+    rc::Rc,
+};
 
 type Result = core::result::Result<(), Error>;
 
@@ -110,20 +115,75 @@ impl ReturnCode {
     }
 }
 
+#[derive(Default)]
+pub struct ContractStore {
+    pub instantiated: HashMap<Vec<u8>, Vec<u8>>,
+    pub entrance_count: HashMap<Vec<u8>, u32>,
+    pub allow_reentry: HashMap<Vec<u8>, bool>,
+    pub deployed: HashMap<Vec<u8>, Contract>,
+}
+
+impl ContractStore {
+    pub fn get_entrance_count(&self, callee: Vec<u8>) -> u32 {
+        self.entrance_count.get(&callee).unwrap_or(&0).clone()
+    }
+
+    pub fn get_allow_reentry(&self, callee: Vec<u8>) -> bool {
+        self.allow_reentry.get(&callee).unwrap_or(&false).clone()
+    }
+
+    pub fn set_allow_reentry(&mut self, callee: Vec<u8>, allow: bool) {
+        if allow == false {
+            self.allow_reentry.remove(&callee);
+        } else {
+            self.allow_reentry.insert(callee, allow);
+        }
+    }
+
+    pub fn increase_entrance(&mut self, callee: Vec<u8>) -> Result {
+        let entrance = self.entrance_count.get(&callee).unwrap_or(&0).clone();
+
+        self.entrance_count.insert(callee, entrance + 1);
+
+        Ok(())
+    }
+
+    pub fn decrease_entrance(&mut self, callee: Vec<u8>) -> Result {
+        let entrance = self.entrance_count.get(&callee).unwrap_or(&0).clone();
+
+        if entrance == 0 {
+            // todo: update error
+            return Err(Error::Unknown)
+        }
+
+        self.entrance_count.insert(callee, entrance - 1);
+
+        Ok(())
+    }
+}
+
+pub struct Contract {
+    pub deploy: fn(),
+    pub call: fn(),
+}
+
 /// The off-chain engine.
+#[derive(Clone)]
 pub struct Engine {
     /// The environment database.
-    pub database: Database,
+    pub database: Rc<RefCell<Database>>,
     /// The current execution context.
-    pub exec_context: ExecContext,
+    pub exec_context: Rc<RefCell<ExecContext>>,
     /// Recorder for relevant interactions with the engine.
     /// This is specifically about debug info. This info is
     /// not available in the `contracts` pallet.
-    pub(crate) debug_info: DebugInfo,
+    pub(crate) debug_info: Rc<RefCell<DebugInfo>>,
     /// The chain specification.
-    pub chain_spec: ChainSpec,
+    pub chain_spec: Rc<RefCell<ChainSpec>>,
     /// Handler for registered chain extensions.
-    pub chain_extension_handler: ChainExtensionHandler,
+    pub chain_extension_handler: Rc<RefCell<ChainExtensionHandler>>,
+    /// Contracts' store.
+    pub contracts: Rc<RefCell<ContractStore>>,
 }
 
 /// The chain specification.
@@ -158,11 +218,12 @@ impl Engine {
     // Creates a new `Engine instance.
     pub fn new() -> Self {
         Self {
-            database: Database::new(),
-            exec_context: ExecContext::new(),
-            debug_info: DebugInfo::new(),
-            chain_spec: ChainSpec::default(),
-            chain_extension_handler: ChainExtensionHandler::new(),
+            database: Rc::new(RefCell::new(Database::new())),
+            exec_context: Rc::new(RefCell::new(ExecContext::new())),
+            debug_info: Rc::new(RefCell::new(DebugInfo::new())),
+            chain_spec: Rc::new(RefCell::new(ChainSpec::default())),
+            chain_extension_handler: Rc::new(RefCell::new(ChainExtensionHandler::new())),
+            contracts: Rc::new(RefCell::new(ContractStore::default())),
         }
     }
 }
@@ -190,8 +251,10 @@ impl Engine {
             .map_err(|_| Error::TransferFailed)?;
 
         self.database
+            .borrow_mut()
             .set_balance(&contract, contract_old_balance - increment);
         self.database
+            .borrow_mut()
             .set_balance(&dest, dest_old_balance + increment);
         Ok(())
     }
@@ -217,7 +280,7 @@ impl Engine {
             Vec::new()
         };
 
-        self.debug_info.record_event(EmittedEvent {
+        self.debug_info.borrow_mut().record_event(EmittedEvent {
             topics: topics_vec,
             data: data.to_vec(),
         });
@@ -229,11 +292,13 @@ impl Engine {
         let callee = self.get_callee();
         let account_id = AccountId::from_bytes(&callee[..]);
 
-        self.debug_info.inc_writes(account_id.clone());
+        self.debug_info.borrow_mut().inc_writes(account_id.clone());
         self.debug_info
+            .borrow_mut()
             .record_cell_for_account(account_id, key.to_vec());
 
         self.database
+            .borrow_mut()
             .insert_into_contract_storage(&callee, key, encoded_value.to_vec())
             .map(|v| <u32>::try_from(v.len()).expect("usize to u32 conversion failed"))
     }
@@ -243,8 +308,12 @@ impl Engine {
         let callee = self.get_callee();
         let account_id = AccountId::from_bytes(&callee[..]);
 
-        self.debug_info.inc_reads(account_id);
-        match self.database.get_from_contract_storage(&callee, key) {
+        self.debug_info.borrow_mut().inc_reads(account_id);
+        match self
+            .database
+            .borrow_mut()
+            .get_from_contract_storage(&callee, key)
+        {
             Some(val) => {
                 set_output(output, val);
                 Ok(())
@@ -259,8 +328,12 @@ impl Engine {
         let callee = self.get_callee();
         let account_id = AccountId::from_bytes(&callee[..]);
 
-        self.debug_info.inc_writes(account_id);
-        match self.database.remove_contract_storage(&callee, key) {
+        self.debug_info.borrow_mut().inc_writes(account_id);
+        match self
+            .database
+            .borrow_mut()
+            .remove_contract_storage(&callee, key)
+        {
             Some(val) => {
                 set_output(output, &val);
                 Ok(())
@@ -274,8 +347,9 @@ impl Engine {
         let callee = self.get_callee();
         let account_id = AccountId::from_bytes(&callee[..]);
 
-        self.debug_info.inc_reads(account_id);
+        self.debug_info.borrow_mut().inc_reads(account_id);
         self.database
+            .borrow_mut()
             .get_from_contract_storage(&callee, key)
             .map(|val| val.len() as u32)
     }
@@ -285,11 +359,13 @@ impl Engine {
     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());
+        self.debug_info.borrow_mut().inc_writes(account_id.clone());
         let _ = self
             .debug_info
+            .borrow_mut()
             .remove_cell_for_account(account_id, key.to_vec());
         self.database
+            .borrow_mut()
             .remove_contract_storage(&callee, key)
             .map(|val| val.len() as u32)
     }
@@ -320,23 +396,27 @@ impl Engine {
     pub fn caller(&self, output: &mut &mut [u8]) {
         let caller = self
             .exec_context
+            .borrow()
             .caller
             .as_ref()
             .expect("no caller has been set")
-            .as_bytes();
-        set_output(output, caller);
+            .clone();
+        set_output(output, caller.as_bytes());
     }
 
     /// Returns the balance of the executed contract.
     pub fn balance(&self, output: &mut &mut [u8]) {
         let contract = self
             .exec_context
+            .borrow()
             .callee
             .as_ref()
-            .expect("no callee has been set");
+            .expect("no callee has been set")
+            .clone();
 
         let balance_in_storage = self
             .database
+            .borrow()
             .get_balance(contract.as_bytes())
             .expect("currently executing contract must exist");
         let balance = scale::Encode::encode(&balance_in_storage);
@@ -346,24 +426,27 @@ impl Engine {
     /// Returns the transferred value for the called contract.
     pub fn value_transferred(&self, output: &mut &mut [u8]) {
         let value_transferred: Vec<u8> =
-            scale::Encode::encode(&self.exec_context.value_transferred);
+            scale::Encode::encode(&self.exec_context.borrow().value_transferred);
         set_output(output, &value_transferred[..])
     }
 
     /// Returns the address of the executed contract.
     pub fn address(&self, output: &mut &mut [u8]) {
         let callee = self
             .exec_context
+            .borrow()
             .callee
             .as_ref()
             .expect("no callee has been set")
-            .as_bytes();
-        set_output(output, callee)
+            .clone();
+        set_output(output, callee.as_bytes())
     }
 
     /// Records the given debug message and appends to stdout.
     pub fn debug_message(&mut self, message: &str) {
-        self.debug_info.record_debug_message(String::from(message));
+        self.debug_info
+            .borrow_mut()
+            .record_debug_message(String::from(message));
         print!("{}", message);
     }
 
@@ -390,14 +473,14 @@ impl Engine {
     /// Returns the current block number.
     pub fn block_number(&self, output: &mut &mut [u8]) {
         let block_number: Vec<u8> =
-            scale::Encode::encode(&self.exec_context.block_number);
+            scale::Encode::encode(&self.exec_context.borrow().block_number);
         set_output(output, &block_number[..])
     }
 
     /// Returns the timestamp of the current block.
     pub fn block_timestamp(&self, output: &mut &mut [u8]) {
         let block_timestamp: Vec<u8> =
-            scale::Encode::encode(&self.exec_context.block_timestamp);
+            scale::Encode::encode(&self.exec_context.borrow().block_timestamp);
         set_output(output, &block_timestamp[..])
     }
 
@@ -409,7 +492,7 @@ impl Engine {
     /// (i.e. the chain's existential deposit).
     pub fn minimum_balance(&self, output: &mut &mut [u8]) {
         let minimum_balance: Vec<u8> =
-            scale::Encode::encode(&self.chain_spec.minimum_balance);
+            scale::Encode::encode(&self.chain_spec.borrow().minimum_balance);
         set_output(output, &minimum_balance[..])
     }
 
@@ -440,7 +523,11 @@ impl Engine {
 
     /// Emulates gas price calculation.
     pub fn weight_to_fee(&self, gas: u64, output: &mut &mut [u8]) {
-        let fee = self.chain_spec.gas_price.saturating_mul(gas.into());
+        let fee = self
+            .chain_spec
+            .borrow()
+            .gas_price
+            .saturating_mul(gas.into());
         let fee: Vec<u8> = scale::Encode::encode(&fee);
         set_output(output, &fee[..])
     }
@@ -453,8 +540,8 @@ impl Engine {
         output: &mut &mut [u8],
     ) {
         let encoded_input = input.encode();
-        let (status_code, out) = self
-            .chain_extension_handler
+        let mut chain_extension_handler = self.chain_extension_handler.borrow_mut();
+        let (status_code, out) = chain_extension_handler
             .eval(func_id, &encoded_input)
             .unwrap_or_else(|error| {
                 panic!(
@@ -513,6 +600,19 @@ impl Engine {
             Err(_) => Err(Error::EcdsaRecoveryFailed),
         }
     }
+
+    /// Register the contract into the local storage.
+    pub fn register_contract(
+        &mut self,
+        hash: &[u8],
+        deploy: fn(),
+        call: fn(),
+    ) -> Option<Contract> {
+        self.contracts
+            .borrow_mut()
+            .deployed
+            .insert(hash.to_vec(), Contract { deploy, call })
+    }
 }
 
 /// Copies the `slice` into `output`.

crates/engine/src/lib.rs

@@ -22,7 +22,7 @@ pub mod test_api;
 
 mod chain_extension;
 mod database;
-mod exec_context;
+pub mod exec_context;
 mod hashing;
 mod types;