@secondlayer/subgraphs 7.1.0 → 7.3.0

package/dist/runtime/replay.js

@@ -17,7 +17,7 @@ import { createHash } from "node:crypto";
 // package.json
 var package_default = {
   name: "@secondlayer/subgraphs",
-  version: "7.1.0",
+  version: "7.3.0",
   description: "Describe the Stacks data you want as one TypeScript file; it fills itself and survives reorgs.",
   license: "MIT",
   repository: {
@@ -77,8 +77,8 @@ var package_default = {
     prepublishOnly: "bun run build"
   },
   dependencies: {
-    "@secondlayer/shared": "^13.0.0",
-    "@secondlayer/stacks": "^6.3.0",
+    "@secondlayer/shared": "^13.2.0",
+    "@secondlayer/stacks": "^6.4.0",
     "@secondlayer/verify": "^0.6.0",
     esbuild: "^0.28.2",
     kysely: "0.28.17",
@@ -1134,13 +1134,199 @@ function buildHttpClient() {
   return createInternalIndexHttpClient();
 }
 
-// src/runtime/trigger-evaluator.ts
-import { getSourceDb as getSourceDb3 } from "@secondlayer/shared/db";
+// src/runtime/chain-data-reader.ts
+import { getSourceDb as getSourceDb2 } from "@secondlayer/shared/db";
 import { resolveTraitContractIds } from "@secondlayer/shared/db/queries/contracts";
+import { hasNoLocalChain } from "@secondlayer/shared/db/queries/instance";
+function databaseChainDataReader(db) {
+  return {
+    async sbtcEvents(fromHeight, toHeight, topics) {
+      if (topics.length === 0)
+        return [];
+      return db.selectFrom("sbtc_events").selectAll().where("block_height", ">=", fromHeight).where("block_height", "<=", toHeight).where("canonical", "=", true).where("topic", "in", [...topics]).orderBy("block_height").orderBy("event_index").execute();
+    },
+    traitContractIds(trait, asOfBlock) {
+      return resolveTraitContractIds(db, trait, asOfBlock);
+    },
+    settlementsConfirmedAfter(after) {
+      return db.selectFrom("sbtc_settlements as s").innerJoin("sbtc_events as e", (join) => join.onRef("e.sweep_txid", "=", "s.sweep_txid").on("e.topic", "=", "withdrawal-accept").on("e.canonical", "=", true)).innerJoin("blocks as b", (join) => join.onRef("b.height", "=", "e.block_height").on("b.canonical", "=", true)).where("s.settlement_confirmed", "=", true).where("s.confirmed_at", ">", after).select([
+        "s.sweep_txid",
+        "s.request_id",
+        "s.btc_confirmations",
+        "s.block_height as btc_block_height",
+        "s.confirmed_at",
+        "e.tx_id",
+        "e.block_height as stacks_block_height",
+        "e.amount",
+        "e.sender",
+        "b.hash as block_hash",
+        "b.timestamp as block_timestamp"
+      ]).execute();
+    }
+  };
+}
+var THROUGH_TIP = Number.MAX_SAFE_INTEGER;
+var TRAIT_REFRESH_MS = 5000;
+var TRAIT_OVERLAP_MS = 5 * 60000;
+var traitCaches = new WeakMap;
+function traitCacheFor(client) {
+  let cache = traitCaches.get(client);
+  if (!cache) {
+    cache = new Map;
+    traitCaches.set(client, cache);
+  }
+  return cache;
+}
+function toSbtcEventRow(e) {
+  return {
+    topic: e.topic,
+    sender: e.sender,
+    bitcoin_txid: e.bitcoin_txid,
+    request_id: e.request_id === null ? null : String(e.request_id),
+    amount: e.amount,
+    sweep_txid: e.sweep_txid,
+    block_height: String(e.block_height),
+    tx_id: e.tx_id,
+    event_index: e.event_index
+  };
+}
+function oneWithdrawalPerSweep(rows) {
+  const bySweep = new Map;
+  for (const row of rows) {
+    if (!row.sweep_txid || !row.confirmed_at)
+      continue;
+    const seen = bySweep.get(row.sweep_txid);
+    if (!seen || row.request_id < seen.request_id) {
+      bySweep.set(row.sweep_txid, row);
+    }
+  }
+  return [...bySweep.values()];
+}
+function hostedChainDataReader(client, opts = {}) {
+  const now = opts.now ?? Date.now;
+  return {
+    async sbtcEvents(fromHeight, toHeight, topics) {
+      if (topics.length === 0)
+        return [];
+      const rows = await client.fetchSbtcEvents(fromHeight, toHeight, topics);
+      return rows.map(toSbtcEventRow);
+    },
+    async traitContractIds(trait, asOfBlock) {
+      const cache = traitCacheFor(client);
+      let entry = cache.get(trait);
+      const due = !entry || asOfBlock > entry.checkedThrough && now() - entry.fetchedAt >= TRAIT_REFRESH_MS;
+      if (due) {
+        const since = entry?.classifiedThrough == null ? undefined : new Date(entry.classifiedThrough - TRAIT_OVERLAP_MS);
+        const rows = await client.listContractsByTrait(trait, since ? { classifiedAfter: since } : undefined);
+        const members = entry?.members ?? new Map;
+        let classifiedThrough = entry?.classifiedThrough ?? null;
+        for (const r of rows) {
+          members.set(r.contract_id, Number(r.block_height));
+          if (r.classified_at) {
+            classifiedThrough = Math.max(classifiedThrough ?? 0, new Date(r.classified_at).getTime());
+          }
+        }
+        entry = {
+          members,
+          classifiedThrough,
+          checkedThrough: asOfBlock,
+          fetchedAt: now()
+        };
+        cache.set(trait, entry);
+      }
+      if (!entry)
+        return [];
+      const ids = [];
+      for (const [contractId, height] of entry.members) {
+        if (height <= asOfBlock)
+          ids.push(contractId);
+      }
+      return ids;
+    },
+    async settlementsConfirmedAfter(after) {
+      const withdrawals = oneWithdrawalPerSweep(await client.fetchSettledWithdrawals(after));
+      const out = [];
+      for (const w of withdrawals) {
+        const accepts = await client.fetchSbtcEvents(0, THROUGH_TIP, ["withdrawal-accept"], { requestId: w.request_id });
+        const accept = accepts.filter((e) => e.sweep_txid === w.sweep_txid).at(-1);
+        if (!accept)
+          continue;
+        const [block] = await client.walkBlocks(accept.block_height, accept.block_height);
+        if (!block)
+          continue;
+        out.push({
+          sweep_txid: w.sweep_txid,
+          request_id: w.request_id,
+          btc_confirmations: w.btc_confirmations ?? 0,
+          btc_block_height: w.btc_block_height,
+          confirmed_at: new Date(w.confirmed_at),
+          tx_id: accept.tx_id,
+          stacks_block_height: accept.block_height,
+          amount: accept.amount,
+          sender: accept.sender,
+          block_hash: block.block_hash,
+          block_timestamp: isoToUnixSeconds(block.block_time)
+        });
+      }
+      return out;
+    }
+  };
+}
+function chainDataReader(opts) {
+  let resolved;
+  const reader = () => {
+    resolved ??= (async () => {
+      const localDb = opts?.localDb ?? getSourceDb2();
+      if (await hasNoLocalChain(getSourceDb2())) {
+        return hostedChainDataReader(opts?.httpClient ?? sharedHttpClient());
+      }
+      return databaseChainDataReader(localDb);
+    })();
+    return resolved;
+  };
+  return {
+    sbtcEvents: async (...args) => (await reader()).sbtcEvents(...args),
+    traitContractIds: async (...args) => (await reader()).traitContractIds(...args),
+    settlementsConfirmedAfter: async (...args) => (await reader()).settlementsConfirmedAfter(...args)
+  };
+}
+var processHttpClient;
+function sharedHttpClient() {
+  processHttpClient ??= buildHttpClient();
+  return processHttpClient;
+}
 
 // src/runtime/decoder-bound.ts
 import { committedHeight } from "@secondlayer/shared";
-import { getSourceDb as getSourceDb2 } from "@secondlayer/shared/db";
+import { getSourceDb as getSourceDb3 } from "@secondlayer/shared/db";
+
+// src/runtime/clarity.ts
+import { cvToValue, deserializeCV } from "@secondlayer/stacks/clarity";
+function decodeClarityValue(hex) {
+  try {
+    const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+    const cv = deserializeCV(cleanHex);
+    return cvToValue(cv);
+  } catch {
+    return hex;
+  }
+}
+function decodeEventData(data) {
+  if (typeof data === "string" && data.startsWith("0x") && data.length > 10) {
+    return decodeClarityValue(data);
+  }
+  if (Array.isArray(data)) {
+    return data.map(decodeEventData);
+  }
+  if (typeof data === "object" && data !== null) {
+    const decoded = {};
+    for (const [key, value] of Object.entries(data)) {
+      decoded[key] = decodeEventData(value);
+    }
+    return decoded;
+  }
+  return data;
+}
 
 // src/runtime/source-matcher.ts
 var patternCache = new Map;
@@ -1183,6 +1369,41 @@ function printContractId(data) {
   const id = (typeof data.contract_identifier === "string" ? data.contract_identifier : undefined) ?? (typeof data.contract_id === "string" ? data.contract_id : undefined);
   return id || undefined;
 }
+var decodedPrints = new WeakMap;
+function decodedPrintTuple(event, data) {
+  if (decodedPrints.has(event))
+    return decodedPrints.get(event) ?? null;
+  const raw = data.raw_value;
+  const value = typeof raw === "string" && raw.startsWith("0x") ? decodeClarityValue(raw) : null;
+  const tuple = value && typeof value === "object" && !Array.isArray(value) ? value : null;
+  decodedPrints.set(event, tuple);
+  return tuple;
+}
+function printFieldEquals(decoded, key, expected) {
+  const value = decoded[key];
+  let actual;
+  if (typeof value === "string")
+    actual = value;
+  else if (typeof value === "bigint" || typeof value === "boolean")
+    actual = String(value);
+  else
+    return false;
+  return typeof expected === "string" ? actual === expected : expected.includes(actual);
+}
+function printFieldsAllow(filter, event, data) {
+  if (!filter.topic && !filter.where)
+    return true;
+  const decoded = decodedPrintTuple(event, data);
+  if (!decoded)
+    return false;
+  if (filter.topic && !printFieldEquals(decoded, "topic", filter.topic))
+    return false;
+  for (const [key, expected] of Object.entries(filter.where ?? {})) {
+    if (!printFieldEquals(decoded, key, expected))
+      return false;
+  }
+  return true;
+}
 function matchFilter(filter, transactions, eventsByTx, traitContracts, factoryContracts = new Map, vmEventsByTx = new Map) {
   const results = [];
   switch (filter.type) {
@@ -1419,7 +1640,7 @@ function matchFilter(filter, transactions, eventsByTx, traitContracts, factoryCo
             return false;
           if (!factoryAllows(filter, contractId, factoryContracts))
             return false;
-          return true;
+          return printFieldsAllow(filter, e, data);
         });
         if (matched.length > 0) {
           results.push({ tx, events: matched });
@@ -1539,11 +1760,21 @@ function referencedTraits(chainSubs) {
   }
   return [...traits];
 }
+function readerFor(opts) {
+  if (opts?.reader)
+    return opts.reader;
+  if (opts?.sourceDb)
+    return databaseChainDataReader(opts.sourceDb);
+  return chainDataReader();
+}
 async function buildTraitContracts(chainSubs, asOfBlock, opts) {
-  const sourceDb = opts?.sourceDb ?? getSourceDb3();
+  const traits = referencedTraits(chainSubs);
+  if (traits.length === 0)
+    return new Map;
+  const reader = readerFor(opts);
   const resolved = new Map;
-  for (const trait of referencedTraits(chainSubs)) {
-    const ids = await resolveTraitContractIds(sourceDb, trait, asOfBlock);
+  for (const trait of traits) {
+    const ids = await reader.traitContractIds(trait, asOfBlock);
     resolved.set(trait, new Set(ids));
   }
   return resolved;
@@ -1626,10 +1857,35 @@ async function emitChainOutbox(db, matches, keyMeta, blockHeight, blockHash, blo
   const result = await db.insertInto("webhook_outbox").values(rows).onConflict((oc) => oc.columns(["webhook_id", "dedup_key"]).doNothing()).executeTakeFirst();
   return Number(result.numInsertedOrUpdatedRows ?? 0);
 }
-async function loadSbtcEventsForBlock(db, blockHeight, topics) {
+function sbtcSubsOf(chainSubs) {
+  return chainSubs.filter((sub) => triggersOf(sub).some((t) => isSbtcTriggerType(t.type)));
+}
+function sbtcTopicsOf(sbtcSubs) {
+  const topics = new Set;
+  for (const sub of sbtcSubs) {
+    for (const trigger of triggersOf(sub)) {
+      const topic = SBTC_TRIGGER_TO_TOPIC[trigger.type];
+      if (topic)
+        topics.add(topic);
+    }
+  }
+  return [...topics];
+}
+async function loadSbtcEventsForRange(chainSubs, fromHeight, toHeight, opts) {
+  const byHeight = new Map;
+  const topics = sbtcTopicsOf(sbtcSubsOf(chainSubs));
   if (topics.length === 0)
-    return [];
-  return db.selectFrom("sbtc_events").selectAll().where("block_height", "=", blockHeight).where("canonical", "=", true).where("topic", "in", topics).execute();
+    return byHeight;
+  const rows = await readerFor(opts).sbtcEvents(fromHeight, toHeight, topics);
+  for (const row of rows) {
+    const height = Number(row.block_height);
+    const list = byHeight.get(height);
+    if (list)
+      list.push(row);
+    else
+      byHeight.set(height, [row]);
+  }
+  return byHeight;
 }
 function toAmountBigInt(v) {
   return v === undefined ? undefined : BigInt(v);
@@ -1714,18 +1970,10 @@ function buildSbtcEventPayload(triggerType, row) {
   };
 }
 async function emitSbtcOutbox(db, chainSubs, blockHeight, blockHash, blockTime, opts) {
-  const sbtcSubs = chainSubs.filter((sub) => triggersOf(sub).some((t) => isSbtcTriggerType(t.type)));
+  const sbtcSubs = sbtcSubsOf(chainSubs);
   if (sbtcSubs.length === 0)
     return 0;
-  const neededTopics = new Set;
-  for (const sub of sbtcSubs) {
-    for (const trigger of triggersOf(sub)) {
-      const topic = SBTC_TRIGGER_TO_TOPIC[trigger.type];
-      if (topic)
-        neededTopics.add(topic);
-    }
-  }
-  const sbtcRows = await loadSbtcEventsForBlock(opts?.sourceDb ?? getSourceDb3(), blockHeight, [...neededTopics]);
+  const sbtcRows = opts?.rows ?? (await loadSbtcEventsForRange(sbtcSubs, blockHeight, blockHeight, opts)).get(blockHeight) ?? [];
   if (sbtcRows.length === 0)
     return 0;
   const replayId = opts?.replayId;
@@ -1810,12 +2058,16 @@ async function replayChainWebhook(db, sub, input, opts) {
   const replayId = deterministicReplayId(sub.id, input.fromBlock, input.toBlock, input.replayIdSuffix);
   const { sources, keyMeta } = buildSourcesMap([sub]);
   const source = opts?.source ?? new PublicApiBlockSource(buildHttpClient(), referencedEventTypes([sub]));
+  const reader = chainDataReader();
   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([sub], to);
+    const traitContracts = await buildTraitContracts([sub], to, { reader });
+    const sbtcByHeight = await loadSbtcEventsForRange([sub], from, to, {
+      reader
+    });
     for (let h = from;h <= to; h++) {
       const bd = blocks.get(h);
       if (!bd)
@@ -1829,7 +2081,8 @@ async function replayChainWebhook(db, sub, input, opts) {
         });
       }
       enqueued += await emitSbtcOutbox(db, [sub], h, bd.block.hash, blockTime, {
-        replayId
+        replayId,
+        rows: sbtcByHeight.get(h) ?? []
       });
     }
   }
@@ -1850,5 +2103,5 @@ export {
   replayWebhook
 };
 
-//# debugId=753AE060316EFD5564756E2164756E21
+//# debugId=E8EBA7C326C2348864756E2164756E21
 //# sourceMappingURL=replay.js.map