FrameData and docs

crates/interpreter/src/inner_models.rs

@@ -1,3 +1,5 @@
+use revm_primitives::{TransactTo, TxEnv};
+
 pub use crate::primitives::CreateScheme;
 use crate::primitives::{Address, Bytes, B256, U256};
 
@@ -35,7 +37,47 @@ pub struct CreateInputs {
     pub gas_limit: u64,
 }
 
+impl CallInputs {
+    pub fn new(tx_env: &TxEnv, gas_limit: u64) -> Option<Self> {
+        let TransactTo::Call(address) = tx_env.transact_to else {
+            return None;
+        };
+
+        Some(CallInputs {
+            contract: address,
+            transfer: Transfer {
+                source: tx_env.caller,
+                target: address,
+                value: tx_env.value,
+            },
+            input: tx_env.data.clone(),
+            gas_limit,
+            context: CallContext {
+                caller: tx_env.caller,
+                address,
+                code_address: address,
+                apparent_value: tx_env.value,
+                scheme: CallScheme::Call,
+            },
+            is_static: false,
+        })
+    }
+}
+
 impl CreateInputs {
+    pub fn new(tx_env: &TxEnv, gas_limit: u64) -> Option<Self> {
+        let TransactTo::Create(scheme) = tx_env.transact_to else {
+            return None;
+        };
+
+        Some(CreateInputs {
+            caller: tx_env.caller,
+            scheme,
+            value: tx_env.value,
+            init_code: tx_env.data.clone(),
+            gas_limit,
+        })
+    }
     /// Returns the address that this create call will create.
     pub fn created_address(&self, nonce: u64) -> Address {
         match self.scheme {

crates/revm/src/builder.rs

@@ -1,5 +1,3 @@
-//! Evm Builder.
-
 use crate::{
     db::{Database, DatabaseRef, EmptyDB, WrapDatabaseRef},
     handler::register,

crates/revm/src/context.rs

@@ -10,7 +10,7 @@ use crate::{
         keccak256, Address, AnalysisKind, Bytecode, Bytes, EVMError, Env, HashSet, Spec, SpecId,
         SpecId::*, B256, U256,
     },
-    CallStackFrame, FrameOrResult, CALL_STACK_LIMIT,
+    CallStackFrame, FrameData, FrameOrResult, JournalCheckpoint, CALL_STACK_LIMIT,
 };
 use alloc::boxed::Box;
 use core::ops::Range;
@@ -280,10 +280,8 @@ impl<DB: Database> EvmContext<DB> {
         ));
 
         FrameOrResult::new_frame(CallStackFrame {
-            is_create: true,
             checkpoint,
-            created_address: Some(created_address),
-            subcall_return_memory_range: 0..0,
+            frame_data: FrameData::Create { created_address },
             interpreter: Interpreter::new(contract, gas.limit(), false),
         })
     }
@@ -292,7 +290,7 @@ impl<DB: Database> EvmContext<DB> {
     pub fn make_call_frame(
         &mut self,
         inputs: &CallInputs,
-        return_memory_offset: Range<usize>,
+        return_memory_range: Range<usize>,
     ) -> FrameOrResult {
         let gas = Gas::new(inputs.gas_limit);
 
@@ -359,10 +357,10 @@ impl<DB: Database> EvmContext<DB> {
             ));
             // Create interpreter and execute subcall and push new CallStackFrame.
             FrameOrResult::new_frame(CallStackFrame {
-                is_create: false,
                 checkpoint,
-                created_address: None,
-                subcall_return_memory_range: return_memory_offset,
+                frame_data: FrameData::Call {
+                    return_memory_range,
+                },
                 interpreter: Interpreter::new(contract, gas.limit(), inputs.is_static),
             })
         } else {
@@ -416,13 +414,13 @@ impl<DB: Database> EvmContext<DB> {
     pub fn call_return(
         &mut self,
         interpreter_result: InterpreterResult,
-        frame: Box<CallStackFrame>,
+        journal_checkpoint: JournalCheckpoint,
     ) -> InterpreterResult {
         // revert changes or not.
         if matches!(interpreter_result.result, return_ok!()) {
             self.journaled_state.checkpoint_commit();
         } else {
-            self.journaled_state.checkpoint_revert(frame.checkpoint);
+            self.journaled_state.checkpoint_revert(journal_checkpoint);
         }
         interpreter_result
     }
@@ -432,13 +430,14 @@ impl<DB: Database> EvmContext<DB> {
     pub fn create_return<SPEC: Spec>(
         &mut self,
         mut interpreter_result: InterpreterResult,
-        frame: Box<CallStackFrame>,
-    ) -> (InterpreterResult, Address) {
-        let address = frame.created_address.unwrap();
+        address: Address,
+        journal_checkpoint: JournalCheckpoint,
+    ) -> InterpreterResult {
+        //let address = frame.created_address.unwrap();
         // if return is not ok revert and return.
         if !matches!(interpreter_result.result, return_ok!()) {
-            self.journaled_state.checkpoint_revert(frame.checkpoint);
-            return (interpreter_result, address);
+            self.journaled_state.checkpoint_revert(journal_checkpoint);
+            return interpreter_result;
         }
         // Host error if present on execution
         // if ok, check contract creation limit and calculate gas deduction on output len.
@@ -448,9 +447,9 @@ impl<DB: Database> EvmContext<DB> {
             && !interpreter_result.output.is_empty()
             && interpreter_result.output.first() == Some(&0xEF)
         {
-            self.journaled_state.checkpoint_revert(frame.checkpoint);
+            self.journaled_state.checkpoint_revert(journal_checkpoint);
             interpreter_result.result = InstructionResult::CreateContractStartingWithEF;
-            return (interpreter_result, address);
+            return interpreter_result;
         }
 
         // EIP-170: Contract code size limit
@@ -463,9 +462,9 @@ impl<DB: Database> EvmContext<DB> {
                     .limit_contract_code_size
                     .unwrap_or(MAX_CODE_SIZE)
         {
-            self.journaled_state.checkpoint_revert(frame.checkpoint);
+            self.journaled_state.checkpoint_revert(journal_checkpoint);
             interpreter_result.result = InstructionResult::CreateContractSizeLimit;
-            return (interpreter_result, frame.created_address.unwrap());
+            return interpreter_result;
         }
         let gas_for_code = interpreter_result.output.len() as u64 * gas::CODEDEPOSIT;
         if !interpreter_result.gas.record_cost(gas_for_code) {
@@ -474,9 +473,9 @@ impl<DB: Database> EvmContext<DB> {
             // final gas fee for adding the contract code to the state, the contract
             //  creation fails (i.e. goes out-of-gas) rather than leaving an empty contract.
             if SPEC::enabled(HOMESTEAD) {
-                self.journaled_state.checkpoint_revert(frame.checkpoint);
+                self.journaled_state.checkpoint_revert(journal_checkpoint);
                 interpreter_result.result = InstructionResult::OutOfGas;
-                return (interpreter_result, address);
+                return interpreter_result;
             } else {
                 interpreter_result.output = Bytes::new();
             }
@@ -499,7 +498,7 @@ impl<DB: Database> EvmContext<DB> {
         self.journaled_state.set_code(address, bytecode);
 
         interpreter_result.result = InstructionResult::Return;
-        (interpreter_result, address)
+        interpreter_result
     }
 }
 /// Test utilities for the [`EvmContext`].
@@ -669,8 +668,12 @@ mod tests {
         let FrameOrResult::Frame(frame) = res else {
             panic!("Expected FrameOrResult::Frame");
         };
-        assert!(!frame.is_create);
-        assert_eq!(frame.created_address, None);
-        assert_eq!(frame.subcall_return_memory_range, 0..0);
+        assert!(!frame.is_create());
+        assert_eq!(
+            frame.frame_data,
+            FrameData::Call {
+                return_memory_range: 0..0
+            }
+        );
     }
 }

crates/revm/src/evm.rs

@@ -148,7 +148,7 @@ impl<EXT, DB: Database> Evm<'_, EXT, DB> {
         // start main loop if CallStackFrame is created correctly
         let result = match first_stack_frame {
             FrameOrResult::Frame(first_stack_frame) => {
-                created_address = first_stack_frame.created_address;
+                created_address = first_stack_frame.created_address();
                 // take instruction talbe
                 let table = self
                     .handler

crates/revm/src/frame.rs

@@ -9,16 +9,21 @@ use core::ops::Range;
 /// Call CallStackFrame.
 #[derive(Debug)]
 pub struct CallStackFrame {
-    /// True if it is create false if it is call.
-    pub is_create: bool,
     /// Journal checkpoint
     pub checkpoint: JournalCheckpoint,
-    /// temporary. If it is create it should have address.
-    pub created_address: Option<Address>,
-    /// temporary. Call range
-    pub subcall_return_memory_range: Range<usize>,
     /// Interpreter
     pub interpreter: Interpreter,
+    /// Frame data
+    pub frame_data: FrameData,
+}
+
+/// Specific data for call or create frame.
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum FrameData {
+    /// Call frame has return memory range where output will be stored.
+    Call { return_memory_range: Range<usize> },
+    /// Create frame has a created address.
+    Create { created_address: Address },
 }
 
 /// Contains either a frame or a result.
@@ -29,6 +34,26 @@ pub enum FrameOrResult {
     Result(InterpreterResult),
 }
 
+impl CallStackFrame {
+    /// Returns true if frame is call frame.
+    pub fn is_call(&self) -> bool {
+        matches!(self.frame_data, FrameData::Call { .. })
+    }
+
+    /// Returns true if frame is create frame.
+    pub fn is_create(&self) -> bool {
+        matches!(self.frame_data, FrameData::Create { .. })
+    }
+
+    /// Returns created address if frame is create otherwise returns None.
+    pub fn created_address(&self) -> Option<Address> {
+        match self.frame_data {
+            FrameData::Create { created_address } => Some(created_address),
+            _ => None,
+        }
+    }
+}
+
 impl FrameOrResult {
     /// Returns new frame.
     pub fn new_frame(frame: CallStackFrame) -> Self {

crates/revm/src/handler.rs

@@ -1,7 +1,3 @@
-//! Handler contains all the logic that is specific to the Evm.
-//! It is used to define different behavior depending on the chain (Optimism,Mainnet) or
-//! hardfork (Berlin, London, ..).
-
 // Modules.
 mod handle_types;
 pub mod mainnet;

crates/revm/src/handler/handle_types/execution_loop.rs

@@ -78,10 +78,10 @@ impl<'a, EXT: 'a, DB: Database + 'a> ExecutionLoopHandler<'a, EXT, DB> {
     pub fn new<SPEC: Spec + 'a>() -> Self {
         Self {
             create_first_frame: Arc::new(mainnet::create_first_frame::<SPEC, EXT, DB>),
-            first_frame_return: Arc::new(mainnet::main_frame_return::<SPEC>),
-            frame_return: Arc::new(mainnet::handle_frame_return::<SPEC, EXT, DB>),
-            sub_call: Arc::new(mainnet::handle_frame_sub_call::<SPEC, EXT, DB>),
-            sub_create: Arc::new(mainnet::handle_frame_sub_create::<SPEC, EXT, DB>),
+            first_frame_return: Arc::new(mainnet::first_frame_return::<SPEC>),
+            frame_return: Arc::new(mainnet::frame_return::<SPEC, EXT, DB>),
+            sub_call: Arc::new(mainnet::sub_call::<SPEC, EXT, DB>),
+            sub_create: Arc::new(mainnet::sub_create::<SPEC, EXT, DB>),
         }
     }
 }

crates/revm/src/handler/handle_types/pre_execution.rs

@@ -34,9 +34,9 @@ impl<'a, EXT: 'a, DB: Database + 'a> PreExecutionHandler<'a, EXT, DB> {
     /// Creates mainnet MainHandles.
     pub fn new<SPEC: Spec + 'a>() -> Self {
         Self {
-            load_precompiles: Arc::new(mainnet::main_load_precompiles::<SPEC>),
-            load_accounts: Arc::new(mainnet::main_load::<SPEC, EXT, DB>),
-            deduct_caller: Arc::new(mainnet::main_deduct_caller::<SPEC, EXT, DB>),
+            load_precompiles: Arc::new(mainnet::load_precompiles::<SPEC>),
+            load_accounts: Arc::new(mainnet::load::<SPEC, EXT, DB>),
+            deduct_caller: Arc::new(mainnet::deduct_caller::<SPEC, EXT, DB>),
         }
     }
 }

crates/revm/src/handler/mainnet.rs

@@ -1,16 +1,14 @@
 //! Mainnet related handlers.
 
-mod frame;
+mod execution_loop;
 mod post_execution;
 mod pre_execution;
 mod validation;
 
-pub use frame::{
-    create_first_frame, frame_return_with_refund_flag, handle_frame_return, handle_frame_sub_call,
-    handle_frame_sub_create, main_frame_return,
+pub use execution_loop::{
+    create_first_frame, first_frame_return, frame_return, frame_return_with_refund_flag, sub_call,
+    sub_create,
 };
 pub use post_execution::{end, output, reimburse_caller, reward_beneficiary};
-pub use pre_execution::{
-    deduct_caller_inner, main_deduct_caller, main_load, main_load_precompiles,
-};
+pub use pre_execution::{deduct_caller, deduct_caller_inner, load, load_precompiles};
 pub use validation::{validate_env, validate_initial_tx_gas, validate_tx_against_state};