@secondlayer/subgraphs 3.6.0 → 3.7.0

package/dist/src/service.js

@@ -578,9 +578,11 @@ function buildEventPayload(filter, tx, event) {
       };
     }
     case "contract_call": {
+      const ccRawHex = event.data?.raw_value;
+      const normalized = typeof ccRawHex === "string" && ccRawHex.startsWith("0x") ? { ...decoded, value: decodeClarityValue(ccRawHex) } : decoded;
       const input = buildContractCallInput(filter, tx);
       return {
-        ...decoded,
+        ...normalized,
         type: "contract_call",
         _eventType: event.type,
         contractId: tx.contract_id ?? "",
@@ -1089,7 +1091,7 @@ function reconstructEvent(e) {
           sender: e.sender,
           recipient: e.recipient,
           amount: e.amount,
-          ..."memo" in e ? { memo: e.memo ?? undefined } : {}
+          ...e.event_type === "stx_transfer" ? { memo: e.memo ?? "" } : {}
         }
       };
     case "stx_lock":
@@ -1108,7 +1110,6 @@ function reconstructEvent(e) {
         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
@@ -1148,19 +1149,21 @@ 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))) {
+function indexEventTypesForFilterTypes(filterTypes) {
+  if (filterTypes.some((t) => TX_SOURCE_TYPES.has(t))) {
     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);
+  for (const t of filterTypes) {
+    const indexType = EVENT_FILTER_TO_INDEX_TYPE[t];
+    if (indexType)
+      types.add(indexType);
   }
   return [...types];
 }
+function referencedIndexEventTypes(subgraph) {
+  return indexEventTypesForFilterTypes(sourceFilters(subgraph).map((f) => f.type));
+}
 function isStreamsIndexEligible(subgraph) {
   if (Array.isArray(subgraph.sources))
     return false;
@@ -1422,6 +1425,8 @@ class SubscriptionMatcher {
     for (const sub of subs) {
       if (sub.status !== "active")
         continue;
+      if (sub.kind !== "subgraph" || !sub.subgraph_name || !sub.table_name)
+        continue;
       this.byId.set(sub.id, sub);
       const k = key(sub.subgraph_name, sub.table_name);
       const arr = this.byKey.get(k);
@@ -2491,8 +2496,8 @@ import { randomUUID } from "node:crypto";
 import { hostname } from "node:os";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
-import { getErrorMessage as getErrorMessage5 } from "@secondlayer/shared";
-import { getTargetDb as getTargetDb6 } from "@secondlayer/shared/db";
+import { getErrorMessage as getErrorMessage6 } from "@secondlayer/shared";
+import { getTargetDb as getTargetDb8 } from "@secondlayer/shared/db";
 import {
   cancelSubgraphOperation,
   claimSubgraphOperation,
@@ -2510,20 +2515,71 @@ import {
   pgSchemaName as pgSchemaName2,
   updateSubgraphStatus as updateSubgraphStatus3
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger12 } from "@secondlayer/shared/logger";
+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";
+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();
+  const delivered = await db.selectFrom("subscription_outbox").select(["subscription_id", "tx_id", "payload"]).where("kind", "=", "chain").where("block_height", ">=", forkHeight).where("status", "=", "delivered").where("event_type", "like", "chain.%.apply").orderBy("block_height").orderBy("id").execute();
+  const bySub = new Map;
+  for (const row of delivered) {
+    const list = bySub.get(row.subscription_id) ?? [];
+    const payload = row.payload;
+    list.push({ tx_id: row.tx_id, event: payload?.event ?? null });
+    bySub.set(row.subscription_id, list);
+  }
+  if (bySub.size > 0) {
+    const rows = [];
+    for (const [subscriptionId, entries] of bySub) {
+      const truncated = entries.length > MAX_ORPHANED_PER_SUB;
+      const payload = {
+        action: "rollback",
+        fork_point_height: forkHeight,
+        orphaned: truncated ? entries.slice(0, MAX_ORPHANED_PER_SUB) : entries,
+        truncated
+      };
+      rows.push({
+        subscription_id: subscriptionId,
+        kind: "chain",
+        subgraph_name: null,
+        table_name: null,
+        block_height: forkHeight,
+        tx_id: null,
+        row_pk: { fork_point_height: forkHeight },
+        event_type: "chain.reorg.rollback",
+        payload,
+        dedup_key: `chainreorg:${subscriptionId}:${forkHeight}`
+      });
+    }
+    await db.insertInto("subscription_outbox").values(rows).onConflict((oc) => oc.columns(["subscription_id", "dedup_key"]).doNothing()).execute();
+    logger9.info("Chain reorg — emitted rollbacks", {
+      forkPointHeight: forkHeight,
+      subscriptions: bySub.size
+    });
+  }
+  await db.transaction().execute(async (trx) => {
+    const cur = await trx.selectFrom("trigger_evaluator_state").select("last_processed_block").where("id", "=", true).forUpdate().executeTakeFirst();
+    if (cur && Number(cur.last_processed_block) >= forkHeight) {
+      await trx.updateTable("trigger_evaluator_state").set({ last_processed_block: forkHeight - 1, updated_at: new Date }).where("id", "=", true).execute();
+    }
+  });
+}
+
 // src/runtime/emitter.ts
 import {
-  getTargetDb as getTargetDb5
+  getTargetDb as getTargetDb6
 } from "@secondlayer/shared/db";
 import { getSubscriptionSigningSecret } from "@secondlayer/shared/db/queries/subscriptions";
-import { logger as logger10 } from "@secondlayer/shared/logger";
+import { logger as logger11 } 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 logger9 } from "@secondlayer/shared/logger";
+import { logger as logger10 } from "@secondlayer/shared/logger";
 
 // src/runtime/formats/cloudevents.ts
 function buildCloudEvents(outboxRow, _sub) {
@@ -2670,7 +2726,7 @@ function buildForFormat(outboxRow, sub, signingSecret) {
     case "standard-webhooks":
       return buildStandardWebhooks(outboxRow, signingSecret);
     default:
-      logger9.warn("Unknown subscription format, falling back to standard-webhooks", {
+      logger10.warn("Unknown subscription format, falling back to standard-webhooks", {
         format: sub.format,
         subscriptionId: sub.id
       });
@@ -2753,7 +2809,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)";
-    logger10.warn("[emitter] refused private egress", {
+    logger11.warn("[emitter] refused private egress", {
       subscription: sub.name,
       url: sub.url
     });
@@ -2849,7 +2905,7 @@ async function settleFailed(db, outboxRow, sub, errText) {
         circuit_opened_at: new Date,
         updated_at: new Date
       }).where("id", "=", sub.id).execute();
-      logger10.warn("Subscription circuit tripped — paused after consecutive failures", {
+      logger11.warn("Subscription circuit tripped — paused after consecutive failures", {
         subscription: sub.name,
         failures: newFailures
       });
@@ -2937,7 +2993,7 @@ async function drainForSub(db, state, sub, rows) {
             await settleFailed(db, row, sub, err);
           }
         } catch (err) {
-          logger10.error("Emitter dispatch crashed", {
+          logger11.error("Emitter dispatch crashed", {
             outboxId: row.id,
             error: err instanceof Error ? err.message : String(err)
           });
@@ -2966,7 +3022,7 @@ async function runRetention(db) {
 }
 async function startEmitter(opts) {
   const emitterId = `emitter-${Math.random().toString(36).slice(2, 10)}`;
-  const db = getTargetDb5();
+  const db = getTargetDb6();
   const state = {
     running: true,
     inFlightBySub: new Map,
@@ -2974,7 +3030,7 @@ async function startEmitter(opts) {
   };
   const pollIntervalMs = opts?.pollIntervalMs ?? 120000;
   const retentionIntervalMs = opts?.retentionIntervalMs ?? 60 * 60000;
-  logger10.info("[emitter] started", { id: emitterId });
+  logger11.info("[emitter] started", { id: emitterId });
   const MATCHER_BOOT_ATTEMPTS = 5;
   let lastErr = null;
   for (let i = 0;i < MATCHER_BOOT_ATTEMPTS; i++) {
@@ -2985,7 +3041,7 @@ async function startEmitter(opts) {
     } catch (err) {
       lastErr = err;
       const delayMs = 500 * 2 ** i;
-      logger10.warn("[emitter] matcher refresh failed, retrying", {
+      logger11.warn("[emitter] matcher refresh failed, retrying", {
         attempt: i + 1,
         delayMs,
         error: err instanceof Error ? err.message : String(err)
@@ -2999,21 +3055,21 @@ async function startEmitter(opts) {
   const stopNew = await listen("subscriptions:new_outbox", () => {
     if (!state.running)
       return;
-    claimAndDrain(db, state, emitterId).catch((err) => logger10.error("[emitter] claim failed", {
+    claimAndDrain(db, state, emitterId).catch((err) => logger11.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) => logger10.error("[emitter] matcher refresh failed", {
+    refreshMatcher(db).catch((err) => logger11.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) => logger10.error("[emitter] poll claim failed", {
+    claimAndDrain(db, state, emitterId).catch((err) => logger11.error("[emitter] poll claim failed", {
       error: err instanceof Error ? err.message : String(err)
     }));
   }, pollIntervalMs);
@@ -3021,7 +3077,7 @@ async function startEmitter(opts) {
   const retention = setInterval(() => {
     if (!state.running)
       return;
-    runRetention(db).catch((err) => logger10.error("[emitter] retention failed", {
+    runRetention(db).catch((err) => logger11.error("[emitter] retention failed", {
       error: err instanceof Error ? err.message : String(err)
     }));
   }, retentionIntervalMs);
@@ -3031,28 +3087,30 @@ async function startEmitter(opts) {
     clearInterval(retention);
     await stopNew();
     await stopChanged();
-    logger10.info("[emitter] stopped", { id: emitterId });
+    logger11.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";
+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) {
+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) {
-    logger11.info("Streams reorg — rewinding subgraphs", {
+    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) {
+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,
@@ -3066,9 +3124,9 @@ function startStreamsReorgPoll(handleReorg, loadDef) {
     if (!running)
       return;
     try {
-      since = await pollReorgsOnce(http, since, handleReorg, loadDef);
+      since = await pollReorgsOnce(http, since, handleReorg, loadDef, handleChainReorg2);
     } catch (err) {
-      logger11.error("Streams reorg poll failed", {
+      logger12.error("Streams reorg poll failed", {
         error: getErrorMessage4(err)
       });
     }
@@ -3076,7 +3134,222 @@ function startStreamsReorgPoll(handleReorg, loadDef) {
       timer = setTimeout(tick, POLL_MS);
   };
   timer = setTimeout(tick, POLL_MS);
-  logger11.info("Streams reorg poll started", { pollMs: POLL_MS });
+  logger12.info("Streams reorg poll started", { pollMs: POLL_MS });
+  return () => {
+    running = false;
+    if (timer)
+      clearTimeout(timer);
+  };
+}
+
+// src/runtime/trigger-evaluator-loop.ts
+import { getErrorMessage as getErrorMessage5 } from "@secondlayer/shared";
+import { getTargetDb as getTargetDb7 } from "@secondlayer/shared/db";
+import { listActiveChainSubscriptions } from "@secondlayer/shared/db/queries/subscriptions";
+import { logger as logger13 } from "@secondlayer/shared/logger";
+
+// src/runtime/trigger-evaluator.ts
+import { resolveTraitContractIds as resolveTraitContractIds2 } from "@secondlayer/shared/db/queries/contracts";
+var TX_LEVEL_TRIGGER_TYPES = new Set(["contract_call", "contract_deploy"]);
+function sourceKey(subscriptionId, triggerIndex) {
+  return `${subscriptionId}#${triggerIndex}`;
+}
+function toAmount(v) {
+  return v === undefined ? undefined : BigInt(v);
+}
+function chainTriggerToFilter(trigger) {
+  const t = trigger;
+  const filter = { ...trigger };
+  const minAmount = toAmount(t.minAmount);
+  const maxAmount = toAmount(t.maxAmount);
+  if (minAmount !== undefined)
+    filter.minAmount = minAmount;
+  if (maxAmount !== undefined)
+    filter.maxAmount = maxAmount;
+  return filter;
+}
+function triggersOf(sub) {
+  return sub.triggers ?? [];
+}
+function buildSourcesMap(chainSubs) {
+  const sources = {};
+  const keyMeta = new Map;
+  for (const sub of chainSubs) {
+    triggersOf(sub).forEach((trigger, triggerIndex) => {
+      const key2 = sourceKey(sub.id, triggerIndex);
+      sources[key2] = chainTriggerToFilter(trigger);
+      keyMeta.set(key2, {
+        subscriptionId: sub.id,
+        triggerIndex,
+        triggerType: trigger.type
+      });
+    });
+  }
+  return { sources, keyMeta };
+}
+function referencedEventTypes(chainSubs) {
+  const filterTypes = new Set;
+  for (const sub of chainSubs) {
+    for (const trigger of triggersOf(sub))
+      filterTypes.add(trigger.type);
+  }
+  return indexEventTypesForFilterTypes([...filterTypes]);
+}
+function referencedTraits(chainSubs) {
+  const traits = new Set;
+  for (const sub of chainSubs) {
+    for (const trigger of triggersOf(sub)) {
+      const trait = trigger.trait;
+      if (trait)
+        traits.add(trait);
+    }
+  }
+  return [...traits];
+}
+async function buildTraitContracts(db, chainSubs, asOfBlock) {
+  const resolved = new Map;
+  for (const trait of referencedTraits(chainSubs)) {
+    const ids = await resolveTraitContractIds2(db, trait, asOfBlock);
+    resolved.set(trait, new Set(ids));
+  }
+  return resolved;
+}
+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 applyRow(meta, blockHeight, blockHash, txId, eventIndex, event) {
+  const payload = {
+    action: "apply",
+    block_hash: blockHash,
+    block_height: blockHeight,
+    tx_id: txId,
+    canonical: true,
+    trigger: meta.triggerType,
+    event
+  };
+  return {
+    subscription_id: meta.subscriptionId,
+    kind: "chain",
+    subgraph_name: null,
+    table_name: null,
+    block_height: blockHeight,
+    tx_id: txId,
+    row_pk: { tx_id: txId, event_index: eventIndex },
+    event_type: `chain.${meta.triggerType}.apply`,
+    payload,
+    dedup_key: chainDedupKey(meta.subscriptionId, txId, eventIndex, blockHash)
+  };
+}
+async function emitChainOutbox(db, matches, keyMeta, blockHeight, blockHash) {
+  const rows = [];
+  for (const match of matches) {
+    const meta = keyMeta.get(match.sourceName);
+    if (!meta)
+      continue;
+    const txId = match.tx.tx_id;
+    if (TX_LEVEL_TRIGGER_TYPES.has(meta.triggerType)) {
+      rows.push(applyRow(meta, blockHeight, blockHash, txId, -1, {
+        tx_id: txId,
+        type: match.tx.type,
+        sender: match.tx.sender,
+        status: match.tx.status,
+        contract_id: match.tx.contract_id ?? null,
+        function_name: match.tx.function_name ?? null,
+        function_args: match.tx.function_args ?? null,
+        result_hex: match.tx.raw_result ?? null
+      }));
+    } else {
+      for (const event of match.events) {
+        rows.push(applyRow(meta, blockHeight, blockHash, txId, event.event_index, {
+          tx_id: txId,
+          type: event.type,
+          event_index: event.event_index,
+          data: event.data
+        }));
+      }
+    }
+  }
+  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;
+}
+
+// src/runtime/trigger-evaluator-loop.ts
+var POLL_MS2 = Number(process.env.TRIGGER_EVALUATOR_POLL_MS) || 5000;
+var BATCH = Number(process.env.TRIGGER_EVALUATOR_BATCH) || 200;
+var MAX_BLOCKS_PER_TICK = Number(process.env.TRIGGER_EVALUATOR_MAX_BLOCKS) || 2000;
+async function readCursor(db) {
+  const row = await db.selectFrom("trigger_evaluator_state").select("last_processed_block").where("id", "=", true).executeTakeFirst();
+  return row ? Number(row.last_processed_block) : 0;
+}
+async function advanceCursor(db, to) {
+  await db.transaction().execute(async (trx) => {
+    const cur = await trx.selectFrom("trigger_evaluator_state").select("last_processed_block").where("id", "=", true).forUpdate().executeTakeFirst();
+    if (cur && Number(cur.last_processed_block) < to) {
+      await trx.updateTable("trigger_evaluator_state").set({ last_processed_block: to, updated_at: new Date }).where("id", "=", true).execute();
+    }
+  });
+}
+async function runEvaluatorOnce(db = getTargetDb7()) {
+  const chainSubs = await listActiveChainSubscriptions(db);
+  const source = new PublicApiBlockSource(buildHttpClient(), referencedEventTypes(chainSubs));
+  const tip = await source.getTip();
+  if (tip <= 0)
+    return 0;
+  const cursor = await readCursor(db);
+  if (cursor === 0 || chainSubs.length === 0) {
+    await advanceCursor(db, tip);
+    return 0;
+  }
+  if (cursor >= tip)
+    return 0;
+  const { sources, keyMeta } = buildSourcesMap(chainSubs);
+  const target = Math.min(tip, cursor + MAX_BLOCKS_PER_TICK);
+  let emitted = 0;
+  for (let from = cursor + 1;from <= target; from = from + BATCH) {
+    const to = Math.min(from + BATCH - 1, target);
+    const blocks = await source.loadBlockRange(from, to);
+    const traitContracts = await buildTraitContracts(db, chainSubs, to);
+    for (let h = from;h <= to; h++) {
+      const bd = blocks.get(h);
+      if (!bd)
+        continue;
+      const matches = evaluateBlock(bd, sources, traitContracts);
+      if (matches.length === 0)
+        continue;
+      emitted += await emitChainOutbox(db, matches, keyMeta, h, bd.block.hash);
+    }
+    await advanceCursor(db, to);
+  }
+  return emitted;
+}
+function startTriggerEvaluator() {
+  let running = true;
+  let timer;
+  const tick = async () => {
+    if (!running)
+      return;
+    try {
+      const emitted = await runEvaluatorOnce();
+      if (emitted > 0) {
+        logger13.info("Trigger evaluator emitted chain deliveries", {
+          count: emitted
+        });
+      }
+    } catch (err) {
+      logger13.error("Trigger evaluator tick failed", {
+        error: getErrorMessage5(err)
+      });
+    }
+    if (running)
+      timer = setTimeout(tick, POLL_MS2);
+  };
+  timer = setTimeout(tick, POLL_MS2);
+  logger13.info("Trigger evaluator started", { pollMs: POLL_MS2 });
   return () => {
     running = false;
     if (timer)
@@ -3103,11 +3376,11 @@ async function catchUpAll(subgraphs, db, concurrency) {
         const def = await loadSubgraphDefinition(sg);
         await catchUpSubgraph(def, sg.name);
       } catch (err) {
-        const msg = getErrorMessage5(err);
+        const msg = getErrorMessage6(err);
         if (isHandlerNotFoundError(err)) {
           await updateSubgraphStatus3(db, sg.name, "error");
         }
-        logger12.error("Subgraph catch-up failed", {
+        logger14.error("Subgraph catch-up failed", {
           subgraph: sg.name,
           error: msg
         });
@@ -3153,7 +3426,7 @@ async function loadSubgraphDefinition(sg) {
   definitionCache.set(sg.name, def);
   if (prevVersion && prevVersion !== sg.version) {
     invalidateSubgraphRoute(sg.name);
-    logger12.info("Subgraph handler reloaded", {
+    logger14.info("Subgraph handler reloaded", {
       subgraph: sg.name,
       from: prevVersion,
       to: sg.version
@@ -3172,7 +3445,7 @@ function cleanupCaches(active) {
   }
 }
 async function synthesizeLegacyReindexOperations() {
-  const db = getTargetDb6();
+  const db = getTargetDb8();
   const stale = (await listSubgraphs2(db)).filter((sg) => sg.status === "reindexing");
   for (const sg of stale) {
     const active = await findActiveSubgraphOperation(db, sg.id);
@@ -3187,7 +3460,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)
       });
-      logger12.info("Queued legacy reindex resume operation", {
+      logger14.info("Queued legacy reindex resume operation", {
         subgraph: sg.name
       });
     } catch (err) {
@@ -3201,7 +3474,7 @@ async function runSubgraphOperation(operation, signal) {
   if (operation.cancel_requested) {
     return 0;
   }
-  const db = getTargetDb6();
+  const db = getTargetDb8();
   const subgraph = await db.selectFrom("subgraphs").selectAll().where("id", "=", operation.subgraph_id).executeTakeFirst();
   if (!subgraph)
     throw new Error(`Subgraph not found: ${operation.subgraph_id}`);
@@ -3237,13 +3510,13 @@ async function runSubgraphOperation(operation, signal) {
 }
 async function startSubgraphOperationRunner(opts) {
   const concurrency = opts?.concurrency ?? DEFAULT_OPERATION_CONCURRENCY;
-  const db = getTargetDb6();
+  const db = getTargetDb8();
   const lockedBy = `${hostname()}:${process.pid}:${randomUUID()}`;
   const active = new Map;
   const activeRuns = new Map;
   let running = true;
   let draining = false;
-  logger12.info("Starting subgraph operation runner", { concurrency, lockedBy });
+  logger14.info("Starting subgraph operation runner", { concurrency, lockedBy });
   const startOperation = (operation) => {
     const controller = new AbortController;
     active.set(operation.id, controller);
@@ -3251,9 +3524,9 @@ async function startSubgraphOperationRunner(opts) {
       if (!running)
         return;
       heartbeatSubgraphOperation(db, operation.id, lockedBy).catch((err) => {
-        logger12.warn("Subgraph operation heartbeat failed", {
+        logger14.warn("Subgraph operation heartbeat failed", {
           operationId: operation.id,
-          error: getErrorMessage5(err)
+          error: getErrorMessage6(err)
         });
       });
     }, HEARTBEAT_INTERVAL_MS);
@@ -3263,9 +3536,9 @@ async function startSubgraphOperationRunner(opts) {
           controller.abort("user-cancelled");
         }
       }).catch((err) => {
-        logger12.warn("Subgraph operation cancel poll failed", {
+        logger14.warn("Subgraph operation cancel poll failed", {
           operationId: operation.id,
-          error: getErrorMessage5(err)
+          error: getErrorMessage6(err)
         });
       });
     }, CANCEL_POLL_INTERVAL_MS);
@@ -3280,14 +3553,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);
-          logger12.info("Subgraph operation cancelled", {
+          logger14.info("Subgraph operation cancelled", {
             operationId: operation.id,
             subgraph: operation.subgraph_name
           });
           return;
         }
         if (controller.signal.aborted) {
-          logger12.info("Subgraph operation interrupted", {
+          logger14.info("Subgraph operation interrupted", {
             operationId: operation.id,
             subgraph: operation.subgraph_name,
             reason
@@ -3295,7 +3568,7 @@ async function startSubgraphOperationRunner(opts) {
           return;
         }
         await completeSubgraphOperation(db, operation.id, lockedBy, processed);
-        logger12.info("Subgraph operation completed", {
+        logger14.info("Subgraph operation completed", {
           operationId: operation.id,
           subgraph: operation.subgraph_name,
           processed
@@ -3303,7 +3576,7 @@ async function startSubgraphOperationRunner(opts) {
       } catch (err) {
         const reason = String(controller.signal.reason ?? "");
         if (controller.signal.aborted && reason === "shutdown") {
-          logger12.info("Subgraph operation interrupted by shutdown", {
+          logger14.info("Subgraph operation interrupted by shutdown", {
             operationId: operation.id,
             subgraph: operation.subgraph_name
           });
@@ -3313,11 +3586,11 @@ async function startSubgraphOperationRunner(opts) {
           await cancelSubgraphOperation(db, operation.id, lockedBy, processed);
           return;
         }
-        await failSubgraphOperation(db, operation.id, lockedBy, getErrorMessage5(err), processed);
-        logger12.error("Subgraph operation failed", {
+        await failSubgraphOperation(db, operation.id, lockedBy, getErrorMessage6(err), processed);
+        logger14.error("Subgraph operation failed", {
           operationId: operation.id,
           subgraph: operation.subgraph_name,
-          error: getErrorMessage5(err)
+          error: getErrorMessage6(err)
         });
       } finally {
         clearInterval(heartbeat);
@@ -3361,23 +3634,23 @@ async function startSubgraphOperationRunner(opts) {
       controller.abort("shutdown");
     }
     await Promise.allSettled(activeRuns.values());
-    logger12.info("Subgraph operation runner stopped");
+    logger14.info("Subgraph operation runner stopped");
   };
 }
 async function startSubgraphProcessor(opts) {
   const concurrency = opts?.concurrency ?? DEFAULT_CONCURRENCY;
   let running = true;
-  logger12.info("Starting subgraph processor", { concurrency });
+  logger14.info("Starting subgraph processor", { concurrency });
   const stopOperations = await startSubgraphOperationRunner({
     concurrency: Number.parseInt(process.env.SUBGRAPH_OPERATION_CONCURRENCY ?? String(DEFAULT_OPERATION_CONCURRENCY))
   });
-  const targetDb = getTargetDb6();
+  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)
       return;
-    const db = getTargetDb6();
+    const db = getTargetDb8();
     const subgraphs = (await listSubgraphs2(db)).filter((v) => v.status === "active");
     cleanupCaches(subgraphs);
     await catchUpAll(subgraphs, db, concurrency);
@@ -3392,37 +3665,39 @@ async function startSubgraphProcessor(opts) {
         await handleSubgraphReorg(blockHeight, loadSubgraphDefinition);
       }
     } catch (err) {
-      logger12.error("Subgraph reorg handling failed", {
-        error: getErrorMessage5(err)
+      logger14.error("Subgraph reorg handling failed", {
+        error: getErrorMessage6(err)
       });
     }
   }, { connectionString: sourceListenerUrl() });
   const pollInterval = setInterval(async () => {
     if (!running)
       return;
-    const db = getTargetDb6();
+    const db = getTargetDb8();
     const subgraphs = (await listSubgraphs2(db)).filter((v) => v.status === "active");
     cleanupCaches(subgraphs);
     await catchUpAll(subgraphs, db, concurrency);
   }, POLL_INTERVAL_MS);
-  const stopStreamsReorgPoll = process.env.SUBGRAPH_SOURCE === "streams-index" ? startStreamsReorgPoll(handleSubgraphReorg, loadSubgraphDefinition) : undefined;
+  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();
-  logger12.info("Subgraph processor ready");
+  logger14.info("Subgraph processor ready");
   return async () => {
     running = false;
     clearInterval(pollInterval);
     await stopListening();
     await stopReorgListening();
     stopStreamsReorgPoll?.();
+    stopTriggerEvaluator?.();
     await stopOperations();
     await stopEmitter();
-    logger12.info("Subgraph processor stopped");
+    logger14.info("Subgraph processor stopped");
   };
 }
 
 // src/service.ts
 import { getDb } from "@secondlayer/shared/db";
-import { logger as logger13 } from "@secondlayer/shared/logger";
+import { logger as logger15 } from "@secondlayer/shared/logger";
 import { sql as sql5 } from "kysely";
 var HEARTBEAT_INTERVAL_MS2 = 30000;
 var SERVICE_NAME = "subgraph-processor";
@@ -3430,7 +3705,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) {
-    logger13.warn("subgraph-processor heartbeat write failed", {
+    logger15.warn("subgraph-processor heartbeat write failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
@@ -3441,7 +3716,7 @@ var processor = await startSubgraphProcessor({
 await writeHeartbeat();
 var heartbeatInterval = setInterval(writeHeartbeat, HEARTBEAT_INTERVAL_MS2);
 var shutdown = async () => {
-  logger13.info("Shutting down subgraph processor...");
+  logger15.info("Shutting down subgraph processor...");
   clearInterval(heartbeatInterval);
   await processor();
   process.exit(0);
@@ -3449,5 +3724,5 @@ var shutdown = async () => {
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
 
-//# debugId=7F079106165EB8F064756E2164756E21
+//# debugId=4BE2D954B659151B64756E2164756E21
 //# sourceMappingURL=service.js.map