refactor(common): make ProviderBuilder generic over Network (#13250)

* refactor(common): make `ProviderBuilder` generic over `Network`

- Updated `ProviderBuilder` helper to be generic, which will facilate `FoundryNetwork` rollout
- Adjusted the instantiation of `ProviderBuilder` in various locations to use `AnyNetwork`.
- Enhanced the `build` and `build_with_wallet` methods to accommodate the new generic structure.

* fix: relax trait bound on `N::TransactionRequest`

* fix: comment

* fix: comment

Author: mablr

crates/cheatcodes/src/evm/fork.rs

@@ -3,6 +3,7 @@ use crate::{
     json::json_value_to_token,
 };
 use alloy_dyn_abi::DynSolValue;
+use alloy_network::AnyNetwork;
 use alloy_primitives::{B256, U256};
 use alloy_provider::Provider;
 use alloy_rpc_types::Filter;
@@ -238,7 +239,7 @@ impl Cheatcode for eth_getLogsCall {
             .database
             .active_fork_url()
             .ok_or_else(|| fmt_err!("no active fork URL found"))?;
-        let provider = ProviderBuilder::new(&url).build()?;
+        let provider = ProviderBuilder::<AnyNetwork>::new(&url).build()?;
         let mut filter = Filter::new().address(*target).from_block(from_block).to_block(to_block);
         for (i, &topic) in topics.iter().enumerate() {
             filter.topics[i] = topic.into();
@@ -275,7 +276,7 @@ impl Cheatcode for getRawBlockHeaderCall {
             .database
             .active_fork_url()
             .ok_or_else(|| fmt_err!("no active fork"))?;
-        let provider = ProviderBuilder::new(&url).build()?;
+        let provider = ProviderBuilder::<AnyNetwork>::new(&url).build()?;
         let block_number = u64::try_from(blockNumber)
             .map_err(|_| fmt_err!("block number must be less than 2^64"))?;
         let block =
@@ -397,7 +398,7 @@ fn persist_caller(ccx: &mut CheatsCtxt) {
 
 /// Performs an Ethereum JSON-RPC request to the given endpoint.
 fn rpc_call(url: &str, method: &str, params: &str) -> Result {
-    let provider = ProviderBuilder::new(url).build()?;
+    let provider = ProviderBuilder::<AnyNetwork>::new(url).build()?;
     let params_json: serde_json::Value = serde_json::from_str(params)?;
     let result =
         foundry_common::block_on(provider.raw_request(method.to_string().into(), params_json))

crates/common/src/provider/mod.rs

@@ -8,16 +8,18 @@ use crate::{
     provider::{curl_transport::CurlTransport, runtime_transport::RuntimeTransportBuilder},
 };
 use alloy_chains::NamedChain;
+use alloy_network::{Network, NetworkWallet};
 use alloy_provider::{
     Identity, ProviderBuilder as AlloyProviderBuilder, RootProvider,
-    fillers::{ChainIdFiller, FillProvider, GasFiller, JoinFill, NonceFiller, WalletFiller},
+    fillers::{FillProvider, JoinFill, RecommendedFillers, WalletFiller},
     network::{AnyNetwork, EthereumWallet},
 };
 use alloy_rpc_client::ClientBuilder;
 use alloy_transport::{layers::RetryBackoffLayer, utils::guess_local_url};
 use eyre::{Result, WrapErr};
 use reqwest::Url;
 use std::{
+    marker::PhantomData,
     net::SocketAddr,
     path::{Path, PathBuf},
     str::FromStr,
@@ -36,20 +38,8 @@ const POLL_INTERVAL_BLOCK_TIME_SCALE_FACTOR: f32 = 0.6;
 pub type RetryProvider<N = AnyNetwork> = RootProvider<N>;
 
 /// Helper type alias for a retry provider with a signer
-pub type RetryProviderWithSigner<N = AnyNetwork> = FillProvider<
-    JoinFill<
-        JoinFill<
-            Identity,
-            JoinFill<
-                GasFiller,
-                JoinFill<
-                    alloy_provider::fillers::BlobGasFiller,
-                    JoinFill<NonceFiller, ChainIdFiller>,
-                >,
-            >,
-        >,
-        WalletFiller<EthereumWallet>,
-    >,
+pub type RetryProviderWithSigner<N = AnyNetwork, W = EthereumWallet> = FillProvider<
+    JoinFill<JoinFill<Identity, <N as RecommendedFillers>::RecommendedFillers>, WalletFiller<W>>,
     RootProvider<N>,
     N,
 >;
@@ -84,8 +74,10 @@ pub fn try_get_http_provider(builder: impl AsRef<str>) -> Result<RetryProvider>
 }
 
 /// Helper type to construct a `RetryProvider`
+///
+/// This builder is generic over the network type `N`, defaulting to `AnyNetwork`.
 #[derive(Debug)]
-pub struct ProviderBuilder {
+pub struct ProviderBuilder<N: Network = AnyNetwork> {
     // Note: this is a result, so we can easily chain builder calls
     url: Result<Url>,
     chain: NamedChain,
@@ -104,10 +96,12 @@ pub struct ProviderBuilder {
     no_proxy: bool,
     /// Whether to output curl commands instead of making requests.
     curl_mode: bool,
+    /// Phantom data for the network type.
+    _network: PhantomData<N>,
 }
 
-impl ProviderBuilder {
-    /// Creates a new builder instance
+impl<N: Network> ProviderBuilder<N> {
+    /// Creates a new ProviderBuilder helper instance.
     pub fn new(url_str: &str) -> Self {
         // a copy is needed for the next lines to work
         let mut url_str = url_str;
@@ -156,6 +150,7 @@ impl ProviderBuilder {
             accept_invalid_certs: false,
             no_proxy: false,
             curl_mode: false,
+            _network: PhantomData,
         }
     }
 
@@ -278,7 +273,7 @@ impl ProviderBuilder {
     }
 
     /// Constructs the `RetryProvider` taking all configs into account.
-    pub fn build(self) -> Result<RetryProvider> {
+    pub fn build(self) -> Result<RetryProvider<N>> {
         let Self {
             url,
             chain,
@@ -292,6 +287,7 @@ impl ProviderBuilder {
             accept_invalid_certs,
             no_proxy,
             curl_mode,
+            ..
         } = self;
         let url = url?;
 
@@ -303,7 +299,7 @@ impl ProviderBuilder {
             let transport = CurlTransport::new(url).with_headers(headers).with_jwt(jwt);
             let client = ClientBuilder::default().layer(retry_layer).transport(transport, is_local);
 
-            let provider = AlloyProviderBuilder::<_, _, AnyNetwork>::default()
+            let provider = AlloyProviderBuilder::<_, _, N>::default()
                 .connect_provider(RootProvider::new(client));
 
             return Ok(provider);
@@ -330,14 +326,22 @@ impl ProviderBuilder {
             );
         }
 
-        let provider = AlloyProviderBuilder::<_, _, AnyNetwork>::default()
-            .connect_provider(RootProvider::new(client));
+        let provider =
+            AlloyProviderBuilder::<_, _, N>::default().connect_provider(RootProvider::new(client));
 
         Ok(provider)
     }
+}
 
+impl<N: Network> ProviderBuilder<N> {
     /// Constructs the `RetryProvider` with a wallet.
-    pub fn build_with_wallet(self, wallet: EthereumWallet) -> Result<RetryProviderWithSigner> {
+    pub fn build_with_wallet<W: NetworkWallet<N> + Clone>(
+        self,
+        wallet: W,
+    ) -> Result<RetryProviderWithSigner<N, W>>
+    where
+        N: RecommendedFillers,
+    {
         let Self {
             url,
             chain,
@@ -351,6 +355,7 @@ impl ProviderBuilder {
             accept_invalid_certs,
             no_proxy,
             curl_mode,
+            ..
         } = self;
         let url = url?;
 
@@ -362,7 +367,7 @@ impl ProviderBuilder {
             let transport = CurlTransport::new(url).with_headers(headers).with_jwt(jwt);
             let client = ClientBuilder::default().layer(retry_layer).transport(transport, is_local);
 
-            let provider = AlloyProviderBuilder::<_, _, AnyNetwork>::default()
+            let provider = AlloyProviderBuilder::<_, _, N>::default()
                 .with_recommended_fillers()
                 .wallet(wallet)
                 .connect_provider(RootProvider::new(client));
@@ -392,7 +397,7 @@ impl ProviderBuilder {
             );
         }
 
-        let provider = AlloyProviderBuilder::<_, _, AnyNetwork>::default()
+        let provider = AlloyProviderBuilder::<_, _, N>::default()
             .with_recommended_fillers()
             .wallet(wallet)
             .connect_provider(RootProvider::new(client));
@@ -426,7 +431,7 @@ mod tests {
 
     #[test]
     fn can_auto_correct_missing_prefix() {
-        let builder = ProviderBuilder::new("localhost:8545");
+        let builder = ProviderBuilder::<AnyNetwork>::new("localhost:8545");
         assert!(builder.url.is_ok());
 
         let url = builder.url.unwrap();