@secondlayer/subgraphs 3.7.2 → 3.7.4

package/dist/src/runtime/replay.js

@@ -1,16 +1,661 @@
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/runtime/source-matcher.ts
+var patternCache = new Map;
+function matchPattern(value, pattern) {
+  if (!pattern.includes("*"))
+    return value === pattern;
+  let re = patternCache.get(pattern);
+  if (!re) {
+    const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    re = new RegExp(`^${regex}$`);
+    patternCache.set(pattern, re);
+  }
+  return re.test(value);
+}
+var EMPTY_SET = new Set;
+function traitAllows(filter, contractId, traitContracts) {
+  const trait = filter.trait;
+  if (!trait)
+    return true;
+  if (!contractId)
+    return false;
+  return (traitContracts.get(trait) ?? EMPTY_SET).has(contractId);
+}
+function assetContract(assetId) {
+  return assetId?.split("::")[0];
+}
+function matchFilter(filter, transactions, eventsByTx, traitContracts) {
+  const results = [];
+  switch (filter.type) {
+    case "stx_transfer":
+    case "stx_mint":
+    case "stx_burn":
+    case "stx_lock": {
+      const eventType = `${filter.type}_event`;
+      for (const tx of transactions) {
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        const matched = txEvents.filter((e) => e.type === eventType);
+        if (matched.length === 0)
+          continue;
+        const filtered = matched.filter((e) => {
+          const data = e.data;
+          if (!data)
+            return false;
+          if ("sender" in filter && filter.sender) {
+            if (!matchPattern(data.sender, filter.sender))
+              return false;
+          }
+          if ("recipient" in filter && filter.recipient) {
+            if (!matchPattern(data.recipient, filter.recipient))
+              return false;
+          }
+          if ("lockedAddress" in filter && filter.lockedAddress) {
+            if (!matchPattern(data.locked_address, filter.lockedAddress))
+              return false;
+          }
+          if ("minAmount" in filter && filter.minAmount !== undefined) {
+            const amount = BigInt(data.amount ?? data.locked_amount ?? "0");
+            if (amount < filter.minAmount)
+              return false;
+          }
+          if ("maxAmount" in filter && filter.maxAmount !== undefined) {
+            const amount = BigInt(data.amount ?? "0");
+            if (amount > filter.maxAmount)
+              return false;
+          }
+          return true;
+        });
+        if (filtered.length > 0) {
+          results.push({ tx, events: filtered });
+        }
+      }
+      break;
+    }
+    case "ft_transfer":
+    case "ft_mint":
+    case "ft_burn": {
+      const eventType = `${filter.type}_event`;
+      for (const tx of transactions) {
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        const matched = txEvents.filter((e) => {
+          if (e.type !== eventType)
+            return false;
+          const data = e.data;
+          if (!data)
+            return false;
+          if (filter.assetIdentifier) {
+            const assetId = data.asset_identifier;
+            if (!assetId || !matchPattern(assetId, filter.assetIdentifier))
+              return false;
+          }
+          if (!traitAllows(filter, assetContract(data.asset_identifier), traitContracts))
+            return false;
+          if ("sender" in filter && filter.sender) {
+            if (!matchPattern(data.sender, filter.sender))
+              return false;
+          }
+          if ("recipient" in filter && filter.recipient) {
+            if (!matchPattern(data.recipient, filter.recipient))
+              return false;
+          }
+          if (filter.minAmount !== undefined) {
+            const amount = BigInt(data.amount ?? "0");
+            if (amount < filter.minAmount)
+              return false;
+          }
+          return true;
+        });
+        if (matched.length > 0) {
+          results.push({ tx, events: matched });
+        }
+      }
+      break;
+    }
+    case "nft_transfer":
+    case "nft_mint":
+    case "nft_burn": {
+      const eventType = `${filter.type}_event`;
+      for (const tx of transactions) {
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        const matched = txEvents.filter((e) => {
+          if (e.type !== eventType)
+            return false;
+          const data = e.data;
+          if (!data)
+            return false;
+          if (filter.assetIdentifier) {
+            const assetId = data.asset_identifier;
+            if (!assetId || !matchPattern(assetId, filter.assetIdentifier))
+              return false;
+          }
+          if (!traitAllows(filter, assetContract(data.asset_identifier), traitContracts))
+            return false;
+          if ("sender" in filter && filter.sender) {
+            if (!matchPattern(data.sender, filter.sender))
+              return false;
+          }
+          if ("recipient" in filter && filter.recipient) {
+            if (!matchPattern(data.recipient, filter.recipient))
+              return false;
+          }
+          return true;
+        });
+        if (matched.length > 0) {
+          results.push({ tx, events: matched });
+        }
+      }
+      break;
+    }
+    case "contract_call": {
+      for (const tx of transactions) {
+        if (tx.type !== "contract_call")
+          continue;
+        if (filter.contractId) {
+          if (!tx.contract_id || !matchPattern(tx.contract_id, filter.contractId))
+            continue;
+        }
+        if (filter.functionName) {
+          if (!tx.function_name || !matchPattern(tx.function_name, filter.functionName))
+            continue;
+        }
+        if (filter.caller) {
+          if (!matchPattern(tx.sender, filter.caller))
+            continue;
+        }
+        if (!traitAllows(filter, tx.contract_id, traitContracts))
+          continue;
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        results.push({ tx, events: txEvents });
+      }
+      break;
+    }
+    case "contract_deploy": {
+      for (const tx of transactions) {
+        if (tx.type !== "smart_contract")
+          continue;
+        if (filter.deployer) {
+          if (!matchPattern(tx.sender, filter.deployer))
+            continue;
+        }
+        if (filter.contractName) {
+          const name = tx.contract_id?.split(".")[1] ?? "";
+          if (!matchPattern(name, filter.contractName))
+            continue;
+        }
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        results.push({ tx, events: txEvents });
+      }
+      break;
+    }
+    case "print_event": {
+      for (const tx of transactions) {
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        const matched = txEvents.filter((e) => {
+          if (e.type !== "smart_contract_event" && e.type !== "contract_event")
+            return false;
+          const data = e.data;
+          if (!data)
+            return false;
+          if (data.topic !== "print")
+            return false;
+          const printContractId = data.contract_identifier ?? data.contract_id;
+          if (filter.contractId) {
+            if (!printContractId || !matchPattern(printContractId, filter.contractId))
+              return false;
+          }
+          if (!traitAllows(filter, printContractId, traitContracts))
+            return false;
+          return true;
+        });
+        if (matched.length > 0) {
+          results.push({ tx, events: matched });
+        }
+      }
+      break;
+    }
+  }
+  return results;
+}
+function matchSources(sources, transactions, events, traitContracts = new Map) {
+  const eventsByTx = new Map;
+  for (const event of events) {
+    const list = eventsByTx.get(event.tx_id) ?? [];
+    list.push(event);
+    eventsByTx.set(event.tx_id, list);
+  }
+  const seen = new Set;
+  const results = [];
+  for (const [sourceName, filter] of Object.entries(sources)) {
+    const matches = matchFilter(filter, transactions, eventsByTx, traitContracts);
+    for (const match of matches) {
+      const dedupeKey = `${match.tx.tx_id}:${sourceName}`;
+      if (!seen.has(dedupeKey)) {
+        seen.add(dedupeKey);
+        results.push({ ...match, sourceName });
+      }
+    }
+  }
+  return results;
+}
+
 // src/runtime/replay.ts
 import { createHash } from "node:crypto";
 import { getTargetDb } from "@secondlayer/shared/db";
 import { getSubscription } from "@secondlayer/shared/db/queries/subscriptions";
-import { logger } from "@secondlayer/shared/logger";
+import { logger as logger2 } from "@secondlayer/shared/logger";
 import { sql } 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 } 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,
+          ...e.event_type === "stx_transfer" ? { memo: e.memo ?? "" } : {}
+        }
+      };
+    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_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 indexEventTypesForFilterTypes(filterTypes) {
+  if (filterTypes.some((t) => TX_SOURCE_TYPES.has(t))) {
+    return ALL_INDEX_EVENT_TYPES;
+  }
+  const types = new Set;
+  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;
+  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) {
+    logger.debug("Subgraph not streams-index eligible, using DB tap", {
+      subgraph: subgraph.name
+    });
+  }
+  return postgresBlockSource;
+}
+
+// src/runtime/trigger-evaluator.ts
+import { resolveTraitContractIds } 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 key = sourceKey(sub.id, triggerIndex);
+      sources[key] = chainTriggerToFilter(trigger);
+      keyMeta.set(key, {
+        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 resolveTraitContractIds(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, replayId) {
+  const base = `chain:${subscriptionId}:${txId}:${eventIndex}:${blockHash}`;
+  return replayId ? `replay:${replayId}:${base}` : base;
+}
+function applyRow(meta, blockHeight, blockHash, txId, eventIndex, event, replayId) {
+  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, replayId),
+    ...replayId ? { is_replay: true } : {}
+  };
+}
+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);
+    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
+      }, replayId));
+    } 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
+        }, replayId));
+      }
+    }
+  }
+  if (rows.length === 0)
+    return 0;
+  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/replay.ts
 var BATCH_SIZE = 500;
 function replayDedupKey(subgraphName, tableName, row, replayId) {
@@ -46,10 +691,13 @@ async function replaySubscription(input) {
   const sub = await getSubscription(db, input.accountId, input.subscriptionId);
   if (!sub)
     throw new Error("Subscription not found");
+  if (sub.kind === "chain") {
+    return replayChainSubscription(db, sub, input);
+  }
   const subgraphName = sub.subgraph_name;
   const tableName = sub.table_name;
   if (sub.kind !== "subgraph" || !subgraphName || !tableName) {
-    throw new Error("replay is only supported for subgraph subscriptions");
+    throw new Error("replay is only supported for subgraph or chain subscriptions");
   }
   const schema = await resolveSchemaName(db, subgraphName);
   const replayId = deterministicReplayId(sub.id, input.fromBlock, input.toBlock, input.replayIdSuffix);
@@ -87,7 +735,41 @@ async function replaySubscription(input) {
       break;
     offset += BATCH_SIZE;
   }
-  logger.info("Replay enqueued", {
+  logger2.info("Replay enqueued", {
+    subscription: sub.name,
+    replayId,
+    scanned,
+    enqueued,
+    fromBlock: input.fromBlock,
+    toBlock: input.toBlock
+  });
+  return { replayId, enqueuedCount: enqueued, scannedCount: scanned };
+}
+var CHAIN_REPLAY_BATCH = 200;
+async function replayChainSubscription(db, sub, input) {
+  const replayId = deterministicReplayId(sub.id, input.fromBlock, input.toBlock, input.replayIdSuffix);
+  const { sources, keyMeta } = buildSourcesMap([sub]);
+  const source = new PublicApiBlockSource(buildHttpClient(), referencedEventTypes([sub]));
+  let scanned = 0;
+  let enqueued = 0;
+  for (let from = input.fromBlock;from <= input.toBlock; from += CHAIN_REPLAY_BATCH) {
+    const to = Math.min(from + CHAIN_REPLAY_BATCH - 1, input.toBlock);
+    const blocks = await source.loadBlockRange(from, to);
+    const traitContracts = await buildTraitContracts(db, [sub], to);
+    for (let h = from;h <= to; h++) {
+      const bd = blocks.get(h);
+      if (!bd)
+        continue;
+      scanned++;
+      const matches = evaluateBlock(bd, sources, traitContracts);
+      if (matches.length === 0)
+        continue;
+      enqueued += await emitChainOutbox(db, matches, keyMeta, h, bd.block.hash, {
+        replayId
+      });
+    }
+  }
+  logger2.info("Chain replay enqueued", {
     subscription: sub.name,
     replayId,
     scanned,
@@ -101,5 +783,5 @@ export {
   replaySubscription
 };
 
-//# debugId=757891FB3BFD957264756E2164756E21
+//# debugId=5038D6E43C1A22BA64756E2164756E21
 //# sourceMappingURL=replay.js.map