feat(fevm): L3 testing

crates/blockchain/blockchain.rs

@@ -15,9 +15,7 @@ use ethereum_rust_core::H256;
 
 use ethereum_rust_storage::error::StoreError;
 use ethereum_rust_storage::Store;
-use ethereum_rust_vm::{
-    evm_state, execute_block, get_state_transitions, spec_id, EvmState, SpecId,
-};
+use ethereum_rust_vm::{evm_state, execute_block, spec_id, EvmState, SpecId};
 
 //TODO: Implement a struct Chain or BlockChain to encapsulate
 //functionality and canonical chain state and config
@@ -41,11 +39,11 @@ pub fn add_block(block: &Block, storage: &Store) -> Result<(), ChainError> {
     // Validate the block pre-execution
     validate_block(block, &parent_header, &state)?;
 
-    let receipts = execute_block(block, &mut state)?;
+    let (receipts, account_updates) = execute_block(block, &mut state)?;
 
-    validate_gas_used(&receipts, &block.header)?;
+    dbg!(&account_updates);
 
-    let account_updates = get_state_transitions(&mut state);
+    validate_gas_used(&receipts, &block.header)?;
 
     // Apply the account updates over the last block's state and compute the new state root
     let new_state_root = state
@@ -166,6 +164,8 @@ pub fn validate_gas_used(
     block_header: &BlockHeader,
 ) -> Result<(), ChainError> {
     if let Some(last) = receipts.last() {
+        dbg!(last.cumulative_gas_used);
+        dbg!(block_header.gas_used);
         if last.cumulative_gas_used != block_header.gas_used {
             return Err(ChainError::InvalidBlock(InvalidBlockError::GasUsedMismatch));
         }

crates/blockchain/payload.rs

@@ -418,6 +418,7 @@ fn apply_plain_transaction(
 
 fn finalize_payload(context: &mut PayloadBuildContext) -> Result<(), StoreError> {
     let account_updates = get_state_transitions(context.evm_state);
+    dbg!(&account_updates);
     context.payload.header.state_root = context
         .store()
         .ok_or(StoreError::MissingStore)?

crates/common/types/transaction.rs

@@ -1528,7 +1528,7 @@ mod serde_impl {
         pub gas: Option<u64>,
         #[serde(default)]
         pub value: U256,
-        #[serde(default, with = "crate::serde_utils::bytes", alias = "data")]
+        #[serde(default, with = "crate::serde_utils::bytes")]
         pub input: Bytes,
         #[serde(default, with = "crate::serde_utils::u64::hex_str")]
         pub gas_price: u64,

crates/vm/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2021"
 [dependencies]
 ethereum_rust-core = { path = "../common", default-features = false }
 ethereum_rust-storage = { path = "../storage/store", default-features = false }
+ethereum_rust_levm = { path = "./levm" }
 revm = { version = "14.0.3", features = [
     "serde",
     "std",

crates/vm/db.rs

@@ -1,4 +1,5 @@
-use ethereum_rust_core::{types::BlockHash, Address as CoreAddress, H256 as CoreH256};
+use ethereum_rust_core::{types::BlockHash, Address as CoreAddress, H256 as CoreH256, U256};
+use ethereum_rust_levm::db::Database as LevmDatabase;
 use ethereum_rust_storage::{error::StoreError, Store};
 use revm::primitives::{
     AccountInfo as RevmAccountInfo, Address as RevmAddress, Bytecode as RevmBytecode,
@@ -10,6 +11,41 @@ pub struct StoreWrapper {
     pub block_hash: BlockHash,
 }
 
+impl LevmDatabase for StoreWrapper {
+    fn get_account_info(&self, address: CoreAddress) -> ethereum_rust_levm::account::AccountInfo {
+        let acc_info = self
+            .store
+            .get_account_info_by_hash(self.block_hash, address)
+            .unwrap()
+            .unwrap_or_default();
+
+        let acc_code = self
+            .store
+            .get_account_code(acc_info.code_hash)
+            .unwrap()
+            .unwrap();
+
+        ethereum_rust_levm::account::AccountInfo {
+            balance: acc_info.balance,
+            nonce: acc_info.nonce,
+            bytecode: acc_code,
+        }
+    }
+
+    fn get_storage_slot(&self, address: CoreAddress, key: CoreH256) -> U256 {
+        self.store
+            .get_storage_at_hash(self.block_hash, address, key)
+            .unwrap()
+            .unwrap_or_default()
+    }
+
+    fn get_block_hash(&self, block_number: u64) -> Option<CoreH256> {
+        let a = self.store.get_block_header(block_number).unwrap();
+
+        a.map(|a| CoreH256::from(a.compute_block_hash().0))
+    }
+}
+
 impl revm::Database for StoreWrapper {
     type Error = StoreError;
 

crates/vm/levm/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "ethereum_rust-levm"
+name = "ethereum_rust_levm"
 version.workspace = true
 edition.workspace = true
 

crates/vm/levm/Makefile

@@ -6,7 +6,7 @@ help: ## 📚 Show help for each of the Makefile recipes
 	@grep -E '^[a-zA-Z0-9_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
 
 test: ## 🧪 Runs all tests except Ethereum tests
-	cargo test -p ethereum_rust-levm
+	cargo test -p ethereum_rust_levm
 
 lint: ## 🧹 Linter check
 	cargo clippy --all-targets --all-features -- -D warnings

crates/vm/levm/bench/revm_comparison/Cargo.toml

@@ -8,7 +8,7 @@ name = "revm_comparison"
 path = "src/lib.rs"
 
 [dependencies]
-ethereum_rust-levm = { path = "../../" }
+ethereum_rust_levm = { path = "../../" }
 hex = "0.4.3"
 revm = "9.0.0"
 bytes = "1.8.0"

crates/vm/levm/src/db.rs

@@ -86,11 +86,7 @@ impl Cache {
     }
 
     pub fn get_storage_slot(&self, address: Address, key: H256) -> Option<StorageSlot> {
-        self.get_account(address)
-            .expect("Account should have been cached")
-            .storage
-            .get(&key)
-            .cloned()
+        self.get_account(address)?.storage.get(&key).cloned()
     }
 
     pub fn add_account(&mut self, address: &Address, account: &Account) {

crates/vm/levm/src/opcode_handlers/environment.rs

@@ -181,7 +181,7 @@ impl VM {
             .stack
             .push(U256::from(current_call_frame.bytecode.len()))?;
 
-        self.env.consumed_gas += gas_cost::CODESIZE;
+        self.increase_consumed_gas(current_call_frame, gas_cost::CODESIZE)?;
 
         Ok(OpcodeSuccess::Continue)
     }

crates/vm/levm/src/opcode_handlers/push.rs

@@ -1,12 +1,11 @@
-use ethereum_rust_core::U256;
-
 use crate::{
     call_frame::CallFrame,
     constants::gas_cost,
     errors::{OpcodeSuccess, VMError},
     opcodes::Opcode,
     vm::VM,
 };
+use ethereum_rust_core::U256;
 
 // Push Operations
 // Opcodes: PUSH0, PUSH1 ... PUSH32

crates/vm/levm/src/opcode_handlers/stack_memory_storage_flow.rs

@@ -147,7 +147,7 @@ impl VM {
     }
 
     // SSTORE operation
-    // TODO: add gas consumption
+    // TODO: add gas REFUNDS
     pub fn op_sstore(
         &mut self,
         current_call_frame: &mut CallFrame,
@@ -165,21 +165,36 @@ impl VM {
 
         let address = current_call_frame.to;
 
-        let original_value = if self.cache.is_slot_cached(&address, key) {
-            self.cache
-                .get_storage_slot(address, key)
-                .expect("Storage slot should have been cached")
-                .original_value
+        let mut base_dynamic_gas: U256 = U256::zero();
+
+        let storage_slot = if self.cache.is_slot_cached(&address, key) {
+            self.cache.get_storage_slot(address, key).unwrap()
         } else {
-            self.cache_from_db(&address);
-            self.db.get_storage_slot(address, key)
+            // If slot is cold 2100 is added to base_dynamic_gas
+            base_dynamic_gas += U256::from(2100);
+
+            self.get_storage_slot(&address, key) // it is not in cache because of previous if
         };
 
+        base_dynamic_gas += if value == storage_slot.current_value {
+            U256::from(100)
+        } else if storage_slot.current_value == storage_slot.original_value {
+            if storage_slot.original_value == U256::zero() {
+                U256::from(20000)
+            } else {
+                U256::from(2900)
+            }
+        } else {
+            U256::from(100)
+        };
+
+        self.increase_consumed_gas(current_call_frame, base_dynamic_gas)?;
+
         self.cache.write_account_storage(
             &address,
             key,
             StorageSlot {
-                original_value,
+                original_value: storage_slot.original_value,
                 current_value: value,
             },
         );

crates/vm/levm/src/opcode_handlers/system.rs

@@ -4,7 +4,7 @@ use crate::{
     errors::{OpcodeSuccess, ResultReason, VMError},
     vm::{word_to_address, VM},
 };
-use ethereum_rust_core::{types::TxKind, Address, U256};
+use ethereum_rust_core::{types::TxKind, U256};
 
 // System Operations (10)
 // Opcodes: CREATE, CALL, CALLCODE, RETURN, DELEGATECALL, CREATE2, STATICCALL, REVERT, INVALID, SELFDESTRUCT
@@ -16,7 +16,7 @@ impl VM {
         current_call_frame: &mut CallFrame,
     ) -> Result<OpcodeSuccess, VMError> {
         let gas = current_call_frame.stack.pop()?;
-        let code_address = Address::from_low_u64_be(current_call_frame.stack.pop()?.low_u64());
+        let code_address = word_to_address(current_call_frame.stack.pop()?);
         let value = current_call_frame.stack.pop()?;
         let args_offset = current_call_frame
             .stack
@@ -94,12 +94,13 @@ impl VM {
     }
 
     // CALLCODE operation
+    // TODO: Add gas consumption
     pub fn op_callcode(
         &mut self,
         current_call_frame: &mut CallFrame,
     ) -> Result<OpcodeSuccess, VMError> {
         let gas = current_call_frame.stack.pop()?;
-        let code_address = Address::from_low_u64_be(current_call_frame.stack.pop()?.low_u64());
+        let code_address = word_to_address(current_call_frame.stack.pop()?);
         let value = current_call_frame.stack.pop()?;
         let args_offset = current_call_frame.stack.pop()?.try_into().unwrap();
         let args_size = current_call_frame.stack.pop()?.try_into().unwrap();
@@ -157,12 +158,13 @@ impl VM {
     }
 
     // DELEGATECALL operation
+    // TODO: Add gas consumption
     pub fn op_delegatecall(
         &mut self,
         current_call_frame: &mut CallFrame,
     ) -> Result<OpcodeSuccess, VMError> {
         let gas = current_call_frame.stack.pop()?;
-        let code_address = Address::from_low_u64_be(current_call_frame.stack.pop()?.low_u64());
+        let code_address = word_to_address(current_call_frame.stack.pop()?);
         let args_offset = current_call_frame.stack.pop()?.try_into().unwrap();
         let args_size = current_call_frame.stack.pop()?.try_into().unwrap();
         let ret_offset = current_call_frame.stack.pop()?.try_into().unwrap();
@@ -190,12 +192,13 @@ impl VM {
     }
 
     // STATICCALL operation
+    // TODO: Add gas consumption
     pub fn op_staticcall(
         &mut self,
         current_call_frame: &mut CallFrame,
     ) -> Result<OpcodeSuccess, VMError> {
         let gas = current_call_frame.stack.pop()?;
-        let code_address = Address::from_low_u64_be(current_call_frame.stack.pop()?.low_u64());
+        let code_address = word_to_address(current_call_frame.stack.pop()?);
         let args_offset = current_call_frame.stack.pop()?.try_into().unwrap();
         let args_size = current_call_frame.stack.pop()?.try_into().unwrap();
         let ret_offset = current_call_frame.stack.pop()?.try_into().unwrap();
@@ -222,6 +225,7 @@ impl VM {
     }
 
     // CREATE operation
+    // TODO: Add gas consumption
     pub fn op_create(
         &mut self,
         current_call_frame: &mut CallFrame,
@@ -240,6 +244,7 @@ impl VM {
     }
 
     // CREATE2 operation
+    // TODO: Add gas consumption
     pub fn op_create2(
         &mut self,
         current_call_frame: &mut CallFrame,

crates/vm/levm/src/utils.rs

@@ -7,7 +7,7 @@ use crate::{
 };
 use bytes::Bytes;
 use ethereum_rust_core::{types::TxKind, Address, U256};
-use std::collections::HashMap;
+use std::{collections::HashMap, sync::Arc};
 
 pub fn ops_to_bytecode(operations: &[Operation]) -> Bytes {
     operations
@@ -96,9 +96,7 @@ pub fn new_vm_with_ops_addr_bal_db(
         env,
         Default::default(),
         Default::default(),
-        Box::new(db),
+        Arc::new(db),
         cache,
-        Default::default(),
-        None,
     )
 }