feat: add inspect_system_call method to Evm trait

Adds a dedicated inspect_system_call method that executes system calls
with inspection enabled without committing state changes. This separates
the concerns of inspection and transaction execution for system calls.

- Add inspect_system_call to Evm trait with documentation
- Implement across all EVM types (Either, EthEvm, OpEvm)
- Refactor transact_system_call to always use non-inspecting variant
- Add required ResultAndState import to either.rs

Author: rezbera

crates/evm/src/either.rs

@@ -1,6 +1,6 @@
 use crate::{Evm, EvmEnv};
 use alloy_primitives::{Address, Bytes};
-use revm::context::{either, BlockEnv};
+use revm::context::{either, result::ResultAndState, BlockEnv};
 
 impl<L, R> Evm for either::Either<L, R>
 where
@@ -45,6 +45,15 @@ where
         either::for_both!(self, evm => evm.transact(tx))
     }
 
+    fn inspect_system_call(
+        &mut self,
+        caller: Address,
+        contract: Address,
+        data: Bytes,
+    ) -> Result<ResultAndState<Self::HaltReason>, Self::Error> {
+        either::for_both!(self, evm => evm.inspect_system_call(caller, contract, data))
+    }
+
     fn transact_system_call(
         &mut self,
         caller: Address,

crates/evm/src/eth/mod.rs

@@ -137,17 +137,22 @@ where
         }
     }
 
+    fn inspect_system_call(
+        &mut self,
+        caller: Address,
+        contract: Address,
+        data: Bytes,
+    ) -> Result<ResultAndState<Self::HaltReason>, Self::Error> {
+        self.inner.inspect_system_call_with_caller(caller, contract, data)
+    }
+
     fn transact_system_call(
         &mut self,
         caller: Address,
         contract: Address,
         data: Bytes,
     ) -> Result<ResultAndState<Self::HaltReason>, Self::Error> {
-        if self.inspect {
-            self.inner.inspect_system_call_with_caller(caller, contract, data)
-        } else {
-            self.inner.system_call_with_caller(caller, contract, data)
-        }
+        self.inner.system_call_with_caller(caller, contract, data)
     }
 
     fn finish(self) -> (Self::DB, EvmEnv<Self::Spec>) {

crates/evm/src/evm.rs

@@ -88,6 +88,18 @@ pub trait Evm {
         self.transact_raw(tx.into_tx_env())
     }
 
+    /// Inspects a system call without committing state changes.
+    ///
+    /// This method executes a system call with inspection enabled, allowing observation of the
+    /// execution without modifying the underlying state. Similar to [`Evm::transact_system_call`]
+    /// but returns the result with state changes that can be examined or discarded.
+    fn inspect_system_call(
+        &mut self,
+        caller: Address,
+        contract: Address,
+        data: Bytes,
+    ) -> Result<ResultAndState<Self::HaltReason>, Self::Error>;
+
     /// Executes a system call.
     ///
     /// Note: this will only keep the target `contract` in the state. This is done because revm is

crates/op-evm/src/lib.rs

@@ -116,17 +116,22 @@ where
         }
     }
 
+    fn inspect_system_call(
+        &mut self,
+        caller: Address,
+        contract: Address,
+        data: Bytes,
+    ) -> Result<ResultAndState<Self::HaltReason>, Self::Error> {
+        self.inner.inspect_system_call_with_caller(caller, contract, data)
+    }
+
     fn transact_system_call(
         &mut self,
         caller: Address,
         contract: Address,
         data: Bytes,
     ) -> Result<ResultAndState<Self::HaltReason>, Self::Error> {
-        if self.inspect {
-            self.inner.inspect_system_call_with_caller(caller, contract, data)
-        } else {
-            self.inner.system_call_with_caller(caller, contract, data)
-        }
+        self.inner.system_call_with_caller(caller, contract, data)
     }
 
     fn finish(self) -> (Self::DB, EvmEnv<Self::Spec>) {