refactor(cheatcode): use rate limit args in create fork cheatcode

crates/common/src/evm.rs

@@ -55,6 +55,13 @@ pub struct EvmArgs {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub fork_block_number: Option<u64>,
 
+    /// Number of retries.
+    ///
+    /// See --fork-url.
+    #[clap(long, requires = "fork_url", value_name = "RETRIES")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub fork_retries: Option<u32>,
+
     /// Initial retry backoff on encountering errors.
     ///
     /// See --fork-url.

crates/common/src/provider.rs

@@ -96,9 +96,9 @@ impl ProviderBuilder {
         Self {
             url,
             chain: Chain::Mainnet,
-            max_retry: 100,
-            timeout_retry: 5,
-            initial_backoff: 100,
+            max_retry: 8,
+            timeout_retry: 8,
+            initial_backoff: 800,
             timeout: REQUEST_TIMEOUT,
             // 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,
@@ -131,6 +131,19 @@ impl ProviderBuilder {
         self
     }
 
+    /// How often to retry a failed request. If `None`, defaults to the already-set value.
+    pub fn maybe_max_retry(mut self, max_retry: Option<u32>) -> Self {
+        self.max_retry = max_retry.unwrap_or(self.max_retry);
+        self
+    }
+
+    /// The starting backoff delay to use after the first failed request. If `None`, defaults to
+    /// the already-set value.
+    pub fn maybe_initial_backoff(mut self, initial_backoff: Option<u64>) -> Self {
+        self.initial_backoff = initial_backoff.unwrap_or(self.initial_backoff);
+        self
+    }
+
     /// How often to retry a failed request due to connection issues
     pub fn timeout_retry(mut self, timeout_retry: u32) -> Self {
         self.timeout_retry = timeout_retry;

crates/evm/core/src/fork/multi.rs

@@ -198,12 +198,6 @@ pub struct MultiForkHandler {
     /// All created Forks in order to reuse them
     forks: HashMap<ForkId, CreatedFork>,
 
-    /// The retries to allow for new providers
-    retries: u32,
-
-    /// Initial backoff delay for requests
-    backoff: u64,
-
     /// Optional periodic interval to flush rpc cache
     flush_cache_interval: Option<tokio::time::Interval>,
 }
@@ -217,9 +211,6 @@ impl MultiForkHandler {
             handlers: Default::default(),
             pending_tasks: Default::default(),
             forks: Default::default(),
-            retries: 8,
-            // 800ms
-            backoff: 800,
             flush_cache_interval: None,
         }
     }
@@ -258,10 +249,8 @@ impl MultiForkHandler {
                 return
             }
 
-            let retries = self.retries;
-            let backoff = self.backoff;
             // need to create a new fork
-            let task = Box::pin(create_fork(fork, retries, backoff));
+            let task = Box::pin(create_fork(fork));
             self.pending_tasks.push(ForkTask::Create(task, fork_id, sender, Vec::new()));
         }
     }
@@ -459,15 +448,11 @@ fn create_fork_id(url: &str, num: Option<u64>) -> ForkId {
 /// Creates a new fork
 ///
 /// This will establish a new `Provider` to the endpoint and return the Fork Backend
-async fn create_fork(
-    mut fork: CreateFork,
-    retries: u32,
-    backoff: u64,
-) -> eyre::Result<(CreatedFork, Handler)> {
+async fn create_fork(mut fork: CreateFork) -> eyre::Result<(CreatedFork, Handler)> {
     let provider = Arc::new(
         ProviderBuilder::new(fork.url.as_str())
-            .max_retry(retries)
-            .initial_backoff(backoff)
+            .maybe_max_retry(fork.evm_opts.fork_retries)
+            .maybe_initial_backoff(fork.evm_opts.fork_retry_backoff)
             .compute_units_per_second(fork.evm_opts.get_compute_units_per_second())
             .build()?,
     );

crates/evm/core/src/opts.rs

@@ -24,6 +24,9 @@ pub struct EvmOpts {
     /// pins the block number for the state fork
     pub fork_block_number: Option<u64>,
 
+    /// The number of retries
+    pub fork_retries: Option<u32>,
+
     /// initial retry backoff
     pub fork_retry_backoff: Option<u64>,