fix(levm): fix last blockchain tests for LEVM (#2842)

**Motivation**

- Fix remaining blockchain tests for Prague with LEVM.

**Description**

- Precompiles shouldn't be executed in case they are delegation target
of the same transaction in which they are being called.
- It also fixes a problem in the transfer of value in CALL. (It just
moves the place where the value transfer is performed)

After this there are no more `blockchain` tests we need to fix.


<!-- Link to issues: Resolves #111, Resolves #222 -->

Co-authored-by: @DiegoCivi

Author: JereSalo

cmd/ef_tests/blockchain/tests/prague.rs

@@ -3,64 +3,15 @@ use std::path::Path;
 use ef_tests_blockchain::test_runner::parse_and_execute;
 use ethrex_vm::EvmEngine;
 
-// TODO: enable these tests once the evm is updated.
-#[cfg(not(feature = "levm"))]
-const SKIPPED_TESTS_REVM: [&str; 1] = [
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_non_empty_storage[fork_Prague-blockchain_test-zero_nonce]",
-];
-
-#[cfg(feature = "levm")]
-const SKIPPED_TESTS_LEVM: [&str; 34] = [
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile_not_enough_gas_for_precompile_execution[fork_Prague-precompile_0x0000000000000000000000000000000000000006-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile[fork_Prague-precompile_0x0000000000000000000000000000000000000011-call_opcode_CALL-evm_code_type_LEGACY-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile_not_enough_gas_for_precompile_execution[fork_Prague-precompile_0x0000000000000000000000000000000000000009-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile[fork_Prague-precompile_0x000000000000000000000000000000000000000b-call_opcode_CALL-evm_code_type_LEGACY-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile_not_enough_gas_for_precompile_execution[fork_Prague-precompile_0x000000000000000000000000000000000000000e-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile_not_enough_gas_for_precompile_execution[fork_Prague-precompile_0x0000000000000000000000000000000000000004-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile[fork_Prague-precompile_0x0000000000000000000000000000000000000009-call_opcode_CALL-evm_code_type_LEGACY-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile[fork_Prague-precompile_0x000000000000000000000000000000000000000c-call_opcode_CALL-evm_code_type_LEGACY-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile_not_enough_gas_for_precompile_execution[fork_Prague-precompile_0x000000000000000000000000000000000000000c-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile[fork_Prague-precompile_0x000000000000000000000000000000000000000a-call_opcode_CALL-evm_code_type_LEGACY-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile_not_enough_gas_for_precompile_execution[fork_Prague-precompile_0x0000000000000000000000000000000000000008-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile_not_enough_gas_for_precompile_execution[fork_Prague-precompile_0x0000000000000000000000000000000000000001-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile[fork_Prague-precompile_0x0000000000000000000000000000000000000006-call_opcode_CALL-evm_code_type_LEGACY-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile_not_enough_gas_for_precompile_execution[fork_Prague-precompile_0x000000000000000000000000000000000000000f-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile[fork_Prague-precompile_0x0000000000000000000000000000000000000010-call_opcode_CALL-evm_code_type_LEGACY-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile[fork_Prague-precompile_0x000000000000000000000000000000000000000f-call_opcode_CALL-evm_code_type_LEGACY-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile_not_enough_gas_for_precompile_execution[fork_Prague-precompile_0x0000000000000000000000000000000000000011-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile[fork_Prague-precompile_0x0000000000000000000000000000000000000002-call_opcode_CALL-evm_code_type_LEGACY-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile_not_enough_gas_for_precompile_execution[fork_Prague-precompile_0x000000000000000000000000000000000000000b-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile[fork_Prague-precompile_0x000000000000000000000000000000000000000e-call_opcode_CALL-evm_code_type_LEGACY-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile[fork_Prague-precompile_0x0000000000000000000000000000000000000005-call_opcode_CALL-evm_code_type_LEGACY-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile[fork_Prague-precompile_0x000000000000000000000000000000000000000d-call_opcode_CALL-evm_code_type_LEGACY-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile[fork_Prague-precompile_0x0000000000000000000000000000000000000001-call_opcode_CALL-evm_code_type_LEGACY-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile[fork_Prague-precompile_0x0000000000000000000000000000000000000004-call_opcode_CALL-evm_code_type_LEGACY-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile_not_enough_gas_for_precompile_execution[fork_Prague-precompile_0x0000000000000000000000000000000000000007-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile_not_enough_gas_for_precompile_execution[fork_Prague-precompile_0x0000000000000000000000000000000000000003-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile_not_enough_gas_for_precompile_execution[fork_Prague-precompile_0x0000000000000000000000000000000000000005-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile_not_enough_gas_for_precompile_execution[fork_Prague-precompile_0x0000000000000000000000000000000000000010-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile[fork_Prague-precompile_0x0000000000000000000000000000000000000007-call_opcode_CALL-evm_code_type_LEGACY-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile_not_enough_gas_for_precompile_execution[fork_Prague-precompile_0x000000000000000000000000000000000000000d-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile[fork_Prague-precompile_0x0000000000000000000000000000000000000008-call_opcode_CALL-evm_code_type_LEGACY-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile_not_enough_gas_for_precompile_execution[fork_Prague-precompile_0x0000000000000000000000000000000000000002-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile_not_enough_gas_for_precompile_execution[fork_Prague-precompile_0x000000000000000000000000000000000000000a-blockchain_test_from_state_test]",
-    "tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_precompile[fork_Prague-precompile_0x0000000000000000000000000000000000000003-call_opcode_CALL-evm_code_type_LEGACY-blockchain_test_from_state_test]",
-];
-
-// NOTE: These 3 tests fail on LEVM with a stack overflow if we do not increase the stack size by using RUST_MIN_STACK=11000000
-//"tests/prague/eip6110_deposits/test_deposits.py::test_deposit[fork_Prague-blockchain_test-single_deposit_from_contract_call_high_depth]",
-//"tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_max_depth_call_stack[fork_Prague-blockchain_test]",
-//"tests/prague/eip7702_set_code_tx/test_set_code_txs_2.py::test_pointer_contract_pointer_loop[fork_Prague-blockchain_test]",
-
 #[cfg(not(feature = "levm"))]
 fn parse_and_execute_with_revm(path: &Path) -> datatest_stable::Result<()> {
-    parse_and_execute(path, EvmEngine::REVM, Some(&SKIPPED_TESTS_REVM));
+    parse_and_execute(path, EvmEngine::REVM, None);
     Ok(())
 }
 
 #[cfg(feature = "levm")]
 fn parse_and_execute_with_levm(path: &Path) -> datatest_stable::Result<()> {
-    parse_and_execute(path, EvmEngine::LEVM, Some(&SKIPPED_TESTS_LEVM));
+    parse_and_execute(path, EvmEngine::LEVM, None);
     Ok(())
 }
 

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

@@ -767,40 +767,41 @@ impl<'a> VM<'a> {
             calldata
         };
 
-        let new_depth = {
-            let current_call_frame = self.current_call_frame_mut()?;
-
-            // 2. Validate max depth has not been reached yet.
-            let new_depth = current_call_frame
-                .depth
-                .checked_add(1)
-                .ok_or(InternalError::ArithmeticOperationOverflow)?;
+        // 2. Validate max depth has not been reached yet.
+        let new_depth = self
+            .current_call_frame()?
+            .depth
+            .checked_add(1)
+            .ok_or(InternalError::ArithmeticOperationOverflow)?;
 
-            if new_depth > 1024 {
-                current_call_frame.gas_used = current_call_frame
-                    .gas_used
-                    .checked_sub(gas_limit)
-                    .ok_or(InternalError::GasOverflow)?;
-                current_call_frame.stack.push(REVERT_FOR_CALL)?;
-                return Ok(OpcodeResult::Continue { pc_increment: 1 });
-            }
+        if new_depth > 1024 {
+            self.current_call_frame_mut()?.gas_used = self
+                .current_call_frame()?
+                .gas_used
+                .checked_sub(gas_limit)
+                .ok_or(InternalError::GasOverflow)?;
+            self.current_call_frame_mut()?.stack.push(REVERT_FOR_CALL)?;
+            return Ok(OpcodeResult::Continue { pc_increment: 1 });
+        }
 
-            if bytecode.is_empty() && is_delegation {
-                current_call_frame.gas_used = current_call_frame
-                    .gas_used
-                    .checked_sub(gas_limit)
-                    .ok_or(InternalError::GasOverflow)?;
-                current_call_frame.stack.push(SUCCESS_FOR_CALL)?;
-                return Ok(OpcodeResult::Continue { pc_increment: 1 });
-            }
-            new_depth
-        };
         // Transfer value from caller to callee.
         if should_transfer_value {
             self.decrease_account_balance(msg_sender, value)?;
             self.increase_account_balance(to, value)?;
         }
 
+        if bytecode.is_empty() && is_delegation {
+            self.current_call_frame_mut()?.gas_used = self
+                .current_call_frame()?
+                .gas_used
+                .checked_sub(gas_limit)
+                .ok_or(InternalError::GasOverflow)?;
+            self.current_call_frame_mut()?
+                .stack
+                .push(SUCCESS_FOR_CALL)?;
+            return Ok(OpcodeResult::Continue { pc_increment: 1 });
+        }
+
         let new_call_frame = CallFrame::new(
             msg_sender,
             to,

crates/vm/levm/src/utils.rs

@@ -707,4 +707,11 @@ impl<'a> VM<'a> {
 
         Ok((callee, code))
     }
+
+    /// Checks if an address is delegation target in current transaction.
+    pub fn is_delegation_target(&self, address: Address) -> bool {
+        self.tx.authorization_list().as_ref().map_or(false, |list| {
+            list.iter().any(|item| item.address == address)
+        })
+    }
 }

crates/vm/levm/src/vm.rs

@@ -2,11 +2,12 @@ use crate::{
     call_frame::CallFrame,
     db::gen_db::GeneralizedDatabase,
     environment::Environment,
-    errors::{ExecutionReport, OpcodeResult, VMError},
+    errors::{ExecutionReport, OpcodeResult, PrecompileError, VMError},
     hooks::hook::Hook,
     precompiles::execute_precompile,
     TransientStorage,
 };
+use bytes::Bytes;
 use ethrex_common::{
     types::{Transaction, TxKind},
     Address, H256, U256,
@@ -145,15 +146,30 @@ impl<'a> VM<'a> {
     }
 
     pub fn execute_precompile(&mut self) -> Result<ExecutionReport, VMError> {
-        let callframe = self.current_call_frame_mut()?;
-
-        let precompile_address = callframe.code_address;
-        let calldata = &callframe.calldata;
-        let gas_used = &mut callframe.gas_used;
-        let gas_limit = callframe.gas_limit;
-
-        let precompile_result =
-            execute_precompile(precompile_address, calldata, gas_used, gas_limit);
+        let precompile_address = self.current_call_frame()?.code_address;
+
+        let precompile_result = match self.is_delegation_target(precompile_address) {
+            // Avoid executing precompile if it is target of a delegation in EIP-7702 transaction.
+            true => {
+                let gas_limit = self.current_call_frame()?.gas_limit;
+                if gas_limit == 0 {
+                    // `pointer_to_precompile.json` tests that it should fail in a call with zero gas limit.
+                    Err(VMError::PrecompileError(PrecompileError::NotEnoughGas))
+                } else {
+                    Ok(Bytes::new())
+                }
+            }
+            // Otherwise, execute precompile
+            false => {
+                let callframe = self.current_call_frame_mut()?;
+                execute_precompile(
+                    precompile_address,
+                    &callframe.calldata,
+                    &mut callframe.gas_used,
+                    callframe.gas_limit,
+                )
+            }
+        };
 
         let report = self.handle_precompile_result(precompile_result)?;