refactor: remove CTX phantomdata from precompile providers

crates/handler/src/evm.rs

@@ -123,7 +123,7 @@ impl<CTX, INSP, PRECOMPILES> ExecuteEvm
     for Evm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, PRECOMPILES>
 where
     CTX: ContextSetters + ContextTr<Journal: JournalTr<FinalOutput = JournalOutput>>,
-    PRECOMPILES: PrecompileProvider<Context = CTX, Output = InterpreterResult>,
+    PRECOMPILES: PrecompileProvider<CTX, Output = InterpreterResult>,
 {
     type Output = Result<
         ResultAndState<HaltReason>,
@@ -141,7 +141,7 @@ impl<CTX, INSP, PRECOMPILES> ExecuteCommitEvm
 where
     CTX: ContextSetters
         + ContextTr<Journal: JournalTr<FinalOutput = JournalOutput>, Db: DatabaseCommit>,
-    PRECOMPILES: PrecompileProvider<Context = CTX, Output = InterpreterResult>,
+    PRECOMPILES: PrecompileProvider<CTX, Output = InterpreterResult>,
 {
     type CommitOutput = Result<
         ExecutionResult<HaltReason>,

crates/handler/src/frame.rs

@@ -74,7 +74,7 @@ pub struct EthFrame<EVM, ERROR, IW: InterpreterTypes> {
 impl<EVM, ERROR> Frame for EthFrame<EVM, ERROR, EthInterpreter>
 where
     EVM: EvmTr<
-        Precompiles: PrecompileProvider<Context = EVM::Context, Output = InterpreterResult>,
+        Precompiles: PrecompileProvider<EVM::Context, Output = InterpreterResult>,
         Instructions: InstructionProvider<
             Context = EVM::Context,
             InterpreterTypes = EthInterpreter,
@@ -146,7 +146,7 @@ impl<EVM, ERROR> EthFrame<EVM, ERROR, EthInterpreter>
 where
     EVM: EvmTr<
         Context: ContextTr,
-        Precompiles: PrecompileProvider<Context = EVM::Context, Output = InterpreterResult>,
+        Precompiles: PrecompileProvider<EVM::Context, Output = InterpreterResult>,
         Instructions: InstructionProvider,
     >,
     ERROR: From<ContextTrDbError<EVM::Context>> + From<PrecompileError>,
@@ -514,7 +514,7 @@ impl<EVM, ERROR> EthFrame<EVM, ERROR, EthInterpreter>
 where
     EVM: EvmTr<
         Context: ContextTr,
-        Precompiles: PrecompileProvider<Context = EVM::Context, Output = InterpreterResult>,
+        Precompiles: PrecompileProvider<EVM::Context, Output = InterpreterResult>,
         Instructions: InstructionProvider<
             Context = EVM::Context,
             InterpreterTypes = EthInterpreter,

crates/handler/src/mainnet_builder.rs

@@ -6,7 +6,7 @@ use interpreter::interpreter::EthInterpreter;
 use primitives::hardfork::SpecId;
 
 pub type MainnetEvm<CTX, INSP = ()> =
-    Evm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, EthPrecompiles<CTX>>;
+    Evm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, EthPrecompiles>;
 
 pub type MainnetContext<DB> = Context<BlockEnv, TxEnv, CfgEnv, DB, Journal<DB>, ()>;
 

crates/handler/src/precompile_provider.rs

@@ -8,64 +8,69 @@ use primitives::{hardfork::SpecId, Address, Bytes};
 use std::boxed::Box;
 
 #[auto_impl(&mut, Box)]
-pub trait PrecompileProvider {
-    type Context: ContextTr;
+pub trait PrecompileProvider<CTX: ContextTr> {
     type Output;
 
-    fn set_spec(&mut self, spec: <<Self::Context as ContextTr>::Cfg as Cfg>::Spec);
+    fn set_spec(&mut self, spec: <CTX::Cfg as Cfg>::Spec);
 
     /// Run the precompile.
     fn run(
         &mut self,
-        context: &mut Self::Context,
+        context: &mut CTX,
         address: &Address,
         bytes: &Bytes,
         gas_limit: u64,
     ) -> Result<Option<Self::Output>, PrecompileError>;
 
     /// Get the warm addresses.
-    fn warm_addresses(&self) -> Box<impl Iterator<Item = Address> + '_>;
+    fn warm_addresses(&self) -> Box<impl Iterator<Item = Address>>;
 
     /// Check if the address is a precompile.
     fn contains(&self, address: &Address) -> bool;
 }
 
-pub struct EthPrecompiles<CTX> {
+pub struct EthPrecompiles {
     pub precompiles: &'static Precompiles,
-    pub _phantom: core::marker::PhantomData<CTX>,
 }
 
-impl<CTX> Clone for EthPrecompiles<CTX> {
+impl EthPrecompiles {
+    /// Returns addresses of the precompiles.
+    pub fn warm_addresses(&self) -> Box<impl Iterator<Item = Address>> {
+        Box::new(self.precompiles.addresses().cloned())
+    }
+
+    /// Returns whether the address is a precompile.
+    pub fn contains(&self, address: &Address) -> bool {
+        self.precompiles.contains(address)
+    }
+}
+
+impl Clone for EthPrecompiles {
     fn clone(&self) -> Self {
         Self {
             precompiles: self.precompiles,
-            _phantom: core::marker::PhantomData,
         }
     }
 }
 
-impl<CTX> Default for EthPrecompiles<CTX> {
+impl Default for EthPrecompiles {
     fn default() -> Self {
         Self {
             precompiles: Precompiles::new(PrecompileSpecId::from_spec_id(SpecId::LATEST)),
-            _phantom: core::marker::PhantomData,
         }
     }
 }
 
-impl<CTX> PrecompileProvider for EthPrecompiles<CTX>
-where
-    CTX: ContextTr,
-{
-    type Context = CTX;
+impl<CTX: ContextTr> PrecompileProvider<CTX> for EthPrecompiles {
     type Output = InterpreterResult;
-    fn set_spec(&mut self, spec: <<Self::Context as ContextTr>::Cfg as Cfg>::Spec) {
+
+    fn set_spec(&mut self, spec: <CTX::Cfg as Cfg>::Spec) {
         self.precompiles = Precompiles::new(PrecompileSpecId::from_spec_id(spec.into()));
     }
 
     fn run(
         &mut self,
-        _context: &mut Self::Context,
+        _context: &mut CTX,
         address: &Address,
         bytes: &Bytes,
         gas_limit: u64,
@@ -102,10 +107,10 @@ where
     }
 
     fn warm_addresses(&self) -> Box<impl Iterator<Item = Address>> {
-        Box::new(self.precompiles.addresses().cloned())
+        self.warm_addresses()
     }
 
     fn contains(&self, address: &Address) -> bool {
-        self.precompiles.contains(address)
+        self.contains(address)
     }
 }

crates/inspector/src/mainnet_inspect.rs

@@ -29,7 +29,7 @@ impl<CTX, INSP, PRECOMPILES> InspectEvm
 where
     CTX: ContextSetters + ContextTr<Journal: JournalTr<FinalOutput = JournalOutput> + JournalExt>,
     INSP: Inspector<CTX, EthInterpreter>,
-    PRECOMPILES: PrecompileProvider<Context = CTX, Output = InterpreterResult>,
+    PRECOMPILES: PrecompileProvider<CTX, Output = InterpreterResult>,
 {
     type Inspector = INSP;
 
@@ -52,7 +52,7 @@ where
     CTX: ContextSetters
         + ContextTr<Journal: JournalTr<FinalOutput = JournalOutput> + JournalExt, Db: DatabaseCommit>,
     INSP: Inspector<CTX, EthInterpreter>,
-    PRECOMPILES: PrecompileProvider<Context = CTX, Output = InterpreterResult>,
+    PRECOMPILES: PrecompileProvider<CTX, Output = InterpreterResult>,
 {
     fn inspect_commit_previous(&mut self) -> Self::CommitOutput {
         self.inspect_previous().map(|r| {

crates/inspector/src/traits.rs

@@ -80,7 +80,7 @@ impl<EVM, ERROR> InspectorFrame for EthFrame<EVM, ERROR, EthInterpreter>
 where
     EVM: EvmTr<
             Context: ContextTr,
-            Precompiles: PrecompileProvider<Context = EVM::Context, Output = InterpreterResult>,
+            Precompiles: PrecompileProvider<EVM::Context, Output = InterpreterResult>,
             Instructions: InstructionProvider<
                 Context = EVM::Context,
                 InterpreterTypes = EthInterpreter,

crates/optimism/src/api/exec.rs

@@ -42,7 +42,7 @@ impl<CTX, INSP, PRECOMPILE> ExecuteEvm
     for OpEvm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, PRECOMPILE>
 where
     CTX: OpContextTr,
-    PRECOMPILE: PrecompileProvider<Context = CTX, Output = InterpreterResult>,
+    PRECOMPILE: PrecompileProvider<CTX, Output = InterpreterResult>,
 {
     type Output = Result<ResultAndState<OpHaltReason>, OpError<CTX>>;
 
@@ -56,7 +56,7 @@ impl<CTX, INSP, PRECOMPILE> ExecuteCommitEvm
     for OpEvm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, PRECOMPILE>
 where
     CTX: OpContextTr<Db: DatabaseCommit>,
-    PRECOMPILE: PrecompileProvider<Context = CTX, Output = InterpreterResult>,
+    PRECOMPILE: PrecompileProvider<CTX, Output = InterpreterResult>,
 {
     type CommitOutput = Result<ExecutionResult<OpHaltReason>, OpError<CTX>>;
 
@@ -73,7 +73,7 @@ impl<CTX, INSP, PRECOMPILE> InspectEvm
 where
     CTX: OpContextTr<Journal: JournalExt>,
     INSP: Inspector<CTX, EthInterpreter>,
-    PRECOMPILE: PrecompileProvider<Context = CTX, Output = InterpreterResult>,
+    PRECOMPILE: PrecompileProvider<CTX, Output = InterpreterResult>,
 {
     type Inspector = INSP;
 
@@ -92,7 +92,7 @@ impl<CTX, INSP, PRECOMPILE> InspectCommitEvm
 where
     CTX: OpContextTr<Journal: JournalExt, Db: DatabaseCommit>,
     INSP: Inspector<CTX, EthInterpreter>,
-    PRECOMPILE: PrecompileProvider<Context = CTX, Output = InterpreterResult>,
+    PRECOMPILE: PrecompileProvider<CTX, Output = InterpreterResult>,
 {
     fn inspect_commit_previous(&mut self) -> Self::CommitOutput {
         self.inspect_previous().map(|r| {

crates/optimism/src/evm.rs

@@ -1,4 +1,4 @@
-use crate::precompiles::OpPrecompileProvider;
+use crate::precompiles::OpPrecompiles;
 use revm::{
     context::{setters::ContextSetters, Evm, EvmData},
     context_interface::ContextTr,
@@ -11,18 +11,16 @@ use revm::{
     },
 };
 
-pub struct OpEvm<CTX, INSP, I = EthInstructions<EthInterpreter, CTX>, P = OpPrecompileProvider<CTX>>(
+pub struct OpEvm<CTX, INSP, I = EthInstructions<EthInterpreter, CTX>, P = OpPrecompiles>(
     pub Evm<CTX, INSP, I, P>,
 );
 
-impl<CTX: Host, INSP>
-    OpEvm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, OpPrecompileProvider<CTX>>
-{
+impl<CTX: Host, INSP> OpEvm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, OpPrecompiles> {
     pub fn new(ctx: CTX, inspector: INSP) -> Self {
         Self(Evm {
             data: EvmData { ctx, inspector },
             instruction: EthInstructions::new_mainnet(),
-            precompiles: OpPrecompileProvider::default(),
+            precompiles: OpPrecompiles::default(),
         })
     }
 }

crates/optimism/src/precompiles.rs

@@ -14,27 +14,24 @@ use revm::{
 use std::boxed::Box;
 
 // Optimism precompile provider
-pub struct OpPrecompileProvider<CTX> {
+pub struct OpPrecompiles {
     /// Inner precompile provider is same as Ethereums.
-    inner: EthPrecompiles<CTX>,
+    inner: EthPrecompiles,
 }
 
-impl<CTX> Clone for OpPrecompileProvider<CTX> {
+impl Clone for OpPrecompiles {
     fn clone(&self) -> Self {
         Self {
             inner: self.inner.clone(),
         }
     }
 }
 
-impl<CTX> OpPrecompileProvider<CTX> {
-    /// Create a new [`OpPrecompileProvider`] with the given precompiles.
+impl OpPrecompiles {
+    /// Create a new [`OpPrecompiles`] with the given precompiles.
     pub fn new(precompiles: &'static Precompiles) -> Self {
         Self {
-            inner: EthPrecompiles {
-                precompiles,
-                _phantom: core::marker::PhantomData,
-            },
+            inner: EthPrecompiles { precompiles },
         }
     }
 
@@ -92,22 +89,21 @@ pub fn isthumus() -> &'static Precompiles {
     })
 }
 
-impl<CTX> PrecompileProvider for OpPrecompileProvider<CTX>
+impl<CTX> PrecompileProvider<CTX> for OpPrecompiles
 where
     CTX: ContextTr<Cfg: Cfg<Spec = OpSpecId>>,
 {
-    type Context = CTX;
     type Output = InterpreterResult;
 
     #[inline]
-    fn set_spec(&mut self, spec: <<Self::Context as ContextTr>::Cfg as Cfg>::Spec) {
+    fn set_spec(&mut self, spec: <CTX::Cfg as Cfg>::Spec) {
         *self = Self::new_with_spec(spec);
     }
 
     #[inline]
     fn run(
         &mut self,
-        context: &mut Self::Context,
+        context: &mut CTX,
         address: &Address,
         bytes: &Bytes,
         gas_limit: u64,
@@ -116,7 +112,7 @@ where
     }
 
     #[inline]
-    fn warm_addresses(&self) -> Box<impl Iterator<Item = Address> + '_> {
+    fn warm_addresses(&self) -> Box<impl Iterator<Item = Address>> {
         self.inner.warm_addresses()
     }
 
@@ -126,7 +122,7 @@ where
     }
 }
 
-impl<CTX> Default for OpPrecompileProvider<CTX> {
+impl Default for OpPrecompiles {
     fn default() -> Self {
         Self::new_with_spec(OpSpecId::ISTHMUS)
     }

examples/erc20_gas/src/exec.rs

@@ -19,7 +19,7 @@ pub fn transact_erc20evm<EVM>(
 where
     EVM: EvmTr<
         Context: ContextTr<Journal: JournalTr<FinalOutput = JournalOutput>>,
-        Precompiles: PrecompileProvider<Context = EVM::Context, Output = InterpreterResult>,
+        Precompiles: PrecompileProvider<EVM::Context, Output = InterpreterResult>,
         Instructions: InstructionProvider<
             Context = EVM::Context,
             InterpreterTypes = EthInterpreter,
@@ -35,7 +35,7 @@ pub fn transact_erc20evm_commit<EVM>(
 where
     EVM: EvmTr<
         Context: ContextTr<Journal: JournalTr<FinalOutput = JournalOutput>, Db: DatabaseCommit>,
-        Precompiles: PrecompileProvider<Context = EVM::Context, Output = InterpreterResult>,
+        Precompiles: PrecompileProvider<EVM::Context, Output = InterpreterResult>,
         Instructions: InstructionProvider<
             Context = EVM::Context,
             InterpreterTypes = EthInterpreter,