Update EVM account mapping, add contract account handling

chain-evm/src/machine.rs

@@ -16,8 +16,10 @@ use ethereum_types::{H160, H256, U256};
 use evm::{
     backend::{Backend, Basic},
     executor::stack::{Accessed, StackExecutor, StackState, StackSubstateMetadata},
-    Context, ExitFatal, ExitReason, ExitRevert, Transfer,
+    Context, CreateScheme, ExitFatal, ExitReason, ExitRevert, Transfer,
 };
+use ripemd::Digest;
+use sha3::Keccak256;
 use std::collections::{BTreeMap, BTreeSet};
 use thiserror::Error;
 
@@ -220,6 +222,36 @@ impl<'a, T> VirtualMachine<'a, T> {
     }
 }
 
+pub fn generate_address_create<State: EvmState>(
+    vm: VirtualMachine<State>,
+    caller: Address,
+) -> Address {
+    let precompiles = Precompiles::new();
+    let config = vm.config;
+    let executor = StackExecutor::new_with_precompiles(vm, config, &precompiles);
+
+    executor.create_address(CreateScheme::Legacy { caller })
+}
+
+pub fn generate_address_create2<State: EvmState>(
+    vm: VirtualMachine<State>,
+    caller: Address,
+    init_code: ByteCode,
+    salt: H256,
+) -> Address {
+    let precompiles = Precompiles::new();
+    let config = vm.config;
+    let executor = StackExecutor::new_with_precompiles(vm, config, &precompiles);
+
+    let code_hash = H256::from_slice(Keccak256::digest(&init_code).as_slice());
+
+    executor.create_address(CreateScheme::Create2 {
+        caller,
+        code_hash,
+        salt,
+    })
+}
+
 /// Top-level abstraction for the EVM with the
 /// necessary types used to get the runtime going.
 fn execute_transaction<State: EvmState, F, T>(vm: VirtualMachine<State>, f: F) -> Result<T, Error>
@@ -232,7 +264,6 @@ where
     let config = vm.config;
     let gas_price = vm.gas_price();
 
-    // let memory_stack_state = MemoryStackState::new(vm.substate.metadata.clone(), &vm);
     let mut executor = StackExecutor::new_with_precompiles(vm, config, &precompiles);
 
     let (exit_reason, val) = f(&mut executor);
@@ -284,8 +315,6 @@ fn convert_access_list_to_tuples_vec(access_list: AccessList) -> Vec<(Address, V
 }
 
 /// Execute a CREATE transaction
-#[allow(clippy::too_many_arguments)]
-#[allow(clippy::boxed_local)]
 pub fn transact_create<State: EvmState>(
     vm: VirtualMachine<State>,
     value: U256,
@@ -296,12 +325,11 @@ pub fn transact_create<State: EvmState>(
     let gas_limit = vm.gas_limit;
     let access_list = convert_access_list_to_tuples_vec(access_list);
     execute_transaction(vm, |executor| {
-        executor.transact_create(caller, value, init_code.to_vec(), gas_limit, access_list)
+        executor.transact_create(caller, value, init_code.into(), gas_limit, access_list)
     })
 }
 
 /// Execute a CREATE2 transaction
-#[allow(clippy::too_many_arguments)]
 pub fn transact_create2<State: EvmState>(
     vm: VirtualMachine<State>,
     value: U256,
@@ -325,7 +353,6 @@ pub fn transact_create2<State: EvmState>(
 }
 
 /// Execute a CALL transaction
-#[allow(clippy::too_many_arguments)]
 pub fn transact_call<State: EvmState>(
     vm: VirtualMachine<State>,
     address: Address,

chain-evm/src/precompiles/mod.rs

@@ -73,38 +73,21 @@ pub struct Precompiles(pub prelude::BTreeMap<prelude::Address, PrecompileFn>);
 
 impl Precompiles {
     pub fn new() -> Self {
-        let addresses = prelude::vec![
-            ECRecover::ADDRESS,
-            SHA256::ADDRESS,
-            RIPEMD160::ADDRESS,
-            Identity::ADDRESS,
-            ModExp::ADDRESS,
-            Bn128Add::ADDRESS,
-            Bn128Mul::ADDRESS,
-            Bn128Pair::ADDRESS,
-            Blake2F::ADDRESS,
-            ExitToNear::ADDRESS,
-            ExitToEthereum::ADDRESS,
+        let fun: Vec<(prelude::Address, PrecompileFn)> = vec![
+            (ECRecover::ADDRESS, ECRecover::run),
+            (SHA256::ADDRESS, SHA256::run),
+            (RIPEMD160::ADDRESS, RIPEMD160::run),
+            (Identity::ADDRESS, Identity::run),
+            (ModExp::ADDRESS, ModExp::run),
+            (Bn128Add::ADDRESS, Bn128Add::run),
+            (Bn128Mul::ADDRESS, Bn128Mul::run),
+            (Bn128Pair::ADDRESS, Bn128Pair::run),
+            (Blake2F::ADDRESS, Blake2F::run),
+            (ExitToNear::ADDRESS, ExitToNear::run),
+            (ExitToEthereum::ADDRESS, ExitToEthereum::run),
         ];
-        let fun: prelude::Vec<PrecompileFn> = prelude::vec![
-            ECRecover::run,
-            SHA256::run,
-            RIPEMD160::run,
-            Identity::run,
-            ModExp::run,
-            Bn128Add::run,
-            Bn128Mul::run,
-            Bn128Pair::run,
-            Blake2F::run,
-            ExitToNear::run,
-            ExitToEthereum::run,
-        ];
-        let mut map = prelude::BTreeMap::new();
-        for (address, fun) in addresses.into_iter().zip(fun) {
-            map.insert(address, fun);
-        }
 
-        Precompiles(map)
+        Precompiles(fun.into_iter().collect())
     }
 }
 

chain-evm/src/state/account.rs

@@ -84,9 +84,13 @@ pub struct AccountState {
 
 impl Account {
     pub fn is_empty(&self) -> bool {
-        self.state.nonce.is_zero()
-            && self.balance == Balance::zero()
-            && self.state.storage.is_empty()
+        self.balance == Balance::zero() && self.state.is_empty()
+    }
+}
+
+impl AccountState {
+    pub fn is_empty(&self) -> bool {
+        self.nonce.is_zero() && self.code.is_empty() && self.storage.is_empty()
     }
 }
 
@@ -115,11 +119,20 @@ impl AccountTrie {
     }
 }
 
-#[cfg(test)]
+#[cfg(any(test, feature = "property-test-api"))]
 mod test {
     use super::*;
-
-    const MAX_SIZE: u64 = u64::MAX;
+    use quickcheck::{Arbitrary, Gen};
+
+    impl Arbitrary for AccountState {
+        fn arbitrary<G: Gen>(g: &mut G) -> Self {
+            Self {
+                storage: Storage::new(),
+                code: Box::new([Arbitrary::arbitrary(g); 32]),
+                nonce: u64::arbitrary(g).into(),
+            }
+        }
+    }
 
     #[test]
     fn account_balance_u256_zero() {
@@ -128,6 +141,8 @@ mod test {
 
     #[test]
     fn account_balance_u256_checked_add() {
+        const MAX_SIZE: u64 = u64::MAX;
+
         let val = 100u64;
         assert_eq!(
             Balance::from(val).checked_add(U256::from(0u64).try_into().unwrap()),
@@ -154,6 +169,8 @@ mod test {
 
     #[test]
     fn account_balance_u256_can_never_use_more_than_64_bits() {
+        const MAX_SIZE: u64 = u64::MAX;
+
         // convert from u64
         assert_eq!(Balance::from(MAX_SIZE), Balance(MAX_SIZE));
         // try to convert from U256

chain-evm/src/state/logs.rs

@@ -7,7 +7,7 @@ use super::Trie;
 /// In-memory representation of all logs.
 pub type BlockLogsTrie = Trie<BlockHash, Vec<Log>>;
 
-#[derive(Default, Clone, PartialEq, Eq)]
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
 pub struct LogsState {
     block_logs: BlockLogsTrie,
 }

chain-impl-mockchain/src/accounting/account/mod.rs

@@ -208,17 +208,48 @@ impl<ID: Clone + Eq + Hash, Extra: Clone> Ledger<ID, Extra> {
             .map_err(|e| e.into())
     }
 
+    #[cfg(feature = "evm")]
+    pub fn evm_move_state(
+        mut self,
+        new_identifier: ID,
+        old_identifier: &ID,
+    ) -> Result<Self, LedgerError> {
+        // get old state
+        match self.get_state(old_identifier).cloned() {
+            Ok(state) => {
+                // remove old state
+                self.0 = self.0.update(old_identifier, |_| Ok(None))?;
+                // move state
+                self.0
+                    .insert_or_update(new_identifier, state.clone(), |st| {
+                        if !st.evm_state.is_empty() {
+                            return Err(LedgerError::AlreadyExists);
+                        }
+                        Ok(Some(AccountState {
+                            value: st.value.checked_add(state.value)?,
+                            evm_state: state.evm_state,
+                            ..st.clone()
+                        }))
+                    })
+                    .map(Ledger)
+            }
+            // if does not exist do nothing
+            Err(LedgerError::NonExistent) => Ok(self),
+            Err(e) => Err(e),
+        }
+    }
+
     #[cfg(feature = "evm")]
     pub fn evm_insert_or_update(
         &self,
-        identifier: &ID,
+        identifier: ID,
         value: Value,
         evm_state: chain_evm::state::AccountState,
         extra: Extra,
     ) -> Result<Self, LedgerError> {
         self.0
             .insert_or_update(
-                identifier.clone(),
+                identifier,
                 AccountState::new_evm(evm_state.clone(), value, extra),
                 |st| {
                     Ok(Some(AccountState {
@@ -326,8 +357,98 @@ mod tests {
         }
     }
 
+    #[cfg(feature = "evm")]
+    #[quickcheck]
+    #[allow(clippy::too_many_arguments)]
+    fn evm_functions_test(
+        account_id1: Identifier,
+        account_id2: Identifier,
+        account_id3: Identifier,
+        value1: Value,
+        value2: Value,
+        value3: Value,
+        evm_state1: chain_evm::state::AccountState,
+        evm_state2: chain_evm::state::AccountState,
+    ) -> bool {
+        let mut ledger = Ledger::new();
+
+        ledger = ledger
+            .evm_insert_or_update(account_id1.clone(), value1, evm_state1.clone(), ())
+            .unwrap();
+
+        assert_eq!(
+            ledger.get_state(&account_id1),
+            Ok(&AccountState::new_evm(evm_state1, value1, ()))
+        );
+
+        ledger = ledger
+            .evm_insert_or_update(account_id1.clone(), value2, evm_state2.clone(), ())
+            .unwrap();
+
+        assert_eq!(
+            ledger.get_state(&account_id1),
+            Ok(&AccountState::new_evm(evm_state2.clone(), value2, ()))
+        );
+
+        ledger = ledger
+            .evm_move_state(account_id2.clone(), &account_id1)
+            .unwrap();
+
+        if account_id1 != account_id2 {
+            assert_eq!(
+                ledger.get_state(&account_id1),
+                Err(LedgerError::NonExistent)
+            );
+        }
+
+        assert_eq!(
+            ledger.get_state(&account_id2),
+            Ok(&AccountState::new_evm(evm_state2.clone(), value2, ()))
+        );
+
+        ledger = ledger
+            .evm_insert_or_update(
+                account_id3.clone(),
+                value3,
+                chain_evm::state::AccountState::default(),
+                (),
+            )
+            .unwrap();
+
+        assert_eq!(
+            ledger.get_state(&account_id3),
+            Ok(&AccountState::new_evm(
+                chain_evm::state::AccountState::default(),
+                value3,
+                ()
+            ))
+        );
+
+        ledger = ledger
+            .evm_move_state(account_id3.clone(), &account_id2)
+            .unwrap();
+
+        if account_id2 != account_id3 {
+            assert_eq!(
+                ledger.get_state(&account_id2),
+                Err(LedgerError::NonExistent)
+            );
+
+            assert_eq!(
+                ledger.get_state(&account_id3),
+                Ok(&AccountState::new_evm(
+                    evm_state2,
+                    value3.saturating_add(value2),
+                    ()
+                ))
+            );
+        }
+
+        true
+    }
+
     #[quickcheck]
-    pub fn account_ledger_test(
+    fn account_ledger_test(
         mut ledger: Ledger,
         account_id: Identifier,
         value: Value,