fix(levm): fix revert cases for contracts to run correctly

cmd/ethereum_rust/Cargo.toml

@@ -41,3 +41,4 @@ path = "./ethereum_rust.rs"
 default = []
 dev = ["dep:ethereum_rust-dev"]
 l2 = ["ethereum_rust-vm/l2"]
+levm = ["ethereum_rust-vm/levm", "ethereum_rust-blockchain/levm"]

crates/blockchain/Cargo.toml

@@ -10,6 +10,7 @@ thiserror.workspace = true
 sha3.workspace = true
 tracing.workspace = true
 bytes.workspace = true
+cfg-if = "1.0.0"
 
 ethereum_rust-rlp.workspace = true
 ethereum_rust-core = { path = "../common", default-features = false }
@@ -29,3 +30,4 @@ libmdbx = [
     "ethereum_rust-storage/default",
     "ethereum_rust-vm/libmdbx",
 ]
+levm = ["ethereum_rust-vm/levm"]

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
@@ -27,7 +25,10 @@ use ethereum_rust_vm::{
 /// canonical chain/head. Fork choice needs to be updated for that in a separate step.
 ///
 /// Performs pre and post execution validation, and updates the database with the post state.
+#[cfg(not(feature = "levm"))]
 pub fn add_block(block: &Block, storage: &Store) -> Result<(), ChainError> {
+    use ethereum_rust_vm::get_state_transitions;
+
     let block_hash = block.header.compute_block_hash();
 
     // Validate if it can be the new head and find the parent
@@ -63,6 +64,48 @@ pub fn add_block(block: &Block, storage: &Store) -> Result<(), ChainError> {
     Ok(())
 }
 
+/// Adds a new block to the store. It may or may not be canonical, as long as its ancestry links
+/// with the canonical chain and its parent's post-state is calculated. It doesn't modify the
+/// canonical chain/head. Fork choice needs to be updated for that in a separate step.
+///
+/// Performs pre and post execution validation, and updates the database with the post state.
+#[cfg(feature = "levm")]
+pub fn add_block(block: &Block, storage: &Store) -> Result<(), ChainError> {
+    let block_hash = block.header.compute_block_hash();
+
+    // Validate if it can be the new head and find the parent
+    let Ok(parent_header) = find_parent_header(&block.header, storage) else {
+        // If the parent is not present, we store it as pending.
+        storage.add_pending_block(block.clone())?;
+        return Err(ChainError::ParentNotFound);
+    };
+    let mut state = evm_state(storage.clone(), block.header.parent_hash);
+
+    // Validate the block pre-execution
+    validate_block(block, &parent_header, &state)?;
+
+    let (receipts, account_updates) = execute_block(block, &mut state)?;
+
+    dbg!(&account_updates);
+
+    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
+        .database()
+        .ok_or(ChainError::StoreError(StoreError::MissingStore))?
+        .apply_account_updates(block.header.parent_hash, &account_updates)?
+        .ok_or(ChainError::ParentStateNotFound)?;
+
+    // Check state root matches the one in block header after execution
+    validate_state_root(&block.header, new_state_root)?;
+
+    store_block(storage, block.clone())?;
+    store_receipts(storage, receipts, block_hash)?;
+
+    Ok(())
+}
+
 /// Stores block and header in the database
 pub fn store_block(storage: &Store, block: Block) -> Result<(), ChainError> {
     storage.add_block(block)?;
@@ -166,6 +209,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

@@ -1594,7 +1594,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", optional = true }
 revm = { version = "14.0.3", features = [
     "serde",
     "std",
@@ -38,3 +39,4 @@ l2 = []
 c-kzg = ["revm/c-kzg"]
 blst = ["revm/blst"]
 libmdbx = ["ethereum_rust-storage/default", "ethereum_rust-core/libmdbx"]
+levm = ["ethereum_rust_levm"]

crates/vm/db.rs

@@ -10,6 +10,48 @@ pub struct StoreWrapper {
     pub block_hash: BlockHash,
 }
 
+cfg_if::cfg_if! {
+    if #[cfg(feature = "levm")] {
+        use ethereum_rust_core::{U256 as CoreU256};
+        use ethereum_rust_levm::db::Database as LevmDatabase;
+
+        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) -> CoreU256 {
+                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/errors.rs

@@ -63,3 +63,15 @@ pub struct TransactionReport {
     // a transaction could create multiple new contracts, but whatever.
     pub created_address: Option<Address>,
 }
+
+impl TransactionReport {
+    /// Function to add gas to report without exceeding the maximum gas limit
+    pub fn add_gas_with_max(&mut self, gas: u64, max: u64) {
+        self.gas_used = self.gas_used.saturating_add(gas);
+        self.gas_used = self.gas_used.min(max);
+    }
+
+    pub fn is_success(&self) -> bool {
+        matches!(self.result, TxResult::Success)
+    }
+}

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

@@ -105,8 +105,24 @@ impl VM {
             .pop()?
             .try_into()
             .unwrap_or(usize::MAX);
-        let value = U256::from_big_endian(&current_call_frame.calldata.slice(offset..offset + 32));
-        current_call_frame.stack.push(value)?;
+
+        // This check is because if offset is larger than the calldata then we should push 0 to the stack.
+        let result = if offset < current_call_frame.calldata.len() {
+            // Read calldata from offset to the end
+            let calldata = current_call_frame.calldata.slice(offset..);
+
+            // Get the 32 bytes from the data slice, padding with 0 if fewer than 32 bytes are available
+            let mut padded_calldata = [0u8; 32];
+            let data_len_to_copy = calldata.len().min(32);
+
+            padded_calldata[..data_len_to_copy].copy_from_slice(&calldata[..data_len_to_copy]);
+
+            U256::from_big_endian(&padded_calldata)
+        } else {
+            U256::zero()
+        };
+
+        current_call_frame.stack.push(result)?;
 
         Ok(OpcodeSuccess::Continue)
     }
@@ -181,7 +197,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

@@ -159,7 +159,7 @@ impl VM {
     }
 
     // SSTORE operation
-    // TODO: add gas consumption
+    // TODO: add gas REFUNDS
     pub fn op_sstore(
         &mut self,
         current_call_frame: &mut CallFrame,
@@ -177,21 +177,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 {
+            // 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 {
-            self.cache_from_db(&address);
-            self.db.get_storage_slot(address, key)
+            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,
             },
         );