@secondlayer/subgraphs 4.1.1 → 4.1.3

package/dist/src/runtime/processor.js

@@ -2075,6 +2075,8 @@ function indexEventTypesForFilterTypes(filterTypes) {
   return [...types];
 }
 function referencedIndexEventTypes(subgraph) {
+  if (!subgraph.sources)
+    return [];
   return indexEventTypesForFilterTypes(sourceFilters(subgraph).map((f) => f.type));
 }
 function isStreamsIndexEligible(subgraph) {
@@ -3192,6 +3194,66 @@ function startCatchUpLeader(opts = {}) {
   });
 }
 
+// src/runtime/decoder-bound.ts
+import { decodeStreamsCursor, isEmptyRangeCursor } from "@secondlayer/shared";
+import { getSourceDb as getSourceDb3 } from "@secondlayer/shared/db";
+function decoderNameForEventType(indexEventType) {
+  return `decode.${indexEventType}.v1`;
+}
+function decoderNamesForIndexEventTypes(eventTypes) {
+  return eventTypes.map(decoderNameForEventType);
+}
+function decoderNamesForSubgraph(subgraph) {
+  return decoderNamesForIndexEventTypes(referencedIndexEventTypes(subgraph));
+}
+function usesDecodedIndexPlane(subgraph) {
+  return process.env.SUBGRAPH_SOURCE === "streams-index" && isStreamsIndexEligible(subgraph);
+}
+function committedHeight(cursor) {
+  if (!cursor)
+    return null;
+  try {
+    const decoded = decodeStreamsCursor(cursor);
+    if (isEmptyRangeCursor(decoded))
+      return decoded.block_height;
+    return Math.max(0, decoded.block_height - 1);
+  } catch {
+    return null;
+  }
+}
+async function decoderBoundTip(decoderNames, opts) {
+  if (decoderNames.length === 0)
+    return { kind: "unbounded" };
+  const sourceDb = opts?.sourceDb ?? getSourceDb3();
+  const rows = await sourceDb.selectFrom("decoder_checkpoints").select(["decoder_name", "last_cursor"]).where("decoder_name", "in", decoderNames).execute();
+  const byName = new Map(rows.map((r) => [r.decoder_name, r.last_cursor]));
+  const missing = [];
+  const heights = [];
+  for (const name of decoderNames) {
+    const height = committedHeight(byName.get(name));
+    if (height === null)
+      missing.push(name);
+    else
+      heights.push(height);
+  }
+  if (missing.length > 0)
+    return { kind: "stall", missing };
+  return { kind: "height", height: Math.min(...heights) };
+}
+async function boundSourceTip(rawTip, decoderNames, opts) {
+  const bound = await decoderBoundTip(decoderNames, opts);
+  if (bound.kind === "stall")
+    return { ok: false, missing: bound.missing };
+  if (bound.kind === "unbounded") {
+    return { ok: true, tip: rawTip, floor: null };
+  }
+  return {
+    ok: true,
+    tip: Math.min(rawTip, bound.height),
+    floor: bound.height
+  };
+}
+
 // src/runtime/catchup.ts
 var LOG_INTERVAL = 1000;
 var STANDARD_CATCHUP_BATCH_CONFIG = {
@@ -3302,7 +3364,31 @@ async function catchUpSubgraph(subgraph, subgraphName) {
     if (!subgraphRow)
       return 0;
     const lastProcessedBlock = Number(subgraphRow.last_processed_block);
-    const chainTip = await source.getTip();
+    const rawTip = await source.getTip();
+    if (rawTip <= 0)
+      return 0;
+    let chainTip = rawTip;
+    if (usesDecodedIndexPlane(subgraph)) {
+      const bound = await boundSourceTip(rawTip, decoderNamesForSubgraph(subgraph));
+      if (!bound.ok) {
+        logger8.warn("Subgraph catch-up stalled: missing decoder checkpoint", {
+          event: "subgraph_catchup_decoder_stall",
+          subgraph: subgraphName,
+          missing: bound.missing
+        });
+        return 0;
+      }
+      if (bound.floor !== null && bound.floor < rawTip) {
+        logger8.debug("Subgraph catch-up tip bounded by decoder progress", {
+          event: "subgraph_catchup_decoder_floor",
+          subgraph: subgraphName,
+          rawTip,
+          floor: bound.floor,
+          tip: bound.tip
+        });
+      }
+      chainTip = bound.tip;
+    }
     if (chainTip <= 0 || lastProcessedBlock >= chainTip)
       return 0;
     const subgraphStart = Number(subgraphRow.start_block) || 1;
@@ -3765,7 +3851,29 @@ async function processBlockRange(def, opts) {
 async function resolveBlockRange(source, def, opts) {
   const definitionStart = def.startBlock ?? 1;
   const fromBlock = opts?.startBlockFloor != null ? Math.max(definitionStart, opts.startBlockFloor) : definitionStart;
-  return { fromBlock, toBlock: await source.getTip() };
+  const rawTip = await source.getTip();
+  if (!usesDecodedIndexPlane(def)) {
+    return { fromBlock, toBlock: rawTip };
+  }
+  const bound = await boundSourceTip(rawTip, decoderNamesForSubgraph(def));
+  if (!bound.ok) {
+    logger10.warn("Reindex stalled: missing decoder checkpoint", {
+      event: "subgraph_reindex_decoder_stall",
+      subgraph: def.name,
+      missing: bound.missing
+    });
+    throw new Error(`Reindex stalled: missing decoder checkpoint (${bound.missing.join(", ")})`);
+  }
+  if (bound.floor !== null && bound.floor < rawTip) {
+    logger10.debug("Reindex tip bounded by decoder progress", {
+      event: "subgraph_reindex_decoder_floor",
+      subgraph: def.name,
+      rawTip,
+      floor: bound.floor,
+      tip: bound.tip
+    });
+  }
+  return { fromBlock, toBlock: bound.tip };
 }
 async function clearReindexMetadata(db, subgraphName) {
   await db.updateTable("subgraphs").set({ reindex_from_block: null, reindex_to_block: null }).where("name", "=", subgraphName).execute();
@@ -4555,5 +4663,5 @@ export {
   startSubgraphOperationRunner
 };
 
-//# debugId=DC53F813C2D7B5F564756E2164756E21
+//# debugId=0FA31971C86CC61564756E2164756E21
 //# sourceMappingURL=processor.js.map