Implement Celo transfer precompile

Author: karlb

crates/anvil/src/eth/backend/executor.rs

@@ -1,5 +1,5 @@
 use crate::{
-    PrecompileFactory,
+    HybridPrecompileProvider, PrecompileFactory,
     eth::{
         backend::{
             db::Db, env::Env, mem::op_haltreason_to_instruction_result,
@@ -434,7 +434,7 @@ pub fn new_evm_with_inspector<DB, I>(
     db: DB,
     env: &Env,
     inspector: I,
-) -> EitherEvm<DB, I, PrecompilesMap>
+) -> EitherEvm<DB, I, HybridPrecompileProvider>
 where
     DB: Database<Error = DatabaseError> + Debug,
     I: Inspector<EthEvmContext<DB>> + Inspector<OpContext<DB>>,
@@ -461,7 +461,7 @@ where
             op_context,
             inspector,
             EthInstructions::default(),
-            PrecompilesMap::from_static(op_precompiles),
+            HybridPrecompileProvider::standard_only(PrecompilesMap::from_static(op_precompiles)),
         ));
 
         let op = OpEvm::new(op_evm, true);
@@ -492,7 +492,9 @@ where
             eth_context,
             inspector,
             EthInstructions::default(),
-            PrecompilesMap::from_static(eth_precompiles),
+            // TODO: Only use standard precompiles here and pull out version with stateful
+            // precompiles into a Celo-specific version of the Optimism branch.
+            HybridPrecompileProvider::new(PrecompilesMap::from_static(eth_precompiles)),
         );
 
         let eth = EthEvm::new(eth_evm, true);
@@ -506,7 +508,7 @@ pub fn new_evm_with_inspector_ref<'db, DB, I>(
     db: &'db DB,
     env: &Env,
     inspector: &'db mut I,
-) -> EitherEvm<WrapDatabaseRef<&'db DB>, &'db mut I, PrecompilesMap>
+) -> EitherEvm<WrapDatabaseRef<&'db DB>, &'db mut I, HybridPrecompileProvider>
 where
     DB: DatabaseRef<Error = DatabaseError> + Debug + 'db + ?Sized,
     I: Inspector<EthEvmContext<WrapDatabaseRef<&'db DB>>>

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

@@ -45,7 +45,6 @@ use alloy_evm::{
     Database, Evm,
     eth::EthEvmContext,
     overrides::{OverrideBlockHashes, apply_state_overrides},
-    precompiles::PrecompilesMap,
 };
 use alloy_network::{
     AnyHeader, AnyRpcBlock, AnyRpcHeader, AnyRpcTransaction, AnyTxEnvelope, AnyTxType,
@@ -1162,7 +1161,7 @@ impl Backend {
         db: &'db DB,
         env: &Env,
         inspector: &'db mut I,
-    ) -> EitherEvm<WrapDatabaseRef<&'db DB>, &'db mut I, PrecompilesMap>
+    ) -> EitherEvm<WrapDatabaseRef<&'db DB>, &'db mut I, crate::HybridPrecompileProvider>
     where
         DB: DatabaseRef + ?Sized,
         I: Inspector<EthEvmContext<WrapDatabaseRef<&'db DB>>>

crates/anvil/src/evm.rs

@@ -3,12 +3,16 @@ use std::fmt::Debug;
 use alloy_evm::{
     Database, Evm,
     eth::EthEvmContext,
-    precompiles::{DynPrecompile, PrecompileInput, PrecompilesMap},
+    precompiles::{DynPrecompile, PrecompileInput},
 };
 use foundry_evm_core::either_evm::EitherEvm;
 use op_revm::OpContext;
 use revm::{Inspector, precompile::PrecompileWithAddress};
 
+mod celo_precompile;
+mod stateful_precompile;
+pub use stateful_precompile::HybridPrecompileProvider;
+
 /// Object-safe trait that enables injecting extra precompiles when using
 /// `anvil` as a library.
 pub trait PrecompileFactory: Send + Sync + Unpin + Debug {
@@ -18,14 +22,14 @@ pub trait PrecompileFactory: Send + Sync + Unpin + Debug {
 
 /// Inject precompiles into the EVM dynamically.
 pub fn inject_precompiles<DB, I>(
-    evm: &mut EitherEvm<DB, I, PrecompilesMap>,
+    evm: &mut EitherEvm<DB, I, HybridPrecompileProvider>,
     precompiles: Vec<(PrecompileWithAddress, u64)>,
 ) where
     DB: Database,
     I: Inspector<EthEvmContext<DB>> + Inspector<OpContext<DB>>,
 {
     for (PrecompileWithAddress(addr, func), gas) in precompiles {
-        evm.precompiles_mut().apply_precompile(&addr, move |_| {
+        evm.precompiles_mut().standard_precompiles.apply_precompile(&addr, move |_| {
             Some(DynPrecompile::from(move |input: PrecompileInput<'_>| func(input.data, gas)))
         });
     }
@@ -55,7 +59,7 @@ mod tests {
         primitives::hardfork::SpecId,
     };
 
-    use crate::{PrecompileFactory, inject_precompiles};
+    use crate::{HybridPrecompileProvider, PrecompileFactory, inject_precompiles};
 
     // A precompile activated in the `Prague` spec.
     const ETH_PRAGUE_PRECOMPILE: Address = address!("0x0000000000000000000000000000000000000011");
@@ -91,8 +95,10 @@ mod tests {
     /// Creates a new EVM instance with the custom precompile factory.
     fn create_eth_evm(
         spec: SpecId,
-    ) -> (foundry_evm::Env, EitherEvm<EmptyDBTyped<Infallible>, NoOpInspector, PrecompilesMap>)
-    {
+    ) -> (
+        foundry_evm::Env,
+        EitherEvm<EmptyDBTyped<Infallible>, NoOpInspector, HybridPrecompileProvider>,
+    ) {
         let eth_env = foundry_evm::Env {
             evm_env: EvmEnv { block_env: Default::default(), cfg_env: CfgEnv::new_with_spec(spec) },
             tx: TxEnv {
@@ -122,7 +128,9 @@ mod tests {
                 eth_evm_context,
                 NoOpInspector,
                 EthInstructions::<EthInterpreter, EthEvmContext<EmptyDB>>::default(),
-                PrecompilesMap::from_static(eth_precompiles),
+                HybridPrecompileProvider::standard_only(PrecompilesMap::from_static(
+                    eth_precompiles,
+                )),
             ),
             true,
         ));
@@ -136,7 +144,7 @@ mod tests {
         op_spec: OpSpecId,
     ) -> (
         crate::eth::backend::env::Env,
-        EitherEvm<EmptyDBTyped<Infallible>, NoOpInspector, PrecompilesMap>,
+        EitherEvm<EmptyDBTyped<Infallible>, NoOpInspector, HybridPrecompileProvider>,
     ) {
         let op_env = crate::eth::backend::env::Env {
             evm_env: EvmEnv { block_env: Default::default(), cfg_env: CfgEnv::new_with_spec(spec) },
@@ -180,7 +188,9 @@ mod tests {
                 op_evm_context,
                 NoOpInspector,
                 EthInstructions::<EthInterpreter, OpContext<EmptyDB>>::default(),
-                PrecompilesMap::from_static(op_precompiles),
+                HybridPrecompileProvider::standard_only(PrecompilesMap::from_static(
+                    op_precompiles,
+                )),
             )),
             true,
         ));

crates/anvil/src/evm/celo_precompile.rs

@@ -0,0 +1,68 @@
+use alloy_primitives::{Address, U256};
+use revm::context::{ContextTr, JournalTr};
+
+/// Celo transfer precompile implementation
+/// Address: 0xfd (253)
+/// Input: from (32 bytes) || to (32 bytes) || value (32 bytes) = 96 bytes total
+/// Gas cost: 9000
+pub fn celo_transfer_precompile<CTX: ContextTr>(
+    mut context: CTX,
+    inputs: &revm::interpreter::InputsImpl,
+    gas_limit: u64,
+) -> Result<Option<revm::interpreter::InterpreterResult>, String> {
+    use revm::interpreter::{Gas, InstructionResult, InterpreterResult};
+
+    // Gas cost for Celo transfer precompile
+    const CELO_TRANSFER_GAS_COST: u64 = 9000;
+
+    // Check minimum gas requirement
+    if gas_limit < CELO_TRANSFER_GAS_COST {
+        return Err("Insufficient gas for Celo transfer precompile".to_string());
+    }
+
+    let mut result = InterpreterResult {
+        result: InstructionResult::Return,
+        gas: Gas::new(gas_limit),
+        output: Default::default(),
+    };
+
+    // Record gas cost
+    if !result.gas.record_cost(CELO_TRANSFER_GAS_COST) {
+        return Err("Out of gas in Celo transfer precompile".to_string());
+    }
+
+    // Validate input length (must be exactly 96 bytes: 32 + 32 + 32)
+    let input_bytes = inputs.input.bytes(&mut context);
+    if input_bytes.len() != 96 {
+        return Err(format!(
+            "Invalid input length for Celo transfer precompile: expected 96 bytes, got {}",
+            input_bytes.len()
+        ));
+    }
+
+    // Parse input: from (bytes 12-32), to (bytes 44-64), value (bytes 64-96)
+    let from_bytes = &input_bytes[12..32];
+    let to_bytes = &input_bytes[44..64];
+    let value_bytes = &input_bytes[64..96];
+
+    let from_address = Address::from_slice(from_bytes);
+    let to_address = Address::from_slice(to_bytes);
+    let value = U256::from_be_slice(value_bytes);
+
+    eprintln!("\t[Celo Transfer] from: {from_address:?}, to: {to_address:?}, value: {value}");
+
+    // Perform the transfer using JournalTr.transfer
+    if let Err(e) = context.journal_mut().transfer(from_address, to_address, value) {
+        eprintln!("[Celo Transfer] Transfer failed: {e:?}");
+        result.result = InstructionResult::PrecompileError;
+        return Ok(Some(result));
+    }
+
+    eprintln!("\t[Celo Transfer] Transfer successful");
+
+    // No output data for successful transfer
+    result.output = alloy_primitives::Bytes::new();
+    result.result = InstructionResult::Return;
+
+    Ok(Some(result))
+}

crates/anvil/src/evm/stateful_precompile.rs

@@ -0,0 +1,92 @@
+use super::celo_precompile::celo_transfer_precompile;
+use alloy_evm::precompiles::PrecompilesMap;
+use alloy_primitives::{Address, address};
+use revm::{
+    context::{Cfg, ContextTr},
+    handler::PrecompileProvider,
+};
+use std::fmt::Debug;
+
+const CELO_TRANSFER_ADDRESS: Address = address!("0x00000000000000000000000000000000000000fd");
+
+/// Hybrid precompile provider that combines standard precompiles with stateful precompiles
+#[derive(Debug)]
+pub struct HybridPrecompileProvider {
+    /// Standard precompiles map
+    pub standard_precompiles: PrecompilesMap,
+    // This should be mapping, but we can't store generic function pointers in a HashMap and
+    // ContextTr is not dyn-compatible.
+    // stateful_precompiles: HashMap<
+    //     Address,
+    //     fn(
+    //         &mut CTX,
+    //         &revm::interpreter::InputsImpl,
+    //         u64,
+    //     ) -> Result<Option<revm::interpreter::InterpreterResult>, String>,
+    // >,
+    /// Stateful precompile addresses
+    stateful_precompile_addresses: Vec<Address>,
+}
+
+impl HybridPrecompileProvider {
+    /// Create a new hybrid provider with standard precompiles and stateful precompiles
+    pub fn new(standard_precompiles: PrecompilesMap) -> Self {
+        Self { standard_precompiles, stateful_precompile_addresses: vec![CELO_TRANSFER_ADDRESS] }
+    }
+
+    /// Create a new hybrid provider with only standard precompiles
+    pub fn standard_only(standard_precompiles: PrecompilesMap) -> Self {
+        Self { standard_precompiles, stateful_precompile_addresses: Vec::new() }
+    }
+
+    /// Get all addresses (both standard and stateful precompiles)
+    pub fn addresses(&self) -> Box<impl Iterator<Item = Address>> {
+        let standard_addresses = self.standard_precompiles.addresses().copied();
+        Box::new(self.stateful_precompile_addresses.iter().copied().chain(standard_addresses))
+    }
+}
+
+impl<CTX> PrecompileProvider<CTX> for HybridPrecompileProvider
+where
+    CTX: ContextTr,
+    PrecompilesMap: PrecompileProvider<CTX, Output = revm::interpreter::InterpreterResult>,
+{
+    type Output = revm::interpreter::InterpreterResult;
+
+    fn set_spec(&mut self, spec: <<CTX as ContextTr>::Cfg as Cfg>::Spec) -> bool {
+        <PrecompilesMap as PrecompileProvider<CTX>>::set_spec(&mut self.standard_precompiles, spec)
+    }
+
+    fn run(
+        &mut self,
+        context: &mut CTX,
+        address: &Address,
+        inputs: &revm::interpreter::InputsImpl,
+        is_static: bool,
+        gas_limit: u64,
+    ) -> Result<Option<Self::Output>, String> {
+        // Check if this is the Celo transfer precompile
+        if address == &CELO_TRANSFER_ADDRESS {
+            return celo_transfer_precompile(context, inputs, gas_limit);
+        }
+
+        // Fall back to standard precompiles
+        self.standard_precompiles.run(context, address, inputs, is_static, gas_limit)
+    }
+
+    fn warm_addresses(&self) -> Box<impl Iterator<Item = Address>> {
+        let standard_addresses =
+            <PrecompilesMap as PrecompileProvider<CTX>>::warm_addresses(&self.standard_precompiles);
+        Box::new(self.stateful_precompile_addresses.iter().copied().chain(standard_addresses))
+    }
+
+    fn contains(&self, address: &Address) -> bool {
+        // Check stateful precompiles first
+        if self.stateful_precompile_addresses.contains(address) {
+            return true;
+        }
+
+        // Check standard precompiles
+        <PrecompilesMap as PrecompileProvider<CTX>>::contains(&self.standard_precompiles, address)
+    }
+}

crates/anvil/src/lib.rs

@@ -54,7 +54,7 @@ pub use alloy_hardforks::EthereumHardfork;
 pub mod eth;
 /// Evm related abstractions
 mod evm;
-pub use evm::{PrecompileFactory, inject_precompiles};
+pub use evm::{HybridPrecompileProvider, PrecompileFactory, inject_precompiles};
 
 /// support for polling filters
 pub mod filter;