Revert "refactor(handler): provide &CallInputstoPrecompileProvider::run (bluealloy#2921)"

This reverts commit 827d572.

Author: Soubhik-10

crates/handler/src/frame.rs

@@ -193,7 +193,16 @@ impl EthFrame<EthInterpreter> {
         let is_static = inputs.is_static;
         let gas_limit = inputs.gas_limit;
 
-        if let Some(result) = precompiles.run(ctx, &inputs).map_err(ERROR::from_string)? {
+        if let Some(result) = precompiles
+            .run(
+                ctx,
+                &inputs.bytecode_address,
+                &interpreter_input,
+                is_static,
+                gas_limit,
+            )
+            .map_err(ERROR::from_string)?
+        {
             if result.result.is_ok() {
                 ctx.journal_mut().checkpoint_commit();
             } else {

crates/handler/src/precompile_provider.rs

@@ -1,7 +1,7 @@
 use auto_impl::auto_impl;
 use context::{Cfg, LocalContextTr};
 use context_interface::ContextTr;
-use interpreter::{CallInput, CallInputs, Gas, InstructionResult, InterpreterResult};
+use interpreter::{CallInput, Gas, InputsImpl, InstructionResult, InterpreterResult};
 use precompile::PrecompileError;
 use precompile::{PrecompileSpecId, Precompiles};
 use primitives::{hardfork::SpecId, Address, Bytes};
@@ -23,7 +23,10 @@ pub trait PrecompileProvider<CTX: ContextTr> {
     fn run(
         &mut self,
         context: &mut CTX,
-        inputs: &CallInputs,
+        address: &Address,
+        inputs: &InputsImpl,
+        is_static: bool,
+        gas_limit: u64,
     ) -> Result<Option<Self::Output>, String>;
 
     /// Get the warm addresses.
@@ -90,15 +93,18 @@ impl<CTX: ContextTr> PrecompileProvider<CTX> for EthPrecompiles {
     fn run(
         &mut self,
         context: &mut CTX,
-        inputs: &CallInputs,
+        address: &Address,
+        inputs: &InputsImpl,
+        _is_static: bool,
+        gas_limit: u64,
     ) -> Result<Option<InterpreterResult>, String> {
-        let Some(precompile) = self.precompiles.get(&inputs.bytecode_address) else {
+        let Some(precompile) = self.precompiles.get(address) else {
             return Ok(None);
         };
 
         let mut result = InterpreterResult {
             result: InstructionResult::Return,
-            gas: Gas::new(inputs.gas_limit),
+            gas: Gas::new(gas_limit),
             output: Bytes::new(),
         };
 
@@ -115,7 +121,7 @@ impl<CTX: ContextTr> PrecompileProvider<CTX> for EthPrecompiles {
             CallInput::Bytes(bytes) => bytes.0.iter().as_slice(),
         };
 
-        match precompile.execute(input_bytes, inputs.gas_limit) {
+        match precompile.execute(input_bytes, gas_limit) {
             Ok(output) => {
                 let underflow = result.gas.record_cost(output.gas_used);
                 assert!(underflow, "Gas underflow is not possible");

crates/op-revm/src/precompiles.rs

@@ -4,7 +4,7 @@ use revm::{
     context::Cfg,
     context_interface::ContextTr,
     handler::{EthPrecompiles, PrecompileProvider},
-    interpreter::{CallInputs, InterpreterResult},
+    interpreter::{InputsImpl, InterpreterResult},
     precompile::{
         self, bn254, secp256r1, Precompile, PrecompileError, PrecompileId, PrecompileResult,
         Precompiles,
@@ -111,9 +111,13 @@ where
     fn run(
         &mut self,
         context: &mut CTX,
-        inputs: &CallInputs,
+        address: &Address,
+        inputs: &InputsImpl,
+        is_static: bool,
+        gas_limit: u64,
     ) -> Result<Option<Self::Output>, String> {
-        self.inner.run(context, inputs)
+        self.inner
+            .run(context, address, inputs, is_static, gas_limit)
     }
 
     #[inline]

examples/custom_precompile_journal/src/precompile_provider.rs

@@ -4,7 +4,7 @@ use revm::{
     context::Cfg,
     context_interface::{ContextTr, JournalTr, LocalContextTr, Transaction},
     handler::{EthPrecompiles, PrecompileProvider},
-    interpreter::{CallInputs, Gas, InstructionResult, InterpreterResult},
+    interpreter::{Gas, InputsImpl, InstructionResult, InterpreterResult},
     precompile::{PrecompileError, PrecompileOutput, PrecompileResult},
     primitives::{address, hardfork::SpecId, Address, Bytes, U256},
 };
@@ -52,15 +52,21 @@ where
     fn run(
         &mut self,
         context: &mut CTX,
-        inputs: &CallInputs,
+        address: &Address,
+        inputs: &InputsImpl,
+        is_static: bool,
+        gas_limit: u64,
     ) -> Result<Option<Self::Output>, String> {
         // Check if this is our custom precompile
-        if inputs.bytecode_address == CUSTOM_PRECOMPILE_ADDRESS {
-            return Ok(Some(run_custom_precompile(context, inputs)?));
+        if *address == CUSTOM_PRECOMPILE_ADDRESS {
+            return Ok(Some(run_custom_precompile(
+                context, inputs, is_static, gas_limit,
+            )?));
         }
 
         // Otherwise, delegate to standard Ethereum precompiles
-        self.inner.run(context, inputs)
+        self.inner
+            .run(context, address, inputs, is_static, gas_limit)
     }
 
     fn warm_addresses(&self) -> Box<impl Iterator<Item = Address>> {
@@ -78,7 +84,9 @@ where
 /// Runs our custom precompile
 fn run_custom_precompile<CTX: ContextTr>(
     context: &mut CTX,
-    inputs: &CallInputs,
+    inputs: &InputsImpl,
+    is_static: bool,
+    gas_limit: u64,
 ) -> Result<InterpreterResult, String> {
     let input_bytes = match &inputs.input {
         revm::interpreter::CallInput::SharedBuffer(range) => {
@@ -97,13 +105,13 @@ fn run_custom_precompile<CTX: ContextTr>(
 
     let result = if input_bytes.is_empty() {
         // Read storage operation
-        handle_read_storage(context, inputs.gas_limit)
+        handle_read_storage(context, gas_limit)
     } else if input_bytes.len() == 32 {
-        if inputs.is_static {
+        if is_static {
             return Err("Cannot modify state in static context".to_string());
         }
         // Write storage operation
-        handle_write_storage(context, &input_bytes, inputs.gas_limit)
+        handle_write_storage(context, &input_bytes, gas_limit)
     } else {
         Err(PrecompileError::Other("Invalid input length".to_string()))
     };
@@ -116,7 +124,7 @@ fn run_custom_precompile<CTX: ContextTr>(
                 } else {
                     InstructionResult::Return
                 },
-                gas: Gas::new(inputs.gas_limit),
+                gas: Gas::new(gas_limit),
                 output: output.bytes,
             };
             let underflow = interpreter_result.gas.record_cost(output.gas_used);
@@ -131,7 +139,7 @@ fn run_custom_precompile<CTX: ContextTr>(
             } else {
                 InstructionResult::PrecompileError
             },
-            gas: Gas::new(inputs.gas_limit),
+            gas: Gas::new(gas_limit),
             output: Bytes::new(),
         }),
     }