refactor(anvil)!: simplify PrecompileFactory API to use DynPrecompile (#12411)

* refactor(anvil)!: simplify PrecompileFactory API to use DynPrecompile

Changed PrecompileFactory::precompiles() return type from Vec<(Precompile, u64)> to Vec<(Address, DynPrecompile)> for a cleaner and more flexible API.

The previous API required wrapping precompile functions in the Precompile type with gas limits. The new API directly uses DynPrecompile, which is more straightforward and allows users to create custom precompiles with arbitrary logic without needing to understand the legacy Precompile wrapper.

Updated inject_custom_precompiles to accept the new type and simplified the injection logic to directly apply DynPrecompiles without additional wrapping.

Updated all tests and implementations to use the new API with proper type annotations for closure parameters.

BREAKING CHANGE: PrecompileFactory::precompiles() now returns Vec<(Address, DynPrecompile)> instead of Vec<(Precompile, u64)>

Co-Authored-By: Claude <[email protected]>

* touchup

---------

Co-authored-by: Claude <[email protected]>

Author: mattsse

crates/anvil/src/eth/backend/mem/mod.rs

@@ -813,8 +813,8 @@ impl Backend {
         precompiles_map.extend(self.env.read().networks.precompiles());
 
         if let Some(factory) = &self.precompile_factory {
-            for (precompile, _) in &factory.precompiles() {
-                precompiles_map.insert(precompile.id().name().to_string(), *precompile.address());
+            for (address, precompile) in factory.precompiles() {
+                precompiles_map.insert(precompile.precompile_id().to_string(), address);
             }
         }
 

crates/anvil/src/evm.rs

@@ -1,44 +1,44 @@
 use alloy_evm::{
     Database, Evm,
     eth::EthEvmContext,
-    precompiles::{DynPrecompile, PrecompileInput, PrecompilesMap},
+    precompiles::{DynPrecompile, PrecompilesMap},
 };
-
+use alloy_primitives::Address;
 use foundry_evm::core::either_evm::EitherEvm;
 use op_revm::OpContext;
-use revm::{Inspector, precompile::Precompile};
+use revm::Inspector;
 use std::fmt::Debug;
 
 /// Object-safe trait that enables injecting extra precompiles when using
 /// `anvil` as a library.
 pub trait PrecompileFactory: Send + Sync + Unpin + Debug {
     /// Returns a set of precompiles to extend the EVM with.
-    fn precompiles(&self) -> Vec<(Precompile, u64)>;
+    fn precompiles(&self) -> Vec<(Address, DynPrecompile)>;
 }
 
 /// Inject custom precompiles into the EVM dynamically.
 pub fn inject_custom_precompiles<DB, I>(
     evm: &mut EitherEvm<DB, I, PrecompilesMap>,
-    precompiles: Vec<(Precompile, u64)>,
+    precompiles: Vec<(Address, DynPrecompile)>,
 ) where
     DB: Database,
     I: Inspector<EthEvmContext<DB>> + Inspector<OpContext<DB>>,
 {
-    for (precompile, gas) in precompiles {
-        let addr = *precompile.address();
-        let func = *precompile.precompile();
-        evm.precompiles_mut().apply_precompile(&addr, move |_| {
-            Some(DynPrecompile::from(move |input: PrecompileInput<'_>| func(input.data, gas)))
-        });
+    for (addr, precompile) in precompiles {
+        evm.precompiles_mut().apply_precompile(&addr, move |_| Some(precompile));
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use std::{borrow::Cow, convert::Infallible};
+    use std::convert::Infallible;
 
     use crate::{PrecompileFactory, inject_custom_precompiles};
-    use alloy_evm::{EthEvm, Evm, EvmEnv, eth::EthEvmContext, precompiles::PrecompilesMap};
+    use alloy_evm::{
+        EthEvm, Evm, EvmEnv,
+        eth::EthEvmContext,
+        precompiles::{DynPrecompile, PrecompilesMap},
+    };
     use alloy_op_evm::OpEvm;
     use alloy_primitives::{Address, Bytes, TxKind, U256, address};
     use foundry_evm::core::either_evm::EitherEvm;
@@ -52,10 +52,7 @@ mod tests {
         handler::{EthPrecompiles, instructions::EthInstructions},
         inspector::NoOpInspector,
         interpreter::interpreter::EthInterpreter,
-        precompile::{
-            Precompile, PrecompileId, PrecompileOutput, PrecompileResult, PrecompileSpecId,
-            Precompiles,
-        },
+        precompile::{PrecompileOutput, PrecompileSpecId, Precompiles},
         primitives::hardfork::SpecId,
     };
 
@@ -73,24 +70,21 @@ mod tests {
     struct CustomPrecompileFactory;
 
     impl PrecompileFactory for CustomPrecompileFactory {
-        fn precompiles(&self) -> Vec<(Precompile, u64)> {
+        fn precompiles(&self) -> Vec<(Address, DynPrecompile)> {
+            use alloy_evm::precompiles::PrecompileInput;
             vec![(
-                Precompile::from((
-                    PrecompileId::Custom(Cow::Borrowed("custom_echo")),
-                    PRECOMPILE_ADDR,
-                    custom_echo_precompile as fn(&[u8], u64) -> PrecompileResult,
-                )),
-                1000,
+                PRECOMPILE_ADDR,
+                DynPrecompile::from(|input: PrecompileInput<'_>| {
+                    Ok(PrecompileOutput {
+                        bytes: Bytes::copy_from_slice(input.data),
+                        gas_used: 0,
+                        reverted: false,
+                    })
+                }),
             )]
         }
     }
 
-    /// Custom precompile that echoes the input data.
-    /// In this example it uses `0xdeadbeef` as the input data, returning it as output.
-    fn custom_echo_precompile(input: &[u8], _gas_limit: u64) -> PrecompileResult {
-        Ok(PrecompileOutput { bytes: Bytes::copy_from_slice(input), gas_used: 0, reverted: false })
-    }
-
     /// Creates a new EVM instance with the custom precompile factory.
     fn create_eth_evm(
         spec: SpecId,

crates/anvil/tests/it/fork.rs

@@ -26,9 +26,7 @@ use foundry_config::Config;
 use foundry_evm_networks::NetworkConfigs;
 use foundry_test_utils::rpc::{self, next_http_rpc_endpoint, next_rpc_endpoint};
 use futures::StreamExt;
-use revm::precompile::{Precompile, PrecompileId, PrecompileOutput, PrecompileResult};
 use std::{
-    borrow::Cow,
     collections::{BTreeMap, BTreeSet},
     sync::Arc,
     thread::sleep,
@@ -1868,22 +1866,22 @@ async fn test_config_with_osaka_hardfork() {
 
 #[tokio::test(flavor = "multi_thread")]
 async fn test_config_with_osaka_hardfork_with_precompile_factory() {
-    fn custom_echo_precompile(input: &[u8], _gas_limit: u64) -> PrecompileResult {
-        Ok(PrecompileOutput { bytes: Bytes::copy_from_slice(input), gas_used: 0, reverted: false })
-    }
-
     #[derive(Debug)]
     struct CustomPrecompileFactory;
 
     impl PrecompileFactory for CustomPrecompileFactory {
-        fn precompiles(&self) -> Vec<(Precompile, u64)> {
+        fn precompiles(&self) -> Vec<(Address, alloy_evm::precompiles::DynPrecompile)> {
             vec![(
-                Precompile::from((
-                    PrecompileId::Custom(Cow::Borrowed("custom_echo")),
-                    address!("0x0000000000000000000000000000000000000071"),
-                    custom_echo_precompile as fn(&[u8], u64) -> PrecompileResult,
-                )),
-                1000,
+                address!("0x0000000000000000000000000000000000000071"),
+                alloy_evm::precompiles::DynPrecompile::from(
+                    |input: alloy_evm::precompiles::PrecompileInput<'_>| {
+                        Ok(revm::precompile::PrecompileOutput {
+                            bytes: Bytes::copy_from_slice(input.data),
+                            gas_used: 0,
+                            reverted: false,
+                        })
+                    },
+                ),
             )]
         }
     }