restore CI and contain Base behind its feature

Author: lukasrosario

.github/workflows/test.yml

@@ -131,4 +131,4 @@ jobs:
             args+=(--partition "$NEXTEST_PARTITION")
           fi
           args+=(--no-fail-fast)
-          cargo nextest run --locked --features monad "${args[@]}"
+          cargo nextest run --locked --features base,monad "${args[@]}"

Makefile

@@ -15,9 +15,9 @@ CARGO_TARGET_DIR ?= target
 # List of features to use when building. Can be overridden via the environment.
 # No jemalloc on Windows
 ifeq ($(OS),Windows_NT)
-    FEATURES ?= aws-kms gcp-kms turnkey cli asm-keccak monad optimism
+    FEATURES ?= aws-kms gcp-kms turnkey cli asm-keccak base monad optimism
 else
-    FEATURES ?= jemalloc aws-kms gcp-kms turnkey cli asm-keccak monad optimism
+    FEATURES ?= jemalloc aws-kms gcp-kms turnkey cli asm-keccak base monad optimism
 endif
 
 ##@ Help

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

@@ -40,15 +40,7 @@ pub(crate) fn build_simulated_deposit_receipt<H>(
 /// Resolves the deposit nonce and receipt version active at `hardfork`.
 ///
 /// Base is an OP-stack chain, so it gates the same two fields on its own upgrade names.
-fn deposit_metadata(
-    #[cfg_attr(
-        not(any(feature = "base", feature = "optimism")),
-        allow(unused_variables)
-    )]
-    hardfork: FoundryHardfork,
-    #[cfg_attr(not(any(feature = "base", feature = "optimism")), allow(unused_variables))]
-    caller_nonce: u64,
-) -> (Option<u64>, Option<u64>) {
+fn deposit_metadata(hardfork: FoundryHardfork, caller_nonce: u64) -> (Option<u64>, Option<u64>) {
     #[cfg(feature = "base")]
     if matches!(hardfork, FoundryHardfork::Base(_)) {
         let upgrade = BaseUpgrade::from(hardfork);
@@ -60,10 +52,10 @@ fn deposit_metadata(
     #[cfg(feature = "optimism")]
     {
         let hardfork = OpHardfork::from(hardfork);
-        return (
+        (
             (hardfork >= OpHardfork::Regolith).then_some(caller_nonce),
             (hardfork >= OpHardfork::Canyon).then_some(1),
-        );
+        )
     }
     #[cfg(not(feature = "optimism"))]
     (None, None)

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

@@ -244,7 +244,7 @@ use tempo_revm::{
 };
 use tokio::{sync::RwLock as AsyncRwLock, task::JoinSet};
 
-/// Network-specific transaction data produced by [`Backend::build_call_env`].
+/// Network-specific transaction data produced by [`Backend::build_call_env_with_base`].
 #[derive(Default, Clone, Debug)]
 struct CallTransactionInfo {
     /// OP-compatible deposit fields shared by Base and Optimism RPC requests.
@@ -744,7 +744,7 @@ pub trait BackendInspector<DB: Database>:
     + Inspector<BaseContext<DB>>
     + Inspector<OpEvmContext<DB>>
     + Inspector<TempoContext<DB>>
-    + Inspector<MonadContext<DB>>
+    + Inspector<alloy_monad_evm::MonadContext<DB>>
 {
 }
 #[cfg(all(feature = "base", feature = "optimism", feature = "monad"))]
@@ -753,7 +753,7 @@ impl<DB: Database, T> BackendInspector<DB> for T where
         + Inspector<BaseContext<DB>>
         + Inspector<OpEvmContext<DB>>
         + Inspector<TempoContext<DB>>
-        + Inspector<MonadContext<DB>>
+        + Inspector<alloy_monad_evm::MonadContext<DB>>
 {
 }
 #[cfg(all(feature = "base", feature = "optimism", not(feature = "monad")))]
@@ -777,15 +777,15 @@ pub trait BackendInspector<DB: Database>:
     Inspector<EthEvmContext<DB>>
     + Inspector<BaseContext<DB>>
     + Inspector<TempoContext<DB>>
-    + Inspector<MonadContext<DB>>
+    + Inspector<alloy_monad_evm::MonadContext<DB>>
 {
 }
 #[cfg(all(feature = "base", not(feature = "optimism"), feature = "monad"))]
 impl<DB: Database, T> BackendInspector<DB> for T where
     T: Inspector<EthEvmContext<DB>>
         + Inspector<BaseContext<DB>>
         + Inspector<TempoContext<DB>>
-        + Inspector<MonadContext<DB>>
+        + Inspector<alloy_monad_evm::MonadContext<DB>>
 {
 }
 #[cfg(all(feature = "base", not(feature = "optimism"), not(feature = "monad")))]
@@ -9483,19 +9483,13 @@ where
         evm_env: &EvmEnv,
     ) -> Result<(), InvalidTransactionError> {
         self.validate_pool_transaction_for(tx, account, evm_env)?;
-        #[cfg(any(feature = "base", feature = "optimism"))]
-        let is_deposit = tx.transaction.as_ref().is_deposit();
-        #[cfg(not(any(feature = "base", feature = "optimism")))]
-        let is_deposit = false;
+        // EIP-8130 counts nonces per channel in the nonce manager, so `tx.nonce()` is not
+        // comparable to the account's protocol nonce. Admission already validated the channel.
         #[cfg(feature = "base")]
-        let is_eip8130 = tx.transaction.as_ref().is_eip8130();
-        #[cfg(not(feature = "base"))]
-        let is_eip8130 = false;
-        if tx.nonce() > account.nonce
-            && !is_deposit
-            && !is_eip8130
-            && !tx.transaction.as_ref().is_tempo()
-        {
+        if tx.transaction.as_ref().is_eip8130() {
+            return Ok(());
+        }
+        if tx.nonce() > account.nonce {
             return Err(InvalidTransactionError::NonceTooHigh);
         }
         Ok(())

crates/anvil/src/eth/error/mod.rs

@@ -112,16 +112,18 @@ pub enum BlockchainError {
         "EIP-7702 fields received but is not supported by the current hardfork.\n\nYou can use it by running anvil with '--hardfork prague' or later."
     )]
     EIP7702TransactionUnsupportedAtHardfork,
+    // Base is an OP-stack chain and uses the same deposit envelope, so only the hint that names
+    // the flags able to enable it varies with the compiled-in families.
     #[cfg_attr(
         all(feature = "base", feature = "optimism"),
         error(
-            "deposit transaction received but is not supported.\n\nYou can use it by running anvil with '--optimism' or '--network base'."
+            "op-stack deposit tx received but is not supported.\n\nYou can use it by running anvil with '--optimism' or '--network base'."
         )
     )]
     #[cfg_attr(
         all(feature = "base", not(feature = "optimism")),
         error(
-            "deposit transaction received but is not supported.\n\nYou can use it by running anvil with '--network base'."
+            "op-stack deposit tx received but is not supported.\n\nYou can use it by running anvil with '--network base'."
         )
     )]
     #[cfg_attr(

crates/anvil/tests/it/optimism.rs

@@ -82,7 +82,7 @@ async fn test_deposits_not_supported_if_optimism_disabled() {
 
     let err = provider.send_transaction(tx).await.unwrap_err();
     let s = err.to_string();
-    assert!(s.contains("deposit transaction received but is not supported"), "{s:?}");
+    assert!(s.contains("op-stack deposit tx received but is not supported"), "{s:?}");
 }
 
 #[tokio::test(flavor = "multi_thread")]

crates/cast/src/args.rs

@@ -1,6 +1,8 @@
+#[cfg(feature = "base")]
+use crate::cmd::resolve_network;
 use crate::{
     Cast, SimpleCast,
-    cmd::{erc20::IERC20, resolve_network},
+    cmd::erc20::IERC20,
     opts::{Cast as CastArgs, CastSubcommand, ToBaseArgs},
     traces::identifier::SignaturesIdentifier,
     tx::CastTxSender,
@@ -421,45 +423,43 @@ pub async fn run_command(args: CastArgs) -> Result<()> {
             // Can use either --raw or specify raw as a field
             let is_raw_block = raw || fields.contains(&"raw".into());
             let output = if is_raw_block {
+                // Base encodes EIP-8130 transactions, so the raw block is only faithful with a
+                // Base-typed provider. Base is the only family inferred here; every other one
+                // still comes from `--network` alone.
+                #[cfg(feature = "base")]
                 let network = match network {
-                    Some(network) => network,
-                    None => resolve_network(&config).await?,
+                    Some(network) => Some(network),
+                    None => {
+                        resolve_network(&config).await?.is_base().then_some(NetworkVariant::Base)
+                    }
                 };
                 match network {
                     #[cfg(feature = "base")]
-                    NetworkVariant::Base => {
+                    Some(NetworkVariant::Base) => {
                         let provider =
                             ProviderBuilder::<BaseNetwork>::from_config(&config)?.build()?;
                         Cast::new(&provider)
                             .block_raw(block.unwrap_or(BlockId::Number(Latest)), full)
                             .await?
                     }
                     #[cfg(feature = "optimism")]
-                    NetworkVariant::Optimism => {
+                    Some(NetworkVariant::Optimism) => {
                         let provider =
                             ProviderBuilder::<Optimism>::from_config(&config)?.build()?;
 
                         Cast::new(&provider)
                             .block_raw(block.unwrap_or(BlockId::Number(Latest)), full)
                             .await?
                     }
-                    NetworkVariant::Tempo => {
+                    Some(NetworkVariant::Tempo) => {
                         let provider =
                             ProviderBuilder::<TempoNetwork>::from_config(&config)?.build()?;
                         Cast::new(&provider)
                             .block_raw(block.unwrap_or(BlockId::Number(Latest)), full)
                             .await?
                     }
-                    NetworkVariant::Ethereum => {
-                        let provider =
-                            ProviderBuilder::<Ethereum>::from_config(&config)?.build()?;
-                        Cast::new(&provider)
-                            .block_raw(block.unwrap_or(BlockId::Number(Latest)), full)
-                            .await?
-                    }
-                    // Monad blocks are Ethereum-shaped, so they use the Ethereum-typed provider.
-                    #[cfg(feature = "monad")]
-                    NetworkVariant::Monad => {
+                    // Ethereum (default) or no --raw flag
+                    _ => {
                         let provider =
                             ProviderBuilder::<Ethereum>::from_config(&config)?.build()?;
                         Cast::new(&provider)
@@ -749,42 +749,39 @@ pub async fn run_command(args: CastArgs) -> Result<()> {
             let config = rpc.load_config()?;
             // Can use either --raw or specify raw as a field
             let is_raw = raw || field.as_ref().is_some_and(|f| f == "raw");
+            // Base encodes EIP-8130 transactions, so the response is only faithful with a
+            // Base-typed provider. Base is the only family inferred here; every other one still
+            // comes from `--network` alone.
+            #[cfg(feature = "base")]
             let network = match network {
-                Some(network) => network,
-                None => resolve_network(&config).await?,
+                Some(network) => Some(network),
+                None => resolve_network(&config).await?.is_base().then_some(NetworkVariant::Base),
             };
             let output = match network {
                 #[cfg(feature = "base")]
-                NetworkVariant::Base => {
+                Some(NetworkVariant::Base) => {
                     let provider = ProviderBuilder::<BaseNetwork>::from_config(&config)?.build()?;
                     Cast::new(&provider)
                         .transaction(tx_hash, from, nonce, field, is_raw, to_request, lane)
                         .await?
                 }
                 #[cfg(feature = "optimism")]
-                NetworkVariant::Optimism => {
+                Some(NetworkVariant::Optimism) => {
                     let provider = ProviderBuilder::<Optimism>::from_config(&config)?.build()?;
 
                     Cast::new(&provider)
                         .transaction(tx_hash, from, nonce, field, is_raw, to_request, lane)
                         .await?
                 }
-                NetworkVariant::Tempo => {
+                Some(NetworkVariant::Tempo) => {
                     let provider =
                         ProviderBuilder::<TempoNetwork>::from_config(&config)?.build()?;
                     Cast::new(&provider)
                         .transaction(tx_hash, from, nonce, field, is_raw, to_request, lane)
                         .await?
                 }
-                NetworkVariant::Ethereum => {
-                    let provider = utils::get_provider(&config)?;
-                    Cast::new(&provider)
-                        .transaction(tx_hash, from, nonce, field, is_raw, to_request, lane)
-                        .await?
-                }
-                // Monad transactions are Ethereum-shaped, so they use the default provider.
-                #[cfg(feature = "monad")]
-                NetworkVariant::Monad => {
+                // Ethereum (default) or no --raw flag
+                _ => {
                     let provider = utils::get_provider(&config)?;
                     Cast::new(&provider)
                         .transaction(tx_hash, from, nonce, field, is_raw, to_request, lane)

crates/cast/src/cmd/access_list.rs

@@ -1,7 +1,8 @@
 use super::auth::confirm_auth_rpc_disclosure;
+#[cfg(feature = "base")]
+use crate::cmd::resolve_network;
 use crate::{
     Cast,
-    cmd::resolve_network,
     tx::{CastTxBuilder, SenderKind},
 };
 use alloy_ens::NameOrAddress;
@@ -74,13 +75,8 @@ impl AccessListArgs {
             return self.run_with_network::<TempoNetwork>().await;
         }
 
-        let config = self.rpc.load_config()?;
-        let network = resolve_network(&config).await?;
-        if network.is_tempo() {
-            return self.run_with_network::<TempoNetwork>().await;
-        }
         #[cfg(feature = "base")]
-        if network.is_base() {
+        if resolve_network(&self.rpc.load_config()?).await?.is_base() {
             return self.run_with_network::<BaseNetwork>().await;
         }
 

crates/cast/src/cmd/call.rs

@@ -1042,15 +1042,16 @@ mod tests {
         assert_eq!(config.chain, Some(Chain::mainnet()));
     }
 
+    /// Base chain IDs resolved to Optimism before Base support existed, so a build without the
+    /// `base` feature — which is what release binaries ship — must keep resolving them that way.
     #[test]
-    #[cfg(not(feature = "base"))]
-    fn chain_id_rejects_disabled_base_network() {
-        let error = infer_network_from_chain_id(NetworkConfigs::default(), 8453).unwrap_err();
-        assert_eq!(
-            error.to_string(),
-            "cannot infer execution network from chain ID 8453: network family `base` is not \
-             enabled in this build"
-        );
+    #[cfg(all(not(feature = "base"), feature = "optimism"))]
+    fn chain_id_without_base_still_resolves_to_optimism() {
+        for chain_id in [8453, 84532] {
+            let networks = infer_network_from_chain_id(NetworkConfigs::default(), chain_id)
+                .unwrap_or_else(|error| panic!("chain ID {chain_id} must still resolve: {error}"));
+            assert!(networks.is_optimism(), "chain ID {chain_id} must resolve to Optimism");
+        }
     }
 
     #[test]

crates/cast/src/cmd/da_estimate.rs

@@ -1,8 +1,7 @@
 //! Estimates the data availability size of a block for opstack.
 
-use super::resolve_network;
 use alloy_consensus::BlockHeader;
-use alloy_network::{BlockResponse, Ethereum, Network, eip2718::Encodable2718};
+use alloy_network::{AnyNetwork, BlockResponse, Ethereum, Network, eip2718::Encodable2718};
 use alloy_provider::Provider;
 use alloy_rpc_types::BlockId;
 #[cfg(feature = "base")]
@@ -34,8 +33,11 @@ impl DAEstimateArgs {
         let Self { block, rpc, network } = self;
         let config = rpc.load_config()?;
         let network = match network {
-            Some(network) => network,
-            None => resolve_network(&config).await?,
+            Some(n) => n,
+            None => {
+                let provider = ProviderBuilder::<AnyNetwork>::from_config(&config)?.build()?;
+                provider.get_chain_id().await?.into()
+            }
         };
         match network {
             #[cfg(feature = "base")]