refactor: Move deterministic fail out of the instance manager loop

Author: evaporei

core/src/subgraph/instance_manager.rs

@@ -468,9 +468,26 @@ where
     let store_for_err = ctx.inputs.store.cheap_clone();
     let logger = ctx.state.logger.cheap_clone();
     let id_for_err = ctx.inputs.deployment.hash.clone();
-    let mut should_try_unfail_deterministic = true;
     let mut should_try_unfail_non_deterministic = true;
 
+    // If a subgraph failed for deterministic reasons, before start indexing, we first
+    // revert the deployment head. It should lead to the same result since the error was
+    // deterministic.
+    if let Some(current_ptr) = ctx.inputs.store.block_ptr()? {
+        if let Some(parent_ptr) = ctx.inputs.triggers_adapter.parent_ptr(&current_ptr).await? {
+            // This reverts the deployment head to the parent_ptr if
+            // deterministic errors happened.
+            //
+            // There's no point in calling it if we have no current or parent block
+            // pointers, because there would be: no block to revert to or to search
+            // errors from (first execution).
+            let _outcome = ctx
+                .inputs
+                .store
+                .unfail_deterministic_error(&current_ptr, &parent_ptr)?;
+        }
+    }
+
     // Exponential backoff that starts with two minutes and keeps
     // increasing its timeout exponentially until it reaches the ceiling.
     let mut backoff = ExponentialBackoff::new(MINUTE * 2, *SUBGRAPH_ERROR_RETRY_CEIL_SECS);
@@ -607,38 +624,6 @@ where
             let start = Instant::now();
             let deployment_failed = ctx.block_stream_metrics.deployment_failed.clone();
 
-            // If a subgraph failed for deterministic reasons, before processing a new block, we
-            // revert the deployment head. It should lead to the same result since the error was
-            // deterministic.
-            //
-            // As an optimization we check this only on the first run.
-            if should_try_unfail_deterministic {
-                should_try_unfail_deterministic = false;
-
-                if let Some(current_ptr) = ctx.inputs.store.block_ptr()? {
-                    if let Some(parent_ptr) =
-                        ctx.inputs.triggers_adapter.parent_ptr(&current_ptr).await?
-                    {
-                        // This reverts the deployment head to the parent_ptr if
-                        // deterministic errors happened.
-                        //
-                        // There's no point in calling it if we have no current or parent block
-                        // pointers, because there would be: no block to revert to or to search
-                        // errors from (first execution).
-                        let outcome = ctx
-                            .inputs
-                            .store
-                            .unfail_deterministic_error(&current_ptr, &parent_ptr)?;
-
-                        if let UnfailOutcome::Unfailed = outcome {
-                            // If the unfail happened, we must restart the BlockStream so the
-                            // reverted block isn't skipped.
-                            break;
-                        }
-                    }
-                }
-            }
-
             let res = process_block(
                 &logger,
                 ctx.inputs.triggers_adapter.cheap_clone(),