Merge branch 'master' into refactor/anvil_txtype_enveloppe_macro

Author: mablr

Cargo.lock

@@ -944,30 +944,16 @@ impl TypedReceipt {
 fn convert_receipt_to_rpc(
     receipt: ReceiptWithBloom<Receipt<alloy_primitives::Log>>,
 ) -> ReceiptWithBloom<Receipt<alloy_rpc_types::Log>> {
-    let rpc_logs: Vec<alloy_rpc_types::Log> = receipt
-        .receipt
-        .logs
-        .into_iter()
-        .map(|log| alloy_rpc_types::Log {
-            inner: log,
-            block_hash: None,
-            block_number: None,
-            block_timestamp: None,
-            transaction_hash: None,
-            transaction_index: None,
-            log_index: None,
-            removed: false,
-        })
-        .collect();
-
-    ReceiptWithBloom {
-        receipt: Receipt {
-            status: receipt.receipt.status,
-            cumulative_gas_used: receipt.receipt.cumulative_gas_used,
-            logs: rpc_logs,
-        },
-        logs_bloom: receipt.logs_bloom,
-    }
+    receipt.map_logs(|log| alloy_rpc_types::Log {
+        inner: log,
+        block_hash: None,
+        block_number: None,
+        block_timestamp: None,
+        transaction_hash: None,
+        transaction_index: None,
+        log_index: None,
+        removed: false,
+    })
 }
 
 impl TypedReceiptRpc {

crates/anvil/core/src/eth/transaction/mod.rs

@@ -1211,7 +1211,6 @@ impl NodeConfig {
                 .initial_backoff(self.fork_retry_backoff.as_millis() as u64)
                 .compute_units_per_second(self.compute_units_per_second)
                 .max_retry(self.fork_request_retries)
-                .initial_backoff(1000)
                 .headers(self.fork_headers.clone())
                 .build()
                 .wrap_err("failed to establish provider to fork url")?,

crates/anvil/src/config.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/eth/backend/mem/mod.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/src/evm.rs

@@ -54,11 +54,10 @@ pub fn spec_id_from_ethereum_hardfork(hardfork: EthereumHardfork) -> SpecId {
         EthereumHardfork::Cancun => SpecId::CANCUN,
         EthereumHardfork::Prague => SpecId::PRAGUE,
         EthereumHardfork::Osaka => SpecId::OSAKA,
-        EthereumHardfork::Bpo1
-        | EthereumHardfork::Bpo2
-        | EthereumHardfork::Bpo3
-        | EthereumHardfork::Bpo4
-        | EthereumHardfork::Bpo5 => unimplemented!(),
+        EthereumHardfork::Bpo1 | EthereumHardfork::Bpo2 => SpecId::OSAKA,
+        EthereumHardfork::Bpo3 | EthereumHardfork::Bpo4 | EthereumHardfork::Bpo5 => {
+            unimplemented!()
+        }
         f => unreachable!("unimplemented {}", f),
     }
 }
@@ -75,7 +74,7 @@ pub fn spec_id_from_optimism_hardfork(hardfork: OpHardfork) -> OpSpecId {
         OpHardfork::Holocene => OpSpecId::HOLOCENE,
         OpHardfork::Isthmus => OpSpecId::ISTHMUS,
         OpHardfork::Interop => OpSpecId::INTEROP,
-        OpHardfork::Jovian => OpSpecId::ISTHMUS,
+        OpHardfork::Jovian => OpSpecId::JOVIAN,
         f => unreachable!("unimplemented {}", f),
     }
 }

crates/anvil/src/hardfork.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,
+                        })
+                    },
+                ),
             )]
         }
     }