Merge remote-tracking branch 'origin/main' into devnet3

Author: rakita

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/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())
+    });
+}

crates/precompile/src/blake2.rs

@@ -54,7 +54,7 @@ pub fn run(input: &[u8], gas_limit: u64) -> PrecompileResult {
     let t_0 = u64::from_le_bytes(input[196..204].try_into().unwrap());
     let t_1 = u64::from_le_bytes(input[204..212].try_into().unwrap());
 
-    crypto().blake2_compress(rounds, &mut h, m, [t_0, t_1], f);
+    crypto().blake2_compress(rounds, &mut h, &m, &[t_0, t_1], f);
 
     let mut out = [0u8; 64];
     for (i, h) in (0..64).step_by(8).zip(h.iter()) {
@@ -124,7 +124,7 @@ pub mod algo {
     /// returns a new state vector.  The number of rounds, "r", is 12 for
     /// BLAKE2b and 10 for BLAKE2s.  Rounds are numbered from 0 to r - 1.
     #[allow(clippy::many_single_char_names)]
-    pub fn compress(rounds: usize, h: &mut [u64; 8], m: [u64; 16], t: [u64; 2], f: bool) {
+    pub fn compress(rounds: usize, h: &mut [u64; 8], m: &[u64; 16], t: &[u64; 2], f: bool) {
         #[cfg(all(target_feature = "avx2", feature = "std"))]
         {
             // only if it is compiled with avx2 flag and it is std, we can use avx2.
@@ -133,7 +133,7 @@ pub mod algo {
                 unsafe {
                     super::avx2::compress_block(
                         rounds,
-                        &m,
+                        m,
                         h,
                         ((t[1] as u128) << 64) | (t[0] as u128),
                         if f { !0 } else { 0 },
@@ -157,7 +157,7 @@ pub mod algo {
             v[14] = !v[14] // Invert all bits if the last-block-flag is set.
         }
         for i in 0..rounds {
-            round(&mut v, &m, i);
+            round(&mut v, m, i);
         }
 
         for i in 0..8 {

crates/precompile/src/interface.rs

@@ -89,7 +89,7 @@ pub trait Crypto: Send + Sync + Debug {
         recid: u8,
         msg: &[u8; 32],
     ) -> Result<[u8; 32], PrecompileError> {
-        crate::secp256k1::ecrecover_bytes(*sig, recid, *msg)
+        crate::secp256k1::ecrecover_bytes(sig, recid, msg)
             .ok_or(PrecompileError::Secp256k1RecoverFailed)
     }
 
@@ -101,14 +101,14 @@ pub trait Crypto: Send + Sync + Debug {
 
     /// Blake2 compression function.
     #[inline]
-    fn blake2_compress(&self, rounds: u32, h: &mut [u64; 8], m: [u64; 16], t: [u64; 2], f: bool) {
+    fn blake2_compress(&self, rounds: u32, h: &mut [u64; 8], m: &[u64; 16], t: &[u64; 2], f: bool) {
         crate::blake2::algo::compress(rounds as usize, h, m, t, f);
     }
 
     /// secp256r1 (P-256) signature verification.
     #[inline]
     fn secp256r1_verify_signature(&self, msg: &[u8; 32], sig: &[u8; 64], pk: &[u8; 64]) -> bool {
-        crate::secp256r1::verify_signature(*msg, *sig, *pk).is_some()
+        crate::secp256r1::verify_signature(msg, sig, pk).is_some()
     }
 
     /// KZG point evaluation.