Merge remote-tracking branch 'origin/main' into rakita/state-gas

Author: rakita

book/src/awesome.md

@@ -27,6 +27,7 @@ A curated list of excellent Revm-related resources. Feel free to contribute to t
 - [**Foundry:**](https://github.com/foundry-rs/foundry) A portable and modular toolkit for rapid Ethereum application development in Rust.
 - [**Hardhat:**](https://github.com/NomicFoundation/hardhat) A comprehensive development environment for compiling, deploying, testing, and debugging Ethereum software.
 - [**Arbiter:**](https://github.com/harnesslabs/arbiter) smart-contract simulation.
+- [**OpTrace:**](https://github.com/tanghaosuan11/op_trace) A high-performance, GUI-based EVM debugger with a programmable engine for deep-dive trace analysis.
 
 #### Frameworks and Libraries
 - [**revm-inspectors:**](https://github.com/paradigmxyz/revm-inspectors) Hooks for EVM execution.

crates/context/interface/src/local.rs

@@ -218,11 +218,7 @@ pub trait LocalContextTr {
 
     /// Slice of the shared memory buffer returns None if range is not valid or buffer can't be borrowed.
     fn shared_memory_buffer_slice(&self, range: Range<usize>) -> Option<Ref<'_, [u8]>> {
-        let buffer = self.shared_memory_buffer();
-        buffer.borrow().get(range.clone())?;
-        Some(Ref::map(buffer.borrow(), |b| {
-            b.get(range).unwrap_or_default()
-        }))
+        Ref::filter_map(self.shared_memory_buffer().borrow(), |b| b.get(range)).ok()
     }
 
     /// Clear the local context.

crates/database/src/states/state_builder.rs

@@ -21,12 +21,6 @@ pub struct StateBuilder<DB> {
     ///
     /// Default is false.
     with_bundle_update: bool,
-    /// Do we want to merge transitions in background?
-    ///
-    /// This will allow evm to continue executing.
-    ///
-    /// Default is false.
-    with_background_transition_merge: bool,
     /// If we want to set different block hashes,
     with_block_hashes: BlockHashCache,
     /// BAL state.
@@ -57,7 +51,6 @@ impl<DB: Database> StateBuilder<DB> {
             with_cache_prestate: None,
             with_bundle_prestate: None,
             with_bundle_update: false,
-            with_background_transition_merge: false,
             with_block_hashes: BlockHashCache::new(),
             bal_state: BalState::default(),
         }
@@ -72,7 +65,6 @@ impl<DB: Database> StateBuilder<DB> {
             with_cache_prestate: self.with_cache_prestate,
             with_bundle_prestate: self.with_bundle_prestate,
             with_bundle_update: self.with_bundle_update,
-            with_background_transition_merge: self.with_background_transition_merge,
             with_block_hashes: self.with_block_hashes,
             bal_state: self.bal_state,
         }
@@ -132,15 +124,6 @@ impl<DB: Database> StateBuilder<DB> {
         }
     }
 
-    /// Starts the thread that will take transitions and do merge to the bundle state
-    /// in the background.
-    pub fn with_background_transition_merge(self) -> Self {
-        Self {
-            with_background_transition_merge: true,
-            ..self
-        }
-    }
-
     /// Sets the block hashes for the state.
     pub fn with_block_hashes(self, block_hashes: BlockHashCache) -> Self {
         Self {

crates/handler/src/precompile_provider.rs

@@ -1,7 +1,7 @@
 use auto_impl::auto_impl;
 use context::{Cfg, LocalContextTr};
 use context_interface::{ContextTr, JournalTr};
-use interpreter::{CallInput, CallInputs, Gas, InstructionResult, InterpreterResult};
+use interpreter::{CallInputs, Gas, InstructionResult, InterpreterResult};
 use precompile::{PrecompileSpecId, Precompiles};
 use primitives::{hardfork::SpecId, Address, Bytes};
 use std::{
@@ -101,22 +101,7 @@ impl<CTX: ContextTr> PrecompileProvider<CTX> for EthPrecompiles {
             output: Bytes::new(),
         };
 
-        let exec_result = {
-            let r;
-            let input_bytes = match &inputs.input {
-                CallInput::SharedBuffer(range) => {
-                    if let Some(slice) = context.local().shared_memory_buffer_slice(range.clone()) {
-                        r = slice;
-                        r.as_ref()
-                    } else {
-                        &[]
-                    }
-                }
-                CallInput::Bytes(bytes) => bytes.0.iter().as_slice(),
-            };
-            precompile.execute(input_bytes, inputs.gas_limit)
-        };
-
+        let exec_result = precompile.execute(&inputs.input.as_bytes(context), inputs.gas_limit);
         match exec_result {
             Ok(output) => {
                 *result.gas.tracker_mut() = output.gas;

crates/interpreter/src/instructions/system.rs

@@ -111,28 +111,12 @@ pub fn calldataload<WIRE: InterpreterTypes, H: ?Sized>(context: InstructionConte
     let input_len = input.len();
     if offset < input_len {
         let count = 32.min(input_len - offset);
-
+        let input = &*input.as_bytes_memory(&context.interpreter.memory);
         // SAFETY: `count` is bounded by the calldata length.
         // This is `word[..count].copy_from_slice(input[offset..offset + count])`, written using
         // raw pointers as apparently the compiler cannot optimize the slice version, and using
         // `get_unchecked` twice is uglier.
-        match context.interpreter.input.input() {
-            CallInput::Bytes(bytes) => {
-                unsafe {
-                    ptr::copy_nonoverlapping(bytes.as_ptr().add(offset), word.as_mut_ptr(), count)
-                };
-            }
-            CallInput::SharedBuffer(range) => {
-                let input_slice = context.interpreter.memory.global_slice(range.clone());
-                unsafe {
-                    ptr::copy_nonoverlapping(
-                        input_slice.as_ptr().add(offset),
-                        word.as_mut_ptr(),
-                        count,
-                    )
-                };
-            }
-        }
+        unsafe { ptr::copy_nonoverlapping(input.as_ptr().add(offset), word.as_mut_ptr(), count) };
     }
     *offset_ptr = word.into();
 }

crates/interpreter/src/interpreter/shared_memory.rs

@@ -226,9 +226,10 @@ impl SharedMemory {
     fn slice_range_with_base(&self, range: Range<usize>, base: usize) -> Ref<'_, [u8]> {
         let buffer = self.buffer_ref();
         Ref::map(buffer, |b| {
-            match b.get(range.start + base..range.end + base) {
+            let range = range.start + base..range.end + base;
+            match b.get(range.clone()) {
                 Some(slice) => slice,
-                None => debug_unreachable!("slice OOB: range; len: {}", self.len()),
+                None => debug_unreachable!("slice OOB: {range:?}; len: {}", self.len()),
             }
         })
     }

crates/interpreter/src/interpreter_action/call_inputs.rs

@@ -1,13 +1,17 @@
+use crate::interpreter_types::MemoryTr;
 use context_interface::{ContextTr, LocalContextTr};
 use core::ops::Range;
 use primitives::{Address, Bytes, B256, U256};
 use state::Bytecode;
+
 /// Input enum for a call.
 ///
 /// As CallInput uses shared memory buffer it can get overridden if not used directly when call happens.
 #[derive(Clone, Debug, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum CallInput {
+    /// Bytes of the call data.
+    Bytes(Bytes),
     /// The Range points to the SharedMemory buffer. Buffer can be found in [`context_interface::LocalContextTr::shared_memory_buffer_slice`] function.
     /// And can be accessed with `evm.ctx().local().shared_memory_buffer()`
     ///
@@ -16,12 +20,11 @@ pub enum CallInput {
     /// Use it with caution, CallInput shared buffer can be overridden if context from child call is returned so
     /// recommendation is to fetch buffer at first Inspector call and clone it from [`context_interface::LocalContextTr::shared_memory_buffer_slice`] function.
     SharedBuffer(Range<usize>),
-    /// Bytes of the call data.
-    Bytes(Bytes),
 }
 
 impl CallInput {
     /// Returns the length of the call input.
+    #[inline]
     pub fn len(&self) -> usize {
         match self {
             Self::Bytes(bytes) => bytes.len(),
@@ -30,10 +33,39 @@ impl CallInput {
     }
 
     /// Returns `true` if the call input is empty.
+    #[inline]
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
+    /// Returns the bytes of the call input from the given context.
+    #[inline]
+    pub fn as_bytes<'a, CTX: ContextTr>(
+        &'a self,
+        ctx: &'a CTX,
+    ) -> impl core::ops::Deref<Target = [u8]> + 'a {
+        match self {
+            Self::Bytes(bytes) => CallInputRef::Bytes(bytes.as_ref()),
+            Self::SharedBuffer(range) => {
+                CallInputRef::SharedBuffer(ctx.local().shared_memory_buffer_slice(range.clone()))
+            }
+        }
+    }
+
+    /// Returns the bytes of the call input from the given memory.
+    #[inline]
+    pub fn as_bytes_memory<'a, M: MemoryTr>(
+        &'a self,
+        memory: &'a M,
+    ) -> impl core::ops::Deref<Target = [u8]> + 'a {
+        match self {
+            Self::Bytes(bytes) => CallInputRef::Bytes(bytes.as_ref()),
+            Self::SharedBuffer(range) => {
+                CallInputRef::SharedBuffer(Some(memory.global_slice(range.clone())))
+            }
+        }
+    }
+
     /// Returns the bytes of the call input.
     ///
     /// SharedMemory buffer can be shrunked or overwritten if the child call returns the
@@ -43,10 +75,7 @@ impl CallInput {
     ///
     /// If this `CallInput` is a `SharedBuffer`, the slice will be copied
     /// into a fresh `Bytes` buffer, which can pose a performance penalty.
-    pub fn bytes<CTX>(&self, ctx: &CTX) -> Bytes
-    where
-        CTX: ContextTr,
-    {
+    pub fn bytes<CTX: ContextTr>(&self, ctx: &CTX) -> Bytes {
         match self {
             CallInput::Bytes(bytes) => bytes.clone(),
             CallInput::SharedBuffer(range) => ctx
@@ -61,7 +90,24 @@ impl CallInput {
 impl Default for CallInput {
     #[inline]
     fn default() -> Self {
-        CallInput::SharedBuffer(0..0)
+        CallInput::Bytes(Bytes::new())
+    }
+}
+
+enum CallInputRef<'a> {
+    Bytes(&'a [u8]),
+    SharedBuffer(Option<core::cell::Ref<'a, [u8]>>),
+}
+
+impl core::ops::Deref for CallInputRef<'_> {
+    type Target = [u8];
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        match self {
+            Self::Bytes(x) => x,
+            Self::SharedBuffer(x) => x.as_deref().unwrap_or_default(),
+        }
     }
 }
 

crates/op-revm/src/handler.rs

@@ -157,9 +157,7 @@ where
 
         if !cfg.is_fee_charge_disabled() {
             let Some(additional_cost) = chain.tx_cost_with_tx(tx, spec) else {
-                return Err(ERROR::from_string(
-                    "[OPTIMISM] Failed to load enveloped transaction.".into(),
-                ));
+                return Err(OpTransactionError::MissingEnvelopedTx.into());
             };
             let Some(new_balance) = balance.checked_sub(additional_cost) else {
                 return Err(InvalidTransaction::LackOfFundForMaxFee {
@@ -319,9 +317,7 @@ where
         let spec = cfg.spec();
 
         let Some(enveloped_tx) = tx.enveloped_tx() else {
-            return Err(ERROR::from_string(
-                "[OPTIMISM] Failed to load enveloped transaction.".into(),
-            ));
+            return Err(OpTransactionError::MissingEnvelopedTx.into());
         };
 
         let l1_cost = l1_block_info.calculate_tx_l1_cost(enveloped_tx, spec);

examples/custom_precompile_journal/src/precompile_provider.rs

@@ -79,16 +79,7 @@ fn run_custom_precompile<CTX: ContextTr>(
     context: &mut CTX,
     inputs: &CallInputs,
 ) -> Result<InterpreterResult, String> {
-    let input_bytes = match &inputs.input {
-        revm::interpreter::CallInput::SharedBuffer(range) => {
-            if let Some(slice) = context.local().shared_memory_buffer_slice(range.clone()) {
-                slice.to_vec()
-            } else {
-                vec![]
-            }
-        }
-        revm::interpreter::CallInput::Bytes(bytes) => bytes.0.to_vec(),
-    };
+    let input_bytes = inputs.input.bytes(context);
 
     // For this example, we'll implement a simple precompile that:
     // - If called with empty data: reads a storage value