fix retry logic bug

Author: dylanlott

src/tasks/submit.rs

@@ -140,10 +140,7 @@ impl SubmitTask {
 
         // Simulate the transaction with a call to the host provider
         if let Some(maybe_error) = self.sim_with_call(&tx).await {
-            warn!(
-                error = ?maybe_error,
-                "error in transaction simulation"
-            );
+            warn!(error = ?maybe_error, "error in transaction simulation");
             if let Err(e) = maybe_error {
                 return Err(e);
             }
@@ -207,20 +204,11 @@ impl SubmitTask {
     ) -> Result<TransactionRequest, eyre::Error> {
         // TODO: ENG-1082 Implement fills
         let fills = vec![];
-
         // Extract the signature components from the response
         let (v, r, s) = extract_signature_components(&resp.sig);
 
-        // Bump gas with each retry to replace the previous
-        // transaction while maintaining the same nonce
-        // TODO: Clean this up if this works 
-        let gas_coefficient: u64 = (15 * (retry_count + 1)).try_into().unwrap();
-        let gas_limit: u64 = 1_500_000 + (gas_coefficient * 1_000_000);
-        let max_priority_fee_per_gas: u128 = (retry_count as u128);
-        debug!(
-            retry_count,
-            gas_coefficient, gas_limit, max_priority_fee_per_gas, "calculated gas limit"
-        );
+        // Calculate gas limits based on retry attempts
+        let (max_fee_per_gas, max_priority_fee_per_gas) = calculate_gas_limits(retry_count);
 
         // manually retrieve nonce
         let nonce =
@@ -242,8 +230,9 @@ impl SubmitTask {
             .build_blob_tx(fills, header, v, r, s, block)?
             .with_from(self.provider().default_signer_address())
             .with_to(self.config.builder_helper_address)
-            .with_gas_limit(gas_limit)
+            .with_max_fee_per_gas(max_fee_per_gas.into())
             .with_max_priority_fee_per_gas(max_priority_fee_per_gas)
+            .with_max_fee_per_blob_gas(max_fee_per_gas)
             .with_nonce(nonce);
 
         debug!(?tx, "prepared transaction request");
@@ -258,9 +247,12 @@ impl SubmitTask {
         tx: TransactionRequest,
     ) -> Result<ControlFlow, eyre::Error> {
         debug!(
+            ?tx.max_fee_per_gas,
+            ?tx.max_fee_per_blob_gas,
+            ?tx.max_priority_fee_per_gas,
+            nonce = ?tx.nonce,
             host_block_number = %resp.req.host_block_number,
             gas_limit = %resp.req.gas_limit,
-            nonce = ?tx.nonce,
             "sending transaction to network"
         );
 
@@ -286,6 +278,12 @@ impl SubmitTask {
         // question mark unwraps join error, which would be an internal panic
         // then if let checks for rpc error
         if let Err(e) = fut.await? {
+            let err_str = e.to_string();
+            if err_str.contains("replacement transaction underpriced") {
+                // bump gas and repeat
+                debug!("UNDERPRICE ERROR DETECTED");
+                return Ok(ControlFlow::Retry);
+            }
             error!(error = %e, "Primary tx broadcast failed. Skipping transaction.");
             return Ok(ControlFlow::Skip);
         }
@@ -341,54 +339,42 @@ impl SubmitTask {
 
         // Retry loop
         let result = loop {
+            // Log the retry attempt
             let span = debug_span!("SubmitTask::retrying_handle_inbound", retries);
 
-            let inbound_result = match self
-                .handle_inbound(retries, block)
-                .instrument(span.clone())
-                .await
-            {
-                Ok(control_flow) => {
-                    debug!(?control_flow, retries, "successfully handled inbound block");
-                    control_flow
-                }
-                Err(err) => {
-                    // Log the retry attempt
-                    retries += 1;
-
-                    // Delay until next slot if we get a 403 error
-                    if err.to_string().contains("403 Forbidden") {
-                        let (slot_number, _, _) = self.calculate_slot_window()?;
-                        debug!(slot_number, ?block, "403 detected - not assigned to slot");
-                        return Ok(ControlFlow::Skip);
-                    } else {
-                        error!(error = %err, "error handling inbound block");
+            let inbound_result =
+                match self.handle_inbound(retries, block).instrument(span.clone()).await {
+                    Ok(control_flow) => {
+                        debug!(?control_flow, retries, "successfully handled inbound block");
+                        control_flow
                     }
-
-                    ControlFlow::Retry
-                }
-            };
+                    Err(err) => {
+                        retries += 1;
+                        // Delay until next slot if we get a 403 error
+                        if err.to_string().contains("403 Forbidden") {
+                            let (slot_number, _, _) = self.calculate_slot_window()?;
+                            debug!(slot_number, ?block, "403 detected - not assigned to slot");
+                            return Ok(ControlFlow::Skip);
+                        } else {
+                            error!(error = %err, "error handling inbound block");
+                        }
+
+                        ControlFlow::Retry
+                    }
+                };
 
             let guard = span.entered();
 
             match inbound_result {
                 ControlFlow::Retry => {
+                    retries += 1;
                     if retries > retry_limit {
                         counter!("builder.building_too_many_retries").increment(1);
                         debug!("retries exceeded - skipping block");
                         return Ok(ControlFlow::Skip);
                     }
                     drop(guard);
-
-                    // Detect a slot change and break out of the loop in that case too
-                    let (this_slot, start, end) = self.calculate_slot_window()?;
-                    if this_slot != current_slot {
-                        debug!("slot changed - skipping block");
-                        break inbound_result;
-                    }
-
-                    // Otherwise retry the block
-                    debug!(retries, this_slot, start, end, "retrying block");
+                    debug!(retries, start, end, "retrying block");
                     continue;
                 }
                 ControlFlow::Skip => {
@@ -471,3 +457,21 @@ impl SubmitTask {
         (sender, handle)
     }
 }
+
+fn calculate_gas_limits(retry_count: usize) -> (u128, u128) {
+    // Set a base gas amount
+    let base_gas = 1_500_000;
+    // Define a gas coefficient
+    let gas_coefficient: u64 = 1 + (retry_count as u64);
+    // Determine gas limit by multiplying base gas by the coefficient
+    let max_fee_per_gas: u128 = (base_gas + (gas_coefficient * base_gas)) as u128;
+    // Determine priority gas fee by multiplying retry count by the coefficient
+    let max_priority_fee_per_gas: u128 =
+        (1 + retry_count as u128) * (gas_coefficient as u128 * 100_000);
+
+    debug!(
+        retry_count,
+        gas_coefficient, max_fee_per_gas, max_priority_fee_per_gas, "calculated gas limits"
+    );
+    (max_fee_per_gas, max_priority_fee_per_gas)
+}