fix: make retry attempts respect current slot number

Author: dylanlott

src/tasks/submit/task.rs

@@ -130,9 +130,9 @@ impl SubmitTask {
         retry_limit: usize,
     ) -> eyre::Result<ControlFlow> {
         let submitting_start_time = Instant::now();
-
-        let (current_slot, start, end) = self.calculate_slot_window();
-        debug!(current_slot, start, end, "calculating target slot window");
+        let now = utils::now();
+        let (initial_slot, start, end) = self.calculate_slot_window();
+        debug!(initial_slot, start, end, now, "calculating target slot window");
 
         let mut req = bumpable.req().clone();
 
@@ -147,6 +147,9 @@ impl SubmitTask {
             let inbound_result = match self.send_transaction(req).instrument(span.clone()).await {
                 Ok(control_flow) => control_flow,
                 Err(error) => {
+                    if let Some(value) = self.slot_still_valid(initial_slot) {
+                        return value;
+                    }
                     // Log error and retry
                     error!(%error, "error handling inbound block");
                     ControlFlow::Retry
@@ -157,6 +160,9 @@ impl SubmitTask {
 
             match inbound_result {
                 ControlFlow::Retry => {
+                    if let Some(value) = self.slot_still_valid(initial_slot) {
+                        return value;
+                    }
                     // bump the req
                     req = bumpable.bumped();
                     if bumpable.bump_count() > retry_limit {
@@ -192,6 +198,19 @@ impl SubmitTask {
         Ok(result)
     }
 
+    /// Checks if a slot is still valid during submission retries.
+    fn slot_still_valid(&self, initial_slot: u64) -> Option<Result<ControlFlow, eyre::Error>> {
+        let (current_slot, _, _) = self.calculate_slot_window();
+        if current_slot != initial_slot {
+            // If the slot has changed, skip the block
+            debug!(current_slot, initial_slot, "slot changed before submission - skipping block");
+            counter!("builder.slot_missed").increment(1);
+            return Some(Ok(ControlFlow::Skip));
+        }
+        debug!(current_slot, "slot still valid - continuing submission");
+        None
+    }
+
     /// Calculates and returns the slot number and its start and end timestamps for the current instant.
     fn calculate_slot_window(&self) -> (u64, u64, u64) {
         let now_ts = utils::now();
@@ -236,14 +255,21 @@ impl SubmitTask {
                 self.config.clone(),
                 self.constants,
             );
-            let bumpable =
-                match prep.prep_transaction(&sim_result.env.host).instrument(span.clone()).await {
-                    Ok(bumpable) => bumpable,
-                    Err(error) => {
-                        error!(%error, "failed to prepare transaction for submission");
-                        continue;
-                    }
-                };
+            let bumpable = match prep
+                .prep_transaction(&sim_result.env.host)
+                .instrument(span.clone())
+                .await
+            {
+                Ok(bumpable) => bumpable,
+                Err(error) => {
+                    // NB: I think this needs to handle 403 errors
+                    error.to_string().contains("403 Forbidden").then(|| {
+                        warn!(%error, "403 forbidden error detected - SHOULD be skipping block");
+                    });
+                    error!(%error, "failed to prepare transaction for submission");
+                    continue;
+                }
+            };
 
             // Simulate the transaction to check for reverts
             if let Err(error) = self.sim_with_call(bumpable.req()).instrument(span.clone()).await {