Implement Celo transfer precompile

Author: karlb

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

@@ -8,6 +8,7 @@ use crate::{
         error::InvalidTransactionError,
         pool::transactions::PoolTransaction,
     },
+    evm::celo_precompile::celo_precompile_lookup,
     inject_precompiles,
     mem::inspector::AnvilInspector,
 };
@@ -462,7 +463,12 @@ where
             op_context,
             inspector,
             EthInstructions::default(),
-            PrecompilesMap::from_static(op_precompiles),
+            if env.is_celo {
+                PrecompilesMap::from_static(op_precompiles)
+                    .with_precompile_lookup(celo_precompile_lookup)
+            } else {
+                PrecompilesMap::from_static(op_precompiles)
+            },
         ));
 
         let op = OpEvm::new(op_evm, true);

crates/anvil/src/evm.rs

@@ -9,6 +9,8 @@ use foundry_evm_core::either_evm::EitherEvm;
 use op_revm::OpContext;
 use revm::{Inspector, precompile::PrecompileWithAddress};
 
+pub mod celo_precompile;
+
 /// Object-safe trait that enables injecting extra precompiles when using
 /// `anvil` as a library.
 pub trait PrecompileFactory: Send + Sync + Unpin + Debug {

crates/anvil/src/evm/celo_precompile.rs

@@ -0,0 +1,90 @@
+use alloy_evm::precompiles::{DynPrecompile, PrecompileInput};
+use alloy_primitives::{Address, U256, address};
+use revm::precompile::{PrecompileError, PrecompileOutput, PrecompileResult};
+
+pub const CELO_TRANSFER_ADDRESS: Address = address!("0x00000000000000000000000000000000000000fd");
+
+/// Gas cost for Celo transfer precompile
+const CELO_TRANSFER_GAS_COST: u64 = 9000;
+
+/// Celo transfer precompile implementation using EvmInternals
+/// Address: 0xfd (253)
+/// Input: from (32 bytes) || to (32 bytes) || value (32 bytes) = 96 bytes total
+/// Gas cost: 9000
+///
+/// This implementation uses load_account to modify balances directly instead of
+/// requiring journal access, making it compatible with PrecompilesMap lookup function.
+pub fn celo_transfer_precompile(input: PrecompileInput<'_>) -> PrecompileResult {
+    // Check minimum gas requirement
+    if input.gas < CELO_TRANSFER_GAS_COST {
+        return Err(PrecompileError::OutOfGas);
+    }
+
+    // Validate input length (must be exactly 96 bytes: 32 + 32 + 32)
+    if input.data.len() != 96 {
+        return Err(PrecompileError::Other(format!(
+            "Invalid input length for Celo transfer precompile: expected 96 bytes, got {}",
+            input.data.len()
+        )));
+    }
+
+    // Parse input: from (bytes 12-32), to (bytes 44-64), value (bytes 64-96)
+    let from_bytes = &input.data[12..32];
+    let to_bytes = &input.data[44..64];
+    let value_bytes = &input.data[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);
+
+    // Perform the transfer using load_account to modify balances directly
+    let mut internals = input.internals;
+
+    // Load and check the from account balance first
+    {
+        let from_account = match internals.load_account(from_address) {
+            Ok(account) => account,
+            Err(e) => {
+                return Err(PrecompileError::Other(format!("Failed to load from account: {e:?}")));
+            }
+        };
+
+        // Check if from account has sufficient balance
+        if from_account.data.info.balance < value {
+            return Err(PrecompileError::Other("Insufficient balance".into()));
+        }
+
+        // Deduct balance from the from account
+        from_account.data.info.balance -= value;
+    }
+
+    // Load and update the to account
+    {
+        let to_account = match internals.load_account(to_address) {
+            Ok(account) => account,
+            Err(e) => {
+                return Err(PrecompileError::Other(format!("Failed to load to account: {e:?}")));
+            }
+        };
+
+        // Check for overflow in to account
+        if to_account.data.info.balance.checked_add(value).is_none() {
+            return Err(PrecompileError::Other("Balance overflow in to account".into()));
+        }
+
+        // Add balance to the to account
+        to_account.data.info.balance += value;
+    }
+
+    // No output data for successful transfer
+    Ok(PrecompileOutput::new(CELO_TRANSFER_GAS_COST, alloy_primitives::Bytes::new()))
+}
+
+/// Can be used as PrecompilesMap lookup function
+pub fn celo_precompile_lookup(address: &Address) -> Option<DynPrecompile> {
+    if *address == CELO_TRANSFER_ADDRESS {
+        Some(DynPrecompile::new_stateful(celo_transfer_precompile))
+    } else {
+        None
+    }
+}