Inspector wip

Cargo.toml

@@ -55,6 +55,10 @@ context-interface = { path = "crates/context/interface", package = "revm-context
 handler = { path = "crates/handler", package = "revm-handler", version = "1.0.0", default-features = false }
 handler-interface = { path = "crates/handler/interface", package = "revm-handler-interface", version = "1.0.0", default-features = false }
 
+# mics
+cfg-if = { version = "1.0", default-features = false }
+auto_impl = { version = "1.2.0" }
+derive-where = { version = "1.2.7", default-features = false }
 
 [workspace.package]
 license = "MIT"

bins/revme/src/cmd/statetest/runner.rs

@@ -458,6 +458,7 @@ pub fn execute_test_suite(
                                 error: Ok(()),
                             },
                             inspector: StepPrintInspector::new(),
+                            frame_input_stack: Vec::new(),
                         },
                         handler: EthHandler::new(
                             EthValidation::new(),

crates/bytecode/src/opcode.rs

@@ -138,6 +138,12 @@ impl OpCode {
         }
     }
 
+    /// Returns the opcode as a usize.
+    #[inline]
+    pub const fn as_usize(&self) -> usize {
+        self.0 as usize
+    }
+
     /// Returns the opcode information.
     #[inline]
     pub const fn info(&self) -> OpCodeInfo {

crates/context/Cargo.toml

@@ -24,7 +24,6 @@ all = "warn"
 [dependencies]
 # revm
 interpreter.workspace = true
-precompile.workspace = true
 context-interface.workspace = true
 primitives.workspace = true
 database-interface.workspace = true
@@ -34,9 +33,7 @@ bytecode.workspace = true
 database = { workspace = true, optional = true }
 
 # misc
-derive-where = { version = "1.2.7", default-features = false }
-dyn-clone = "1.0"
-auto_impl = "1.2.0"
+derive-where.workspace = true
 
 # Optional
 serde = { version = "1.0", default-features = false, features = [

crates/context/interface/Cargo.toml

@@ -27,12 +27,10 @@ primitives.workspace = true
 database-interface.workspace = true
 state.workspace = true
 specification.workspace = true
-bytecode.workspace = true
 
 # mics
-dyn-clone = "1.0"
-cfg-if = { version = "1.0", default-features = false }
-auto_impl = "1.2.0"
+cfg-if.workspace = true
+auto_impl.workspace = true
 
 # Optional
 serde = { version = "1.0", default-features = false, features = [

crates/database/interface/Cargo.toml

@@ -22,10 +22,12 @@ rust_2018_idioms = "deny"
 all = "warn"
 
 [dependencies]
+# revm
 state.workspace = true
 primitives.workspace = true
 
-auto_impl = "1.2"
+# mics
+auto_impl.workspace = true
 
 # Optional
 serde = { version = "1.0", default-features = false, features = [
@@ -48,6 +50,4 @@ alloy-sol-types = "0.8"
 default = ["std"]
 std = ["serde?/std"]
 serde = ["dep:serde"]
-asyncdb = [
-    "dep:tokio",
-]
+asyncdb = ["dep:tokio"]

crates/handler/Cargo.toml

@@ -33,11 +33,6 @@ bytecode.workspace = true
 database = { workspace = true, optional = true }
 handler-interface.workspace = true
 
-# misc
-derive-where = { version = "1.2.7", default-features = false }
-dyn-clone = "1.0"
-auto_impl = "1.2.0"
-
 # Optional
 serde = { version = "1.0", default-features = false, features = [
     "derive",

crates/handler/interface/src/frame.rs

@@ -8,14 +8,14 @@ pub trait Frame: Sized {
     type Error;
 
     fn init_first(
-        cxt: &mut Self::Context,
-        frame_action: Self::FrameInit,
+        ctx: &mut Self::Context,
+        frame_input: Self::FrameInit,
     ) -> Result<FrameOrResultGen<Self, Self::FrameResult>, Self::Error>;
 
     fn init(
         &self,
-        cxt: &mut Self::Context,
-        frame_action: Self::FrameInit,
+        ctx: &mut Self::Context,
+        frame_input: Self::FrameInit,
     ) -> Result<FrameOrResultGen<Self, Self::FrameResult>, Self::Error>;
 
     fn run(
@@ -25,7 +25,7 @@ pub trait Frame: Sized {
 
     fn return_result(
         &mut self,
-        cxt: &mut Self::Context,
+        ctx: &mut Self::Context,
         result: Self::FrameResult,
     ) -> Result<(), Self::Error>;
 }

crates/handler/src/execution.rs

@@ -8,7 +8,7 @@ use handler_interface::{ExecutionHandler, Frame as FrameTrait, FrameOrResultGen}
 use interpreter::{
     interpreter::{EthInstructionProvider, EthInterpreter},
     return_ok, return_revert, CallInputs, CallScheme, CallValue, CreateInputs, CreateScheme,
-    EOFCreateInputs, EOFCreateKind, Gas, NewFrameAction,
+    EOFCreateInputs, EOFCreateKind, FrameInput, Gas,
 };
 use primitives::TxKind;
 use specification::hardfork::SpecId;
@@ -37,12 +37,8 @@ where
         + JournalStateGetter
         + CfgGetter,
     ERROR: From<InvalidTransaction> + From<JournalStateGetterDBError<CTX>>,
-    FRAME: FrameTrait<
-        Context = CTX,
-        Error = ERROR,
-        FrameInit = NewFrameAction,
-        FrameResult = FrameResult,
-    >,
+    FRAME:
+        FrameTrait<Context = CTX, Error = ERROR, FrameInit = FrameInput, FrameResult = FrameResult>,
 {
     type Context = CTX;
     type Error = ERROR;
@@ -60,8 +56,8 @@ where
         let tx = context.tx();
         let input = tx.common_fields().input().clone();
 
-        let init_frame: NewFrameAction = match tx.kind() {
-            TxKind::Call(target_address) => NewFrameAction::Call(Box::new(CallInputs {
+        let init_frame: FrameInput = match tx.kind() {
+            TxKind::Call(target_address) => FrameInput::Call(Box::new(CallInputs {
                 input,
                 gas_limit,
                 target_address,
@@ -76,14 +72,14 @@ where
             TxKind::Create => {
                 // if first byte of data is magic 0xEF00, then it is EOFCreate.
                 if spec.is_enabled_in(SpecId::PRAGUE_EOF) && input.starts_with(&EOF_MAGIC_BYTES) {
-                    NewFrameAction::EOFCreate(Box::new(EOFCreateInputs::new(
+                    FrameInput::EOFCreate(Box::new(EOFCreateInputs::new(
                         tx.common_fields().caller(),
                         tx.common_fields().value(),
                         gas_limit,
                         EOFCreateKind::Tx { initdata: input },
                     )))
                 } else {
-                    NewFrameAction::Create(Box::new(CreateInputs {
+                    FrameInput::Create(Box::new(CreateInputs {
                         caller: tx.common_fields().caller(),
                         scheme: CreateScheme::Create,
                         value: tx.common_fields().value(),

crates/handler/src/frame.rs

@@ -12,8 +12,8 @@ use interpreter::{
     interpreter::{EthInterpreter, InstructionProvider},
     interpreter_wiring::{LoopControl, ReturnData, RuntimeFlag},
     return_ok, return_revert, CallInputs, CallOutcome, CallValue, CreateInputs, CreateOutcome,
-    CreateScheme, EOFCreateInputs, EOFCreateKind, Gas, Host, InputsImpl, InstructionResult,
-    InterpreterAction, InterpreterResult, InterpreterWire, NewFrameAction, NewInterpreter,
+    CreateScheme, EOFCreateInputs, EOFCreateKind, FrameInput, Gas, Host, InputsImpl,
+    InstructionResult, InterpreterAction, InterpreterResult, InterpreterWire, NewInterpreter,
     SharedMemory,
 };
 use precompile::PrecompileErrors;
@@ -72,7 +72,7 @@ pub struct EthFrame<CTX, ERROR, IW: InterpreterWire, PRECOMPILE, INSTRUCTIONS> {
     pub interpreter: NewInterpreter<IW>,
     /// Precompiles provider.
     pub precompiles: PRECOMPILE,
-    /// Insturction provider.
+    /// Instruction provider.
     pub instructions: INSTRUCTIONS,
     // This is worth making as a generic type FrameSharedContext.
     pub memory: Rc<RefCell<SharedMemory>>,
@@ -191,7 +191,8 @@ where
         } else {
             let account = ctx.journal().load_account_code(inputs.bytecode_address)?;
 
-            let code_hash = account.info.code_hash();
+            // TODO Request from foundry to get bytecode hash.
+            let _code_hash = account.info.code_hash();
             let mut bytecode = account.info.code.clone().unwrap_or_default();
 
             // ExtDelegateCall is not allowed to call non-EOF contracts.
@@ -301,12 +302,13 @@ where
         }
 
         // Create address
-        let mut init_code_hash = B256::ZERO;
+        // TODO incorporating code hash inside interpreter. It was a request by foundry.
+        let mut _init_code_hash = B256::ZERO;
         let created_address = match inputs.scheme {
             CreateScheme::Create => inputs.caller.create(old_nonce),
             CreateScheme::Create2 { salt } => {
-                init_code_hash = keccak256(&inputs.init_code);
-                inputs.caller.create2(salt.to_be_bytes(), init_code_hash)
+                _init_code_hash = keccak256(&inputs.init_code);
+                inputs.caller.create2(salt.to_be_bytes(), _init_code_hash)
             }
         };
 
@@ -452,20 +454,18 @@ where
             return return_error(InstructionResult::CreateCollision);
         };
 
-        let bytecode = Bytecode::new_legacy(input).into_analyzed();
-
         let interpreter_input = InputsImpl {
             target_address: created_address,
             caller_address: inputs.caller,
-            input: Bytes::new(),
+            input,
             call_value: inputs.value,
         };
 
         Ok(FrameOrResultGen::Frame(Self::new(
             FrameData::Create(CreateFrame { created_address }),
             NewInterpreter::new(
                 memory.clone(),
-                bytecode,
+                Bytecode::Eof(Arc::new(initcode)),
                 interpreter_input,
                 false,
                 false,
@@ -481,20 +481,20 @@ where
 
     pub fn init_with_context(
         depth: usize,
-        frame_init: NewFrameAction,
+        frame_init: FrameInput,
         memory: Rc<RefCell<SharedMemory>>,
         precompile: PRECOMPILE,
         instructions: INSTRUCTION,
         ctx: &mut CTX,
     ) -> Result<FrameOrResultGen<Self, FrameResult>, ERROR> {
         match frame_init {
-            NewFrameAction::Call(inputs) => {
+            FrameInput::Call(inputs) => {
                 Self::make_call_frame(ctx, depth, memory, &inputs, precompile, instructions)
             }
-            NewFrameAction::Create(inputs) => {
+            FrameInput::Create(inputs) => {
                 Self::make_create_frame(ctx, depth, memory, &inputs, precompile, instructions)
             }
-            NewFrameAction::EOFCreate(inputs) => {
+            FrameInput::EOFCreate(inputs) => {
                 Self::make_eofcreate_frame(ctx, depth, memory, &inputs, precompile, instructions)
             }
         }
@@ -516,12 +516,12 @@ where
 {
     type Context = CTX;
     type Error = ERROR;
-    type FrameInit = NewFrameAction;
+    type FrameInit = FrameInput;
     type FrameResult = FrameResult;
 
     fn init_first(
         ctx: &mut Self::Context,
-        frame_action: Self::FrameInit,
+        frame_input: Self::FrameInit,
     ) -> Result<FrameOrResultGen<Self, Self::FrameResult>, Self::Error> {
         let memory = Rc::new(RefCell::new(SharedMemory::new()));
         let precompiles = PRECOMPILE::new(ctx);
@@ -533,7 +533,7 @@ where
         }
 
         memory.borrow_mut().new_context();
-        Self::init_with_context(0, frame_action, memory, precompiles, instructions, ctx)
+        Self::init_with_context(0, frame_input, memory, precompiles, instructions, ctx)
     }
 
     fn init(

crates/handler/src/lib.rs

@@ -43,8 +43,7 @@ use context_interface::{
     TransactionGetter,
 };
 use handler_interface::{
-    ExecutionHandler, Frame, FrameOrResultGen, Handler, PostExecutionHandler, PreExecutionHandler,
-    ValidationHandler,
+    ExecutionHandler, Handler, PostExecutionHandler, PreExecutionHandler, ValidationHandler,
 };
 use interpreter::Host;
 

crates/handler/src/precompile_provider.rs

@@ -1,6 +1,5 @@
 use context_interface::{Cfg, CfgGetter};
 use handler_interface::PrecompileProvider;
-use interpreter::Host;
 use interpreter::{Gas, InstructionResult, InterpreterResult};
 use precompile::PrecompileErrors;
 use precompile::{PrecompileSpecId, Precompiles};

crates/inspector/Cargo.toml

@@ -26,8 +26,8 @@ all = "warn"
 revm.workspace = true
 
 # mics
-auto_impl = { version = "1.2", default-features = false }
-derive-where = { version = "1.2.7", default-features = false }
+auto_impl.workspace = true
+derive-where.workspace = true
 
 # Optional
 serde = { version = "1.0", default-features = false, features = [