@secondlayer/subgraphs 3.4.0 → 3.6.0

package/dist/src/service.js

@@ -518,21 +518,21 @@ function buildEventPayload(filter, tx, event) {
       return {
         sender: decoded.sender,
         recipient: decoded.recipient,
-        tokenId: decoded.value,
+        tokenId: decoded.raw_value ?? decoded.value,
         assetIdentifier: decoded.asset_identifier,
         tx: txMeta
       };
     case "nft_mint":
       return {
         recipient: decoded.recipient,
-        tokenId: decoded.value,
+        tokenId: decoded.raw_value ?? decoded.value,
         assetIdentifier: decoded.asset_identifier,
         tx: txMeta
       };
     case "nft_burn":
       return {
         sender: decoded.sender,
-        tokenId: decoded.value,
+        tokenId: decoded.raw_value ?? decoded.value,
         assetIdentifier: decoded.asset_identifier,
         tx: txMeta
       };
@@ -564,8 +564,8 @@ function buildEventPayload(filter, tx, event) {
         tx: txMeta
       };
     case "print_event": {
-      const decodedRawValue = decoded.raw_value;
-      const rawValue = decodedRawValue && typeof decodedRawValue === "object" && !Array.isArray(decodedRawValue) ? decodedRawValue : decoded.value;
+      const rawHex = event.data?.raw_value;
+      const rawValue = typeof rawHex === "string" && rawHex.startsWith("0x") ? decodeClarityValue(rawHex) : decoded.value;
       const clarityObj = rawValue && typeof rawValue === "object" && !Array.isArray(rawValue) ? rawValue : null;
       const topic = clarityObj?.topic ? String(clarityObj.topic) : decoded.topic ?? "";
       const { topic: _, ...rest } = clarityObj ?? {};
@@ -949,10 +949,7 @@ function matchSources(sources, transactions, events, traitContracts = new Map) {
 }
 
 // src/runtime/block-processor.ts
-import {
-  getSourceDb,
-  getTargetDb
-} from "@secondlayer/shared/db";
+import { getTargetDb } from "@secondlayer/shared/db";
 import { resolveTraitContractIds } from "@secondlayer/shared/db/queries/contracts";
 import {
   isByoSubgraph,
@@ -960,15 +957,287 @@ import {
   resolveSubgraphDb,
   updateSubgraphStatus
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger4 } from "@secondlayer/shared/logger";
+import { logger as logger5 } from "@secondlayer/shared/logger";
 import { sql as sql3 } from "kysely";
 
 // src/schema/utils.ts
 import { pgSchemaName } from "@secondlayer/shared/db/queries/subgraphs";
 
+// src/runtime/block-source.ts
+import { getSourceDb } from "@secondlayer/shared/db";
+import { IndexHttpClient } from "@secondlayer/shared/index-http";
+import { logger as logger3 } from "@secondlayer/shared/logger";
+
+// src/runtime/batch-loader.ts
+async function loadBlockRange(db, fromHeight, toHeight) {
+  const [blocks, txs, events] = await Promise.all([
+    db.selectFrom("blocks").selectAll().where("height", ">=", fromHeight).where("height", "<=", toHeight).where("canonical", "=", true).execute(),
+    db.selectFrom("transactions").selectAll().where("block_height", ">=", fromHeight).where("block_height", "<=", toHeight).execute(),
+    db.selectFrom("events").selectAll().where("block_height", ">=", fromHeight).where("block_height", "<=", toHeight).execute()
+  ]);
+  const txsByHeight = new Map;
+  for (const tx of txs) {
+    const h = Number(tx.block_height);
+    const list = txsByHeight.get(h) ?? [];
+    list.push(tx);
+    txsByHeight.set(h, list);
+  }
+  const eventsByHeight = new Map;
+  for (const evt of events) {
+    const h = Number(evt.block_height);
+    const list = eventsByHeight.get(h) ?? [];
+    list.push(evt);
+    eventsByHeight.set(h, list);
+  }
+  const result = new Map;
+  for (const block of blocks) {
+    const h = Number(block.height);
+    result.set(h, {
+      block,
+      txs: txsByHeight.get(h) ?? [],
+      events: eventsByHeight.get(h) ?? []
+    });
+  }
+  return result;
+}
+function avgEventsPerBlock(batch) {
+  if (batch.size === 0)
+    return 0;
+  let totalEvents = 0;
+  for (const data of batch.values()) {
+    totalEvents += data.events.length;
+  }
+  return totalEvents / batch.size;
+}
+
+// src/runtime/reconstruct.ts
+function isoToUnixSeconds(iso) {
+  if (!iso)
+    return 0;
+  return Math.floor(new Date(iso).getTime() / 1000);
+}
+function reconstructBlock(b) {
+  return {
+    height: b.block_height,
+    hash: b.block_hash,
+    parent_hash: b.parent_hash,
+    burn_block_height: b.burn_block_height,
+    burn_block_hash: b.burn_block_hash,
+    timestamp: isoToUnixSeconds(b.block_time),
+    canonical: true,
+    created_at: new Date(0)
+  };
+}
+function reconstructTransaction(t) {
+  return {
+    tx_id: t.tx_id,
+    block_height: t.block_height,
+    tx_index: t.tx_index,
+    type: t.tx_type,
+    sender: t.sender,
+    status: t.status,
+    contract_id: t.contract_call?.contract_id ?? t.smart_contract?.contract_id ?? null,
+    function_name: t.contract_call?.function_name ?? null,
+    function_args: t.contract_call?.function_args_hex ?? [],
+    raw_result: t.contract_call?.result_hex ?? null,
+    raw_tx: "",
+    created_at: new Date(0)
+  };
+}
+function reconstructEvent(e) {
+  const base = {
+    id: `${e.tx_id}#${e.event_index}`,
+    tx_id: e.tx_id,
+    block_height: e.block_height,
+    event_index: e.event_index,
+    created_at: new Date(0)
+  };
+  switch (e.event_type) {
+    case "ft_transfer":
+    case "ft_mint":
+    case "ft_burn":
+      return {
+        ...base,
+        type: `${e.event_type}_event`,
+        data: {
+          asset_identifier: e.asset_identifier,
+          sender: e.sender,
+          recipient: e.recipient,
+          amount: e.amount
+        }
+      };
+    case "nft_transfer":
+    case "nft_mint":
+    case "nft_burn":
+      return {
+        ...base,
+        type: `${e.event_type}_event`,
+        data: {
+          asset_identifier: e.asset_identifier,
+          sender: e.sender,
+          recipient: e.recipient,
+          raw_value: e.value
+        }
+      };
+    case "stx_transfer":
+    case "stx_mint":
+    case "stx_burn":
+      return {
+        ...base,
+        type: `${e.event_type}_event`,
+        data: {
+          sender: e.sender,
+          recipient: e.recipient,
+          amount: e.amount,
+          ..."memo" in e ? { memo: e.memo ?? undefined } : {}
+        }
+      };
+    case "stx_lock":
+      return {
+        ...base,
+        type: "stx_lock_event",
+        data: {
+          locked_address: e.sender,
+          locked_amount: e.amount,
+          unlock_height: e.payload.unlock_height
+        }
+      };
+    case "print":
+      return {
+        ...base,
+        type: "contract_event",
+        data: {
+          topic: e.payload.topic,
+          contract_id: e.contract_id,
+          contract_identifier: e.contract_id,
+          value: e.payload.value,
+          raw_value: e.payload.raw_value
+        }
+      };
+  }
+}
+
+// src/runtime/block-source.ts
+class PostgresBlockSource {
+  async getTip() {
+    const progress = await getSourceDb().selectFrom("index_progress").selectAll().where("network", "=", process.env.NETWORK ?? "mainnet").executeTakeFirst();
+    return progress ? Number(progress.highest_seen_block) : 0;
+  }
+  loadBlockRange(fromHeight, toHeight) {
+    return loadBlockRange(getSourceDb(), fromHeight, toHeight);
+  }
+}
+var EVENT_FILTER_TO_INDEX_TYPE = {
+  stx_transfer: "stx_transfer",
+  stx_mint: "stx_mint",
+  stx_burn: "stx_burn",
+  stx_lock: "stx_lock",
+  ft_transfer: "ft_transfer",
+  ft_mint: "ft_mint",
+  ft_burn: "ft_burn",
+  nft_transfer: "nft_transfer",
+  nft_mint: "nft_mint",
+  nft_burn: "nft_burn",
+  print_event: "print"
+};
+var TX_SOURCE_TYPES = new Set(["contract_call", "contract_deploy"]);
+var ALL_INDEX_EVENT_TYPES = [
+  ...new Set(Object.values(EVENT_FILTER_TO_INDEX_TYPE))
+];
+function sourceFilters(subgraph) {
+  const sources = subgraph.sources;
+  return Array.isArray(sources) ? sources : Object.values(sources);
+}
+function referencedIndexEventTypes(subgraph) {
+  const filters = sourceFilters(subgraph);
+  if (filters.some((f) => TX_SOURCE_TYPES.has(f.type))) {
+    return ALL_INDEX_EVENT_TYPES;
+  }
+  const types = new Set;
+  for (const f of filters) {
+    const t = EVENT_FILTER_TO_INDEX_TYPE[f.type];
+    if (t)
+      types.add(t);
+  }
+  return [...types];
+}
+function isStreamsIndexEligible(subgraph) {
+  if (Array.isArray(subgraph.sources))
+    return false;
+  const filters = sourceFilters(subgraph);
+  if (filters.length === 0)
+    return false;
+  for (const f of filters) {
+    const known = EVENT_FILTER_TO_INDEX_TYPE[f.type] || TX_SOURCE_TYPES.has(f.type);
+    if (!known)
+      return false;
+  }
+  return true;
+}
+
+class PublicApiBlockSource {
+  http;
+  eventTypes;
+  constructor(http, eventTypes) {
+    this.http = http;
+    this.eventTypes = eventTypes;
+  }
+  getTip() {
+    return this.http.getIndexTip();
+  }
+  async loadBlockRange(fromHeight, toHeight) {
+    const [blocks, txs, eventLists] = await Promise.all([
+      this.http.walkBlocks(fromHeight, toHeight),
+      this.http.walkTransactions(fromHeight, toHeight),
+      Promise.all(this.eventTypes.map((t) => this.http.walkEvents(t, fromHeight, toHeight)))
+    ]);
+    const map = new Map;
+    for (const b of blocks) {
+      map.set(b.block_height, {
+        block: reconstructBlock(b),
+        txs: [],
+        events: []
+      });
+    }
+    for (const t of txs) {
+      map.get(t.block_height)?.txs.push(reconstructTransaction(t));
+    }
+    for (const list of eventLists) {
+      for (const e of list) {
+        map.get(e.block_height)?.events.push(reconstructEvent(e));
+      }
+    }
+    for (const bd of map.values()) {
+      bd.txs.sort((a, b) => a.tx_index - b.tx_index);
+      bd.events.sort((a, b) => a.event_index - b.event_index);
+    }
+    return map;
+  }
+}
+var postgresBlockSource = new PostgresBlockSource;
+function buildHttpClient() {
+  const baseUrl = process.env.SUBGRAPH_INDEX_API_URL ?? process.env.STREAMS_API_URL ?? "http://api:3800";
+  return new IndexHttpClient({
+    indexBaseUrl: baseUrl,
+    streamsBaseUrl: baseUrl,
+    streamsApiKey: process.env.STREAMS_INTERNAL_API_KEY ?? "sk-sl_streams_l2_internal"
+  });
+}
+function resolveBlockSource(subgraph) {
+  if (process.env.SUBGRAPH_SOURCE === "streams-index" && subgraph && isStreamsIndexEligible(subgraph)) {
+    return new PublicApiBlockSource(buildHttpClient(), referencedIndexEventTypes(subgraph));
+  }
+  if (process.env.SUBGRAPH_SOURCE === "streams-index" && subgraph) {
+    logger3.debug("Subgraph not streams-index eligible, using DB tap", {
+      subgraph: subgraph.name
+    });
+  }
+  return postgresBlockSource;
+}
+
 // src/runtime/outbox-emit.ts
 import { createHash } from "node:crypto";
-import { logger as logger3 } from "@secondlayer/shared/logger";
+import { logger as logger4 } from "@secondlayer/shared/logger";
 var loggedKillSwitch = false;
 function isEmitOutboxEnabled() {
   return process.env.SECONDLAYER_EMIT_OUTBOX !== "false";
@@ -987,7 +1256,7 @@ function stableStringify(obj) {
 async function emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, blockHeight) {
   if (!isEmitOutboxEnabled()) {
     if (!loggedKillSwitch) {
-      logger3.warn("SECONDLAYER_EMIT_OUTBOX=false — outbox emission bypassed");
+      logger4.warn("SECONDLAYER_EMIT_OUTBOX=false — outbox emission bypassed");
       loggedKillSwitch = true;
     }
     return 0;
@@ -1228,7 +1497,6 @@ async function resolveTraitContracts(subgraph, blockHeight, db) {
   return resolved;
 }
 async function processBlock(subgraph, subgraphName, blockHeight, opts) {
-  const sourceDb = getSourceDb();
   const targetDb = getTargetDb();
   const blockStart = performance.now();
   const result = {
@@ -1246,25 +1514,18 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
     txs = opts.preloaded.txs;
     evts = opts.preloaded.events;
   } else {
-    block = await sourceDb.selectFrom("blocks").selectAll().where("height", "=", blockHeight).executeTakeFirst();
-    if (!block) {
-      logger4.warn("Block not found for subgraph processing", {
+    const data = (await resolveBlockSource(subgraph).loadBlockRange(blockHeight, blockHeight)).get(blockHeight);
+    if (!data) {
+      logger5.debug("Block not found or non-canonical for subgraph processing", {
         subgraph: subgraphName,
         blockHeight
       });
       result.skipped = true;
       return result;
     }
-    if (!block.canonical) {
-      logger4.debug("Skipping non-canonical block", {
-        subgraph: subgraphName,
-        blockHeight
-      });
-      result.skipped = true;
-      return result;
-    }
-    txs = await sourceDb.selectFrom("transactions").selectAll().where("block_height", "=", blockHeight).execute();
-    evts = await sourceDb.selectFrom("events").selectAll().where("block_height", "=", blockHeight).execute();
+    block = data.block;
+    txs = data.txs;
+    evts = data.events;
   }
   const traitContracts = await resolveTraitContracts(subgraph, blockHeight, targetDb);
   const matched = matchSources(subgraph.sources, txs, evts, traitContracts);
@@ -1355,7 +1616,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
         const { rows } = await sql3.raw(`SELECT n_live_tup AS count FROM pg_stat_user_tables WHERE schemaname = '${schemaName}' AND relname = '${table}'`).execute(route.dataDb);
         const count = Number(rows[0]?.count ?? 0);
         if (count >= 1e7) {
-          logger4.warn("Subgraph table exceeds 10M rows (estimate)", {
+          logger5.warn("Subgraph table exceeds 10M rows (estimate)", {
             subgraph: subgraphName,
             table,
             count
@@ -1363,7 +1624,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
         }
       }
     } catch (err) {
-      logger4.debug("Row count sample failed", {
+      logger5.debug("Row count sample failed", {
         subgraph: subgraphName,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -1437,7 +1698,7 @@ class StatsAccumulator {
 
 // src/runtime/reindex.ts
 import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
-import { getRawClient, getSourceDb as getSourceDb2, getTargetDb as getTargetDb2 } from "@secondlayer/shared/db";
+import { getRawClient, getTargetDb as getTargetDb2 } from "@secondlayer/shared/db";
 import {
   recordGapBatch,
   resolveGaps
@@ -1446,7 +1707,7 @@ import {
   recordSubgraphProcessed as recordSubgraphProcessed2,
   updateSubgraphStatus as updateSubgraphStatus2
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger5 } from "@secondlayer/shared/logger";
+import { logger as logger6 } from "@secondlayer/shared/logger";
 
 // src/schema/generator.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -1539,48 +1800,6 @@ function generateSubgraphSQL(def, schemaNameOverride) {
   return { statements, hash };
 }
 
-// src/runtime/batch-loader.ts
-async function loadBlockRange(db, fromHeight, toHeight) {
-  const [blocks, txs, events] = await Promise.all([
-    db.selectFrom("blocks").selectAll().where("height", ">=", fromHeight).where("height", "<=", toHeight).where("canonical", "=", true).execute(),
-    db.selectFrom("transactions").selectAll().where("block_height", ">=", fromHeight).where("block_height", "<=", toHeight).execute(),
-    db.selectFrom("events").selectAll().where("block_height", ">=", fromHeight).where("block_height", "<=", toHeight).execute()
-  ]);
-  const txsByHeight = new Map;
-  for (const tx of txs) {
-    const h = Number(tx.block_height);
-    const list = txsByHeight.get(h) ?? [];
-    list.push(tx);
-    txsByHeight.set(h, list);
-  }
-  const eventsByHeight = new Map;
-  for (const evt of events) {
-    const h = Number(evt.block_height);
-    const list = eventsByHeight.get(h) ?? [];
-    list.push(evt);
-    eventsByHeight.set(h, list);
-  }
-  const result = new Map;
-  for (const block of blocks) {
-    const h = Number(block.height);
-    result.set(h, {
-      block,
-      txs: txsByHeight.get(h) ?? [],
-      events: eventsByHeight.get(h) ?? []
-    });
-  }
-  return result;
-}
-function avgEventsPerBlock(batch) {
-  if (batch.size === 0)
-    return 0;
-  let totalEvents = 0;
-  for (const data of batch.values()) {
-    totalEvents += data.events.length;
-  }
-  return totalEvents / batch.size;
-}
-
 // src/runtime/reindex.ts
 var LOG_INTERVAL = 1000;
 var HEALTH_FLUSH_INTERVAL = 1000;
@@ -1641,7 +1860,7 @@ function coalesceFailedBlocks(blocks) {
   return ranges;
 }
 async function processBlockRange(def, opts) {
-  const sourceDb = getSourceDb2();
+  const source = resolveBlockSource(def);
   const targetDb = getTargetDb2();
   const subgraphName = def.name;
   const { fromBlock, toBlock, status } = opts;
@@ -1671,11 +1890,11 @@ async function processBlockRange(def, opts) {
     lastHealthFlushAt = Date.now();
   };
   let nextBatchEnd = Math.min(currentHeight + batchSize - 1, toBlock);
-  let nextBatchPromise = loadBlockRange(sourceDb, currentHeight, nextBatchEnd);
+  let nextBatchPromise = source.loadBlockRange(currentHeight, nextBatchEnd);
   while (currentHeight <= toBlock) {
     if (opts.signal?.aborted) {
       aborted = true;
-      logger5.info("Block processing aborted", {
+      logger6.info("Block processing aborted", {
         subgraph: subgraphName,
         currentBlock: currentHeight,
         reason: String(opts.signal.reason ?? "unknown")
@@ -1687,7 +1906,7 @@ async function processBlockRange(def, opts) {
     const nextStart = batchEnd + 1;
     if (nextStart <= toBlock) {
       nextBatchEnd = Math.min(nextStart + batchSize - 1, toBlock);
-      nextBatchPromise = loadBlockRange(sourceDb, nextStart, nextBatchEnd);
+      nextBatchPromise = source.loadBlockRange(nextStart, nextBatchEnd);
     }
     const batchFailedBlocks = [];
     for (let height = currentHeight;height <= batchEnd; height++) {
@@ -1705,7 +1924,7 @@ async function processBlockRange(def, opts) {
         });
       } catch (err) {
         const errorMsg = err instanceof Error ? err.message : String(err);
-        logger5.error("Block processing error", {
+        logger6.error("Block processing error", {
           subgraph: subgraphName,
           blockHeight: height,
           error: errorMsg
@@ -1739,7 +1958,7 @@ async function processBlockRange(def, opts) {
         lastProgressFlushAt = now;
       }
       if (blocksProcessed % LOG_INTERVAL === 0) {
-        logger5.info(`${status === "reindexing" ? "Reindex" : "Backfill"} progress`, {
+        logger6.info(`${status === "reindexing" ? "Reindex" : "Backfill"} progress`, {
           subgraph: subgraphName,
           processed: blocksProcessed,
           total: totalBlocks,
@@ -1758,7 +1977,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) => {
-        logger5.warn("Failed to record subgraph gaps", {
+        logger6.warn("Failed to record subgraph gaps", {
           subgraph: subgraphName,
           error: err instanceof Error ? err.message : String(err)
         });
@@ -1775,32 +1994,26 @@ async function processBlockRange(def, opts) {
   await flushHealth();
   return { blocksProcessed, totalEventsProcessed, totalErrors, aborted };
 }
-async function resolveBlockRange(sourceDb, def, opts) {
+async function resolveBlockRange(source, def, opts) {
   const fromBlock = opts?.fromBlock ?? def.startBlock ?? 1;
-  let toBlock;
-  if (opts?.toBlock != null) {
-    toBlock = opts.toBlock;
-  } else {
-    const progress = await sourceDb.selectFrom("index_progress").selectAll().where("network", "=", process.env.NETWORK ?? "mainnet").executeTakeFirst();
-    toBlock = progress?.highest_seen_block ?? 0;
-  }
+  const toBlock = opts?.toBlock != null ? opts.toBlock : await source.getTip();
   return { fromBlock, toBlock };
 }
 async function clearReindexMetadata(db, subgraphName) {
   await db.updateTable("subgraphs").set({ reindex_from_block: null, reindex_to_block: null }).where("name", "=", subgraphName).execute();
 }
 async function reindexSubgraph(def, opts) {
-  const sourceDb = getSourceDb2();
+  const source = resolveBlockSource(def);
   const targetDb = getTargetDb2();
   const client = getRawClient("target");
   const subgraphName = def.name;
   const schemaName = opts?.schemaName ?? pgSchemaName(subgraphName);
   await updateSubgraphStatus2(targetDb, subgraphName, "reindexing");
-  logger5.info("Reindex starting", { subgraph: subgraphName });
+  logger6.info("Reindex starting", { subgraph: subgraphName });
   try {
-    const { fromBlock, toBlock } = await resolveBlockRange(sourceDb, def, opts);
+    const { fromBlock, toBlock } = await resolveBlockRange(source, def, opts);
     if (fromBlock > toBlock) {
-      logger5.info("No blocks to reindex", {
+      logger6.info("No blocks to reindex", {
         subgraph: subgraphName,
         fromBlock,
         toBlock
@@ -1813,7 +2026,7 @@ async function reindexSubgraph(def, opts) {
     for (const stmt of statements) {
       await client.unsafe(stmt);
     }
-    logger5.info("Schema recreated for reindex", { subgraph: subgraphName });
+    logger6.info("Schema recreated for reindex", { subgraph: subgraphName });
     await targetDb.updateTable("subgraphs").set({
       last_processed_block: initialReindexProgressBlock(fromBlock),
       reindex_from_block: fromBlock,
@@ -1824,7 +2037,7 @@ async function reindexSubgraph(def, opts) {
       last_error_at: null,
       updated_at: new Date
     }).where("name", "=", subgraphName).execute();
-    logger5.info("Reindexing blocks", {
+    logger6.info("Reindexing blocks", {
       subgraph: subgraphName,
       fromBlock,
       toBlock,
@@ -1845,9 +2058,9 @@ async function reindexSubgraph(def, opts) {
       if (reason === "user-cancelled") {
         await updateSubgraphStatus2(targetDb, subgraphName, "active");
         await clearReindexMetadata(targetDb, subgraphName);
-        logger5.info("Reindex cancelled by user", { subgraph: subgraphName });
+        logger6.info("Reindex cancelled by user", { subgraph: subgraphName });
       } else {
-        logger5.info("Reindex interrupted by shutdown, will resume", {
+        logger6.info("Reindex interrupted by shutdown, will resume", {
           subgraph: subgraphName
         });
       }
@@ -1855,7 +2068,7 @@ async function reindexSubgraph(def, opts) {
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
-    logger5.info("Reindex complete", {
+    logger6.info("Reindex complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed,
       events: result.totalEventsProcessed,
@@ -1863,7 +2076,7 @@ async function reindexSubgraph(def, opts) {
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger5.error("Reindex failed", {
+    logger6.error("Reindex failed", {
       subgraph: subgraphName,
       error: getErrorMessage2(err)
     });
@@ -1885,7 +2098,7 @@ async function resumeReindex(def, opts) {
   const fromBlock = resolveReindexResumeBlock(row);
   const toBlock = Number(row.reindex_to_block);
   if (fromBlock == null) {
-    logger5.info("No reindex metadata, starting fresh reindex", {
+    logger6.info("No reindex metadata, starting fresh reindex", {
       subgraph: subgraphName
     });
     return reindexSubgraph(def, {
@@ -1894,12 +2107,12 @@ async function resumeReindex(def, opts) {
     });
   }
   if (fromBlock > toBlock) {
-    logger5.info("Resume: no remaining blocks", { subgraph: subgraphName });
+    logger6.info("Resume: no remaining blocks", { subgraph: subgraphName });
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
     return { processed: 0 };
   }
-  logger5.info("Resuming reindex", {
+  logger6.info("Resuming reindex", {
     subgraph: subgraphName,
     fromBlock,
     toBlock,
@@ -1920,9 +2133,9 @@ async function resumeReindex(def, opts) {
       if (reason === "user-cancelled") {
         await updateSubgraphStatus2(targetDb, subgraphName, "active");
         await clearReindexMetadata(targetDb, subgraphName);
-        logger5.info("Resume cancelled by user", { subgraph: subgraphName });
+        logger6.info("Resume cancelled by user", { subgraph: subgraphName });
       } else {
-        logger5.info("Resume interrupted by shutdown, will resume again", {
+        logger6.info("Resume interrupted by shutdown, will resume again", {
           subgraph: subgraphName
         });
       }
@@ -1930,13 +2143,13 @@ async function resumeReindex(def, opts) {
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
-    logger5.info("Resumed reindex complete", {
+    logger6.info("Resumed reindex complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger5.error("Resumed reindex failed", {
+    logger6.error("Resumed reindex failed", {
       subgraph: subgraphName,
       error: getErrorMessage2(err)
     });
@@ -1947,7 +2160,7 @@ async function resumeReindex(def, opts) {
 async function backfillSubgraph(def, opts) {
   const targetDb = getTargetDb2();
   const subgraphName = def.name;
-  logger5.info("Backfill starting", {
+  logger6.info("Backfill starting", {
     subgraph: subgraphName,
     from: opts.fromBlock,
     to: opts.toBlock
@@ -1964,17 +2177,17 @@ async function backfillSubgraph(def, opts) {
       signal: opts.signal
     });
     if (result.aborted) {
-      logger5.info("Backfill aborted", { subgraph: subgraphName });
+      logger6.info("Backfill aborted", { subgraph: subgraphName });
       return { processed: result.blocksProcessed };
     }
     const resolved = await resolveGaps(targetDb, subgraphName, opts.fromBlock, opts.toBlock).catch(() => 0);
     if (resolved > 0) {
-      logger5.info("Resolved subgraph gaps via backfill", {
+      logger6.info("Resolved subgraph gaps via backfill", {
         subgraph: subgraphName,
         resolved
       });
     }
-    logger5.info("Backfill complete", {
+    logger6.info("Backfill complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed,
       events: result.totalEventsProcessed,
@@ -1982,7 +2195,7 @@ async function backfillSubgraph(def, opts) {
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger5.error("Backfill failed", {
+    logger6.error("Backfill failed", {
       subgraph: subgraphName,
       error: getErrorMessage2(err)
     });
@@ -1991,12 +2204,12 @@ async function backfillSubgraph(def, opts) {
 }
 
 // src/runtime/catchup.ts
-import { getSourceDb as getSourceDb3, getTargetDb as getTargetDb3 } from "@secondlayer/shared/db";
+import { getTargetDb as getTargetDb3 } from "@secondlayer/shared/db";
 import {
   recordGapBatch as recordGapBatch2
 } from "@secondlayer/shared/db/queries/subgraph-gaps";
 import { getSubgraph } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger6 } from "@secondlayer/shared/logger";
+import { logger as logger7 } from "@secondlayer/shared/logger";
 var LOG_INTERVAL2 = 1000;
 var STANDARD_CATCHUP_BATCH_CONFIG = {
   defaultBatchSize: 500,
@@ -2067,22 +2280,19 @@ async function catchUpSubgraph(subgraph, subgraphName) {
     return 0;
   catchingUp.add(subgraphName);
   try {
-    const sourceDb = getSourceDb3();
+    const source = resolveBlockSource(subgraph);
     const targetDb = getTargetDb3();
     const subgraphRow = await getSubgraph(targetDb, subgraphName);
     if (!subgraphRow)
       return 0;
     const lastProcessedBlock = Number(subgraphRow.last_processed_block);
-    const progress = await sourceDb.selectFrom("index_progress").selectAll().where("network", "=", process.env.NETWORK ?? "mainnet").executeTakeFirst();
-    if (!progress)
-      return 0;
-    const chainTip = Number(progress.highest_seen_block);
-    if (lastProcessedBlock >= chainTip)
+    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;
-    logger6.info("Subgraph catch-up starting", {
+    logger7.info("Subgraph catch-up starting", {
       subgraph: subgraphName,
       from: startBlock,
       to: chainTip,
@@ -2094,11 +2304,11 @@ async function catchUpSubgraph(subgraph, subgraphName) {
     let batchSize = batchConfig.defaultBatchSize;
     let currentHeight = startBlock;
     let prefetchedBatchEnd = Math.min(currentHeight + batchSize - 1, chainTip);
-    let nextBatchPromise = batchConfig.prefetch ? loadBlockRange(sourceDb, currentHeight, prefetchedBatchEnd) : undefined;
+    let nextBatchPromise = batchConfig.prefetch ? source.loadBlockRange(currentHeight, prefetchedBatchEnd) : undefined;
     while (currentHeight <= chainTip) {
       const currentRow = await getSubgraph(targetDb, subgraphName);
       if (!currentRow || currentRow.status !== "active") {
-        logger6.info("Subgraph status changed, stopping catch-up", {
+        logger7.info("Subgraph status changed, stopping catch-up", {
           subgraph: subgraphName,
           status: currentRow?.status ?? "deleted"
         });
@@ -2112,13 +2322,13 @@ async function catchUpSubgraph(subgraph, subgraphName) {
         const nextStart = batchEnd + 1;
         if (nextStart <= chainTip) {
           prefetchedBatchEnd = Math.min(nextStart + batchSize - 1, chainTip);
-          nextBatchPromise = loadBlockRange(sourceDb, nextStart, prefetchedBatchEnd);
+          nextBatchPromise = source.loadBlockRange(nextStart, prefetchedBatchEnd);
         } else {
           nextBatchPromise = undefined;
         }
       } else {
         batchEnd = Math.min(currentHeight + batchSize - 1, chainTip);
-        batch = await loadBlockRange(sourceDb, currentHeight, batchEnd);
+        batch = await source.loadBlockRange(currentHeight, batchEnd);
       }
       const batchFailedBlocks = [];
       for (let height = currentHeight;height <= batchEnd; height++) {
@@ -2134,7 +2344,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
             preloaded: blockData
           });
         } catch (err) {
-          logger6.error("Block processing error during catch-up", {
+          logger7.error("Block processing error during catch-up", {
             subgraph: subgraphName,
             blockHeight: height,
             error: err instanceof Error ? err.message : String(err)
@@ -2153,7 +2363,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
           }
         }
         if (processed % LOG_INTERVAL2 === 0) {
-          logger6.info("Subgraph catch-up progress", {
+          logger7.info("Subgraph catch-up progress", {
             subgraph: subgraphName,
             processed,
             total: totalBlocks,
@@ -2165,7 +2375,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
       if (batchFailedBlocks.length > 0) {
         const gaps = coalesceGaps(batchFailedBlocks);
         await recordGapBatch2(targetDb, subgraphRow.id, subgraphName, gaps).catch((err) => {
-          logger6.warn("Failed to record subgraph gaps", {
+          logger7.warn("Failed to record subgraph gaps", {
             subgraph: subgraphName,
             error: err instanceof Error ? err.message : String(err)
           });
@@ -2176,7 +2386,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
       currentHeight = batchEnd + 1;
     }
     await stats.flush(targetDb);
-    logger6.info("Subgraph catch-up complete", {
+    logger7.info("Subgraph catch-up complete", {
       subgraph: subgraphName,
       processed
     });
@@ -2193,13 +2403,13 @@ import {
   listSubgraphs,
   resolveSubgraphRawClient
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger7 } from "@secondlayer/shared/logger";
+import { logger as logger8 } from "@secondlayer/shared/logger";
 async function handleSubgraphReorg(blockHeight, loadSubgraphDef) {
   const targetDb = getTargetDb4();
   const activeSubgraphs = (await listSubgraphs(targetDb)).filter((v) => v.status === "active");
   if (activeSubgraphs.length === 0)
     return;
-  logger7.info("Propagating reorg to subgraphs", {
+  logger8.info("Propagating reorg to subgraphs", {
     blockHeight,
     subgraphCount: activeSubgraphs.length
   });
@@ -2247,7 +2457,7 @@ async function handleSubgraphReorg(blockHeight, loadSubgraphDef) {
           }).as("row_pk"),
           eb2.val("pending").as("status")
         ]).where("subgraph_name", "=", sg.name).where("table_name", "=", tableName).where("status", "=", "active")).onConflict((oc) => oc.column("dedup_key").doNothing()).execute().catch((err) => {
-          logger7.warn("Failed to emit revert event for subscriptions", {
+          logger8.warn("Failed to emit revert event for subscriptions", {
             subgraph: sg.name,
             table: tableName,
             blockHeight,
@@ -2255,19 +2465,19 @@ async function handleSubgraphReorg(blockHeight, loadSubgraphDef) {
           });
         });
       }
-      logger7.info("Subgraph reorg cleanup done", {
+      logger8.info("Subgraph reorg cleanup done", {
         subgraph: sg.name,
         blockHeight,
         tablesAffected: Object.keys(revertedByTable).length
       });
       const def = await loadSubgraphDef(sg);
       await processBlock(def, sg.name, blockHeight);
-      logger7.info("Subgraph reorg reprocessed", {
+      logger8.info("Subgraph reorg reprocessed", {
         subgraph: sg.name,
         blockHeight
       });
     } catch (err) {
-      logger7.error("Subgraph reorg handling failed", {
+      logger8.error("Subgraph reorg handling failed", {
         subgraph: sg.name,
         blockHeight,
         error: getErrorMessage3(err)
@@ -2281,7 +2491,7 @@ import { randomUUID } from "node:crypto";
 import { hostname } from "node:os";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
-import { getErrorMessage as getErrorMessage4 } from "@secondlayer/shared";
+import { getErrorMessage as getErrorMessage5 } from "@secondlayer/shared";
 import { getTargetDb as getTargetDb6 } from "@secondlayer/shared/db";
 import {
   cancelSubgraphOperation,
@@ -2300,7 +2510,7 @@ import {
   pgSchemaName as pgSchemaName2,
   updateSubgraphStatus as updateSubgraphStatus3
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger10 } from "@secondlayer/shared/logger";
+import { logger as logger12 } from "@secondlayer/shared/logger";
 import { listen as listen2 } from "@secondlayer/shared/queue/listener";
 
 // src/runtime/emitter.ts
@@ -2308,12 +2518,12 @@ import {
   getTargetDb as getTargetDb5
 } from "@secondlayer/shared/db";
 import { getSubscriptionSigningSecret } from "@secondlayer/shared/db/queries/subscriptions";
-import { logger as logger9 } from "@secondlayer/shared/logger";
+import { logger as logger10 } from "@secondlayer/shared/logger";
 import { listen } from "@secondlayer/shared/queue/listener";
 import { sql as sql4 } from "kysely";
 
 // src/runtime/formats/index.ts
-import { logger as logger8 } from "@secondlayer/shared/logger";
+import { logger as logger9 } from "@secondlayer/shared/logger";
 
 // src/runtime/formats/cloudevents.ts
 function buildCloudEvents(outboxRow, _sub) {
@@ -2460,7 +2670,7 @@ function buildForFormat(outboxRow, sub, signingSecret) {
     case "standard-webhooks":
       return buildStandardWebhooks(outboxRow, signingSecret);
     default:
-      logger8.warn("Unknown subscription format, falling back to standard-webhooks", {
+      logger9.warn("Unknown subscription format, falling back to standard-webhooks", {
         format: sub.format,
         subscriptionId: sub.id
       });
@@ -2543,7 +2753,7 @@ async function dispatchOne(db, outboxRow, sub) {
   let responseHeaders = {};
   if (isPrivateEgress(sub.url) && !allowPrivateEgress()) {
     error = "refused private egress (set SECONDLAYER_ALLOW_PRIVATE_EGRESS=true to allow)";
-    logger9.warn("[emitter] refused private egress", {
+    logger10.warn("[emitter] refused private egress", {
       subscription: sub.name,
       url: sub.url
     });
@@ -2639,7 +2849,7 @@ async function settleFailed(db, outboxRow, sub, errText) {
         circuit_opened_at: new Date,
         updated_at: new Date
       }).where("id", "=", sub.id).execute();
-      logger9.warn("Subscription circuit tripped — paused after consecutive failures", {
+      logger10.warn("Subscription circuit tripped — paused after consecutive failures", {
         subscription: sub.name,
         failures: newFailures
       });
@@ -2727,7 +2937,7 @@ async function drainForSub(db, state, sub, rows) {
             await settleFailed(db, row, sub, err);
           }
         } catch (err) {
-          logger9.error("Emitter dispatch crashed", {
+          logger10.error("Emitter dispatch crashed", {
             outboxId: row.id,
             error: err instanceof Error ? err.message : String(err)
           });
@@ -2764,7 +2974,7 @@ async function startEmitter(opts) {
   };
   const pollIntervalMs = opts?.pollIntervalMs ?? 120000;
   const retentionIntervalMs = opts?.retentionIntervalMs ?? 60 * 60000;
-  logger9.info("[emitter] started", { id: emitterId });
+  logger10.info("[emitter] started", { id: emitterId });
   const MATCHER_BOOT_ATTEMPTS = 5;
   let lastErr = null;
   for (let i = 0;i < MATCHER_BOOT_ATTEMPTS; i++) {
@@ -2775,7 +2985,7 @@ async function startEmitter(opts) {
     } catch (err) {
       lastErr = err;
       const delayMs = 500 * 2 ** i;
-      logger9.warn("[emitter] matcher refresh failed, retrying", {
+      logger10.warn("[emitter] matcher refresh failed, retrying", {
         attempt: i + 1,
         delayMs,
         error: err instanceof Error ? err.message : String(err)
@@ -2789,21 +2999,21 @@ async function startEmitter(opts) {
   const stopNew = await listen("subscriptions:new_outbox", () => {
     if (!state.running)
       return;
-    claimAndDrain(db, state, emitterId).catch((err) => logger9.error("[emitter] claim failed", {
+    claimAndDrain(db, state, emitterId).catch((err) => logger10.error("[emitter] claim failed", {
       error: err instanceof Error ? err.message : String(err)
     }));
   });
   const stopChanged = await listen("subscriptions:changed", () => {
     if (!state.running)
       return;
-    refreshMatcher(db).catch((err) => logger9.error("[emitter] matcher refresh failed", {
+    refreshMatcher(db).catch((err) => logger10.error("[emitter] matcher refresh failed", {
       error: err instanceof Error ? err.message : String(err)
     }));
   });
   const poll = setInterval(() => {
     if (!state.running)
       return;
-    claimAndDrain(db, state, emitterId).catch((err) => logger9.error("[emitter] poll claim failed", {
+    claimAndDrain(db, state, emitterId).catch((err) => logger10.error("[emitter] poll claim failed", {
       error: err instanceof Error ? err.message : String(err)
     }));
   }, pollIntervalMs);
@@ -2811,7 +3021,7 @@ async function startEmitter(opts) {
   const retention = setInterval(() => {
     if (!state.running)
       return;
-    runRetention(db).catch((err) => logger9.error("[emitter] retention failed", {
+    runRetention(db).catch((err) => logger10.error("[emitter] retention failed", {
       error: err instanceof Error ? err.message : String(err)
     }));
   }, retentionIntervalMs);
@@ -2821,7 +3031,56 @@ async function startEmitter(opts) {
     clearInterval(retention);
     await stopNew();
     await stopChanged();
-    logger9.info("[emitter] stopped", { id: emitterId });
+    logger10.info("[emitter] stopped", { id: emitterId });
+  };
+}
+
+// src/runtime/streams-reorg-poll.ts
+import { getErrorMessage as getErrorMessage4 } from "@secondlayer/shared";
+import { IndexHttpClient as IndexHttpClient2 } from "@secondlayer/shared/index-http";
+import { logger as logger11 } from "@secondlayer/shared/logger";
+var POLL_MS = Number(process.env.SUBGRAPH_REORG_POLL_MS) || 15000;
+var STARTUP_MARGIN_MS = 60 * 60 * 1000;
+async function pollReorgsOnce(http, cursor, handleReorg, loadDef) {
+  const { reorgs, next_since } = await http.listReorgs(cursor);
+  const sorted = [...reorgs].sort((a, b) => a.fork_point_height - b.fork_point_height);
+  for (const r of sorted) {
+    logger11.info("Streams reorg — rewinding subgraphs", {
+      forkPointHeight: r.fork_point_height
+    });
+    await handleReorg(r.fork_point_height, loadDef);
+  }
+  return next_since ?? cursor;
+}
+function startStreamsReorgPoll(handleReorg, loadDef) {
+  const baseUrl = process.env.SUBGRAPH_INDEX_API_URL ?? process.env.STREAMS_API_URL ?? "http://api:3800";
+  const http = new IndexHttpClient2({
+    indexBaseUrl: baseUrl,
+    streamsBaseUrl: baseUrl,
+    streamsApiKey: process.env.STREAMS_INTERNAL_API_KEY ?? "sk-sl_streams_l2_internal"
+  });
+  let since = new Date(Date.now() - STARTUP_MARGIN_MS).toISOString();
+  let running = true;
+  let timer;
+  const tick = async () => {
+    if (!running)
+      return;
+    try {
+      since = await pollReorgsOnce(http, since, handleReorg, loadDef);
+    } catch (err) {
+      logger11.error("Streams reorg poll failed", {
+        error: getErrorMessage4(err)
+      });
+    }
+    if (running)
+      timer = setTimeout(tick, POLL_MS);
+  };
+  timer = setTimeout(tick, POLL_MS);
+  logger11.info("Streams reorg poll started", { pollMs: POLL_MS });
+  return () => {
+    running = false;
+    if (timer)
+      clearTimeout(timer);
   };
 }
 
@@ -2844,11 +3103,11 @@ async function catchUpAll(subgraphs, db, concurrency) {
         const def = await loadSubgraphDefinition(sg);
         await catchUpSubgraph(def, sg.name);
       } catch (err) {
-        const msg = getErrorMessage4(err);
+        const msg = getErrorMessage5(err);
         if (isHandlerNotFoundError(err)) {
           await updateSubgraphStatus3(db, sg.name, "error");
         }
-        logger10.error("Subgraph catch-up failed", {
+        logger12.error("Subgraph catch-up failed", {
           subgraph: sg.name,
           error: msg
         });
@@ -2894,7 +3153,7 @@ async function loadSubgraphDefinition(sg) {
   definitionCache.set(sg.name, def);
   if (prevVersion && prevVersion !== sg.version) {
     invalidateSubgraphRoute(sg.name);
-    logger10.info("Subgraph handler reloaded", {
+    logger12.info("Subgraph handler reloaded", {
       subgraph: sg.name,
       from: prevVersion,
       to: sg.version
@@ -2928,7 +3187,7 @@ async function synthesizeLegacyReindexOperations() {
         fromBlock: sg.reindex_from_block == null ? undefined : Number(sg.reindex_from_block),
         toBlock: sg.reindex_to_block == null ? undefined : Number(sg.reindex_to_block)
       });
-      logger10.info("Queued legacy reindex resume operation", {
+      logger12.info("Queued legacy reindex resume operation", {
         subgraph: sg.name
       });
     } catch (err) {
@@ -2984,7 +3243,7 @@ async function startSubgraphOperationRunner(opts) {
   const activeRuns = new Map;
   let running = true;
   let draining = false;
-  logger10.info("Starting subgraph operation runner", { concurrency, lockedBy });
+  logger12.info("Starting subgraph operation runner", { concurrency, lockedBy });
   const startOperation = (operation) => {
     const controller = new AbortController;
     active.set(operation.id, controller);
@@ -2992,9 +3251,9 @@ async function startSubgraphOperationRunner(opts) {
       if (!running)
         return;
       heartbeatSubgraphOperation(db, operation.id, lockedBy).catch((err) => {
-        logger10.warn("Subgraph operation heartbeat failed", {
+        logger12.warn("Subgraph operation heartbeat failed", {
           operationId: operation.id,
-          error: getErrorMessage4(err)
+          error: getErrorMessage5(err)
         });
       });
     }, HEARTBEAT_INTERVAL_MS);
@@ -3004,9 +3263,9 @@ async function startSubgraphOperationRunner(opts) {
           controller.abort("user-cancelled");
         }
       }).catch((err) => {
-        logger10.warn("Subgraph operation cancel poll failed", {
+        logger12.warn("Subgraph operation cancel poll failed", {
           operationId: operation.id,
-          error: getErrorMessage4(err)
+          error: getErrorMessage5(err)
         });
       });
     }, CANCEL_POLL_INTERVAL_MS);
@@ -3021,14 +3280,14 @@ async function startSubgraphOperationRunner(opts) {
         const reason = String(controller.signal.reason ?? "");
         if (controller.signal.aborted && reason === "user-cancelled") {
           await cancelSubgraphOperation(db, operation.id, lockedBy, processed);
-          logger10.info("Subgraph operation cancelled", {
+          logger12.info("Subgraph operation cancelled", {
             operationId: operation.id,
             subgraph: operation.subgraph_name
           });
           return;
         }
         if (controller.signal.aborted) {
-          logger10.info("Subgraph operation interrupted", {
+          logger12.info("Subgraph operation interrupted", {
             operationId: operation.id,
             subgraph: operation.subgraph_name,
             reason
@@ -3036,7 +3295,7 @@ async function startSubgraphOperationRunner(opts) {
           return;
         }
         await completeSubgraphOperation(db, operation.id, lockedBy, processed);
-        logger10.info("Subgraph operation completed", {
+        logger12.info("Subgraph operation completed", {
           operationId: operation.id,
           subgraph: operation.subgraph_name,
           processed
@@ -3044,7 +3303,7 @@ async function startSubgraphOperationRunner(opts) {
       } catch (err) {
         const reason = String(controller.signal.reason ?? "");
         if (controller.signal.aborted && reason === "shutdown") {
-          logger10.info("Subgraph operation interrupted by shutdown", {
+          logger12.info("Subgraph operation interrupted by shutdown", {
             operationId: operation.id,
             subgraph: operation.subgraph_name
           });
@@ -3054,11 +3313,11 @@ async function startSubgraphOperationRunner(opts) {
           await cancelSubgraphOperation(db, operation.id, lockedBy, processed);
           return;
         }
-        await failSubgraphOperation(db, operation.id, lockedBy, getErrorMessage4(err), processed);
-        logger10.error("Subgraph operation failed", {
+        await failSubgraphOperation(db, operation.id, lockedBy, getErrorMessage5(err), processed);
+        logger12.error("Subgraph operation failed", {
           operationId: operation.id,
           subgraph: operation.subgraph_name,
-          error: getErrorMessage4(err)
+          error: getErrorMessage5(err)
         });
       } finally {
         clearInterval(heartbeat);
@@ -3102,13 +3361,13 @@ async function startSubgraphOperationRunner(opts) {
       controller.abort("shutdown");
     }
     await Promise.allSettled(activeRuns.values());
-    logger10.info("Subgraph operation runner stopped");
+    logger12.info("Subgraph operation runner stopped");
   };
 }
 async function startSubgraphProcessor(opts) {
   const concurrency = opts?.concurrency ?? DEFAULT_CONCURRENCY;
   let running = true;
-  logger10.info("Starting subgraph processor", { concurrency });
+  logger12.info("Starting subgraph processor", { concurrency });
   const stopOperations = await startSubgraphOperationRunner({
     concurrency: Number.parseInt(process.env.SUBGRAPH_OPERATION_CONCURRENCY ?? String(DEFAULT_OPERATION_CONCURRENCY))
   });
@@ -3133,8 +3392,8 @@ async function startSubgraphProcessor(opts) {
         await handleSubgraphReorg(blockHeight, loadSubgraphDefinition);
       }
     } catch (err) {
-      logger10.error("Subgraph reorg handling failed", {
-        error: getErrorMessage4(err)
+      logger12.error("Subgraph reorg handling failed", {
+        error: getErrorMessage5(err)
       });
     }
   }, { connectionString: sourceListenerUrl() });
@@ -3146,22 +3405,24 @@ async function startSubgraphProcessor(opts) {
     cleanupCaches(subgraphs);
     await catchUpAll(subgraphs, db, concurrency);
   }, POLL_INTERVAL_MS);
+  const stopStreamsReorgPoll = process.env.SUBGRAPH_SOURCE === "streams-index" ? startStreamsReorgPoll(handleSubgraphReorg, loadSubgraphDefinition) : undefined;
   const stopEmitter = await startEmitter();
-  logger10.info("Subgraph processor ready");
+  logger12.info("Subgraph processor ready");
   return async () => {
     running = false;
     clearInterval(pollInterval);
     await stopListening();
     await stopReorgListening();
+    stopStreamsReorgPoll?.();
     await stopOperations();
     await stopEmitter();
-    logger10.info("Subgraph processor stopped");
+    logger12.info("Subgraph processor stopped");
   };
 }
 
 // src/service.ts
 import { getDb } from "@secondlayer/shared/db";
-import { logger as logger11 } from "@secondlayer/shared/logger";
+import { logger as logger13 } from "@secondlayer/shared/logger";
 import { sql as sql5 } from "kysely";
 var HEARTBEAT_INTERVAL_MS2 = 30000;
 var SERVICE_NAME = "subgraph-processor";
@@ -3169,7 +3430,7 @@ async function writeHeartbeat() {
   try {
     await getDb().insertInto("service_heartbeats").values({ name: SERVICE_NAME }).onConflict((oc) => oc.column("name").doUpdateSet({ updated_at: sql5`now()` })).execute();
   } catch (err) {
-    logger11.warn("subgraph-processor heartbeat write failed", {
+    logger13.warn("subgraph-processor heartbeat write failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
@@ -3180,7 +3441,7 @@ var processor = await startSubgraphProcessor({
 await writeHeartbeat();
 var heartbeatInterval = setInterval(writeHeartbeat, HEARTBEAT_INTERVAL_MS2);
 var shutdown = async () => {
-  logger11.info("Shutting down subgraph processor...");
+  logger13.info("Shutting down subgraph processor...");
   clearInterval(heartbeatInterval);
   await processor();
   process.exit(0);
@@ -3188,5 +3449,5 @@ var shutdown = async () => {
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
 
-//# debugId=453058A5195B7A0C64756E2164756E21
+//# debugId=7F079106165EB8F064756E2164756E21
 //# sourceMappingURL=service.js.map