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

Author: rakita

bins/revme/src/cmd/blockchaintest.rs

@@ -657,6 +657,7 @@ fn execute_blockchain_test(
             | ForkSpec::CancunToPragueAtTime15k
             | ForkSpec::PragueToOsakaAtTime15k
             | ForkSpec::BPO1ToBPO2AtTime15k
+            | ForkSpec::BPO2ToAmsterdamAtTime15k
     ) {
         eprintln!("⚠️  Skipping transition fork: {:?}", test_case.network);
         return Ok(());
@@ -760,8 +761,11 @@ fn execute_blockchain_test(
                 error: format!("{e:?}"),
             })?;
 
-        // Track cumulative gas used across all transactions in this block
-        let mut cumulative_gas_used: u64 = 0;
+        // Track cumulative gas used across all transactions in this block.
+        // EIP-8037: Split gas accounting into regular (execution) and state gas.
+        let mut cumulative_tx_gas_used: u64 = 0;
+        let mut block_regular_gas_used: u64 = 0;
+        let mut block_state_gas_used: u64 = 0;
         let mut block_completed = true;
 
         // Execute each transaction in the block
@@ -896,15 +900,11 @@ fn execute_blockchain_test(
                         block_completed = false;
                         break; // Skip to next block
                     }
-                    // EIP-7778: Block gas accounting without refunds.
-                    // For Amsterdam+, block gas = max(spent, floor_gas).
-                    // For pre-Amsterdam, block gas = used() = max(spent - refunded, floor_gas).
+                    // EIP-8037: Split gas accounting.
                     let gas = result.result.gas();
-                    cumulative_gas_used += if spec_id.is_enabled_in(SpecId::AMSTERDAM) {
-                        gas.total_gas_spent().max(gas.floor_gas())
-                    } else {
-                        gas.tx_gas_used()
-                    };
+                    cumulative_tx_gas_used += gas.tx_gas_used();
+                    block_regular_gas_used += gas.block_regular_gas_used();
+                    block_state_gas_used += gas.block_state_gas_used();
                     evm.commit(result.state);
                 }
                 Err(e) => {
@@ -962,20 +962,27 @@ fn execute_blockchain_test(
             }
         }
 
-        // Validate block gas used against header
+        // Validate block gas used against header.
+        // EIP-8037 (Amsterdam+): block gas_used = max(regular_gas, state_gas).
+        // Pre-Amsterdam: block gas_used = cumulative tx_gas_used (includes refunds).
         if block_completed && !should_fail {
             if let Some(block_header) = block.block_header.as_ref() {
                 let expected_gas_used = block_header.gas_used.to::<u64>();
-                if cumulative_gas_used != expected_gas_used {
+                let actual_block_gas_used = if spec_id.is_enabled_in(SpecId::AMSTERDAM) {
+                    block_regular_gas_used.max(block_state_gas_used)
+                } else {
+                    cumulative_tx_gas_used
+                };
+                if actual_block_gas_used != expected_gas_used {
                     if print_env_on_error {
                         eprintln!(
-                            "Block gas used mismatch at block {block_idx}: expected {expected_gas_used}, got {cumulative_gas_used}"
+                            "Block gas used mismatch at block {block_idx}: expected {expected_gas_used}, got {actual_block_gas_used} (regular: {block_regular_gas_used}, state: {block_state_gas_used}, tx: {cumulative_tx_gas_used})"
                         );
                     }
                     return Err(TestExecutionError::BlockGasUsedMismatch {
                         block_idx,
                         expected: expected_gas_used,
-                        actual: cumulative_gas_used,
+                        actual: actual_block_gas_used,
                     });
                 }
             }

crates/context/interface/src/local.rs

@@ -18,28 +18,28 @@ impl<T> Default for FrameStack<T> {
     }
 }
 
-impl<T: Default> FrameStack<T> {
-    /// Creates a new stack with preallocated items by calling `T::default()` `len` times.
-    /// Index will still be `None` until `end_init` is called.
-    pub fn new_prealloc(len: usize) -> Self {
-        let mut stack = Vec::with_capacity(len);
-        for _ in 0..len {
-            stack.push(T::default());
-        }
-        Self { stack, index: None }
-    }
-}
-
 impl<T> FrameStack<T> {
     /// Creates a new, empty stack. It must be initialized with init before use.
     pub fn new() -> Self {
-        // Init N amount of frames to allocate the stack.
+        // p99.9 of call frame depth is 8,
+        // per: https://ethresear.ch/t/evm-stack-and-memory-usage-statistics-report/24209
         Self {
             stack: Vec::with_capacity(8),
             index: None,
         }
     }
 
+    /// Creates a new stack with preallocated items by calling `T::default()` `len` times.
+    /// Index will still be `None` until `end_init` is called.
+    pub fn new_prealloc(len: usize) -> Self
+    where
+        T: Default,
+    {
+        let mut stack = Vec::with_capacity(len);
+        stack.resize_with(len, T::default);
+        Self { stack, index: None }
+    }
+
     /// Initializes the stack with a single item.
     #[inline]
     pub fn start_init(&mut self) -> OutFrame<'_, T> {

crates/handler/src/handler.rs

@@ -133,7 +133,7 @@ pub trait Handler {
             .and_then(|exec_result| {
                 // System calls have no intrinsic gas; build ResultGas from frame result.
                 let gas = exec_result.gas();
-                let result_gas = build_result_gas(&gas, init_and_floor_gas);
+                let result_gas = build_result_gas(gas, init_and_floor_gas);
                 self.execution_result(evm, exec_result, result_gas)
             }) {
             out @ Ok(_) => out,

crates/inspector/src/handler.rs

@@ -173,9 +173,14 @@ where
 /// Handles the start of a frame by calling the appropriate inspector method.
 pub fn frame_start<CTX, INTR: InterpreterTypes>(
     context: &mut CTX,
-    inspector: &mut impl Inspector<CTX, INTR>,
+    inspector: &mut impl Inspector<CTX, INTR, FrameInput, FrameResult>,
     frame_input: &mut FrameInput,
 ) -> Option<FrameResult> {
+    // Generic hook before variant dispatch
+    if let Some(result) = inspector.frame_start(context, frame_input) {
+        return Some(result);
+    }
+    // Variant-specific dispatch
     match frame_input {
         FrameInput::Call(i) => {
             if let Some(output) = inspector.call(context, i) {
@@ -195,10 +200,11 @@ pub fn frame_start<CTX, INTR: InterpreterTypes>(
 /// Handles the end of a frame by calling the appropriate inspector method.
 pub fn frame_end<CTX, INTR: InterpreterTypes>(
     context: &mut CTX,
-    inspector: &mut impl Inspector<CTX, INTR>,
+    inspector: &mut impl Inspector<CTX, INTR, FrameInput, FrameResult>,
     frame_input: &FrameInput,
     frame_output: &mut FrameResult,
 ) {
+    // Variant-specific dispatch first
     match frame_output {
         FrameResult::Call(outcome) => {
             let FrameInput::Call(i) = frame_input else {
@@ -213,6 +219,8 @@ pub fn frame_end<CTX, INTR: InterpreterTypes>(
             inspector.create_end(context, i, outcome);
         }
     }
+    // Generic hook after variant dispatch
+    inspector.frame_end(context, frame_input, frame_output);
 }
 
 /// Run Interpreter loop with inspection support.

crates/inspector/src/inspector.rs

@@ -1,8 +1,9 @@
 use auto_impl::auto_impl;
 use context::{Database, Journal, JournalEntry};
+use handler::FrameResult;
 use interpreter::{
-    interpreter::EthInterpreter, CallInputs, CallOutcome, CreateInputs, CreateOutcome, Interpreter,
-    InterpreterTypes,
+    interpreter::EthInterpreter, CallInputs, CallOutcome, CreateInputs, CreateOutcome, FrameInput,
+    Interpreter, InterpreterTypes,
 };
 use primitives::{Address, Log, U256};
 use state::EvmState;
@@ -14,7 +15,8 @@ use state::EvmState;
 /// Object that is implemented this trait is used in `InspectorHandler` to trace the EVM execution.
 /// And API that allow calling the inspector can be found in [`crate::InspectEvm`] and [`crate::InspectCommitEvm`].
 #[auto_impl(&mut, Box)]
-pub trait Inspector<CTX, INTR: InterpreterTypes = EthInterpreter> {
+pub trait Inspector<CTX, INTR: InterpreterTypes = EthInterpreter, FI = FrameInput, FR = FrameResult>
+{
     /// Called before the interpreter is initialized.
     ///
     /// If `interp.bytecode.set_action` is set the execution of the interpreter is skipped.
@@ -64,6 +66,29 @@ pub trait Inspector<CTX, INTR: InterpreterTypes = EthInterpreter> {
         self.log(context, log);
     }
 
+    /// Called before call/create dispatch. Called with a mutable reference to
+    /// the frame input, allowing mutations of the input before the variant-specific
+    /// hooks (`call`/`create`) are called.
+    ///
+    /// Returning `Some(FrameResult)` will skip execution of the frame entirely,
+    /// and also skips calling `call()`/`create()`. `frame_end` will still be called.
+    #[inline]
+    fn frame_start(&mut self, context: &mut CTX, frame_input: &mut FI) -> Option<FR> {
+        let _ = context;
+        let _ = frame_input;
+        None
+    }
+
+    /// Called after `call_end()`/`create_end()` variant-specific hooks complete.
+    ///
+    /// Allows transformation of the final result regardless of frame kind.
+    #[inline]
+    fn frame_end(&mut self, context: &mut CTX, frame_input: &FI, frame_result: &mut FR) {
+        let _ = context;
+        let _ = frame_input;
+        let _ = frame_result;
+    }
+
     /// Called whenever a call to a contract is about to start.
     ///
     /// Returning `CallOutcome` will override the result of the call.
@@ -122,10 +147,10 @@ pub trait Inspector<CTX, INTR: InterpreterTypes = EthInterpreter> {
     }
 }
 
-impl<CTX, INTR: InterpreterTypes, L, R> Inspector<CTX, INTR> for (L, R)
+impl<CTX, INTR: InterpreterTypes, FI, FR, L, R> Inspector<CTX, INTR, FI, FR> for (L, R)
 where
-    L: Inspector<CTX, INTR>,
-    R: Inspector<CTX, INTR>,
+    L: Inspector<CTX, INTR, FI, FR>,
+    R: Inspector<CTX, INTR, FI, FR>,
 {
     fn initialize_interp(&mut self, interp: &mut Interpreter<INTR>, context: &mut CTX) {
         self.0.initialize_interp(interp, context);
@@ -152,6 +177,17 @@ where
         self.1.log_full(interp, context, log);
     }
 
+    fn frame_start(&mut self, context: &mut CTX, frame_input: &mut FI) -> Option<FR> {
+        let first = self.0.frame_start(context, frame_input);
+        let second = self.1.frame_start(context, frame_input);
+        first.or(second)
+    }
+
+    fn frame_end(&mut self, context: &mut CTX, frame_input: &FI, frame_result: &mut FR) {
+        self.0.frame_end(context, frame_input, frame_result);
+        self.1.frame_end(context, frame_input, frame_result);
+    }
+
     fn call(&mut self, context: &mut CTX, inputs: &mut CallInputs) -> Option<CallOutcome> {
         let first = self.0.call(context, inputs);
         let second = self.1.call(context, inputs);

crates/inspector/src/traits.rs

@@ -5,7 +5,8 @@ use handler::{
     EthFrame, EvmTr, FrameInitOrResult, FrameResult, ItemOrResult,
 };
 use interpreter::{
-    interpreter::EthInterpreter, interpreter_action::FrameInit, CallOutcome, InterpreterTypes,
+    interpreter::EthInterpreter, interpreter_action::FrameInit, CallOutcome, FrameInput,
+    InterpreterTypes,
 };
 
 use crate::{
@@ -26,7 +27,7 @@ pub trait InspectorEvmTr:
 >
 {
     /// The inspector type used for EVM execution inspection.
-    type Inspector: Inspector<Self::Context, EthInterpreter>;
+    type Inspector: Inspector<Self::Context, EthInterpreter, FrameInput, FrameResult>;
 
     /// Returns a tuple of mutable references to the context, the inspector, the frame and the instructions.
     ///
@@ -118,7 +119,7 @@ pub trait InspectorEvmTr:
             {
                 if *was_precompile_called {
                     let logs = ctx.journal_mut().logs()[logs_i..].to_vec();
-                    for log in logs.iter().chain(precompile_call_logs.iter()).cloned() {
+                    for log in logs.into_iter().chain(precompile_call_logs.iter().cloned()) {
                         inspector.log(ctx, log);
                     }
                 }

crates/precompile/Cargo.toml

@@ -74,6 +74,7 @@ criterion.workspace = true
 rand = { workspace = true, features = ["std"] }
 ark-std = { workspace = true }
 rstest.workspace = true
+p256 = { workspace = true, features = ["ecdsa"] }
 
 [features]
 default = ["std", "secp256k1", "blst", "c-kzg", "portable"]

crates/precompile/bench/blake2.rs

@@ -107,8 +107,8 @@ pub fn add_benches(group: &mut BenchmarkGroup<'_, criterion::measurement::WallTi
             blake2::algo::compress(
                 black_box(12),
                 &mut h_copy,
-                black_box(m),
-                black_box(t),
+                &black_box(m),
+                &black_box(t),
                 black_box(false),
             );
         });

crates/precompile/bench/main.rs

@@ -6,6 +6,7 @@ pub mod ecrecover;
 pub mod eip1962;
 pub mod eip2537;
 pub mod eip4844;
+pub mod secp256r1;
 
 use criterion::{criterion_group, criterion_main, Criterion};
 
@@ -35,6 +36,9 @@ pub fn benchmark_crypto_precompiles(c: &mut Criterion) {
 
     // Run Blake2 benchmarks
     blake2::add_benches(&mut group);
+
+    // Run secp256r1 benchmarks
+    secp256r1::add_benches(&mut group);
 }
 
 criterion_group! {

crates/precompile/bench/secp256r1.rs

@@ -0,0 +1,33 @@
+//! Benchmarks for the secp256r1 (P256) precompile
+use criterion::{measurement::Measurement, BenchmarkGroup};
+use p256::ecdsa::{signature::hazmat::PrehashSigner, SigningKey};
+use primitives::Bytes;
+use revm_precompile::secp256r1::p256_verify;
+
+/// Add benches for the secp256r1 precompile
+pub fn add_benches<M: Measurement>(group: &mut BenchmarkGroup<'_, M>) {
+    // Generate a valid P256 signature using p256's own OsRng (rand_core 0.6)
+    let signing_key = SigningKey::random(&mut p256::elliptic_curve::rand_core::OsRng);
+    let verifying_key = signing_key.verifying_key();
+
+    let msg_hash = [0xabu8; 32];
+
+    let (signature, _) = signing_key.sign_prehash(&msg_hash).unwrap();
+    let sig_bytes = signature.to_bytes();
+
+    let pk_encoded = verifying_key.to_encoded_point(false);
+    // Uncompressed point is 0x04 || x || y, skip the 0x04 prefix
+    let pk_bytes = &pk_encoded.as_bytes()[1..];
+
+    // Input layout: msg_hash (32) || r (32) || s (32) || pubkey_x (32) || pubkey_y (32)
+    let mut input = Vec::with_capacity(160);
+    input.extend_from_slice(&msg_hash);
+    input.extend_from_slice(&sig_bytes);
+    input.extend_from_slice(pk_bytes);
+
+    let input = Bytes::from(input);
+
+    group.bench_function("p256verify precompile", |b| {
+        b.iter(|| p256_verify(&input, u64::MAX).unwrap())
+    });
+}