@secondlayer/subgraphs 3.13.0 → 3.14.0

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

@@ -250,23 +250,28 @@ interface ProcessBlockOptions {
 	/** Pre-loaded block data — skips DB reads when provided (used by batch catch-up). */
 	preloaded?: PreloadedBlockData;
 	/**
-	* Crash-safe sequential processing (the reindex path). When set:
-	* - a block whose writes flush commits `last_processed_block = blockHeight`
-	*   (with this status) in the SAME transaction, so a crash can never leave
-	*   committed writes ahead of the checkpoint;
-	* - a block at or below the checkpoint is skipped entirely, so a replay
-	*   (crash-resume overshoot, duplicate dispatch) can never double-apply
-	*   deltas.
-	* Only valid for strictly ascending block walks over the subgraph's own
-	* cursor — backfill/reorg paths that legitimately revisit heights below
-	* the cursor must not set this.
+	* Crash-safe sequential processing. Two checkpoint scopes:
+	* - `{ status }` (reindex): a written block commits
+	*   `subgraphs.last_processed_block = blockHeight` in the SAME transaction
+	*   as its writes; replays skip at/below the cursor. Only for strictly
+	*   ascending walks over the subgraph's own cursor.
+	* - `{ operationId }` (backfill): same guarantee against the OPERATION's
+	*   own `cursor_block` — backfills legitimately revisit heights below the
+	*   live cursor, so they must never checkpoint (or read) the subgraph
+	*   cursor. The advance is a CONDITIONAL monotonic UPDATE: concurrent
+	*   writers serialize on it, and the loser's whole block tx rolls back
+	*   (surfaced as `skipped`, never an error/gap).
+	* Either way: a crash can never leave committed deltas ahead of the
+	* relevant checkpoint.
 	*/
 	atomicProgress?: {
 		status: string
+	} | {
+		operationId: string
 	};
 }
 /** Default per-block retry schedule before a failure counts as persistent. */
-declare const BLOCK_RETRY_DELAYS_MS: unknown;
+declare const BLOCK_RETRY_DELAYS_MS: number[];
 /**
 * processBlock with bounded retries. Throws the last error once the schedule
 * is exhausted — callers decide whether that halts the walk (strict paths) or

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

@@ -1332,6 +1332,7 @@ function matchSources(sources, transactions, events, traitContracts = new Map) {
 // src/runtime/block-processor.ts
 import { getTargetDb } from "@secondlayer/shared/db";
 import { resolveTraitContractIds } from "@secondlayer/shared/db/queries/contracts";
+import { advanceOperationCursor } from "@secondlayer/shared/db/queries/subgraph-operations";
 import {
   isByoSubgraph,
   recordSubgraphProcessed,
@@ -1951,6 +1952,21 @@ async function resolveTraitContracts(subgraph, blockHeight, db) {
   }
   return resolved;
 }
+
+class CursorRaceLostError extends Error {
+  constructor(operationId, height) {
+    super(`op ${operationId} lost cursor race at block ${height}`);
+    this.name = "CursorRaceLostError";
+  }
+}
+function opCursorMode(opts) {
+  const ap = opts?.atomicProgress;
+  return ap && "operationId" in ap ? ap : undefined;
+}
+function statusMode(opts) {
+  const ap = opts?.atomicProgress;
+  return ap && "status" in ap ? ap : undefined;
+}
 var BLOCK_RETRY_DELAYS_MS = [500, 2000, 5000];
 function journalEnabled(opts) {
   return !opts?.skipProgressUpdate;
@@ -2044,12 +2060,19 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
     }
   };
   if (route.byo) {
-    if (opts?.atomicProgress) {
+    if (statusMode(opts)) {
       const row = await targetDb.selectFrom("subgraphs").select("last_processed_block").where("name", "=", subgraphName).executeTakeFirst();
       if (row && Number(row.last_processed_block) >= blockHeight) {
         result.skipped = true;
         return result;
       }
+    } else if (opCursorMode(opts)) {
+      const om = opCursorMode(opts);
+      const row = await targetDb.selectFrom("subgraph_operations").select("cursor_block").where("id", "=", om.operationId).executeTakeFirst();
+      if (row?.cursor_block != null && Number(row.cursor_block) >= blockHeight) {
+        result.skipped = true;
+        return result;
+      }
     }
     let runResult = { processed: 0, errors: 0 };
     let manifest;
@@ -2070,41 +2093,71 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
       if (manifest && manifest.count > 0) {
         await emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block.height);
       }
-      if (opts?.atomicProgress && manifest && manifest.count > 0) {
-        await updateSubgraphStatus(tx, subgraphName, opts.atomicProgress.status, blockHeight);
+      const byoSm = statusMode(opts);
+      const byoOm = opCursorMode(opts);
+      if (byoSm && manifest && manifest.count > 0) {
+        await updateSubgraphStatus(tx, subgraphName, byoSm.status, blockHeight);
+      } else if (byoOm && manifest && manifest.count > 0) {
+        await advanceOperationCursor(tx, byoOm.operationId, blockHeight);
       }
       await applyProgress(tx, runResult);
     });
   } else {
-    await targetDb.transaction().execute(async (tx) => {
-      if (opts?.atomicProgress) {
-        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;
+    try {
+      await targetDb.transaction().execute(async (tx) => {
+        const opMode = opCursorMode(opts);
+        if (statusMode(opts)) {
+          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;
+          }
+        } else if (opMode) {
+          const row = await tx.selectFrom("subgraph_operations").select("cursor_block").where("id", "=", opMode.operationId).executeTakeFirst();
+          if (row?.cursor_block != null && Number(row.cursor_block) >= blockHeight) {
+            result.skipped = true;
+            return;
+          }
         }
-      }
-      const ctx = new SubgraphContext(tx, schemaName, subgraph.schema, blockMeta, initialTx, false, journalEnabled(opts));
-      const handlerStart = performance.now();
-      const runResult = await runHandlers(subgraph, matched, ctx);
-      handlerMs = performance.now() - handlerStart;
-      result.processed = runResult.processed;
-      result.errors = runResult.errors;
-      let flushedWrites = false;
-      if (ctx.pendingOps > 0) {
-        const flushStart = performance.now();
-        const manifest = await ctx.flush();
-        flushedWrites = manifest.count > 0;
-        if (manifest.count > 0) {
-          await emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block.height);
+        const ctx = new SubgraphContext(tx, schemaName, subgraph.schema, blockMeta, initialTx, false, journalEnabled(opts));
+        const handlerStart = performance.now();
+        const runResult = await runHandlers(subgraph, matched, ctx);
+        handlerMs = performance.now() - handlerStart;
+        result.processed = runResult.processed;
+        result.errors = runResult.errors;
+        let flushedWrites = false;
+        if (ctx.pendingOps > 0) {
+          const flushStart = performance.now();
+          const manifest = await ctx.flush();
+          flushedWrites = manifest.count > 0;
+          if (manifest.count > 0) {
+            await emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block.height);
+          }
+          flushMs = performance.now() - flushStart;
         }
-        flushMs = performance.now() - flushStart;
-      }
-      if (opts?.atomicProgress && flushedWrites) {
-        await updateSubgraphStatus(tx, subgraphName, opts.atomicProgress.status, blockHeight);
+        const sm = statusMode(opts);
+        if (sm && flushedWrites) {
+          await updateSubgraphStatus(tx, subgraphName, sm.status, blockHeight);
+        } else if (opMode && flushedWrites) {
+          const advanced = await advanceOperationCursor(tx, opMode.operationId, blockHeight);
+          if (!advanced) {
+            throw new CursorRaceLostError(opMode.operationId, blockHeight);
+          }
+        }
+        await applyProgress(tx, runResult);
+      });
+    } catch (err) {
+      if (err instanceof CursorRaceLostError) {
+        logger5.warn("cursor race lost — block already covered", {
+          subgraph: subgraphName,
+          blockHeight,
+          error: err.message
+        });
+        result.skipped = true;
+        return result;
       }
-      await applyProgress(tx, runResult);
-    });
+      throw err;
+    }
   }
   const totalMs = performance.now() - blockStart;
   result.timing = {
@@ -2145,5 +2198,5 @@ export {
   BLOCK_RETRY_DELAYS_MS
 };
 
-//# debugId=4E6EBDA2299DFCFC64756E2164756E21
+//# debugId=85BBF80E16AD899B64756E2164756E21
 //# sourceMappingURL=block-processor.js.map