Implement MVP for new off-chain testing engine

.gitlab-ci.yml

@@ -124,6 +124,12 @@ test:
     - cargo test --verbose --all-features --no-fail-fast --workspace
     - cargo test --verbose --all-features --no-fail-fast --workspace --doc
 
+      # Just needed as long as we have the `ink-experimental-engine` feature.
+      # We do not invoke `--all-features` here -- this would imply the feature
+      # `ink-experimental-engine`. So in order to still run the tests without the
+      # experimental engine feature we need this command.
+    - cargo test --verbose --features std --no-fail-fast --workspace
+
 docs:
   stage:                           workspace
   <<:                              *docker-env
@@ -179,6 +185,13 @@ codecov:
     # RUSTFLAGS are the cause target cache can't be used here
     - cargo build --verbose --all-features --workspace
     - cargo test --verbose --all-features --no-fail-fast --workspace
+
+    # Just needed as long as we have the `ink-experimental-engine` feature.
+    # We must additionally run the coverage without `--all-features` here -- this
+    # would imply the feature `ink-experimental-engine`. So in order to still run
+    # the tests without the experimental engine feature we need this command.
+    - cargo test --verbose --features std --no-fail-fast --workspace
+
     # coverage with branches
     - grcov . --source-dir . --output-type lcov --llvm --branch --ignore-not-existing
         --ignore "/*" --ignore "tests/*" --output-path lcov-w-branch.info
@@ -240,6 +253,19 @@ examples-test:
         cargo test --verbose --manifest-path examples/delegator/${contract}/Cargo.toml;
       done
 
+examples-test-experimental-engine:
+  stage:                           examples
+  <<:                              *docker-env
+  needs:
+    - job:                         clippy-std
+      artifacts:                   false
+  script:
+    # We test only the examples for which the tests have already been migrated to
+    # use the experimental engine.
+    - cargo test --no-default-features --features std, ink-experimental-engine --verbose --manifest-path examples/erc20/Cargo.toml
+    - cargo test --no-default-features --features std, ink-experimental-engine --verbose --manifest-path examples/contract-terminate/Cargo.toml
+    - cargo test --no-default-features --features std, ink-experimental-engine --verbose --manifest-path examples/contract-transfer/Cargo.toml
+
 examples-fmt:
   stage:                           examples
   <<:                              *docker-env

crates/engine/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "ink_engine"
+version = "3.0.0-rc3"
+authors = ["Parity Technologies <[email protected]>", "Michael Müller <[email protected]>"]
+edition = "2018"
+
+license = "Apache-2.0"
+readme = "README.md"
+repository = "https://github.com/paritytech/ink"
+documentation = "https://docs.rs/ink_engine/"
+homepage = "https://www.parity.io/"
+description = "[ink!] Experimental off-chain environment for testing."
+keywords = ["wasm", "parity", "webassembly", "blockchain", "edsl"]
+categories = ["no-std", "embedded"]
+include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE"]
+
+[dependencies]
+scale = { package = "parity-scale-codec", version = "2.0", default-features = false, features = ["derive", "full"] }
+derive_more = { version = "0.99", default-features = false, features = ["from", "display"] }
+
+sha2 = { version = "0.9" }
+sha3 = { version = "0.9" }
+blake2 = { version = "0.9" }
+
+[features]
+default = ["std"]
+std = [
+    "scale/std",
+]

crates/engine/LICENSE

@@ -0,0 +1 @@
+../../LICENSE

crates/engine/README.md

@@ -0,0 +1 @@
+../../README.md

crates/engine/src/database.rs

@@ -0,0 +1,207 @@
+// Copyright 2018-2021 Parity Technologies (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::types::Balance;
+use scale::KeyedVec;
+use std::collections::HashMap;
+
+const BALANCE_OF: &[u8] = b"balance:";
+const STORAGE_OF: &[u8] = b"contract-storage:";
+
+/// Returns the database key under which to find the balance for account `who`.
+pub fn balance_of_key(who: &[u8]) -> [u8; 32] {
+    let keyed = who.to_vec().to_keyed_vec(BALANCE_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);
+    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>>,
+}
+
+impl Database {
+    /// Creates a new database instance.
+    pub fn new() -> Self {
+        Database {
+            hmap: HashMap::new(),
+        }
+    }
+
+    /// Returns the amount of entries in the database.
+    #[cfg(test)]
+    fn len(&self) -> usize {
+        self.hmap.len()
+    }
+
+    /// Returns a reference to the value corresponding to the key.
+    fn get(&self, key: &[u8]) -> Option<&Vec<u8>> {
+        self.hmap.get(key)
+    }
+
+    /// Returns a reference to the value corresponding to the key.
+    pub fn get_from_contract_storage(
+        &self,
+        account_id: &[u8],
+        key: &[u8],
+    ) -> Option<&Vec<u8>> {
+        let hashed_key = storage_of_contract_key(&account_id, key);
+        self.hmap.get(&hashed_key.to_vec())
+    }
+
+    /// Inserts `value` into the contract storage of `account_id` at storage key `key`.
+    pub fn insert_into_contract_storage(
+        &mut self,
+        account_id: &[u8],
+        key: &[u8],
+        value: Vec<u8>,
+    ) -> Option<Vec<u8>> {
+        let hashed_key = storage_of_contract_key(&account_id, key);
+        self.hmap.insert(hashed_key.to_vec(), value)
+    }
+
+    /// Removes the value at the contract storage of `account_id` at storage key `key`.
+    pub fn remove_contract_storage(
+        &mut self,
+        account_id: &[u8],
+        key: &[u8],
+    ) -> Option<Vec<u8>> {
+        let hashed_key = storage_of_contract_key(&account_id, key);
+        self.hmap.remove(&hashed_key.to_vec())
+    }
+
+    /// Removes a key from the storage, returning the value at the key if the key
+    /// was previously in storage.
+    pub fn remove(&mut self, key: &[u8]) -> Option<Vec<u8>> {
+        self.hmap.remove(key)
+    }
+
+    /// Sets the value of the entry, and returns the entry's old value.
+    pub fn insert(&mut self, key: Vec<u8>, value: Vec<u8>) -> Option<Vec<u8>> {
+        self.hmap.insert(key, value)
+    }
+
+    /// Clears the database, removing all key-value pairs.
+    pub fn clear(&mut self) {
+        self.hmap.clear();
+    }
+
+    /// Returns the balance of `account_id`, if available.
+    pub fn get_balance(&self, account_id: &[u8]) -> Option<Balance> {
+        let hashed_key = balance_of_key(&account_id);
+        self.get(&hashed_key).map(|encoded_balance| {
+            scale::Decode::decode(&mut &encoded_balance[..])
+                .expect("unable to decode balance from database")
+        })
+    }
+
+    /// Sets the balance of `account_id` to `new_balance`.
+    pub fn set_balance(&mut self, account_id: &[u8], new_balance: Balance) {
+        let hashed_key = balance_of_key(&account_id);
+        let encoded_balance = scale::Encode::encode(&new_balance);
+        self.hmap
+            .entry(hashed_key.to_vec())
+            .and_modify(|v| *v = encoded_balance.clone())
+            .or_insert(encoded_balance);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Database;
+
+    #[test]
+    fn basic_operations() {
+        let mut database = Database::new();
+        let key1 = vec![42];
+        let key2 = vec![43];
+        let val1 = vec![44];
+        let val2 = vec![45];
+        let val3 = vec![46];
+
+        assert_eq!(database.len(), 0);
+        assert_eq!(database.get(&key1), None);
+        assert_eq!(database.insert(key1.clone(), val1.clone()), None);
+        assert_eq!(database.get(&key1), Some(&val1));
+        assert_eq!(
+            database.insert(key1.clone(), val2.clone()),
+            Some(val1.clone())
+        );
+        assert_eq!(database.get(&key1), Some(&val2));
+        assert_eq!(database.insert(key2.clone(), val3.clone()), None);
+        assert_eq!(database.len(), 2);
+        assert_eq!(database.remove(&key2), Some(val3));
+        assert_eq!(database.len(), 1);
+        database.clear();
+        assert_eq!(database.len(), 0);
+    }
+
+    #[test]
+    fn contract_storage() {
+        let account_id = vec![1; 32];
+        let mut storage = Database::new();
+        let key1 = vec![42];
+        let key2 = vec![43];
+        let val1 = vec![44];
+        let val2 = vec![45];
+        let val3 = vec![46];
+
+        assert_eq!(storage.len(), 0);
+        assert_eq!(storage.get_from_contract_storage(&account_id, &key1), None);
+        assert_eq!(
+            storage.insert_into_contract_storage(&account_id, &key1, val1.clone()),
+            None
+        );
+        assert_eq!(
+            storage.get_from_contract_storage(&account_id, &key1),
+            Some(&val1)
+        );
+        assert_eq!(
+            storage.insert_into_contract_storage(&account_id, &key1, val2.clone()),
+            Some(val1.clone())
+        );
+        assert_eq!(
+            storage.get_from_contract_storage(&account_id, &key1),
+            Some(&val2)
+        );
+        assert_eq!(
+            storage.insert_into_contract_storage(&account_id, &key2, val3.clone()),
+            None
+        );
+        assert_eq!(storage.len(), 2);
+        assert_eq!(
+            storage.remove_contract_storage(&account_id, &key2),
+            Some(val3)
+        );
+        assert_eq!(storage.len(), 1);
+        assert_eq!(
+            storage.remove_contract_storage(&account_id, &key1),
+            Some(val2)
+        );
+        assert_eq!(storage.len(), 0);
+    }
+}

crates/engine/src/exec_context.rs

@@ -0,0 +1,88 @@
+// Copyright 2018-2021 Parity Technologies (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use super::types::{
+    AccountId,
+    Balance,
+};
+
+/// The context of a contract execution.
+#[cfg_attr(test, derive(Debug, PartialEq, Eq))]
+pub struct ExecContext {
+    /// The caller of the contract execution. Might be user or another contract.
+    ///
+    /// We don't know the specifics of the AccountId ‒ like how many bytes or what
+    /// type of default `AccountId` makes sense ‒ they are left to be initialized
+    /// by the crate which uses the `engine`. Methods which require a caller might
+    /// panic when it has not been set.
+    pub caller: Option<AccountId>,
+    /// The callee of the contract execution. Might be user or another contract.
+    ///
+    /// We don't know the specifics of the AccountId ‒ like how many bytes or what
+    /// type of default `AccountId` makes sense ‒ they are left to be initialized
+    /// by the crate which uses the `engine`. Methods which require a callee might
+    /// panic when it has not been set.
+    pub callee: Option<AccountId>,
+    /// The value transferred to the contract as part of the call.
+    pub value_transferred: Balance,
+}
+
+#[allow(clippy::new_without_default)]
+impl ExecContext {
+    /// Creates a new execution context.
+    pub fn new() -> Self {
+        Self {
+            caller: None,
+            callee: None,
+            value_transferred: 0,
+        }
+    }
+
+    /// Returns the callee.
+    pub fn callee(&self) -> Vec<u8> {
+        self.callee
+            .as_ref()
+            .expect("no callee has been set")
+            .as_bytes()
+            .into()
+    }
+
+    /// Resets the execution context
+    pub fn reset(&mut self) {
+        self.caller = None;
+        self.callee = None;
+        self.value_transferred = Default::default();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        AccountId,
+        ExecContext,
+    };
+
+    #[test]
+    fn basic_operations() {
+        let mut exec_cont = ExecContext::new();
+
+        exec_cont.callee = Some(AccountId::from_bytes(&[13]));
+        exec_cont.caller = Some(AccountId::from_bytes(&[14]));
+        exec_cont.value_transferred = 15;
+        assert_eq!(exec_cont.callee(), vec![13]);
+
+        exec_cont.reset();
+        assert_eq!(exec_cont, ExecContext::new());
+    }
+}