@secondlayer/subgraphs 3.26.1 → 3.26.3

package/dist/src/runtime/reindex.js

@@ -16,6 +16,13 @@ function quotePgIdent(name) {
     return name;
   return `"${name.replace(/"/g, '""')}"`;
 }
+function snakeToCamel(name) {
+  return name.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function pascalCase(name) {
+  const camel = snakeToCamel(name);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
 
 // src/schema/generator.ts
 var TYPE_MAP = {
@@ -3044,9 +3051,278 @@ class StatsAccumulator {
   }
 }
 
+// src/runtime/catchup.ts
+import { getTargetDb as getTargetDb2, sql as sql4 } from "@secondlayer/shared/db";
+import { getSubgraph } from "@secondlayer/shared/db/queries/subgraphs";
+import { logger as logger8 } from "@secondlayer/shared/logger";
+
+// src/runtime/catchup-leader.ts
+import {
+  SUBGRAPH_CATCHUP_LOCK_KEY,
+  createPostgresLeaderBackend,
+  withLeaderLock
+} from "@secondlayer/shared/leader";
+import { targetListenerUrl } from "@secondlayer/shared/queue/listener";
+var catchUpLeader = false;
+function isCatchUpLeader() {
+  return catchUpLeader;
+}
+function startCatchUpLeader(opts = {}) {
+  return withLeaderLock(SUBGRAPH_CATCHUP_LOCK_KEY, async () => {
+    catchUpLeader = true;
+    await opts.onAcquire?.();
+    return () => {
+      catchUpLeader = false;
+    };
+  }, {
+    pollMs: opts.pollMs,
+    heartbeatMs: opts.heartbeatMs,
+    createBackend: opts.createBackend ?? (() => createPostgresLeaderBackend(targetListenerUrl()))
+  });
+}
+
+// src/runtime/catchup.ts
+var LOG_INTERVAL = 1000;
+var STANDARD_CATCHUP_BATCH_CONFIG = {
+  defaultBatchSize: 500,
+  minBatchSize: 100,
+  maxBatchSize: 1000,
+  prefetch: true
+};
+var catchingUp = new Set;
+var subgraphBlockLockHeld = new Set;
+var subgraphBlockLockWaiters = new Map;
+var reorgEpoch = new Map;
+async function acquireSubgraphBlockLock(name) {
+  if (!subgraphBlockLockHeld.has(name)) {
+    subgraphBlockLockHeld.add(name);
+    return () => releaseSubgraphBlockLock(name);
+  }
+  return new Promise((resolve) => {
+    const waiters = subgraphBlockLockWaiters.get(name) ?? [];
+    waiters.push(() => resolve(() => releaseSubgraphBlockLock(name)));
+    subgraphBlockLockWaiters.set(name, waiters);
+  });
+}
+function releaseSubgraphBlockLock(name) {
+  const waiters = subgraphBlockLockWaiters.get(name);
+  if (waiters && waiters.length > 0) {
+    const next = waiters.shift();
+    if (waiters.length === 0)
+      subgraphBlockLockWaiters.delete(name);
+    next();
+    return;
+  }
+  subgraphBlockLockHeld.delete(name);
+}
+async function withSubgraphBlockLock(name, fn) {
+  const release = await acquireSubgraphBlockLock(name);
+  try {
+    return await fn();
+  } finally {
+    release();
+  }
+}
+async function withSubgraphBlockAdvisoryLock(name, fn) {
+  return getTargetDb2().transaction().execute(async (lockTx) => {
+    await sql4`SELECT pg_advisory_xact_lock(hashtext(${`subgraph-block:${name}`}))`.execute(lockTx);
+    return fn();
+  });
+}
+async function withSubgraphBlockWriteLock(name, fn) {
+  return withSubgraphBlockLock(name, () => withSubgraphBlockAdvisoryLock(name, fn));
+}
+function bumpReorgEpoch(name) {
+  reorgEpoch.set(name, (reorgEpoch.get(name) ?? 0) + 1);
+}
+function getReorgEpoch(name) {
+  return reorgEpoch.get(name) ?? 0;
+}
+
+class ReorgEpochChangedError extends Error {
+  constructor(name) {
+    super(`reorg epoch changed for ${name} mid catch-up`);
+    this.name = "ReorgEpochChangedError";
+  }
+}
+function parsePositiveInt(value) {
+  if (value == null || value.trim() === "")
+    return;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+function parseBoolean(value) {
+  if (value == null || value.trim() === "")
+    return;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true")
+    return true;
+  if (normalized === "false")
+    return false;
+  return;
+}
+function resolveCatchupBatchConfig(env = process.env) {
+  const base = STANDARD_CATCHUP_BATCH_CONFIG;
+  const minBatchSize = parsePositiveInt(env.SUBGRAPH_CATCHUP_MIN_BATCH_SIZE) ?? base.minBatchSize;
+  const maxBatchSize = parsePositiveInt(env.SUBGRAPH_CATCHUP_MAX_BATCH_SIZE) ?? base.maxBatchSize;
+  const defaultBatchSize = parsePositiveInt(env.SUBGRAPH_CATCHUP_BATCH_SIZE) ?? base.defaultBatchSize;
+  return {
+    minBatchSize,
+    maxBatchSize,
+    defaultBatchSize: Math.min(Math.max(defaultBatchSize, minBatchSize), maxBatchSize),
+    prefetch: parseBoolean(env.SUBGRAPH_CATCHUP_PREFETCH) ?? base.prefetch
+  };
+}
+function adjustBatchSize(current, avgEvents, config) {
+  if (avgEvents > 50)
+    return Math.max(Math.round(current * 0.5), config.minBatchSize);
+  if (avgEvents < 10)
+    return Math.min(Math.round(current * 1.5), config.maxBatchSize);
+  return current;
+}
+async function catchUpSubgraph(subgraph, subgraphName) {
+  if (catchingUp.has(subgraphName))
+    return 0;
+  catchingUp.add(subgraphName);
+  try {
+    const source = resolveBlockSource(subgraph);
+    const targetDb = getTargetDb2();
+    const subgraphRow = await getSubgraph(targetDb, subgraphName);
+    if (!subgraphRow)
+      return 0;
+    const lastProcessedBlock = Number(subgraphRow.last_processed_block);
+    const chainTip = await source.getTip();
+    if (chainTip <= 0 || lastProcessedBlock >= chainTip)
+      return 0;
+    const subgraphStart = Number(subgraphRow.start_block) || 1;
+    const startBlock = Math.max(lastProcessedBlock + 1, subgraphStart);
+    const totalBlocks = chainTip - lastProcessedBlock;
+    logger8.info("Subgraph catch-up starting", {
+      subgraph: subgraphName,
+      from: startBlock,
+      to: chainTip,
+      blocks: totalBlocks
+    });
+    const stats = new StatsAccumulator(subgraphName, true);
+    let processed = 0;
+    const batchConfig = resolveCatchupBatchConfig();
+    let batchSize = batchConfig.defaultBatchSize;
+    let currentHeight = startBlock;
+    const walkEpoch = getReorgEpoch(subgraphName);
+    let prefetchedBatchEnd = Math.min(currentHeight + batchSize - 1, chainTip);
+    let nextBatchPromise = batchConfig.prefetch ? source.loadBlockRange(currentHeight, prefetchedBatchEnd) : undefined;
+    while (currentHeight <= chainTip) {
+      if (!isCatchUpLeader()) {
+        logger8.info("Lost catch-up leadership, stopping catch-up", {
+          subgraph: subgraphName,
+          processed
+        });
+        break;
+      }
+      const currentRow = await getSubgraph(targetDb, subgraphName);
+      if (!currentRow || currentRow.status !== "active") {
+        logger8.info("Subgraph status changed, stopping catch-up", {
+          subgraph: subgraphName,
+          status: currentRow?.status ?? "deleted"
+        });
+        break;
+      }
+      let batchEnd;
+      let batch;
+      if (nextBatchPromise) {
+        batch = await nextBatchPromise;
+        batchEnd = prefetchedBatchEnd;
+        const nextStart = batchEnd + 1;
+        if (nextStart <= chainTip) {
+          prefetchedBatchEnd = Math.min(nextStart + batchSize - 1, chainTip);
+          nextBatchPromise = source.loadBlockRange(nextStart, prefetchedBatchEnd);
+        } else {
+          nextBatchPromise = undefined;
+        }
+      } else {
+        batchEnd = Math.min(currentHeight + batchSize - 1, chainTip);
+        batch = await source.loadBlockRange(currentHeight, batchEnd);
+      }
+      let stopCatchup = false;
+      for (let height = currentHeight;height <= batchEnd; height++) {
+        let blockData = batch.get(height);
+        if (!blockData) {
+          blockData = (await source.loadBlockRange(height, height)).get(height);
+        }
+        if (!blockData) {
+          logger8.warn("Block missing during catch-up, deferring to next tick", {
+            subgraph: subgraphName,
+            blockHeight: height
+          });
+          stopCatchup = true;
+          break;
+        }
+        const preloaded = blockData;
+        let result;
+        try {
+          result = await withSubgraphBlockWriteLock(subgraphName, async () => {
+            if (getReorgEpoch(subgraphName) !== walkEpoch) {
+              throw new ReorgEpochChangedError(subgraphName);
+            }
+            return processBlockWithRetry(subgraph, subgraphName, height, {
+              preloaded
+            });
+          });
+        } catch (err) {
+          if (err instanceof ReorgEpochChangedError) {
+            logger8.info("Reorg detected mid catch-up, aborting walk without writing further progress", { subgraph: subgraphName, blockHeight: height });
+            stopCatchup = true;
+            break;
+          }
+          const errorMsg = err instanceof Error ? err.message : String(err);
+          logger8.error("Block processing failed persistently during catch-up", {
+            subgraph: subgraphName,
+            blockHeight: height,
+            error: errorMsg
+          });
+          const { updateSubgraphStatus: updateSubgraphStatus2, recordSubgraphProcessed: recordSubgraphProcessed2 } = await import("@secondlayer/shared/db/queries/subgraphs");
+          await recordSubgraphProcessed2(targetDb, subgraphName, 0, 1, `catch-up halted at block ${height}: ${errorMsg}`).catch(() => {});
+          await updateSubgraphStatus2(targetDb, subgraphName, "error").catch(() => {});
+          stopCatchup = true;
+          break;
+        }
+        processed++;
+        if (result.timing) {
+          stats.record(result.timing, result.processed);
+          if (stats.shouldFlush()) {
+            await stats.flush(targetDb);
+          }
+        }
+        if (processed % LOG_INTERVAL === 0) {
+          logger8.info("Subgraph catch-up progress", {
+            subgraph: subgraphName,
+            processed,
+            total: totalBlocks,
+            currentBlock: height,
+            pct: Math.round(processed / totalBlocks * 100)
+          });
+        }
+      }
+      if (stopCatchup)
+        break;
+      const avg = avgEventsPerBlock(batch);
+      batchSize = adjustBatchSize(batchSize, avg, batchConfig);
+      currentHeight = batchEnd + 1;
+    }
+    await stats.flush(targetDb);
+    logger8.info("Subgraph catch-up complete", {
+      subgraph: subgraphName,
+      processed
+    });
+    return processed;
+  } finally {
+    catchingUp.delete(subgraphName);
+  }
+}
+
 // src/runtime/reindex.ts
 import { getErrorMessage as getErrorMessage3 } from "@secondlayer/shared";
-import { getRawClient, getTargetDb as getTargetDb2 } from "@secondlayer/shared/db";
+import { getRawClient, getTargetDb as getTargetDb3 } from "@secondlayer/shared/db";
 import {
   recordGapBatch,
   resolveGaps
@@ -3059,11 +3335,11 @@ import {
   recordSubgraphProcessed as recordSubgraphProcessed2,
   updateSubgraphStatus as updateSubgraphStatus2
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger9 } from "@secondlayer/shared/logger";
+import { logger as logger10 } from "@secondlayer/shared/logger";
 
 // src/runtime/reindex-notify.ts
 import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
-import { logger as logger8 } from "@secondlayer/shared/logger";
+import { logger as logger9 } from "@secondlayer/shared/logger";
 async function notifyReindexComplete(db, subgraphName, stats) {
   try {
     const subgraph = await db.selectFrom("subgraphs").select(["account_id"]).where("name", "=", subgraphName).executeTakeFirst();
@@ -3074,7 +3350,7 @@ async function notifyReindexComplete(db, subgraphName, stats) {
       return;
     const resendKey = process.env.RESEND_API_KEY;
     if (!resendKey) {
-      logger8.warn("RESEND_API_KEY unset — skipping reindex-complete email", {
+      logger9.warn("RESEND_API_KEY unset — skipping reindex-complete email", {
         subgraph: subgraphName
       });
       return;
@@ -3096,14 +3372,14 @@ async function notifyReindexComplete(db, subgraphName, stats) {
     });
     if (!res.ok) {
       const text = await res.text().catch(() => "");
-      logger8.warn("reindex-complete email failed", {
+      logger9.warn("reindex-complete email failed", {
         subgraph: subgraphName,
         status: res.status,
         body: text.slice(0, 200)
       });
     }
   } catch (err) {
-    logger8.warn("reindex-complete email threw", {
+    logger9.warn("reindex-complete email threw", {
       subgraph: subgraphName,
       error: getErrorMessage2(err)
     });
@@ -3111,7 +3387,7 @@ async function notifyReindexComplete(db, subgraphName, stats) {
 }
 
 // src/runtime/reindex.ts
-var LOG_INTERVAL = 1000;
+var LOG_INTERVAL2 = 1000;
 var HEALTH_FLUSH_INTERVAL = 1000;
 var PROGRESS_FLUSH_INTERVAL_MS = 5000;
 var EMPTY_BATCH_HALT_THRESHOLD = 3;
@@ -3131,7 +3407,7 @@ function resolveReindexResumeBlock(row) {
   const reindexFromBlock = Number(row.reindex_from_block);
   return Math.max(lastProcessedBlock + 1, reindexFromBlock);
 }
-function parsePositiveInt(value) {
+function parsePositiveInt2(value) {
   if (value == null || value.trim() === "")
     return;
   const parsed = Number.parseInt(value, 10);
@@ -3139,9 +3415,9 @@ function parsePositiveInt(value) {
 }
 function resolveReindexBatchConfig(env = process.env) {
   const base = STANDARD_REINDEX_BATCH_CONFIG;
-  const minBatchSize = parsePositiveInt(env.SUBGRAPH_REINDEX_MIN_BATCH_SIZE) ?? base.minBatchSize;
-  const maxBatchSize = parsePositiveInt(env.SUBGRAPH_REINDEX_MAX_BATCH_SIZE) ?? base.maxBatchSize;
-  const defaultBatchSize = parsePositiveInt(env.SUBGRAPH_REINDEX_BATCH_SIZE) ?? base.defaultBatchSize;
+  const minBatchSize = parsePositiveInt2(env.SUBGRAPH_REINDEX_MIN_BATCH_SIZE) ?? base.minBatchSize;
+  const maxBatchSize = parsePositiveInt2(env.SUBGRAPH_REINDEX_MAX_BATCH_SIZE) ?? base.maxBatchSize;
+  const defaultBatchSize = parsePositiveInt2(env.SUBGRAPH_REINDEX_BATCH_SIZE) ?? base.defaultBatchSize;
   return {
     minBatchSize,
     maxBatchSize,
@@ -3172,7 +3448,7 @@ function coalesceFailedBlocks(blocks) {
 }
 async function processBlockRange(def, opts) {
   const source = resolveBlockSource(def);
-  const targetDb = getTargetDb2();
+  const targetDb = getTargetDb3();
   const subgraphName = def.name;
   const { fromBlock, toBlock, status } = opts;
   const totalBlocks = toBlock - fromBlock + 1;
@@ -3215,7 +3491,7 @@ async function processBlockRange(def, opts) {
   while (currentHeight <= toBlock) {
     if (opts.signal?.aborted) {
       aborted = true;
-      logger9.info("Block processing aborted", {
+      logger10.info("Block processing aborted", {
         subgraph: subgraphName,
         currentBlock: currentHeight,
         reason: String(opts.signal.reason ?? "unknown")
@@ -3257,14 +3533,16 @@ async function processBlockRange(def, opts) {
       }
       let result;
       try {
-        result = await processBlockWithRetry(def, subgraphName, height, {
+        const mayWrite = blockData.txs.length > 0 || blockData.events.length > 0;
+        const runBlock = () => processBlockWithRetry(def, subgraphName, height, {
           skipProgressUpdate: true,
           atomicProgress,
           preloaded: blockData
         });
+        result = mayWrite ? await withSubgraphBlockWriteLock(subgraphName, runBlock) : await runBlock();
       } catch (err) {
         const errorMsg = getErrorMessage3(err);
-        logger9.error("Block processing failed persistently", {
+        logger10.error("Block processing failed persistently", {
           subgraph: subgraphName,
           blockHeight: height,
           error: errorMsg
@@ -3309,8 +3587,8 @@ async function processBlockRange(def, opts) {
         }
         lastProgressFlushAt = now;
       }
-      if (blocksProcessed % LOG_INTERVAL === 0) {
-        logger9.info(`${status === "reindexing" ? "Reindex" : "Backfill"} progress`, {
+      if (blocksProcessed % LOG_INTERVAL2 === 0) {
+        logger10.info(`${status === "reindexing" ? "Reindex" : "Backfill"} progress`, {
           subgraph: subgraphName,
           processed: blocksProcessed,
           total: totalBlocks,
@@ -3330,7 +3608,7 @@ async function processBlockRange(def, opts) {
     if (batchFailedBlocks.length > 0 && opts.subgraphId) {
       const gaps = coalesceFailedBlocks(batchFailedBlocks);
       await recordGapBatch(targetDb, opts.subgraphId, subgraphName, gaps).catch((err) => {
-        logger9.warn("Failed to record subgraph gaps", {
+        logger10.warn("Failed to record subgraph gaps", {
           subgraph: subgraphName,
           error: err instanceof Error ? err.message : String(err)
         });
@@ -3347,7 +3625,7 @@ async function processBlockRange(def, opts) {
         } else {
           await updateSubgraphStatus2(targetDb, subgraphName, status, jumpTo - 1);
         }
-        logger9.info("Sparse skip", {
+        logger10.info("Sparse skip", {
           subgraph: subgraphName,
           from: batchEnd + 1,
           to: jumpTo - 1,
@@ -3382,16 +3660,16 @@ async function clearReindexMetadata(db, subgraphName) {
 }
 async function reindexSubgraph(def, opts) {
   const source = resolveBlockSource(def);
-  const targetDb = getTargetDb2();
+  const targetDb = getTargetDb3();
   const client = getRawClient("target");
   const subgraphName = def.name;
   const schemaName = opts?.schemaName ?? pgSchemaName(subgraphName);
   await updateSubgraphStatus2(targetDb, subgraphName, "reindexing");
-  logger9.info("Reindex starting", { subgraph: subgraphName });
+  logger10.info("Reindex starting", { subgraph: subgraphName });
   try {
     const { fromBlock, toBlock } = await resolveBlockRange(source, def, opts);
     if (fromBlock > toBlock) {
-      logger9.info("No blocks to reindex", {
+      logger10.info("No blocks to reindex", {
         subgraph: subgraphName,
         fromBlock,
         toBlock
@@ -3405,7 +3683,7 @@ async function reindexSubgraph(def, opts) {
       await client.unsafe(stmt);
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "reindexing", Math.max(0, fromBlock - 1));
-    logger9.info("Schema recreated for reindex", {
+    logger10.info("Schema recreated for reindex", {
       subgraph: subgraphName,
       cursorResetTo: Math.max(0, fromBlock - 1)
     });
@@ -3419,7 +3697,7 @@ async function reindexSubgraph(def, opts) {
       last_error_at: null,
       updated_at: new Date
     }).where("name", "=", subgraphName).execute();
-    logger9.info("Reindexing blocks", {
+    logger10.info("Reindexing blocks", {
       subgraph: subgraphName,
       fromBlock,
       toBlock,
@@ -3441,9 +3719,9 @@ async function reindexSubgraph(def, opts) {
       if (reason === "user-cancelled") {
         await updateSubgraphStatus2(targetDb, subgraphName, "active");
         await clearReindexMetadata(targetDb, subgraphName);
-        logger9.info("Reindex cancelled by user", { subgraph: subgraphName });
+        logger10.info("Reindex cancelled by user", { subgraph: subgraphName });
       } else {
-        logger9.info("Reindex interrupted by shutdown, will resume", {
+        logger10.info("Reindex interrupted by shutdown, will resume", {
           subgraph: subgraphName
         });
       }
@@ -3451,7 +3729,7 @@ async function reindexSubgraph(def, opts) {
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
-    logger9.info("Reindex complete", {
+    logger10.info("Reindex complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed,
       events: result.totalEventsProcessed,
@@ -3464,7 +3742,7 @@ async function reindexSubgraph(def, opts) {
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger9.error("Reindex failed", {
+    logger10.error("Reindex failed", {
       subgraph: subgraphName,
       error: getErrorMessage3(err)
     });
@@ -3473,7 +3751,7 @@ async function reindexSubgraph(def, opts) {
   }
 }
 async function resumeReindex(def, opts) {
-  const targetDb = getTargetDb2();
+  const targetDb = getTargetDb3();
   const subgraphName = def.name;
   const row = await targetDb.selectFrom("subgraphs").select([
     "id",
@@ -3486,7 +3764,7 @@ async function resumeReindex(def, opts) {
   const fromBlock = resolveReindexResumeBlock(row);
   const toBlock = Number(row.reindex_to_block);
   if (fromBlock == null) {
-    logger9.info("No reindex metadata, starting fresh reindex", {
+    logger10.info("No reindex metadata, starting fresh reindex", {
       subgraph: subgraphName
     });
     return reindexSubgraph(def, {
@@ -3495,12 +3773,12 @@ async function resumeReindex(def, opts) {
     });
   }
   if (fromBlock > toBlock) {
-    logger9.info("Resume: no remaining blocks", { subgraph: subgraphName });
+    logger10.info("Resume: no remaining blocks", { subgraph: subgraphName });
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
     return { processed: 0 };
   }
-  logger9.info("Resuming reindex", {
+  logger10.info("Resuming reindex", {
     subgraph: subgraphName,
     fromBlock,
     toBlock,
@@ -3522,9 +3800,9 @@ async function resumeReindex(def, opts) {
       if (reason === "user-cancelled") {
         await updateSubgraphStatus2(targetDb, subgraphName, "active");
         await clearReindexMetadata(targetDb, subgraphName);
-        logger9.info("Resume cancelled by user", { subgraph: subgraphName });
+        logger10.info("Resume cancelled by user", { subgraph: subgraphName });
       } else {
-        logger9.info("Resume interrupted by shutdown, will resume again", {
+        logger10.info("Resume interrupted by shutdown, will resume again", {
           subgraph: subgraphName
         });
       }
@@ -3532,13 +3810,13 @@ async function resumeReindex(def, opts) {
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
-    logger9.info("Resumed reindex complete", {
+    logger10.info("Resumed reindex complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger9.error("Resumed reindex failed", {
+    logger10.error("Resumed reindex failed", {
       subgraph: subgraphName,
       error: getErrorMessage3(err)
     });
@@ -3547,9 +3825,9 @@ async function resumeReindex(def, opts) {
   }
 }
 async function backfillSubgraph(def, opts) {
-  const targetDb = getTargetDb2();
+  const targetDb = getTargetDb3();
   const subgraphName = def.name;
-  logger9.info("Backfill starting", {
+  logger10.info("Backfill starting", {
     subgraph: subgraphName,
     from: opts.fromBlock,
     to: opts.toBlock
@@ -3567,17 +3845,17 @@ async function backfillSubgraph(def, opts) {
       signal: opts.signal
     });
     if (result.aborted) {
-      logger9.info("Backfill aborted", { subgraph: subgraphName });
+      logger10.info("Backfill aborted", { subgraph: subgraphName });
       return { processed: result.blocksProcessed };
     }
     const resolved = await resolveGaps(targetDb, subgraphName, opts.fromBlock, opts.toBlock).catch(() => 0);
     if (resolved > 0) {
-      logger9.info("Resolved subgraph gaps via backfill", {
+      logger10.info("Resolved subgraph gaps via backfill", {
         subgraph: subgraphName,
         resolved
       });
     }
-    logger9.info("Backfill complete", {
+    logger10.info("Backfill complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed,
       events: result.totalEventsProcessed,
@@ -3585,7 +3863,7 @@ async function backfillSubgraph(def, opts) {
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger9.error("Backfill failed", {
+    logger10.error("Backfill failed", {
       subgraph: subgraphName,
       error: getErrorMessage3(err)
     });
@@ -3602,5 +3880,5 @@ export {
   backfillSubgraph
 };
 
-//# debugId=E95B0AF0DF971D5864756E2164756E21
+//# debugId=89B9EBD9DF358DD064756E2164756E21
 //# sourceMappingURL=reindex.js.map