@secondlayer/subgraphs 3.7.1 → 3.7.3

package/dist/src/service.js

@@ -1242,6 +1242,11 @@ function resolveBlockSource(subgraph) {
 import { createHash } from "node:crypto";
 import { logger as logger4 } from "@secondlayer/shared/logger";
 var loggedKillSwitch = false;
+var OP_VERB = {
+  insert: "created",
+  update: "updated",
+  delete: "deleted"
+};
 function isEmitOutboxEnabled() {
   return process.env.SECONDLAYER_EMIT_OUTBOX !== "false";
 }
@@ -1269,12 +1274,10 @@ async function emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block
     return 0;
   const rows = [];
   for (const write of manifest.writes) {
-    if (write.op !== "insert")
-      continue;
     const subs = matcher.match(subgraphName, write.table, write.row);
     if (subs.length === 0)
       continue;
-    const eventType = `${subgraphName}.${write.table}.created`;
+    const eventType = `${subgraphName}.${write.table}.${OP_VERB[write.op]}`;
     for (const s of subs) {
       rows.push({
         subscription_id: s.id,
@@ -2515,12 +2518,93 @@ import {
   pgSchemaName as pgSchemaName2,
   updateSubgraphStatus as updateSubgraphStatus3
 } from "@secondlayer/shared/db/queries/subgraphs";
+import { logger as logger15 } from "@secondlayer/shared/logger";
+import {
+  listen as listen2,
+  sourceListenerUrl,
+  targetListenerUrl as targetListenerUrl4
+} from "@secondlayer/shared/queue/listener";
+
+// 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/streams-reorg-poll.ts
+import { getErrorMessage as getErrorMessage4 } from "@secondlayer/shared";
+import { IndexHttpClient as IndexHttpClient2 } from "@secondlayer/shared/index-http";
+import { logger as logger9 } 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, onReorg) {
+  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) {
+    logger9.info("Streams reorg — rewinding", {
+      forkPointHeight: r.fork_point_height
+    });
+    await onReorg(r.fork_point_height);
+  }
+  return next_since ?? cursor;
+}
+function startStreamsReorgPoll(onReorg) {
+  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, onReorg);
+    } catch (err) {
+      logger9.error("Streams reorg poll failed", {
+        error: getErrorMessage4(err)
+      });
+    }
+    if (running)
+      timer = setTimeout(tick, POLL_MS);
+  };
+  timer = setTimeout(tick, POLL_MS);
+  logger9.info("Streams reorg poll started", { pollMs: POLL_MS });
+  return () => {
+    running = false;
+    if (timer)
+      clearTimeout(timer);
+  };
+}
+
+// src/runtime/subscription-plane.ts
 import { logger as logger14 } from "@secondlayer/shared/logger";
-import { listen as listen2 } from "@secondlayer/shared/queue/listener";
 
 // src/runtime/chain-reorg.ts
 import { getTargetDb as getTargetDb5 } from "@secondlayer/shared/db";
-import { logger as logger9 } from "@secondlayer/shared/logger";
+import { logger as logger10 } from "@secondlayer/shared/logger";
 var MAX_ORPHANED_PER_SUB = 500;
 async function handleChainReorg(forkHeight, db = getTargetDb5()) {
   await db.deleteFrom("subscription_outbox").where("kind", "=", "chain").where("block_height", ">=", forkHeight).where("status", "=", "pending").where("event_type", "like", "chain.%.apply").execute();
@@ -2556,7 +2640,7 @@ async function handleChainReorg(forkHeight, db = getTargetDb5()) {
       });
     }
     await db.insertInto("subscription_outbox").values(rows).onConflict((oc) => oc.columns(["subscription_id", "dedup_key"]).doNothing()).execute();
-    logger9.info("Chain reorg — emitted rollbacks", {
+    logger10.info("Chain reorg — emitted rollbacks", {
       forkPointHeight: forkHeight,
       subscriptions: bySub.size
     });
@@ -2574,12 +2658,13 @@ import {
   getTargetDb as getTargetDb6
 } from "@secondlayer/shared/db";
 import { getSubscriptionSigningSecret } from "@secondlayer/shared/db/queries/subscriptions";
-import { logger as logger11 } from "@secondlayer/shared/logger";
-import { listen } from "@secondlayer/shared/queue/listener";
+import { logger as logger12 } from "@secondlayer/shared/logger";
+import { listen, targetListenerUrl as targetListenerUrl2 } from "@secondlayer/shared/queue/listener";
 import { sql as sql4 } from "kysely";
 
 // src/runtime/formats/index.ts
-import { logger as logger10 } from "@secondlayer/shared/logger";
+import { signSecondlayerWebhook } from "@secondlayer/shared/crypto/secondlayer-webhook";
+import { logger as logger11 } from "@secondlayer/shared/logger";
 
 // src/runtime/formats/cloudevents.ts
 function buildCloudEvents(outboxRow, _sub) {
@@ -2711,7 +2796,7 @@ function buildTrigger(outboxRow, sub) {
 }
 
 // src/runtime/formats/index.ts
-function buildForFormat(outboxRow, sub, signingSecret) {
+function buildBody(outboxRow, sub, signingSecret) {
   switch (sub.format) {
     case "inngest":
       return buildInngest(outboxRow);
@@ -2726,13 +2811,21 @@ function buildForFormat(outboxRow, sub, signingSecret) {
     case "standard-webhooks":
       return buildStandardWebhooks(outboxRow, signingSecret);
     default:
-      logger10.warn("Unknown subscription format, falling back to standard-webhooks", {
+      logger11.warn("Unknown subscription format, falling back to standard-webhooks", {
         format: sub.format,
         subscriptionId: sub.id
       });
       return buildStandardWebhooks(outboxRow, signingSecret);
   }
 }
+function buildForFormat(outboxRow, sub, signingSecret) {
+  const result = buildBody(outboxRow, sub, signingSecret);
+  const sigHeaders = signSecondlayerWebhook(outboxRow.id, result.body);
+  if (sigHeaders) {
+    result.headers = { ...result.headers, ...sigHeaders };
+  }
+  return result;
+}
 
 // src/runtime/emitter.ts
 var BATCH_SIZE = 50;
@@ -2809,7 +2902,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)";
-    logger11.warn("[emitter] refused private egress", {
+    logger12.warn("[emitter] refused private egress", {
       subscription: sub.name,
       url: sub.url
     });
@@ -2905,7 +2998,7 @@ async function settleFailed(db, outboxRow, sub, errText) {
         circuit_opened_at: new Date,
         updated_at: new Date
       }).where("id", "=", sub.id).execute();
-      logger11.warn("Subscription circuit tripped — paused after consecutive failures", {
+      logger12.warn("Subscription circuit tripped — paused after consecutive failures", {
         subscription: sub.name,
         failures: newFailures
       });
@@ -2993,7 +3086,7 @@ async function drainForSub(db, state, sub, rows) {
             await settleFailed(db, row, sub, err);
           }
         } catch (err) {
-          logger11.error("Emitter dispatch crashed", {
+          logger12.error("Emitter dispatch crashed", {
             outboxId: row.id,
             error: err instanceof Error ? err.message : String(err)
           });
@@ -3030,7 +3123,7 @@ async function startEmitter(opts) {
   };
   const pollIntervalMs = opts?.pollIntervalMs ?? 120000;
   const retentionIntervalMs = opts?.retentionIntervalMs ?? 60 * 60000;
-  logger11.info("[emitter] started", { id: emitterId });
+  logger12.info("[emitter] started", { id: emitterId });
   const MATCHER_BOOT_ATTEMPTS = 5;
   let lastErr = null;
   for (let i = 0;i < MATCHER_BOOT_ATTEMPTS; i++) {
@@ -3041,7 +3134,7 @@ async function startEmitter(opts) {
     } catch (err) {
       lastErr = err;
       const delayMs = 500 * 2 ** i;
-      logger11.warn("[emitter] matcher refresh failed, retrying", {
+      logger12.warn("[emitter] matcher refresh failed, retrying", {
         attempt: i + 1,
         delayMs,
         error: err instanceof Error ? err.message : String(err)
@@ -3052,24 +3145,25 @@ async function startEmitter(opts) {
   if (lastErr) {
     throw new Error(`[emitter] matcher refresh failed ${MATCHER_BOOT_ATTEMPTS}×; aborting boot: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`);
   }
+  const listenUrl = targetListenerUrl2();
   const stopNew = await listen("subscriptions:new_outbox", () => {
     if (!state.running)
       return;
-    claimAndDrain(db, state, emitterId).catch((err) => logger11.error("[emitter] claim failed", {
+    claimAndDrain(db, state, emitterId).catch((err) => logger12.error("[emitter] claim failed", {
       error: err instanceof Error ? err.message : String(err)
     }));
-  });
+  }, { connectionString: listenUrl });
   const stopChanged = await listen("subscriptions:changed", () => {
     if (!state.running)
       return;
-    refreshMatcher(db).catch((err) => logger11.error("[emitter] matcher refresh failed", {
+    refreshMatcher(db).catch((err) => logger12.error("[emitter] matcher refresh failed", {
       error: err instanceof Error ? err.message : String(err)
     }));
-  });
+  }, { connectionString: listenUrl });
   const poll = setInterval(() => {
     if (!state.running)
       return;
-    claimAndDrain(db, state, emitterId).catch((err) => logger11.error("[emitter] poll claim failed", {
+    claimAndDrain(db, state, emitterId).catch((err) => logger12.error("[emitter] poll claim failed", {
       error: err instanceof Error ? err.message : String(err)
     }));
   }, pollIntervalMs);
@@ -3077,7 +3171,7 @@ async function startEmitter(opts) {
   const retention = setInterval(() => {
     if (!state.running)
       return;
-    runRetention(db).catch((err) => logger11.error("[emitter] retention failed", {
+    runRetention(db).catch((err) => logger12.error("[emitter] retention failed", {
       error: err instanceof Error ? err.message : String(err)
     }));
   }, retentionIntervalMs);
@@ -3087,60 +3181,17 @@ async function startEmitter(opts) {
     clearInterval(retention);
     await stopNew();
     await stopChanged();
-    logger11.info("[emitter] stopped", { id: emitterId });
+    logger12.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 logger12 } 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, handleChainReorg2) {
-  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) {
-    logger12.info("Streams reorg — rewinding subgraphs", {
-      forkPointHeight: r.fork_point_height
-    });
-    await handleReorg(r.fork_point_height, loadDef);
-    if (handleChainReorg2)
-      await handleChainReorg2(r.fork_point_height);
-  }
-  return next_since ?? cursor;
-}
-function startStreamsReorgPoll(handleReorg, loadDef, handleChainReorg2) {
-  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, handleChainReorg2);
-    } catch (err) {
-      logger12.error("Streams reorg poll failed", {
-        error: getErrorMessage4(err)
-      });
-    }
-    if (running)
-      timer = setTimeout(tick, POLL_MS);
-  };
-  timer = setTimeout(tick, POLL_MS);
-  logger12.info("Streams reorg poll started", { pollMs: POLL_MS });
-  return () => {
-    running = false;
-    if (timer)
-      clearTimeout(timer);
-  };
-}
+// src/runtime/subscription-leader.ts
+import {
+  SUBSCRIPTION_EVALUATOR_LOCK_KEY,
+  createPostgresLeaderBackend as createPostgresLeaderBackend2,
+  withLeaderLock as withLeaderLock2
+} from "@secondlayer/shared/leader";
+import { targetListenerUrl as targetListenerUrl3 } from "@secondlayer/shared/queue/listener";
 
 // src/runtime/trigger-evaluator-loop.ts
 import { getErrorMessage as getErrorMessage5 } from "@secondlayer/shared";
@@ -3217,10 +3268,11 @@ async function buildTraitContracts(db, chainSubs, asOfBlock) {
 function evaluateBlock(block, sources, traitContracts) {
   return matchSources(sources, block.txs, block.events, traitContracts);
 }
-function chainDedupKey(subscriptionId, txId, eventIndex, blockHash) {
-  return `chain:${subscriptionId}:${txId}:${eventIndex}:${blockHash}`;
+function chainDedupKey(subscriptionId, txId, eventIndex, blockHash, replayId) {
+  const base = `chain:${subscriptionId}:${txId}:${eventIndex}:${blockHash}`;
+  return replayId ? `replay:${replayId}:${base}` : base;
 }
-function applyRow(meta, blockHeight, blockHash, txId, eventIndex, event) {
+function applyRow(meta, blockHeight, blockHash, txId, eventIndex, event, replayId) {
   const payload = {
     action: "apply",
     block_hash: blockHash,
@@ -3240,10 +3292,12 @@ function applyRow(meta, blockHeight, blockHash, txId, eventIndex, event) {
     row_pk: { tx_id: txId, event_index: eventIndex },
     event_type: `chain.${meta.triggerType}.apply`,
     payload,
-    dedup_key: chainDedupKey(meta.subscriptionId, txId, eventIndex, blockHash)
+    dedup_key: chainDedupKey(meta.subscriptionId, txId, eventIndex, blockHash, replayId),
+    ...replayId ? { is_replay: true } : {}
   };
 }
-async function emitChainOutbox(db, matches, keyMeta, blockHeight, blockHash) {
+async function emitChainOutbox(db, matches, keyMeta, blockHeight, blockHash, opts) {
+  const replayId = opts?.replayId;
   const rows = [];
   for (const match of matches) {
     const meta = keyMeta.get(match.sourceName);
@@ -3260,7 +3314,7 @@ async function emitChainOutbox(db, matches, keyMeta, blockHeight, blockHash) {
         function_name: match.tx.function_name ?? null,
         function_args: match.tx.function_args ?? null,
         result_hex: match.tx.raw_result ?? null
-      }));
+      }, replayId));
     } else {
       for (const event of match.events) {
         rows.push(applyRow(meta, blockHeight, blockHash, txId, event.event_index, {
@@ -3268,14 +3322,14 @@ async function emitChainOutbox(db, matches, keyMeta, blockHeight, blockHash) {
           type: event.type,
           event_index: event.event_index,
           data: event.data
-        }));
+        }, replayId));
       }
     }
   }
   if (rows.length === 0)
     return 0;
-  await db.insertInto("subscription_outbox").values(rows).onConflict((oc) => oc.columns(["subscription_id", "dedup_key"]).doNothing()).execute();
-  return rows.length;
+  const result = await db.insertInto("subscription_outbox").values(rows).onConflict((oc) => oc.columns(["subscription_id", "dedup_key"]).doNothing()).executeTakeFirst();
+  return Number(result.numInsertedOrUpdatedRows ?? 0);
 }
 
 // src/runtime/trigger-evaluator-loop.ts
@@ -3357,6 +3411,48 @@ function startTriggerEvaluator() {
   };
 }
 
+// src/runtime/subscription-leader.ts
+var evaluatorLeader = false;
+function isEvaluatorLeader() {
+  return evaluatorLeader;
+}
+function gateChainReorgOnLeader(handler, isLeader = isEvaluatorLeader) {
+  return async (forkHeight) => {
+    if (!isLeader())
+      return;
+    await handler(forkHeight);
+  };
+}
+function startTriggerEvaluatorLeader(opts = {}) {
+  const startWork = opts.startWork ?? startTriggerEvaluator;
+  return withLeaderLock2(SUBSCRIPTION_EVALUATOR_LOCK_KEY, async () => {
+    evaluatorLeader = true;
+    const stop = await startWork();
+    return () => {
+      evaluatorLeader = false;
+      stop();
+    };
+  }, {
+    pollMs: opts.pollMs,
+    heartbeatMs: opts.heartbeatMs,
+    createBackend: opts.createBackend ?? (() => createPostgresLeaderBackend2(targetListenerUrl3()))
+  });
+}
+
+// src/runtime/subscription-plane.ts
+async function startSubscriptionPlane() {
+  const streamsIndex = process.env.SUBGRAPH_SOURCE === "streams-index";
+  const stopChainReorgPoll = streamsIndex ? startStreamsReorgPoll(gateChainReorgOnLeader((forkHeight) => handleChainReorg(forkHeight))) : undefined;
+  const stopTriggerEvaluator = streamsIndex ? startTriggerEvaluatorLeader() : undefined;
+  const stopEmitter = await startEmitter();
+  logger14.info("Subscription plane ready", { streamsIndex });
+  return async () => {
+    stopChainReorgPoll?.();
+    await stopTriggerEvaluator?.();
+    await stopEmitter();
+  };
+}
+
 // src/runtime/processor.ts
 var CHANNEL_NEW_BLOCK = "indexer:new_block";
 var CHANNEL_SUBGRAPH_OPERATIONS = "subgraph_operations:new";
@@ -3380,7 +3476,7 @@ async function catchUpAll(subgraphs, db, concurrency) {
         if (isHandlerNotFoundError(err)) {
           await updateSubgraphStatus3(db, sg.name, "error");
         }
-        logger14.error("Subgraph catch-up failed", {
+        logger15.error("Subgraph catch-up failed", {
           subgraph: sg.name,
           error: msg
         });
@@ -3392,12 +3488,6 @@ async function catchUpAll(subgraphs, db, concurrency) {
 function handlerImportUrl(handlerPath, cacheBust = Date.now()) {
   return `${pathToFileURL(resolve(handlerPath)).href}?t=${cacheBust}`;
 }
-function sourceListenerUrl() {
-  return process.env.SOURCE_DATABASE_URL || process.env.DATABASE_URL;
-}
-function targetListenerUrl() {
-  return process.env.TARGET_DATABASE_URL || process.env.DATABASE_URL;
-}
 function isHandlerNotFoundError(err) {
   if (!(err instanceof Error))
     return false;
@@ -3426,7 +3516,7 @@ async function loadSubgraphDefinition(sg) {
   definitionCache.set(sg.name, def);
   if (prevVersion && prevVersion !== sg.version) {
     invalidateSubgraphRoute(sg.name);
-    logger14.info("Subgraph handler reloaded", {
+    logger15.info("Subgraph handler reloaded", {
       subgraph: sg.name,
       from: prevVersion,
       to: sg.version
@@ -3460,7 +3550,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)
       });
-      logger14.info("Queued legacy reindex resume operation", {
+      logger15.info("Queued legacy reindex resume operation", {
         subgraph: sg.name
       });
     } catch (err) {
@@ -3516,7 +3606,7 @@ async function startSubgraphOperationRunner(opts) {
   const activeRuns = new Map;
   let running = true;
   let draining = false;
-  logger14.info("Starting subgraph operation runner", { concurrency, lockedBy });
+  logger15.info("Starting subgraph operation runner", { concurrency, lockedBy });
   const startOperation = (operation) => {
     const controller = new AbortController;
     active.set(operation.id, controller);
@@ -3524,7 +3614,7 @@ async function startSubgraphOperationRunner(opts) {
       if (!running)
         return;
       heartbeatSubgraphOperation(db, operation.id, lockedBy).catch((err) => {
-        logger14.warn("Subgraph operation heartbeat failed", {
+        logger15.warn("Subgraph operation heartbeat failed", {
           operationId: operation.id,
           error: getErrorMessage6(err)
         });
@@ -3536,7 +3626,7 @@ async function startSubgraphOperationRunner(opts) {
           controller.abort("user-cancelled");
         }
       }).catch((err) => {
-        logger14.warn("Subgraph operation cancel poll failed", {
+        logger15.warn("Subgraph operation cancel poll failed", {
           operationId: operation.id,
           error: getErrorMessage6(err)
         });
@@ -3553,14 +3643,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);
-          logger14.info("Subgraph operation cancelled", {
+          logger15.info("Subgraph operation cancelled", {
             operationId: operation.id,
             subgraph: operation.subgraph_name
           });
           return;
         }
         if (controller.signal.aborted) {
-          logger14.info("Subgraph operation interrupted", {
+          logger15.info("Subgraph operation interrupted", {
             operationId: operation.id,
             subgraph: operation.subgraph_name,
             reason
@@ -3568,7 +3658,7 @@ async function startSubgraphOperationRunner(opts) {
           return;
         }
         await completeSubgraphOperation(db, operation.id, lockedBy, processed);
-        logger14.info("Subgraph operation completed", {
+        logger15.info("Subgraph operation completed", {
           operationId: operation.id,
           subgraph: operation.subgraph_name,
           processed
@@ -3576,7 +3666,7 @@ async function startSubgraphOperationRunner(opts) {
       } catch (err) {
         const reason = String(controller.signal.reason ?? "");
         if (controller.signal.aborted && reason === "shutdown") {
-          logger14.info("Subgraph operation interrupted by shutdown", {
+          logger15.info("Subgraph operation interrupted by shutdown", {
             operationId: operation.id,
             subgraph: operation.subgraph_name
           });
@@ -3587,7 +3677,7 @@ async function startSubgraphOperationRunner(opts) {
           return;
         }
         await failSubgraphOperation(db, operation.id, lockedBy, getErrorMessage6(err), processed);
-        logger14.error("Subgraph operation failed", {
+        logger15.error("Subgraph operation failed", {
           operationId: operation.id,
           subgraph: operation.subgraph_name,
           error: getErrorMessage6(err)
@@ -3622,7 +3712,7 @@ async function startSubgraphOperationRunner(opts) {
   await drain();
   const stopListening = await listen2(CHANNEL_SUBGRAPH_OPERATIONS, () => {
     drain();
-  }, { connectionString: targetListenerUrl() });
+  }, { connectionString: targetListenerUrl4() });
   const pollInterval = setInterval(() => {
     drain();
   }, POLL_INTERVAL_MS);
@@ -3634,26 +3724,27 @@ async function startSubgraphOperationRunner(opts) {
       controller.abort("shutdown");
     }
     await Promise.allSettled(activeRuns.values());
-    logger14.info("Subgraph operation runner stopped");
+    logger15.info("Subgraph operation runner stopped");
   };
 }
 async function startSubgraphProcessor(opts) {
   const concurrency = opts?.concurrency ?? DEFAULT_CONCURRENCY;
   let running = true;
-  logger14.info("Starting subgraph processor", { concurrency });
+  logger15.info("Starting subgraph processor", { concurrency });
   const stopOperations = await startSubgraphOperationRunner({
     concurrency: Number.parseInt(process.env.SUBGRAPH_OPERATION_CONCURRENCY ?? String(DEFAULT_OPERATION_CONCURRENCY))
   });
-  const targetDb = getTargetDb8();
-  const activeSubgraphs = (await listSubgraphs2(targetDb)).filter((v) => v.status === "active");
-  await catchUpAll(activeSubgraphs, targetDb, concurrency);
-  const stopListening = await listen2(CHANNEL_NEW_BLOCK, async () => {
-    if (!running)
+  const runCatchUp = async () => {
+    if (!running || !isCatchUpLeader())
       return;
     const db = getTargetDb8();
     const subgraphs = (await listSubgraphs2(db)).filter((v) => v.status === "active");
     cleanupCaches(subgraphs);
     await catchUpAll(subgraphs, db, concurrency);
+  };
+  const stopCatchUpLeader = startCatchUpLeader({ onAcquire: runCatchUp });
+  const stopListening = await listen2(CHANNEL_NEW_BLOCK, async () => {
+    await runCatchUp();
   }, { connectionString: sourceListenerUrl() });
   const stopReorgListening = await listen2("subgraph_reorg", async (payload) => {
     if (!running)
@@ -3665,39 +3756,33 @@ async function startSubgraphProcessor(opts) {
         await handleSubgraphReorg(blockHeight, loadSubgraphDefinition);
       }
     } catch (err) {
-      logger14.error("Subgraph reorg handling failed", {
+      logger15.error("Subgraph reorg handling failed", {
         error: getErrorMessage6(err)
       });
     }
   }, { connectionString: sourceListenerUrl() });
-  const pollInterval = setInterval(async () => {
-    if (!running)
-      return;
-    const db = getTargetDb8();
-    const subgraphs = (await listSubgraphs2(db)).filter((v) => v.status === "active");
-    cleanupCaches(subgraphs);
-    await catchUpAll(subgraphs, db, concurrency);
+  const pollInterval = setInterval(() => {
+    runCatchUp();
   }, POLL_INTERVAL_MS);
-  const stopStreamsReorgPoll = process.env.SUBGRAPH_SOURCE === "streams-index" ? startStreamsReorgPoll(handleSubgraphReorg, loadSubgraphDefinition, (forkHeight) => handleChainReorg(forkHeight)) : undefined;
-  const stopTriggerEvaluator = process.env.SUBGRAPH_SOURCE === "streams-index" ? startTriggerEvaluator() : undefined;
-  const stopEmitter = await startEmitter();
-  logger14.info("Subgraph processor ready");
+  const stopStreamsReorgPoll = process.env.SUBGRAPH_SOURCE === "streams-index" ? startStreamsReorgPoll((forkHeight) => handleSubgraphReorg(forkHeight, loadSubgraphDefinition)) : undefined;
+  const stopSubscriptionPlane = await startSubscriptionPlane();
+  logger15.info("Subgraph processor ready");
   return async () => {
     running = false;
     clearInterval(pollInterval);
+    await stopCatchUpLeader();
     await stopListening();
     await stopReorgListening();
     stopStreamsReorgPoll?.();
-    stopTriggerEvaluator?.();
+    await stopSubscriptionPlane();
     await stopOperations();
-    await stopEmitter();
-    logger14.info("Subgraph processor stopped");
+    logger15.info("Subgraph processor stopped");
   };
 }
 
 // src/service.ts
 import { assertDbSplit, getDb } from "@secondlayer/shared/db";
-import { logger as logger15 } from "@secondlayer/shared/logger";
+import { logger as logger16 } from "@secondlayer/shared/logger";
 import { sql as sql5 } from "kysely";
 var HEARTBEAT_INTERVAL_MS2 = 30000;
 var SERVICE_NAME = "subgraph-processor";
@@ -3705,7 +3790,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) {
-    logger15.warn("subgraph-processor heartbeat write failed", {
+    logger16.warn("subgraph-processor heartbeat write failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
@@ -3717,7 +3802,7 @@ var processor = await startSubgraphProcessor({
 await writeHeartbeat();
 var heartbeatInterval = setInterval(writeHeartbeat, HEARTBEAT_INTERVAL_MS2);
 var shutdown = async () => {
-  logger15.info("Shutting down subgraph processor...");
+  logger16.info("Shutting down subgraph processor...");
   clearInterval(heartbeatInterval);
   await processor();
   process.exit(0);
@@ -3725,5 +3810,5 @@ var shutdown = async () => {
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
 
-//# debugId=FC45FDEF6FFE3A5D64756E2164756E21
+//# debugId=6699532419F8689F64756E2164756E21
 //# sourceMappingURL=service.js.map