refactor calls

crates/interpreter/src/call_inputs.rs

@@ -0,0 +1,111 @@
+use crate::primitives::{Address, Bytes, TransactTo, TxEnv, U256};
+use core::ops::Range;
+use std::boxed::Box;
+
+/// Inputs for a call.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct CallInputs {
+    /// The target of the call.
+    pub contract: Address,
+    /// The transfer, if any, in this call.
+    pub transfer: Transfer,
+    /// The call data of the call.
+    pub input: Bytes,
+    /// The gas limit of the call.
+    pub gas_limit: u64,
+    /// The context of the call.
+    pub context: CallContext,
+    /// Whether this is a static call.
+    pub is_static: bool,
+    /// The return memory offset where the output of the call is written.
+    pub return_memory_offset: Range<usize>,
+}
+
+impl CallInputs {
+    /// Creates new call inputs.
+    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,
+            return_memory_offset: 0..0,
+        })
+    }
+
+    /// Returns boxed call inputs.
+    pub fn new_boxed(tx_env: &TxEnv, gas_limit: u64) -> Option<Box<Self>> {
+        Self::new(tx_env, gas_limit).map(Box::new)
+    }
+}
+
+/// Call schemes.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum CallScheme {
+    /// `CALL`.
+    Call,
+    /// `CALLCODE`
+    CallCode,
+    /// `DELEGATECALL`
+    DelegateCall,
+    /// `STATICCALL`
+    StaticCall,
+}
+
+/// Context of a runtime call.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct CallContext {
+    /// Execution address.
+    pub address: Address,
+    /// Caller address of the EVM.
+    pub caller: Address,
+    /// The address the contract code was loaded from, if any.
+    pub code_address: Address,
+    /// Apparent value of the EVM.
+    pub apparent_value: U256,
+    /// The scheme used for the call.
+    pub scheme: CallScheme,
+}
+
+impl Default for CallContext {
+    fn default() -> Self {
+        CallContext {
+            address: Address::default(),
+            caller: Address::default(),
+            code_address: Address::default(),
+            apparent_value: U256::default(),
+            scheme: CallScheme::Call,
+        }
+    }
+}
+
+/// Transfer from source to target, with given value.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct Transfer {
+    /// The source address.
+    pub source: Address,
+    /// The target address.
+    pub target: Address,
+    /// The transfer value.
+    pub value: U256,
+}

crates/interpreter/src/create_inputs.rs

@@ -0,0 +1,51 @@
+pub use crate::primitives::CreateScheme;
+use crate::primitives::{Address, Bytes, TransactTo, TxEnv, U256};
+use std::boxed::Box;
+
+/// Inputs for a create call.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct CreateInputs {
+    /// Caller address of the EVM.
+    pub caller: Address,
+    /// The create scheme.
+    pub scheme: CreateScheme,
+    /// The value to transfer.
+    pub value: U256,
+    /// The init code of the contract.
+    pub init_code: Bytes,
+    /// The gas limit of the call.
+    pub gas_limit: u64,
+}
+
+impl CreateInputs {
+    /// Creates new create inputs.
+    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 boxed create inputs.
+    pub fn new_boxed(tx_env: &TxEnv, gas_limit: u64) -> Option<Box<Self>> {
+        Self::new(tx_env, gas_limit).map(Box::new)
+    }
+
+    /// Returns the address that this create call will create.
+    pub fn created_address(&self, nonce: u64) -> Address {
+        match self.scheme {
+            CreateScheme::Create => self.caller.create(nonce),
+            CreateScheme::Create2 { salt } => self
+                .caller
+                .create2_from_code(salt.to_be_bytes(), &self.init_code),
+        }
+    }
+}

crates/interpreter/src/gas/calc.rs

@@ -1,6 +1,6 @@
 use super::constants::*;
-use crate::inner_models::SelfDestructResult;
 use crate::primitives::{Address, Spec, SpecId::*, U256};
+use crate::SelfDestructResult;
 use std::vec::Vec;
 
 #[allow(clippy::collapsible_else_if)]

crates/interpreter/src/gas/constants.rs

@@ -37,6 +37,8 @@ pub const TRANSACTION_ZERO_DATA: u64 = 4;
 pub const TRANSACTION_NON_ZERO_DATA_INIT: u64 = 16;
 pub const TRANSACTION_NON_ZERO_DATA_FRONTIER: u64 = 68;
 
+pub const EOF_CREATE_GAS: u64 = 32000;
+
 // berlin eip2929 constants
 pub const ACCESS_LIST_ADDRESS: u64 = 2400;
 pub const ACCESS_LIST_STORAGE_KEY: u64 = 1900;

crates/interpreter/src/host.rs

@@ -1,7 +1,4 @@
-use crate::{
-    primitives::{Address, Bytecode, Env, Log, B256, U256},
-    SelfDestructResult,
-};
+use crate::primitives::{Address, Bytecode, Env, Log, B256, U256};
 
 mod dummy;
 pub use dummy::DummyHost;
@@ -65,3 +62,13 @@ pub struct SStoreResult {
     /// Is storage slot loaded from database
     pub is_cold: bool,
 }
+
+/// Result of a call that resulted in a self destruct.
+#[derive(Default, Clone, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct SelfDestructResult {
+    pub had_value: bool,
+    pub target_exists: bool,
+    pub is_cold: bool,
+    pub previously_destroyed: bool,
+}

crates/interpreter/src/inner_models.rs

@@ -3,26 +3,6 @@ use crate::primitives::{Address, Bytes, TransactTo, TxEnv, U256};
 use core::ops::Range;
 use std::boxed::Box;
 
-/// Inputs for a call.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct CallInputs {
-    /// The target of the call.
-    pub contract: Address,
-    /// The transfer, if any, in this call.
-    pub transfer: Transfer,
-    /// The call data of the call.
-    pub input: Bytes,
-    /// The gas limit of the call.
-    pub gas_limit: u64,
-    /// The context of the call.
-    pub context: CallContext,
-    /// Whether this is a static call.
-    pub is_static: bool,
-    /// The return memory offset where the output of the call is written.
-    pub return_memory_offset: Range<usize>,
-}
-
 /// Inputs for a create call.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -39,40 +19,6 @@ pub struct CreateInputs {
     pub gas_limit: u64,
 }
 
-impl CallInputs {
-    /// Creates new call inputs.
-    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,
-            return_memory_offset: 0..0,
-        })
-    }
-
-    /// Returns boxed call inputs.
-    pub fn new_boxed(tx_env: &TxEnv, gas_limit: u64) -> Option<Box<Self>> {
-        Self::new(tx_env, gas_limit).map(Box::new)
-    }
-}
-
 impl CreateInputs {
     /// Creates new create inputs.
     pub fn new(tx_env: &TxEnv, gas_limit: u64) -> Option<Self> {
@@ -104,67 +50,3 @@ impl CreateInputs {
         }
     }
 }
-
-/// Call schemes.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub enum CallScheme {
-    /// `CALL`.
-    Call,
-    /// `CALLCODE`
-    CallCode,
-    /// `DELEGATECALL`
-    DelegateCall,
-    /// `STATICCALL`
-    StaticCall,
-}
-
-/// Context of a runtime call.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct CallContext {
-    /// Execution address.
-    pub address: Address,
-    /// Caller address of the EVM.
-    pub caller: Address,
-    /// The address the contract code was loaded from, if any.
-    pub code_address: Address,
-    /// Apparent value of the EVM.
-    pub apparent_value: U256,
-    /// The scheme used for the call.
-    pub scheme: CallScheme,
-}
-
-impl Default for CallContext {
-    fn default() -> Self {
-        CallContext {
-            address: Address::default(),
-            caller: Address::default(),
-            code_address: Address::default(),
-            apparent_value: U256::default(),
-            scheme: CallScheme::Call,
-        }
-    }
-}
-
-/// Transfer from source to target, with given value.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct Transfer {
-    /// The source address.
-    pub source: Address,
-    /// The target address.
-    pub target: Address,
-    /// The transfer value.
-    pub value: U256,
-}
-
-/// Result of a call that resulted in a self destruct.
-#[derive(Default, Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct SelfDestructResult {
-    pub had_value: bool,
-    pub target_exists: bool,
-    pub is_cold: bool,
-    pub previously_destroyed: bool,
-}

crates/interpreter/src/instructions/contract.rs

@@ -3,27 +3,32 @@ mod call_helpers;
 pub use call_helpers::{calc_call_gas, get_memory_input_and_out_ranges};
 
 use crate::{
-    gas::{self, COLD_ACCOUNT_ACCESS_COST, WARM_STORAGE_READ_COST},
+    gas::{self, EOF_CREATE_GAS},
     interpreter::{Interpreter, InterpreterAction},
-    primitives::{Address, Bytes, Log, LogData, Spec, SpecId::*, B256, U256},
+    primitives::{Address, Bytes, Spec, SpecId::*, B256, U256},
     CallContext, CallInputs, CallScheme, CreateInputs, CreateScheme, Host, InstructionResult,
     Transfer, MAX_INITCODE_SIZE,
 };
-use core::cmp::min;
-use revm_primitives::BLOCK_HASH_HISTORY;
-use std::{boxed::Box, vec::Vec};
+use std::boxed::Box;
 
-pub fn create3<H: Host>(interpreter: &mut Interpreter, host: &mut H) {}
+pub fn eofcrate<H: Host>(interpreter: &mut Interpreter, host: &mut H) {
+    error_on_disabled_eof!(interpreter);
+    gas!(interpreter, EOF_CREATE_GAS);
+    let initcontainer_index = unsafe { *interpreter.instruction_pointer };
+    pop!(interpreter, value, salt, data_offset, data_size);
 
-pub fn create4<H: Host>(interpreter: &mut Interpreter, host: &mut H) {}
+    interpreter.instruction_pointer = unsafe { interpreter.instruction_pointer.offset(1) };
+}
+
+pub fn txcreate<H: Host>(interpreter: &mut Interpreter, host: &mut H) {}
 
 pub fn return_contract<H: Host>(interpreter: &mut Interpreter, host: &mut H) {}
 
-pub fn call2<H: Host>(interpreter: &mut Interpreter, host: &mut H) {}
+pub fn extcall<H: Host>(interpreter: &mut Interpreter, host: &mut H) {}
 
-pub fn delegate_call2<H: Host>(interpreter: &mut Interpreter, host: &mut H) {}
+pub fn extdcall<H: Host>(interpreter: &mut Interpreter, host: &mut H) {}
 
-pub fn static_call2<H: Host>(interpreter: &mut Interpreter, host: &mut H) {}
+pub fn extscall<H: Host>(interpreter: &mut Interpreter, host: &mut H) {}
 
 pub fn create<const IS_CREATE2: bool, H: Host, SPEC: Spec>(
     interpreter: &mut Interpreter,

crates/interpreter/src/instructions/host.rs

@@ -1,13 +1,12 @@
 use crate::{
     gas::{self, COLD_ACCOUNT_ACCESS_COST, WARM_STORAGE_READ_COST},
-    interpreter::{Interpreter, InterpreterAction},
+    interpreter::Interpreter,
     primitives::{Address, Bytes, Log, LogData, Spec, SpecId::*, B256, U256},
-    CallContext, CallInputs, CallScheme, CreateInputs, CreateScheme, Host, InstructionResult,
-    SStoreResult, Transfer, MAX_INITCODE_SIZE,
+    Host, InstructionResult, SStoreResult,
 };
 use core::cmp::min;
 use revm_primitives::BLOCK_HASH_HISTORY;
-use std::{boxed::Box, vec::Vec};
+use std::vec::Vec;
 
 pub fn balance<H: Host, SPEC: Spec>(interpreter: &mut Interpreter, host: &mut H) {
     pop_address!(interpreter, address);