Add --celo flag to anvil

Author: karlb

crates/anvil/src/cmd.rs

@@ -279,6 +279,7 @@ impl NodeArgs {
             .with_max_persisted_states(self.max_persisted_states)
             .with_optimism(self.evm.optimism)
             .with_odyssey(self.evm.odyssey)
+            .with_celo(self.evm.celo)
             .with_disable_default_create2_deployer(self.evm.disable_default_create2_deployer)
             .with_slots_in_an_epoch(self.slots_in_an_epoch)
             .with_memory_limit(self.evm.memory_limit)
@@ -599,6 +600,10 @@ pub struct AnvilEvmArgs {
     /// Enable Odyssey features
     #[arg(long, alias = "alphanet")]
     pub odyssey: bool,
+
+    /// Run a Celo chain
+    #[arg(long)]
+    pub celo: bool,
 }
 
 /// Resolves an alias passed as fork-url to the matching url defined in the rpc_endpoints section

crates/anvil/src/config.rs

@@ -194,6 +194,8 @@ pub struct NodeConfig {
     pub precompile_factory: Option<Arc<dyn PrecompileFactory>>,
     /// Enable Odyssey features.
     pub odyssey: bool,
+    /// Enable Celo features.
+    pub celo: bool,
     /// Do not print log messages.
     pub silent: bool,
     /// The path where states are cached.
@@ -489,6 +491,7 @@ impl Default for NodeConfig {
             memory_limit: None,
             precompile_factory: None,
             odyssey: false,
+            celo: false,
             silent: false,
             cache_path: None,
         }
@@ -1007,6 +1010,17 @@ impl NodeConfig {
         self
     }
 
+    /// Sets whether to enable Celo support
+    #[must_use]
+    pub fn with_celo(mut self, celo: bool) -> Self {
+        self.celo = celo;
+        if celo {
+            // Celo requires Optimism support
+            self.enable_optimism = true;
+        }
+        self
+    }
+
     /// Makes the node silent to not emit anything on stdout
     #[must_use]
     pub fn silent(self) -> Self {
@@ -1061,6 +1075,7 @@ impl NodeConfig {
                 ..Default::default()
             },
             self.enable_optimism,
+            self.celo,
         );
 
         let fees = FeeManager::new(

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

@@ -10,12 +10,19 @@ pub struct Env {
     pub evm_env: EvmEnv,
     pub tx: OpTransaction<TxEnv>,
     pub is_optimism: bool,
+    pub is_celo: bool,
 }
 
 /// Helper container type for [`EvmEnv`] and [`OpTransaction<TxEnv>`].
 impl Env {
-    pub fn new(cfg: CfgEnv, block: BlockEnv, tx: OpTransaction<TxEnv>, is_optimism: bool) -> Self {
-        Self { evm_env: EvmEnv { cfg_env: cfg, block_env: block }, tx, is_optimism }
+    pub fn new(
+        cfg: CfgEnv,
+        block: BlockEnv,
+        tx: OpTransaction<TxEnv>,
+        is_optimism: bool,
+        is_celo: bool,
+    ) -> Self {
+        Self { evm_env: EvmEnv { cfg_env: cfg, block_env: block }, tx, is_optimism, is_celo }
     }
 }
 

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

@@ -120,6 +120,7 @@ pub struct TransactionExecutor<'a, Db: ?Sized, V: TransactionValidator> {
     pub enable_steps_tracing: bool,
     pub odyssey: bool,
     pub optimism: bool,
+    pub celo: bool,
     pub print_logs: bool,
     pub print_traces: bool,
     /// Recorder used for decoding traces, used together with print_traces
@@ -264,7 +265,7 @@ impl<DB: Db + ?Sized, V: TransactionValidator> TransactionExecutor<'_, DB, V> {
             tx_env.enveloped_tx = Some(alloy_rlp::encode(&tx.transaction.transaction).into());
         }
 
-        Env::new(self.cfg_env.clone(), self.block_env.clone(), tx_env, self.optimism)
+        Env::new(self.cfg_env.clone(), self.block_env.clone(), tx_env, self.optimism, self.celo)
     }
 }
 
@@ -461,7 +462,12 @@ where
             op_context,
             inspector,
             EthInstructions::default(),
-            HybridPrecompileProvider::standard_only(PrecompilesMap::from_static(op_precompiles)),
+            // Conditionally enable Celo precompile based on the is_celo flag
+            if env.is_celo {
+                HybridPrecompileProvider::new(PrecompilesMap::from_static(op_precompiles))
+            } else {
+                HybridPrecompileProvider::standard_only(PrecompilesMap::from_static(op_precompiles))
+            },
         ));
 
         let op = OpEvm::new(op_evm, true);
@@ -492,9 +498,7 @@ where
             eth_context,
             inspector,
             EthInstructions::default(),
-            // 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)),
+            HybridPrecompileProvider::standard_only(PrecompilesMap::from_static(eth_precompiles)),
         );
 
         let eth = EthEvm::new(eth_evm, true);

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

@@ -834,6 +834,11 @@ impl Backend {
         self.env.read().is_optimism
     }
 
+    /// Returns true if Celo features are active
+    pub fn is_celo(&self) -> bool {
+        self.env.read().is_celo
+    }
+
     /// Returns [`BlobParams`] corresponding to the current spec.
     pub fn blob_params(&self) -> BlobParams {
         let spec_id = self.env.read().evm_env.cfg_env.spec;
@@ -1265,6 +1270,7 @@ impl Backend {
             precompile_factory: self.precompile_factory.clone(),
             odyssey: self.odyssey,
             optimism: self.is_optimism(),
+            celo: self.is_celo(),
             blob_params: self.blob_params(),
         };
 
@@ -1352,6 +1358,7 @@ impl Backend {
                     odyssey: self.odyssey,
                     precompile_factory: self.precompile_factory.clone(),
                     optimism: self.is_optimism(),
+                    celo: self.is_celo(),
                     blob_params: self.blob_params(),
                 };
                 let executed_tx = executor.execute();

crates/anvil/src/evm/stateful_precompile.rs

@@ -65,9 +65,11 @@ where
         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);
+        if self.stateful_precompile_addresses.contains(address) {
+            // 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