@secondlayer/subgraphs 3.23.2 → 3.24.0

package/dist/src/runtime/block-processor.d.ts

@@ -450,6 +450,19 @@ interface ProcessBlockOptions {
 	} | {
 		operationId: string
 	};
+	/**
+	* Reorg rewind (f069): set exclusively by `reorg.ts`'s fork-block
+	* reprocess. Bypasses the live-path replay guard (a fork block's height
+	* is, by construction, at or below the current cursor — the guard would
+	* otherwise skip it) and writes the checkpoint via
+	* `rewindLiveProgress` (unconditional — a rewind's whole point is
+	* moving the cursor *backward*, which the live path's conditional
+	* advance would refuse). Safe only because the reorg path holds a
+	* transaction-scoped advisory lock across its whole
+	* delete+reprocess+rewind sequence, so nothing else can interleave a
+	* forward write. Never set this outside `reorg.ts`.
+	*/
+	reorgRewind?: true;
 }
 /** Default per-block retry schedule before a failure counts as persistent. */
 declare const BLOCK_RETRY_DELAYS_MS: number[];

package/dist/src/runtime/block-processor.js

@@ -1627,9 +1627,11 @@ import { resolveTraitContractIds } from "@secondlayer/shared/db/queries/contract
 import { advanceOperationCursor } from "@secondlayer/shared/db/queries/subgraph-operations";
 import {
   isByoSubgraph,
+  recordLiveError,
   recordLiveProgress,
   recordSubgraphProcessed,
   resolveSubgraphDb,
+  rewindLiveProgress,
   updateSubgraphStatus
 } from "@secondlayer/shared/db/queries/subgraphs";
 import { logger as logger6 } from "@secondlayer/shared/logger";
@@ -2337,10 +2339,20 @@ class CursorRaceLostError extends Error {
     this.name = "CursorRaceLostError";
   }
 }
+
+class LiveCursorRaceLostError extends Error {
+  constructor(subgraphName, height) {
+    super(`live cursor race lost for ${subgraphName} at block ${height}`);
+    this.name = "LiveCursorRaceLostError";
+  }
+}
 function opCursorMode(opts) {
   const ap = opts?.atomicProgress;
   return ap && "operationId" in ap ? ap : undefined;
 }
+function isReorgRewind(opts) {
+  return opts?.reorgRewind === true;
+}
 function statusMode(opts) {
   const ap = opts?.atomicProgress;
   return ap && "status" in ap ? ap : undefined;
@@ -2410,7 +2422,11 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
   result.matched = matched.length;
   if (matched.length === 0) {
     if (!opts?.skipProgressUpdate) {
-      await recordLiveProgress(targetDb, subgraphName, blockHeight);
+      if (isReorgRewind(opts)) {
+        await rewindLiveProgress(targetDb, subgraphName, blockHeight);
+      } else {
+        await recordLiveProgress(targetDb, subgraphName, blockHeight);
+      }
     }
     return result;
   }
@@ -2429,13 +2445,23 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
   };
   let handlerMs = 0;
   let flushMs = 0;
-  const applyProgress = async (tx, rr) => {
+  const applyProgress = async (tx, rr, flushedWrites) => {
     if (opts?.skipProgressUpdate)
       return;
+    const rewind = isReorgRewind(opts);
     if (rr.errors > 0 && rr.processed === 0) {
-      await updateSubgraphStatus(tx, subgraphName, "error", blockHeight);
+      if (rewind) {
+        await updateSubgraphStatus(tx, subgraphName, "error", blockHeight);
+      } else {
+        await recordLiveError(tx, subgraphName, blockHeight);
+      }
+    } else if (rewind) {
+      await rewindLiveProgress(tx, subgraphName, blockHeight);
     } else {
-      await recordLiveProgress(tx, subgraphName, blockHeight);
+      const advanced = await recordLiveProgress(tx, subgraphName, blockHeight);
+      if (!advanced && flushedWrites && !route.byo) {
+        throw new LiveCursorRaceLostError(subgraphName, blockHeight);
+      }
     }
     if (rr.processed > 0 || rr.errors > 0) {
       const lastError = rr.errors > 0 ? `${rr.errors} error(s) at block ${blockHeight}` : undefined;
@@ -2484,13 +2510,15 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
       } else if (byoOm && manifest && manifest.count > 0) {
         await advanceOperationCursor(tx, byoOm.operationId, blockHeight);
       }
-      await applyProgress(tx, runResult);
+      await applyProgress(tx, runResult, manifest ? manifest.count > 0 : false);
     });
   } else {
     try {
       await targetDb.transaction().execute(async (tx) => {
         const opMode = opCursorMode(opts);
-        if (statusMode(opts)) {
+        const sm = statusMode(opts);
+        const rewind = isReorgRewind(opts);
+        if (sm) {
           const row = await tx.selectFrom("subgraphs").select("last_processed_block").where("name", "=", subgraphName).executeTakeFirst();
           if (row && Number(row.last_processed_block) >= blockHeight) {
             result.skipped = true;
@@ -2502,6 +2530,12 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
             result.skipped = true;
             return;
           }
+        } else if (!rewind) {
+          const row = await tx.selectFrom("subgraphs").select("last_processed_block").where("name", "=", subgraphName).executeTakeFirst();
+          if (row && Number(row.last_processed_block) >= blockHeight) {
+            result.skipped = true;
+            return;
+          }
         }
         const ctx = new SubgraphContext(tx, schemaName, subgraph.schema, blockMeta, initialTx, false, journalEnabled(opts));
         const handlerStart = performance.now();
@@ -2519,7 +2553,6 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
           }
           flushMs = performance.now() - flushStart;
         }
-        const sm = statusMode(opts);
         if (sm && flushedWrites) {
           await updateSubgraphStatus(tx, subgraphName, sm.status, blockHeight);
         } else if (opMode && flushedWrites) {
@@ -2528,10 +2561,10 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
             throw new CursorRaceLostError(opMode.operationId, blockHeight);
           }
         }
-        await applyProgress(tx, runResult);
+        await applyProgress(tx, runResult, flushedWrites);
       });
     } catch (err) {
-      if (err instanceof CursorRaceLostError) {
+      if (err instanceof CursorRaceLostError || err instanceof LiveCursorRaceLostError) {
         logger6.warn("cursor race lost — block already covered", {
           subgraph: subgraphName,
           blockHeight,
@@ -2544,11 +2577,13 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
     }
   }
   const totalMs = performance.now() - blockStart;
-  result.timing = {
-    totalMs: Math.round(totalMs),
-    handlerMs: Math.round(handlerMs),
-    flushMs: Math.round(flushMs)
-  };
+  if (!result.skipped) {
+    result.timing = {
+      totalMs: Math.round(totalMs),
+      handlerMs: Math.round(handlerMs),
+      flushMs: Math.round(flushMs)
+    };
+  }
   if (blockHeight % 1000 === 0) {
     try {
       const tables = Object.keys(subgraph.schema);
@@ -2583,5 +2618,5 @@ export {
   BLOCK_RETRY_DELAYS_MS
 };
 
-//# debugId=ED4E61C22DF18FC964756E2164756E21
+//# debugId=0C53CE27E78CBEED64756E2164756E21
 //# sourceMappingURL=block-processor.js.map