feat(anvil): allow pass headers to fork-url

crates/anvil/src/cmd.rs

@@ -188,6 +188,7 @@ impl NodeArgs {
                     .fork_block_number
                     .or_else(|| self.evm_opts.fork_url.as_ref().and_then(|f| f.block)),
             )
+            .with_fork_headers(self.evm_opts.fork_headers)
             .with_fork_chain_id(self.evm_opts.fork_chain_id.map(u64::from))
             .fork_request_timeout(self.evm_opts.fork_request_timeout.map(Duration::from_millis))
             .fork_request_retries(self.evm_opts.fork_request_retries)
@@ -328,6 +329,17 @@ pub struct AnvilEvmArgs {
     )]
     pub fork_url: Option<ForkUrl>,
 
+    /// Pass headers to fork-url.
+    ///
+    /// See --fork-url.
+    #[clap(
+        long = "fork-header",
+        value_name = "HEADERS",
+        help_heading = "Fork config",
+        requires = "fork_url"
+    )]
+    pub fork_headers: Vec<String>,
+
     /// Timeout in ms for requests sent to remote JSON-RPC server in forking mode.
     ///
     /// Default value 45000
@@ -527,7 +539,7 @@ impl Future for PeriodicStateDumper {
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.get_mut();
         if this.dump_state.is_none() {
-            return Poll::Pending
+            return Poll::Pending;
         }
 
         loop {
@@ -538,7 +550,7 @@ impl Future for PeriodicStateDumper {
                     }
                     Poll::Pending => {
                         this.in_progress_dump = Some(flush);
-                        return Poll::Pending
+                        return Poll::Pending;
                     }
                 }
             }
@@ -548,7 +560,7 @@ impl Future for PeriodicStateDumper {
                 let path = this.dump_state.clone().expect("exists; see above");
                 this.in_progress_dump = Some(Box::pin(PeriodicStateDumper::dump_state(api, path)));
             } else {
-                break
+                break;
             }
         }
 
@@ -573,7 +585,7 @@ impl StateFile {
         }
         let mut state = Self { path, state: None };
         if !state.path.exists() {
-            return Ok(state)
+            return Ok(state);
         }
 
         state.state = Some(SerializableState::load(&state.path).map_err(|err| err.to_string())?);
@@ -608,14 +620,14 @@ impl FromStr for ForkUrl {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         if let Some((url, block)) = s.rsplit_once('@') {
             if block == "latest" {
-                return Ok(ForkUrl { url: url.to_string(), block: None })
+                return Ok(ForkUrl { url: url.to_string(), block: None });
             }
             // this will prevent false positives for auths `user:password@example.com`
             if !block.is_empty() && !block.contains(':') && !block.contains('.') {
                 let block: u64 = block
                     .parse()
                     .map_err(|_| format!("Failed to parse block number: `{block}`"))?;
-                return Ok(ForkUrl { url: url.to_string(), block: Some(block) })
+                return Ok(ForkUrl { url: url.to_string(), block: Some(block) });
             }
         }
         Ok(ForkUrl { url: s.to_string(), block: None })
@@ -664,6 +676,23 @@ mod tests {
         assert_eq!(args.hardfork, Some(Hardfork::Berlin));
     }
 
+    #[test]
+    fn can_parse_fork_headers() {
+        let args: NodeArgs = NodeArgs::parse_from([
+            "anvil",
+            "--fork-url",
+            "http,://localhost:8545",
+            "--fork-header",
+            "User-Agent: test-agent",
+            "--fork-header",
+            "Referrer: example.com",
+        ]);
+        assert_eq!(
+            args.evm_opts.fork_headers,
+            vec!["User-Agent: test-agent", "Referrer: example.com"]
+        );
+    }
+
     #[test]
     fn can_parse_prune_config() {
         let args: NodeArgs = NodeArgs::parse_from(["anvil", "--prune-history"]);

crates/anvil/src/config.rs

@@ -123,6 +123,8 @@ pub struct NodeConfig {
     pub eth_rpc_url: Option<String>,
     /// pins the block number for the state fork
     pub fork_block_number: Option<u64>,
+    /// headers to use with `eth_rpc_url`
+    pub fork_headers: Vec<String>,
     /// specifies chain id for cache to skip fetching from remote in offline-start mode
     pub fork_chain_id: Option<U256>,
     /// The generator used to generate the dev accounts
@@ -392,6 +394,7 @@ impl Default for NodeConfig {
             config_out: None,
             genesis: None,
             fork_request_timeout: REQUEST_TIMEOUT,
+            fork_headers: vec![],
             fork_request_retries: 5,
             fork_retry_backoff: Duration::from_millis(1_000),
             fork_chain_id: None,
@@ -659,6 +662,13 @@ impl NodeConfig {
         self
     }
 
+    /// Sets the `fork_headers` to use with `eth_rpc_url`
+    #[must_use]
+    pub fn with_fork_headers(mut self, headers: Vec<String>) -> Self {
+        self.fork_headers = headers;
+        self
+    }
+
     /// Sets the `fork_request_timeout` to use for requests
     #[must_use]
     pub fn fork_request_timeout(mut self, fork_request_timeout: Option<Duration>) -> Self {
@@ -756,7 +766,7 @@ impl NodeConfig {
             .expect("Failed writing json");
         }
         if self.silent {
-            return
+            return;
         }
 
         println!("{}", self.as_string(fork))
@@ -767,7 +777,7 @@ impl NodeConfig {
     /// See also [ Config::foundry_block_cache_file()]
     pub fn block_cache_path(&self, block: u64) -> Option<PathBuf> {
         if self.no_storage_caching || self.eth_rpc_url.is_none() {
-            return None
+            return None;
         }
         let chain_id = self.get_chain_id();
 
@@ -901,6 +911,7 @@ impl NodeConfig {
                 .compute_units_per_second(self.compute_units_per_second)
                 .max_retry(10)
                 .initial_backoff(1000)
+                .headers(self.fork_headers.clone())
                 .build()
                 .expect("Failed to establish provider to fork url"),
         );
@@ -1178,7 +1189,7 @@ async fn find_latest_fork_block<M: Middleware>(provider: M) -> Result<u64, M::Er
     for _ in 0..2 {
         if let Some(block) = provider.get_block(num).await? {
             if block.hash.is_some() {
-                break
+                break;
             }
         }
         // block not actually finalized, so we try the block before

crates/common/src/provider.rs

@@ -1,6 +1,9 @@
 //! Commonly used helpers to construct `Provider`s
 
-use crate::{runtime_client::RuntimeClient, ALCHEMY_FREE_TIER_CUPS, REQUEST_TIMEOUT};
+use crate::{
+    runtime_client::{RuntimeClient, RuntimeClientBuilder},
+    ALCHEMY_FREE_TIER_CUPS, REQUEST_TIMEOUT,
+};
 use ethers_core::types::{Chain, U256};
 use ethers_middleware::gas_oracle::{GasCategory, GasOracle, Polygon};
 use ethers_providers::{is_local_endpoint, Middleware, Provider, DEFAULT_LOCAL_POLL_INTERVAL};
@@ -58,6 +61,7 @@ pub struct ProviderBuilder {
     compute_units_per_second: u64,
     /// JWT Secret
     jwt: Option<String>,
+    headers: Vec<String>,
 }
 
 // === impl ProviderBuilder ===
@@ -69,7 +73,7 @@ impl ProviderBuilder {
         if url_str.starts_with("localhost:") {
             // invalid url: non-prefixed URL scheme is not allowed, so we prepend the default http
             // prefix
-            return Self::new(format!("http://{url_str}"))
+            return Self::new(format!("http://{url_str}"));
         }
 
         let url = Url::parse(url_str)
@@ -103,6 +107,7 @@ impl ProviderBuilder {
             // alchemy max cpus <https://github.com/alchemyplatform/alchemy-docs/blob/master/documentation/compute-units.md#rate-limits-cups>
             compute_units_per_second: ALCHEMY_FREE_TIER_CUPS,
             jwt: None,
+            headers: vec![],
         }
     }
 
@@ -174,6 +179,13 @@ impl ProviderBuilder {
         self
     }
 
+    /// Sets http headers
+    pub fn headers(mut self, headers: Vec<String>) -> Self {
+        self.headers = headers;
+
+        self
+    }
+
     /// Same as [`Self:build()`] but also retrieves the `chainId` in order to derive an appropriate
     /// interval
     pub async fn connect(self) -> eyre::Result<RetryProvider> {
@@ -197,18 +209,25 @@ impl ProviderBuilder {
             timeout,
             compute_units_per_second,
             jwt,
+            headers,
         } = self;
         let url = url?;
 
-        let mut provider = Provider::new(RuntimeClient::new(
+        let mut client_builder = RuntimeClientBuilder::new(
             url.clone(),
             max_retry,
             timeout_retry,
             initial_backoff,
             timeout,
             compute_units_per_second,
-            jwt,
-        ));
+        )
+        .with_headers(headers);
+
+        if let Some(jwt) = jwt {
+            client_builder = client_builder.with_jwt(jwt);
+        }
+
+        let mut provider = Provider::new(client_builder.build());
 
         let is_local = is_local_endpoint(url.as_str());
 
@@ -269,7 +288,7 @@ where
         match chain {
             Chain::Polygon | Chain::PolygonMumbai => {
                 let estimator = Polygon::new(chain)?.category(GasCategory::Standard);
-                return Ok(estimator.estimate_eip1559_fees().await?)
+                return Ok(estimator.estimate_eip1559_fees().await?);
             }
             _ => {}
         }