@secondlayer/subgraphs 4.1.4 → 4.1.5

package/dist/src/runtime/reorg.js

@@ -942,15 +942,614 @@ function decodeFunctionArgs(args) {
   return args.map(decodeClarityValue);
 }
 
+// src/runtime/source-matcher.ts
+var patternCache = new Map;
+function matchAny(value, pattern) {
+  return Array.isArray(pattern) ? pattern.some((p) => matchPattern(value, p)) : matchPattern(value, pattern);
+}
+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 factoryAllows(filter, contractId, factoryContracts) {
+  if (!filter.factory)
+    return true;
+  if (!contractId)
+    return false;
+  return (factoryContracts.get(filter.factory.from) ?? EMPTY_SET).has(contractId);
+}
+function readPath(payload, path) {
+  let cur = payload;
+  for (const key of path.split(".")) {
+    if (cur === null || typeof cur !== "object")
+      return;
+    cur = cur[key];
+  }
+  return cur;
+}
+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 printContractId(data) {
+  if (!data)
+    return;
+  const id = (typeof data.contract_identifier === "string" ? data.contract_identifier : undefined) ?? (typeof data.contract_id === "string" ? data.contract_id : undefined);
+  return id || undefined;
+}
+function matchFilter(filter, transactions, eventsByTx, traitContracts, factoryContracts = new Map) {
+  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 || !matchAny(tx.contract_id, filter.contractId))
+            continue;
+        }
+        if (!factoryAllows(filter, tx.contract_id, factoryContracts))
+          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 contractId = printContractId(data);
+          if (filter.contractId) {
+            if (!contractId || !matchAny(contractId, filter.contractId))
+              return false;
+          }
+          if (!traitAllows(filter, contractId, traitContracts))
+            return false;
+          if (!factoryAllows(filter, contractId, factoryContracts))
+            return false;
+          return true;
+        });
+        if (matched.length > 0) {
+          results.push({ tx, events: matched });
+        }
+      }
+      break;
+    }
+  }
+  return results;
+}
+function matchSources(sources, transactions, events, traitContracts = new Map, factoryContracts = 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, factoryContracts);
+    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/runner.ts
 import { getErrorMessage } from "@secondlayer/shared";
 import { logger as logger3 } from "@secondlayer/shared/logger";
 import {
   clarityValueToJS,
-  deserializeCV as deserializeCV3,
+  deserializeCV as deserializeCV4,
   toCamelCase as toCamelCase2
 } from "@secondlayer/stacks/clarity";
 
+// src/print-schema.ts
+import {
+  deserializeCV as deserializeCV3
+} from "@secondlayer/stacks/clarity";
+function camelizeDataKey(str) {
+  return str.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function cvToTree(cv) {
+  switch (cv.type) {
+    case "uint":
+    case "int":
+      return { kind: cv.type };
+    case "true":
+    case "false":
+      return { kind: "bool" };
+    case "address":
+    case "contract":
+      return { kind: "principal" };
+    case "buffer":
+      return { kind: "buffer", len: cv.value.length / 2 };
+    case "ascii":
+      return { kind: "ascii", len: cv.value.length };
+    case "utf8":
+      return { kind: "utf8", len: new TextEncoder().encode(cv.value).length };
+    case "none":
+      return { kind: "optional", inner: null };
+    case "some":
+      return { kind: "optional", inner: cvToTree(cv.value) };
+    case "ok":
+      return { kind: "response", ok: cvToTree(cv.value), err: null };
+    case "err":
+      return { kind: "response", ok: null, err: cvToTree(cv.value) };
+    case "list": {
+      let inner = null;
+      for (const el of cv.value) {
+        const t = cvToTree(el);
+        inner = inner ? unify(inner, t) : t;
+      }
+      return { kind: "list", inner };
+    }
+    case "tuple": {
+      const entries = new Map;
+      for (const [k, v] of Object.entries(cv.value)) {
+        entries.set(k, { tree: cvToTree(v), present: 1 });
+      }
+      return { kind: "tuple", count: 1, entries };
+    }
+  }
+}
+function unifyNullable(a, b) {
+  if (!a)
+    return b;
+  if (!b)
+    return a;
+  return unify(a, b);
+}
+var UNION_KIND_ORDER = {
+  uint: 0,
+  int: 1,
+  bool: 2,
+  principal: 3,
+  buffer: 4,
+  ascii: 5,
+  utf8: 6,
+  list: 7,
+  tuple: 8,
+  response: 9
+};
+function makeUnion(members) {
+  const sorted = [...members].sort((a, b) => (UNION_KIND_ORDER[a.kind] ?? 99) - (UNION_KIND_ORDER[b.kind] ?? 99));
+  return { kind: "union", members: sorted };
+}
+function unify(a, b) {
+  if (a.kind === "optional" || b.kind === "optional") {
+    const ai = a.kind === "optional" ? a.inner : a;
+    const bi = b.kind === "optional" ? b.inner : b;
+    return { kind: "optional", inner: unifyNullable(ai, bi) };
+  }
+  if (a.kind === "union")
+    return unionAdd(a.members, b);
+  if (b.kind === "union")
+    return unionAdd(b.members, a);
+  if (a.kind !== b.kind)
+    return makeUnion([a, b]);
+  switch (a.kind) {
+    case "uint":
+    case "int":
+    case "bool":
+    case "principal":
+      return a;
+    case "buffer":
+    case "ascii":
+    case "utf8":
+      return { kind: a.kind, len: Math.max(a.len, b.len) };
+    case "list":
+      return {
+        kind: "list",
+        inner: unifyNullable(a.inner, b.inner)
+      };
+    case "response": {
+      const rb = b;
+      return {
+        kind: "response",
+        ok: unifyNullable(a.ok, rb.ok),
+        err: unifyNullable(a.err, rb.err)
+      };
+    }
+    case "tuple": {
+      const tb = b;
+      const entries = new Map([...a.entries].map(([k, e]) => [k, { ...e }]));
+      for (const [k, e] of tb.entries) {
+        const existing = entries.get(k);
+        entries.set(k, existing ? {
+          tree: unify(existing.tree, e.tree),
+          present: existing.present + e.present
+        } : { ...e });
+      }
+      return { kind: "tuple", count: a.count + tb.count, entries };
+    }
+  }
+}
+function unionAdd(members, t) {
+  if (t.kind === "union") {
+    let acc = { kind: "union", members };
+    for (const m of t.members)
+      acc = unify(acc, m);
+    return acc;
+  }
+  const next = [...members];
+  for (let i = 0;i < next.length; i++) {
+    const member = next[i];
+    if (!member)
+      continue;
+    const merged = unify(member, t);
+    if (merged.kind !== "union") {
+      next[i] = merged;
+      return makeUnion(next);
+    }
+  }
+  next.push(t);
+  return makeUnion(next);
+}
+function wrapOptional(t) {
+  return t.kind === "optional" ? t : { kind: "optional", inner: t };
+}
+function renderClarity(t) {
+  if (!t)
+    return "?";
+  switch (t.kind) {
+    case "uint":
+    case "int":
+    case "bool":
+    case "principal":
+      return t.kind;
+    case "buffer":
+      return `(buff ${t.len})`;
+    case "ascii":
+      return `(string-ascii ${t.len})`;
+    case "utf8":
+      return `(string-utf8 ${t.len})`;
+    case "optional":
+      return `(optional ${renderClarity(t.inner)})`;
+    case "list":
+      return `(list ${renderClarity(t.inner)})`;
+    case "response":
+      return `(response ${renderClarity(t.ok)} ${renderClarity(t.err)})`;
+    case "tuple": {
+      const parts = [...t.entries].map(([k, e]) => {
+        const tree = e.present < t.count ? wrapOptional(e.tree) : e.tree;
+        return `(${k} ${renderClarity(tree)})`;
+      });
+      return `(tuple ${parts.join(" ")})`;
+    }
+    case "union":
+      return t.members.map(renderClarity).join(" | ");
+  }
+}
+function renderTs(t) {
+  if (!t)
+    return "unknown";
+  switch (t.kind) {
+    case "uint":
+    case "int":
+      return "bigint";
+    case "bool":
+      return "boolean";
+    case "principal":
+    case "buffer":
+    case "ascii":
+    case "utf8":
+      return "string";
+    case "optional":
+      return t.inner ? `${renderTs(t.inner)} | null` : "unknown | null";
+    case "list": {
+      const inner = renderTs(t.inner);
+      return inner.includes(" | ") ? `(${inner})[]` : `${inner}[]`;
+    }
+    case "response": {
+      const sides = [...new Set([renderTs(t.ok), renderTs(t.err)])];
+      return sides.join(" | ");
+    }
+    case "tuple": {
+      const parts = [...t.entries].map(([k, e]) => {
+        const opt = e.present < t.count ? "?" : "";
+        return `${camelizeDataKey(k)}${opt}: ${renderTs(e.tree)}`;
+      });
+      return `{ ${parts.join("; ")} }`;
+    }
+    case "union":
+      return [...new Set(t.members.map((m) => renderTs(m)))].join(" | ");
+  }
+}
+function toColumnType(t) {
+  if (!t)
+    return "jsonb";
+  switch (t.kind) {
+    case "uint":
+      return "uint";
+    case "int":
+      return "int";
+    case "bool":
+      return "boolean";
+    case "principal":
+      return "principal";
+    case "buffer":
+    case "ascii":
+    case "utf8":
+      return "text";
+    case "list":
+    case "tuple":
+      return "jsonb";
+    case "optional":
+      return toColumnType(t.inner);
+    case "response":
+      return t.ok ? toColumnType(t.ok) : "jsonb";
+    case "union":
+      return "jsonb";
+  }
+}
+var MAX_DECODED_PER_TOPIC_NEWEST = 75;
+var MAX_DECODED_PER_TOPIC_OLDEST = 25;
+function inferPrintTopics(samples) {
+  const groups = new Map;
+  for (const s of samples) {
+    const group = groups.get(s.topic);
+    if (group)
+      group.push(s);
+    else
+      groups.set(s.topic, [s]);
+  }
+  const out = [];
+  for (const [topic, rows] of groups) {
+    let first = Number.POSITIVE_INFINITY;
+    let last = Number.NEGATIVE_INFINITY;
+    for (const r of rows) {
+      if (r.blockHeight < first)
+        first = r.blockHeight;
+      if (r.blockHeight > last)
+        last = r.blockHeight;
+    }
+    const withHex = [...rows].filter((r) => r.rawHex !== null).sort((a, b) => b.blockHeight - a.blockHeight);
+    const budget = MAX_DECODED_PER_TOPIC_NEWEST + MAX_DECODED_PER_TOPIC_OLDEST;
+    const picked = withHex.length <= budget ? withHex : [
+      ...withHex.slice(0, MAX_DECODED_PER_TOPIC_NEWEST),
+      ...withHex.slice(-MAX_DECODED_PER_TOPIC_OLDEST)
+    ];
+    const tuples = [];
+    let decoded = 0;
+    for (const p of picked) {
+      try {
+        const cv = deserializeCV3(p.rawHex);
+        decoded++;
+        if (cv.type === "tuple")
+          tuples.push(cv);
+      } catch {}
+    }
+    const nonTuple = decoded > 0 && tuples.length === 0;
+    const fields = [];
+    if (!nonTuple) {
+      const stats = new Map;
+      for (const t of tuples) {
+        for (const [key, value] of Object.entries(t.value)) {
+          if (key === "topic")
+            continue;
+          const tree = cvToTree(value);
+          const existing = stats.get(key);
+          if (existing) {
+            existing.present++;
+            existing.tree = unify(existing.tree, tree);
+            if (value.type === "none")
+              existing.noneCount++;
+            if (value.type === "none" || value.type === "some") {
+              existing.optionalSeen = true;
+            }
+          } else {
+            stats.set(key, {
+              tree,
+              present: 1,
+              noneCount: value.type === "none" ? 1 : 0,
+              optionalSeen: value.type === "none" || value.type === "some"
+            });
+          }
+        }
+      }
+      for (const [name, st] of [...stats].sort(([a], [b]) => a.localeCompare(b))) {
+        const field = {
+          name,
+          camel_name: camelizeDataKey(name),
+          clarity_type: renderClarity(st.tree),
+          ts_type: renderTs(st.tree),
+          column_type: toColumnType(st.tree),
+          always_present: st.present === tuples.length
+        };
+        if (st.optionalSeen) {
+          field.optional_some_rate = (st.present - st.noneCount) / st.present;
+        }
+        fields.push(field);
+      }
+    }
+    out.push({
+      topic,
+      count: rows.length,
+      first_height: first,
+      last_height: last,
+      non_tuple: nonTuple,
+      fields
+    });
+  }
+  return out.sort((a, b) => b.count - a.count);
+}
+
 // src/runtime/print-validate.ts
 var COLUMN_TYPES = new Set([
   "text",
@@ -1032,9 +1631,6 @@ function validatePrintPayload(prints, topic, data) {
 
 // src/runtime/runner.ts
 var DEFAULT_ERROR_THRESHOLD = 50;
-function camelCase(str) {
-  return str.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
-}
 function camelizeKeys(obj) {
   if (obj === null || obj === undefined)
     return obj;
@@ -1044,7 +1640,7 @@ function camelizeKeys(obj) {
     return obj.map(camelizeKeys);
   const result = {};
   for (const [k, v] of Object.entries(obj)) {
-    result[camelCase(k)] = camelizeKeys(v);
+    result[camelizeDataKey(k)] = camelizeKeys(v);
   }
   return result;
 }
@@ -1111,7 +1707,7 @@ function buildContractCallInput(filter, tx) {
       return;
     try {
       const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
-      input[toCamelCase2(arg.name)] = decodeArg(arg.type, deserializeCV3(clean));
+      input[toCamelCase2(arg.name)] = decodeArg(arg.type, deserializeCV4(clean));
     } catch {}
   });
   return input;
@@ -1234,7 +1830,7 @@ function buildEventPayload(filter, tx, event) {
       const { topic: _, ...rest } = clarityObj ?? {};
       const data = Object.keys(rest).length > 0 ? camelizeKeys(rest) : rawValue && typeof rawValue !== "object" ? rawValue : {};
       return {
-        contractId: decoded.contract_identifier ?? tx.contract_id ?? "",
+        contractId: printContractId(decoded) ?? tx.contract_id ?? "",
         topic,
         data: data ?? {},
         tx: txMeta
@@ -1274,380 +1870,118 @@ function buildEventPayload(filter, tx, event) {
 }
 async function runHandlers(subgraph, matched, ctx, opts) {
   let processed = 0;
-  let errors = 0;
-  let skipped = 0;
-  const threshold = opts?.errorThreshold ?? DEFAULT_ERROR_THRESHOLD;
-  const filterLookup = new Map;
-  if (!Array.isArray(subgraph.sources)) {
-    for (const [name, filter] of Object.entries(subgraph.sources)) {
-      filterLookup.set(name, filter);
-    }
-  }
-  const units = [];
-  for (const { tx, events, sourceName } of matched) {
-    if (events.length === 0) {
-      units.push({ tx, sourceName, event: null });
-    } else {
-      for (const event of events)
-        units.push({ tx, sourceName, event });
-    }
-  }
-  units.sort((a, b) => (a.tx.tx_index ?? 0) - (b.tx.tx_index ?? 0) || (a.event?.event_index ?? -1) - (b.event?.event_index ?? -1));
-  for (const { tx, event, sourceName } of units) {
-    if (errors >= threshold) {
-      logger3.error("Subgraph error threshold reached, skipping remaining events", {
-        subgraph: subgraph.name,
-        errors,
-        threshold
-      });
-      return { processed, errors, ...skipped > 0 ? { skipped } : {} };
-    }
-    const handler = subgraph.handlers[sourceName] ?? subgraph.handlers["*"] ?? null;
-    if (!handler) {
-      logger3.warn("No handler found for source", {
-        subgraph: subgraph.name,
-        sourceName,
-        txId: tx.tx_id
-      });
-      continue;
-    }
-    ctx.setTx({
-      txId: tx.tx_id,
-      sender: tx.sender,
-      type: tx.type,
-      status: tx.status,
-      contractId: tx.contract_id ?? null,
-      functionName: tx.function_name ?? null
-    });
-    const filter = filterLookup.get(sourceName);
-    const checkpoint = ctx.opsCheckpoint();
-    try {
-      let payload;
-      if (event === null) {
-        payload = filter ? buildEventPayload(filter, tx, null) : {
-          tx: {
-            txId: tx.tx_id,
-            sender: tx.sender,
-            type: tx.type,
-            status: tx.status,
-            contractId: tx.contract_id,
-            functionName: tx.function_name
-          }
-        };
-      } else if (filter) {
-        payload = buildEventPayload(filter, tx, event);
-      } else {
-        const decoded = decodeEventData(event.data);
-        payload = {
-          ...decoded,
-          _eventId: event.id,
-          _eventType: event.type,
-          _eventIndex: event.event_index,
-          tx: {
-            txId: tx.tx_id,
-            sender: tx.sender,
-            type: tx.type,
-            status: tx.status,
-            contractId: tx.contract_id,
-            functionName: tx.function_name
-          }
-        };
-      }
-      if (event !== null && filter?.type === "print_event" && filter.topic && payload.topic !== filter.topic) {
-        continue;
-      }
-      if (event !== null && filter?.type === "print_event" && filter.prints) {
-        const printPayload = payload;
-        const verdict = validatePrintPayload(filter.prints, printPayload.topic ?? "", printPayload.data ?? {});
-        if (!verdict.ok) {
-          skipped++;
-          logger3.warn("Print payload does not match declared prints schema", {
-            subgraph: subgraph.name,
-            sourceName,
-            topic: printPayload.topic,
-            txId: tx.tx_id,
-            reason: verdict.reason
-          });
-          continue;
-        }
-      }
-      await handler(payload, ctx);
-      processed++;
-    } catch (err) {
-      ctx.rollbackTo(checkpoint);
-      errors++;
-      logger3.error("Subgraph handler error", {
-        subgraph: subgraph.name,
-        sourceName,
-        txId: tx.tx_id,
-        ...event !== null ? { eventId: event.id, eventType: event.type } : {},
-        error: getErrorMessage(err)
-      });
-    }
-  }
-  return { processed, errors, ...skipped > 0 ? { skipped } : {} };
-}
-
-// src/runtime/source-matcher.ts
-var patternCache = new Map;
-function matchAny(value, pattern) {
-  return Array.isArray(pattern) ? pattern.some((p) => matchPattern(value, p)) : matchPattern(value, pattern);
-}
-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 factoryAllows(filter, contractId, factoryContracts) {
-  if (!filter.factory)
-    return true;
-  if (!contractId)
-    return false;
-  return (factoryContracts.get(filter.factory.from) ?? EMPTY_SET).has(contractId);
-}
-function readPath(payload, path) {
-  let cur = payload;
-  for (const key of path.split(".")) {
-    if (cur === null || typeof cur !== "object")
-      return;
-    cur = cur[key];
-  }
-  return cur;
-}
-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, factoryContracts = new Map) {
-  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;
+  let errors = 0;
+  let skipped = 0;
+  const threshold = opts?.errorThreshold ?? DEFAULT_ERROR_THRESHOLD;
+  const filterLookup = new Map;
+  if (!Array.isArray(subgraph.sources)) {
+    for (const [name, filter] of Object.entries(subgraph.sources)) {
+      filterLookup.set(name, filter);
     }
-    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;
+  }
+  const units = [];
+  for (const { tx, events, sourceName } of matched) {
+    if (events.length === 0) {
+      units.push({ tx, sourceName, event: null });
+    } else {
+      for (const event of events)
+        units.push({ tx, sourceName, event });
     }
-    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;
+  }
+  units.sort((a, b) => (a.tx.tx_index ?? 0) - (b.tx.tx_index ?? 0) || (a.event?.event_index ?? -1) - (b.event?.event_index ?? -1));
+  for (const { tx, event, sourceName } of units) {
+    if (errors >= threshold) {
+      logger3.error("Subgraph error threshold reached, skipping remaining events", {
+        subgraph: subgraph.name,
+        errors,
+        threshold
+      });
+      return { processed, errors, ...skipped > 0 ? { skipped } : {} };
+    }
+    const handler = subgraph.handlers[sourceName] ?? subgraph.handlers["*"] ?? null;
+    if (!handler) {
+      logger3.warn("No handler found for source", {
+        subgraph: subgraph.name,
+        sourceName,
+        txId: tx.tx_id
+      });
+      continue;
+    }
+    ctx.setTx({
+      txId: tx.tx_id,
+      sender: tx.sender,
+      type: tx.type,
+      status: tx.status,
+      contractId: tx.contract_id ?? null,
+      functionName: tx.function_name ?? null
+    });
+    const filter = filterLookup.get(sourceName);
+    const checkpoint = ctx.opsCheckpoint();
+    try {
+      let payload;
+      if (event === null) {
+        payload = filter ? buildEventPayload(filter, tx, null) : {
+          tx: {
+            txId: tx.tx_id,
+            sender: tx.sender,
+            type: tx.type,
+            status: tx.status,
+            contractId: tx.contract_id,
+            functionName: tx.function_name
           }
-          if ("recipient" in filter && filter.recipient) {
-            if (!matchPattern(data.recipient, filter.recipient))
-              return false;
+        };
+      } else if (filter) {
+        payload = buildEventPayload(filter, tx, event);
+      } else {
+        const decoded = decodeEventData(event.data);
+        payload = {
+          ...decoded,
+          _eventId: event.id,
+          _eventType: event.type,
+          _eventIndex: event.event_index,
+          tx: {
+            txId: tx.tx_id,
+            sender: tx.sender,
+            type: tx.type,
+            status: tx.status,
+            contractId: tx.contract_id,
+            functionName: tx.function_name
           }
-          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 || !matchAny(tx.contract_id, filter.contractId))
-            continue;
-        }
-        if (!factoryAllows(filter, tx.contract_id, factoryContracts))
-          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 });
+      if (event !== null && filter?.type === "print_event" && filter.topic && payload.topic !== filter.topic) {
+        continue;
       }
-      break;
-    }
-    case "contract_deploy": {
-      for (const tx of transactions) {
-        if (tx.type !== "smart_contract")
+      if (event !== null && filter?.type === "print_event" && filter.prints) {
+        const printPayload = payload;
+        const verdict = validatePrintPayload(filter.prints, printPayload.topic ?? "", printPayload.data ?? {});
+        if (!verdict.ok) {
+          skipped++;
+          logger3.warn("Print payload does not match declared prints schema", {
+            subgraph: subgraph.name,
+            sourceName,
+            topic: printPayload.topic,
+            txId: tx.tx_id,
+            reason: verdict.reason
+          });
           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 || !matchAny(printContractId, filter.contractId))
-              return false;
-          }
-          if (!traitAllows(filter, printContractId, traitContracts))
-            return false;
-          if (!factoryAllows(filter, printContractId, factoryContracts))
-            return false;
-          return true;
-        });
-        if (matched.length > 0) {
-          results.push({ tx, events: matched });
         }
       }
-      break;
-    }
-  }
-  return results;
-}
-function matchSources(sources, transactions, events, traitContracts = new Map, factoryContracts = 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, factoryContracts);
-    for (const match of matches) {
-      const dedupeKey = `${match.tx.tx_id}:${sourceName}`;
-      if (!seen.has(dedupeKey)) {
-        seen.add(dedupeKey);
-        results.push({ ...match, sourceName });
-      }
+      await handler(payload, ctx);
+      processed++;
+    } catch (err) {
+      ctx.rollbackTo(checkpoint);
+      errors++;
+      logger3.error("Subgraph handler error", {
+        subgraph: subgraph.name,
+        sourceName,
+        txId: tx.tx_id,
+        ...event !== null ? { eventId: event.id, eventType: event.type } : {},
+        error: getErrorMessage(err)
+      });
     }
   }
-  return results;
+  return { processed, errors, ...skipped > 0 ? { skipped } : {} };
 }
 
 // src/runtime/block-processor.ts
@@ -1990,7 +2324,7 @@ function reconstructEvent(e) {
         type: "contract_event",
         data: {
           topic: e.payload.topic,
-          contract_identifier: e.contract_id,
+          contract_id: e.contract_id,
           value: e.payload.value,
           raw_value: e.payload.raw_value
         }
@@ -3652,5 +3986,5 @@ export {
   handleSubgraphReorg
 };
 
-//# debugId=33B13FDE84A36A1564756E2164756E21
+//# debugId=CCDDEB49D7B7E7B464756E2164756E21
 //# sourceMappingURL=reorg.js.map