@secondlayer/subgraphs 4.4.1 → 5.0.0

package/dist/src/runtime/runner.js

@@ -1,1332 +0,0 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// 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;
-}
-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, vmEventsByTx = 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 "nested_contract_call":
-    case "var_set":
-    case "map_set":
-    case "map_insert":
-    case "map_delete": {
-      for (const tx of transactions) {
-        const txEvents = vmEventsByTx.get(tx.tx_id) ?? [];
-        const matched = txEvents.filter((e) => {
-          if (e.type !== filter.type)
-            return false;
-          const data = e.data;
-          if (!data)
-            return false;
-          const contractId = printContractId(data);
-          if ("contractId" in filter && filter.contractId) {
-            if (!contractId || !matchAny(contractId, filter.contractId))
-              return false;
-          }
-          if (!traitAllows(filter, contractId, traitContracts))
-            return false;
-          if (!factoryAllows(filter, contractId, factoryContracts))
-            return false;
-          if (filter.type === "nested_contract_call") {
-            if (filter.functionName) {
-              if (typeof data.function_name !== "string" || !matchPattern(data.function_name, filter.functionName))
-                return false;
-            }
-            if (filter.caller) {
-              if (typeof data.caller !== "string" || !matchPattern(data.caller, filter.caller))
-                return false;
-            }
-            if (filter.sender) {
-              if (typeof data.sender !== "string" || !matchPattern(data.sender, filter.sender))
-                return false;
-            }
-          }
-          if (filter.type === "var_set" && filter.varName) {
-            if (typeof data.var_name !== "string" || !matchPattern(data.var_name, filter.varName))
-              return false;
-          }
-          if ((filter.type === "map_set" || filter.type === "map_insert" || filter.type === "map_delete") && filter.map) {
-            if (typeof data.map_name !== "string" || !matchPattern(data.map_name, filter.map))
-              return false;
-          }
-          return true;
-        });
-        if (matched.length > 0)
-          results.push({ tx, events: matched });
-      }
-      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, vmEvents = []) {
-  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 vmEventsByTx = new Map;
-  for (const event of vmEvents) {
-    const list = vmEventsByTx.get(event.tx_id) ?? [];
-    list.push(event);
-    vmEventsByTx.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, vmEventsByTx);
-    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 logger2 } from "@secondlayer/shared/logger";
-import {
-  clarityValueToJS,
-  deserializeCV as deserializeCV3,
-  toCamelCase
-} from "@secondlayer/stacks/clarity";
-
-// src/print-schema.ts
-import {
-  deserializeCV as deserializeCV2
-} from "@secondlayer/stacks/clarity";
-function camelizeDataKey(str) {
-  return str.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
-}
-function camelizeKeys(obj) {
-  if (obj === null || obj === undefined)
-    return obj;
-  if (typeof obj !== "object")
-    return obj;
-  if (Array.isArray(obj))
-    return obj.map(camelizeKeys);
-  const result = {};
-  for (const [k, v] of Object.entries(obj)) {
-    result[camelizeDataKey(k)] = camelizeKeys(v);
-  }
-  return result;
-}
-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 = deserializeCV2(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/materialize.ts
-function resolveColumn(col, event, tx, block) {
-  if ("fromTx" in col) {
-    return { ok: true, value: tx[col.fromTx] };
-  }
-  if ("fromBlock" in col) {
-    return { ok: true, value: block[col.fromBlock] };
-  }
-  const data = event.data;
-  const dataObj = data !== null && typeof data === "object" && !Array.isArray(data) ? data : undefined;
-  if (dataObj && Object.prototype.hasOwnProperty.call(dataObj, col.from)) {
-    return { ok: true, value: dataObj[col.from] };
-  }
-  if (col.from === "topic" && "topic" in event) {
-    return { ok: true, value: event.topic };
-  }
-  if (Object.prototype.hasOwnProperty.call(event, col.from)) {
-    return { ok: true, value: event[col.from] };
-  }
-  return { ok: false, missing: col.from };
-}
-function buildMaterializeRow(spec, event, ctx, tableColumns) {
-  const row = {};
-  for (const [colName, mapping] of Object.entries(spec.columns)) {
-    const resolved = resolveColumn(mapping, event, ctx.tx, ctx.block);
-    if (!resolved.ok) {
-      const colDef = tableColumns[colName];
-      if (colDef?.nullable) {
-        row[colName] = null;
-        continue;
-      }
-      return {
-        ok: false,
-        reason: `required materialize field "${resolved.missing}" missing for column "${colName}"`
-      };
-    }
-    row[colName] = resolved.value ?? null;
-  }
-  return { ok: true, row };
-}
-function applyMaterializeInsert(spec, event, ctx, schema) {
-  const table = schema[spec.table];
-  if (!table) {
-    return { ok: false, reason: `materialize table "${spec.table}" missing` };
-  }
-  const built = buildMaterializeRow(spec, event, ctx, table.columns);
-  if (!built.ok)
-    return built;
-  ctx.insert(spec.table, built.row);
-  return { ok: true };
-}
-
-// src/runtime/print-validate.ts
-var COLUMN_TYPES = new Set([
-  "text",
-  "uint",
-  "int",
-  "principal",
-  "boolean",
-  "timestamp",
-  "jsonb"
-]);
-function isColumnType(field) {
-  return typeof field === "string" && COLUMN_TYPES.has(field);
-}
-function matchesField(field, value) {
-  if (isColumnType(field)) {
-    switch (field) {
-      case "uint":
-      case "int":
-        return typeof value === "bigint" || typeof value === "number";
-      case "boolean":
-        return typeof value === "boolean";
-      case "text":
-      case "principal":
-      case "timestamp":
-        return typeof value === "string" || typeof value === "number" || typeof value === "bigint";
-      case "jsonb":
-        return value !== undefined;
-    }
-  }
-  if (typeof field !== "object" || field === null)
-    return false;
-  if ("optional" in field) {
-    return value === undefined || value === null || matchesField(field.type, value);
-  }
-  if ("tuple" in field) {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-      return false;
-    }
-    return matchesTopic(field.tuple, value).ok;
-  }
-  if ("list" in field) {
-    return Array.isArray(value) && value.every((item) => matchesField(field.list, item));
-  }
-  return false;
-}
-function matchesTopic(declared, data) {
-  for (const [name, field] of Object.entries(declared)) {
-    const present = name in data;
-    const optional = typeof field === "object" && field !== null && "optional" in field;
-    if (!present) {
-      if (optional)
-        continue;
-      return { ok: false, reason: `missing declared field "${name}"` };
-    }
-    if (!matchesField(field, data[name])) {
-      return {
-        ok: false,
-        reason: `field "${name}" does not match its declared type (got ${describe(data[name])})`
-      };
-    }
-  }
-  return { ok: true };
-}
-function describe(value) {
-  if (value === null)
-    return "null";
-  if (Array.isArray(value))
-    return "array";
-  return typeof value;
-}
-function validatePrintPayload(prints, topic, data) {
-  if (!prints)
-    return { ok: true };
-  const declared = prints[topic];
-  if (!declared)
-    return { ok: true };
-  return matchesTopic(declared, data);
-}
-
-// src/runtime/violations.ts
-import { getTargetDb } from "@secondlayer/shared/db";
-import { logger } from "@secondlayer/shared/logger";
-import { sql } from "kysely";
-var VIOLATIONS_CAP_PER_SUBGRAPH = 100;
-function jsonSafe(value) {
-  if (typeof value === "bigint")
-    return value.toString();
-  if (value === null || value === undefined)
-    return value;
-  if (Array.isArray(value))
-    return value.map(jsonSafe);
-  if (typeof value === "object") {
-    const out = {};
-    for (const [k, v] of Object.entries(value)) {
-      out[k] = jsonSafe(v);
-    }
-    return out;
-  }
-  return value;
-}
-async function defaultRecordPrintViolation(input) {
-  try {
-    const db = getTargetDb();
-    const sample = jsonSafe(input.samplePayload);
-    await db.insertInto("subgraph_violations").values({
-      subgraph_name: input.subgraphName,
-      source_name: input.sourceName,
-      block_height: input.blockHeight,
-      tx_id: input.txId,
-      reason: input.reason,
-      sample_payload: sample
-    }).execute();
-    await sql`
-			DELETE FROM subgraph_violations
-			WHERE id IN (
-				SELECT id FROM subgraph_violations
-				WHERE subgraph_name = ${input.subgraphName}
-				ORDER BY seen_at DESC
-				OFFSET ${VIOLATIONS_CAP_PER_SUBGRAPH}
-			)
-		`.execute(db);
-  } catch (err) {
-    logger.warn("Failed to record print violation", {
-      subgraph: input.subgraphName,
-      error: err instanceof Error ? err.message : String(err)
-    });
-  }
-}
-var recorder = defaultRecordPrintViolation;
-async function recordPrintViolation(input) {
-  await recorder(input);
-}
-
-// src/runtime/runner.ts
-var DEFAULT_ERROR_THRESHOLD = 50;
-function decodeFunctionArgs2(args) {
-  let parsed = args;
-  if (typeof parsed === "string") {
-    try {
-      parsed = JSON.parse(parsed);
-    } catch {
-      return [];
-    }
-  }
-  if (!Array.isArray(parsed))
-    return [];
-  return parsed.map((arg) => {
-    if (typeof arg === "string")
-      return decodeClarityValue(arg);
-    return arg;
-  });
-}
-function decodeRawResult(raw) {
-  if (typeof raw === "string" && raw.length > 2) {
-    return decodeClarityValue(raw);
-  }
-  return null;
-}
-function decodeRawHex(hex) {
-  if (hex.startsWith("0x") && hex.length > 2) {
-    return decodeClarityValue(hex);
-  }
-  return hex;
-}
-function safeBigInt(val) {
-  if (typeof val === "bigint")
-    return val;
-  if (typeof val === "number")
-    return BigInt(val);
-  if (typeof val === "string") {
-    try {
-      return BigInt(val);
-    } catch {
-      return 0n;
-    }
-  }
-  return 0n;
-}
-function buildContractCallInput(filter, tx) {
-  const abi = filter.abi;
-  const fnName = tx.function_name;
-  if (!abi || !fnName)
-    return;
-  const fn = abi.functions?.find((f) => f.name === fnName);
-  if (!fn || !Array.isArray(fn.args))
-    return;
-  let rawArgs = tx.function_args;
-  if (typeof rawArgs === "string") {
-    try {
-      rawArgs = JSON.parse(rawArgs);
-    } catch {
-      return;
-    }
-  }
-  if (!Array.isArray(rawArgs))
-    return;
-  const decodeArg = clarityValueToJS;
-  const input = {};
-  fn.args.forEach((arg, i) => {
-    const hex = rawArgs[i];
-    if (typeof hex !== "string")
-      return;
-    try {
-      const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
-      input[toCamelCase(arg.name)] = decodeArg(arg.type, deserializeCV3(clean));
-    } catch {}
-  });
-  return input;
-}
-function buildEventPayload(filter, tx, event) {
-  const txMeta = {
-    txId: tx.tx_id,
-    sender: tx.sender,
-    type: tx.type,
-    status: tx.status,
-    contractId: tx.contract_id ?? null,
-    functionName: tx.function_name ?? null
-  };
-  const decodedArgs = decodeFunctionArgs2(tx.function_args);
-  const decodedResult = decodeRawResult(tx.raw_result);
-  if (!event) {
-    switch (filter.type) {
-      case "contract_call": {
-        const input = buildContractCallInput(filter, tx);
-        return {
-          type: "contract_call",
-          contractId: tx.contract_id ?? "",
-          functionName: tx.function_name ?? "",
-          sender: tx.sender,
-          args: decodedArgs,
-          ...input !== undefined ? { input } : {},
-          result: decodedResult,
-          resultHex: tx.raw_result ?? null,
-          tx: txMeta
-        };
-      }
-      case "contract_deploy":
-        return {
-          contractId: tx.contract_id ?? "",
-          deployer: tx.sender,
-          tx: txMeta
-        };
-      default:
-        return { tx: txMeta };
-    }
-  }
-  const decoded = decodeEventData(event.data);
-  switch (filter.type) {
-    case "ft_transfer":
-      return {
-        sender: decoded.sender,
-        recipient: decoded.recipient,
-        amount: safeBigInt(decoded.amount),
-        assetIdentifier: decoded.asset_identifier,
-        tx: txMeta
-      };
-    case "ft_mint":
-      return {
-        recipient: decoded.recipient,
-        amount: safeBigInt(decoded.amount),
-        assetIdentifier: decoded.asset_identifier,
-        tx: txMeta
-      };
-    case "ft_burn":
-      return {
-        sender: decoded.sender,
-        amount: safeBigInt(decoded.amount),
-        assetIdentifier: decoded.asset_identifier,
-        tx: txMeta
-      };
-    case "nft_transfer":
-      return {
-        sender: decoded.sender,
-        recipient: decoded.recipient,
-        tokenId: decoded.raw_value ?? decoded.value,
-        assetIdentifier: decoded.asset_identifier,
-        tx: txMeta
-      };
-    case "nft_mint":
-      return {
-        recipient: decoded.recipient,
-        tokenId: decoded.raw_value ?? decoded.value,
-        assetIdentifier: decoded.asset_identifier,
-        tx: txMeta
-      };
-    case "nft_burn":
-      return {
-        sender: decoded.sender,
-        tokenId: decoded.raw_value ?? decoded.value,
-        assetIdentifier: decoded.asset_identifier,
-        tx: txMeta
-      };
-    case "stx_transfer":
-      return {
-        sender: decoded.sender,
-        recipient: decoded.recipient,
-        amount: safeBigInt(decoded.amount),
-        memo: decoded.memo ?? "",
-        tx: txMeta
-      };
-    case "stx_mint":
-      return {
-        recipient: decoded.recipient,
-        amount: safeBigInt(decoded.amount),
-        tx: txMeta
-      };
-    case "stx_burn":
-      return {
-        sender: decoded.sender,
-        amount: safeBigInt(decoded.amount),
-        tx: txMeta
-      };
-    case "stx_lock":
-      return {
-        lockedAddress: decoded.locked_address,
-        lockedAmount: safeBigInt(decoded.locked_amount),
-        unlockHeight: safeBigInt(decoded.unlock_height),
-        tx: txMeta
-      };
-    case "print_event": {
-      const rawHex = event.data?.raw_value;
-      const rawValue = typeof rawHex === "string" && rawHex.startsWith("0x") ? decodeClarityValue(rawHex) : decoded.value;
-      const clarityObj = rawValue && typeof rawValue === "object" && !Array.isArray(rawValue) ? rawValue : null;
-      const topic = clarityObj?.topic ? String(clarityObj.topic) : decoded.topic ?? "";
-      const { topic: _, ...rest } = clarityObj ?? {};
-      const data = Object.keys(rest).length > 0 ? camelizeKeys(rest) : rawValue && typeof rawValue !== "object" ? rawValue : {};
-      return {
-        contractId: printContractId(decoded) ?? tx.contract_id ?? "",
-        topic,
-        data: data ?? {},
-        tx: txMeta
-      };
-    }
-    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 {
-        ...normalized,
-        type: "contract_call",
-        _eventType: event.type,
-        contractId: tx.contract_id ?? "",
-        functionName: tx.function_name ?? "",
-        sender: tx.sender,
-        args: decodedArgs,
-        ...input !== undefined ? { input } : {},
-        result: decodedResult,
-        resultHex: tx.raw_result ?? null,
-        tx: txMeta
-      };
-    }
-    case "contract_deploy":
-      return {
-        contractId: tx.contract_id ?? "",
-        deployer: tx.sender,
-        tx: txMeta
-      };
-    case "nested_contract_call": {
-      const data = event.data ?? {};
-      const argsHex = Array.isArray(data.function_args) ? data.function_args.filter((a) => typeof a === "string") : [];
-      return {
-        contractId: printContractId(data) ?? "",
-        sender: typeof data.sender === "string" ? data.sender : null,
-        caller: typeof data.caller === "string" ? data.caller : "",
-        functionName: typeof data.function_name === "string" ? data.function_name : "",
-        args: decodeFunctionArgs2(argsHex),
-        arguments: argsHex,
-        rawResult: typeof data.raw_result === "string" ? data.raw_result : "",
-        result: decodeRawResult(data.raw_result),
-        tx: txMeta
-      };
-    }
-    case "var_set": {
-      const data = event.data ?? {};
-      const rawValue = typeof data.raw_value === "string" ? data.raw_value : "";
-      return {
-        contractId: printContractId(data) ?? "",
-        varName: typeof data.var_name === "string" ? data.var_name : "",
-        rawValue,
-        value: decodeRawHex(rawValue),
-        tx: txMeta
-      };
-    }
-    case "map_set":
-    case "map_insert": {
-      const data = event.data ?? {};
-      const rawKey = typeof data.raw_key === "string" ? data.raw_key : "";
-      const rawValue = typeof data.raw_value === "string" ? data.raw_value : "";
-      return {
-        contractId: printContractId(data) ?? "",
-        map: typeof data.map_name === "string" ? data.map_name : "",
-        rawKey,
-        key: decodeRawHex(rawKey),
-        rawValue,
-        value: decodeRawHex(rawValue),
-        tx: txMeta
-      };
-    }
-    case "map_delete": {
-      const data = event.data ?? {};
-      const rawKey = typeof data.raw_key === "string" ? data.raw_key : "";
-      return {
-        contractId: printContractId(data) ?? "",
-        map: typeof data.map_name === "string" ? data.map_name : "",
-        rawKey,
-        key: decodeRawHex(rawKey),
-        tx: txMeta
-      };
-    }
-    default:
-      return {
-        ...decoded,
-        _eventType: event.type,
-        tx: txMeta
-      };
-  }
-}
-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 });
-    }
-  }
-  const clockRank = (e) => e?.clock === "vm" ? 1 : 0;
-  units.sort((a, b) => (a.tx.tx_index ?? 0) - (b.tx.tx_index ?? 0) || clockRank(a.event) - clockRank(b.event) || (a.event?.event_index ?? -1) - (b.event?.event_index ?? -1));
-  for (const { tx, event, sourceName } of units) {
-    if (errors >= threshold) {
-      logger2.error("Subgraph error threshold reached, skipping remaining events", {
-        subgraph: subgraph.name,
-        errors,
-        threshold
-      });
-      return { processed, errors, ...skipped > 0 ? { skipped } : {} };
-    }
-    const filter = filterLookup.get(sourceName);
-    const materialize = filter && "materialize" in filter && filter.materialize !== undefined ? filter.materialize : undefined;
-    const handler = subgraph.handlers[sourceName] ?? subgraph.handlers["*"] ?? null;
-    if (!handler && !materialize) {
-      logger2.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 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++;
-          logger2.warn("Print payload does not match declared prints schema", {
-            subgraph: subgraph.name,
-            sourceName,
-            topic: printPayload.topic,
-            txId: tx.tx_id,
-            reason: verdict.reason
-          });
-          recordPrintViolation({
-            subgraphName: subgraph.name,
-            sourceName,
-            blockHeight: ctx.block.height,
-            txId: tx.tx_id,
-            reason: verdict.reason,
-            samplePayload: {
-              topic: printPayload.topic ?? "",
-              data: printPayload.data ?? {}
-            }
-          });
-          continue;
-        }
-      }
-      if (materialize) {
-        const result = applyMaterializeInsert(materialize, payload, ctx, subgraph.schema);
-        if (!result.ok) {
-          skipped++;
-          logger2.warn("Materialize skipped: required field missing", {
-            subgraph: subgraph.name,
-            sourceName,
-            txId: tx.tx_id,
-            reason: result.reason
-          });
-          continue;
-        }
-        processed++;
-      } else if (handler) {
-        await handler(payload, ctx);
-        processed++;
-      }
-    } catch (err) {
-      ctx.rollbackTo(checkpoint);
-      errors++;
-      logger2.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 } : {} };
-}
-export {
-  runHandlers,
-  buildEventPayload,
-  buildContractCallInput
-};
-
-//# debugId=90E8BB694CDBE41B64756E2164756E21
-//# sourceMappingURL=runner.js.map