@secondlayer/subgraphs 4.4.1 → 5.0.1

package/dist/{src/testing → testing}/index.js

@@ -1,9 +1,8 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+// src/testing/harness.ts
+import { normalizeAbi as normalizeAbi2, toCamelCase as toCamelCase3 } from "@secondlayer/stacks/clarity";
 
 // src/runtime/context.ts
 import { logger as logger2 } from "@secondlayer/shared/logger";
-import { formatUnits } from "@secondlayer/stacks/utils";
 import { sql } from "kysely";
 
 // src/schema/generator.ts
@@ -149,12 +148,6 @@ function emitFactoryDDL(schemaName) {
     `CREATE INDEX IF NOT EXISTS idx_${schemaName}_factory_height ON ${schemaName}._factory_addresses (block_height)`
   ];
 }
-function emitForeignKeyDDL(schemaName, tableName, tableDef) {
-  return (tableDef.relations ?? []).map((rel) => {
-    const constraintName = quotePgIdent(`fk_${schemaName}_${tableName}_${rel.name}`);
-    return `ALTER TABLE ${quotePgIdent(schemaName)}.${quotePgIdent(tableName)} ADD CONSTRAINT ${constraintName} ` + `FOREIGN KEY (${rel.fields.map(quotePgIdent).join(", ")}) ` + `REFERENCES ${quotePgIdent(schemaName)}.${quotePgIdent(rel.references)} (${rel.referencedColumns.map(quotePgIdent).join(", ")})`;
-  });
-}
 function generateSubgraphSQL(def, schemaNameOverride) {
   const schemaName = schemaNameOverride ?? pgSchemaName(def.name);
   const statements = [];
@@ -170,9 +163,6 @@ function generateSubgraphSQL(def, schemaNameOverride) {
   if (Object.values(def.sources ?? {}).some((src) => src.factory !== undefined)) {
     statements.push(...emitFactoryDDL(schemaName));
   }
-  for (const [tableName, tableDef] of Object.entries(def.schema)) {
-    statements.push(...emitForeignKeyDDL(schemaName, tableName, tableDef));
-  }
   const hashInput = JSON.stringify({
     name: def.name,
     schema: def.schema,
@@ -278,13 +268,13 @@ function createChainReadClient(ctx) {
           note: 'cache: "contract-constant" asserts this value cannot change; the node answered at its own tip'
         });
       }
-      const value2 = await readContract(nodeClient(rpcUrl), {
+      const value = await readContract(nodeClient(rpcUrl), {
         contract: contractId,
         functionName: fn.name,
         args: clarityArgs,
         tip: ctx.indexBlockHash ?? undefined
       });
-      return serializeCV(value2);
+      return serializeCV(value);
     });
     if (!cached) {
       await db.insertInto("chain_read_cache").values({
@@ -325,7 +315,6 @@ function createChainReadClient(ctx) {
 }
 
 // src/runtime/context.ts
-var JOURNAL_RETENTION_BLOCKS = 300;
 var journalEnsured = new Set;
 function validateColumnName(name) {
   if (!/^[a-z_][a-z0-9_]*$/i.test(name)) {
@@ -342,9 +331,9 @@ class SubgraphContext {
   ops = [];
   journal;
   _client;
-  constructor(db, pgSchemaName2, subgraphSchema, block, tx, journal = false) {
+  constructor(db, pgSchemaName, subgraphSchema, block, tx, journal = false) {
     this.db = db;
-    this.pgSchemaName = pgSchemaName2;
+    this.pgSchemaName = pgSchemaName;
     this.subgraphSchema = subgraphSchema;
     this.block = block;
     this._tx = tx;
@@ -448,20 +437,6 @@ class SubgraphContext {
       return;
     this.ops.length = checkpoint;
   }
-  patch(table, where, set) {
-    this.update(table, where, set);
-  }
-  async patchOrInsert(table, key, row) {
-    const existing = await this.findOne(table, key);
-    const resolved = {};
-    for (const [k, v] of Object.entries(row)) {
-      resolved[k] = typeof v === "function" ? v(existing) : v;
-    }
-    this.upsert(table, key, resolved);
-  }
-  formatUnits(value, decimals) {
-    return formatUnits(value, decimals);
-  }
   async readRows(table, where, limit) {
     const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
     const { clause } = buildWhereClause(where);
@@ -563,47 +538,6 @@ class SubgraphContext {
         return row && rowMatches(row, op.data) ? null : row;
     }
   }
-  async count(table, where) {
-    this.validateTable(table);
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
-    const { rows } = await sql.raw(`SELECT COUNT(*)::int AS count FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
-    return Number(rows[0]?.count ?? 0);
-  }
-  async sum(table, column, where) {
-    this.validateTable(table);
-    validateColumnName(column);
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
-    const { rows } = await sql.raw(`SELECT COALESCE(SUM("${column}"), 0) AS total FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
-    return BigInt(rows[0]?.total?.toString() ?? "0");
-  }
-  async min(table, column, where) {
-    this.validateTable(table);
-    validateColumnName(column);
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
-    const { rows } = await sql.raw(`SELECT MIN("${column}") AS val FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
-    const val = rows[0]?.val;
-    return val != null ? BigInt(val.toString()) : null;
-  }
-  async max(table, column, where) {
-    this.validateTable(table);
-    validateColumnName(column);
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
-    const { rows } = await sql.raw(`SELECT MAX("${column}") AS val FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
-    const val = rows[0]?.val;
-    return val != null ? BigInt(val.toString()) : null;
-  }
-  async countDistinct(table, column, where) {
-    this.validateTable(table);
-    validateColumnName(column);
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
-    const { rows } = await sql.raw(`SELECT COUNT(DISTINCT "${column}")::int AS count FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
-    return Number(rows[0]?.count ?? 0);
-  }
   coerceRow(table, row) {
     const tableDef = this.subgraphSchema[table];
     if (!tableDef)
@@ -928,528 +862,172 @@ function buildWhereClause(where) {
   return { clause: parts.join(" AND "), values: [] };
 }
 
-// src/runtime/clarity.ts
-import { cvToValue, deserializeCV as deserializeCV2 } from "@secondlayer/stacks/clarity";
-function decodeClarityValue(hex) {
-  try {
-    const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
-    const cv = deserializeCV2(cleanHex);
-    return cvToValue(cv);
-  } catch {
-    return hex;
-  }
+// src/runtime/runner.ts
+import { getErrorMessage } from "@secondlayer/shared";
+import { logger as logger4 } from "@secondlayer/shared/logger";
+import {
+  clarityValueToJS,
+  deserializeCV as deserializeCV4,
+  toCamelCase as toCamelCase2
+} 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 decodeEventData(data) {
-  if (typeof data === "string" && data.startsWith("0x") && data.length > 10) {
-    return decodeClarityValue(data);
-  }
-  if (Array.isArray(data)) {
-    return data.map(decodeEventData);
+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);
   }
-  if (typeof data === "object" && data !== null) {
-    const decoded = {};
-    for (const [key, value] of Object.entries(data)) {
-      decoded[key] = decodeEventData(value);
+  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 };
     }
-    return decoded;
   }
-  return data;
 }
-function decodeFunctionArgs(args) {
-  return args.map(decodeClarityValue);
+function unifyNullable(a, b) {
+  if (!a)
+    return b;
+  if (!b)
+    return a;
+  return unify(a, b);
 }
-
-// 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);
+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 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);
+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) };
   }
-  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];
+  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 };
+    }
   }
-  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 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 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 logger4 } from "@secondlayer/shared/logger";
-import {
-  clarityValueToJS,
-  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 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 wrapOptional(t) {
+  return t.kind === "optional" ? t : { kind: "optional", inner: t };
 }
 function renderClarity(t) {
   if (!t)
@@ -1576,7 +1154,7 @@ function inferPrintTopics(samples) {
     let decoded = 0;
     for (const p of picked) {
       try {
-        const cv = deserializeCV3(p.rawHex);
+        const cv = deserializeCV2(p.rawHex);
         decoded++;
         if (cv.type === "tuple")
           tuples.push(cv);
@@ -1610,221 +1188,395 @@ function inferPrintTopics(samples) {
           }
         }
       }
-      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;
+      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/clarity.ts
+import { cvToValue, deserializeCV as deserializeCV3 } from "@secondlayer/stacks/clarity";
+function decodeClarityValue(hex) {
+  try {
+    const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+    const cv = deserializeCV3(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/print-validate.ts
+var COLUMN_TYPES = new Set([
+  "text",
+  "uint",
+  "int",
+  "principal",
+  "boolean",
+  "timestamp",
+  "jsonb"
+]);
+
+// 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 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;
         }
-        fields.push(field);
+        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;
     }
-    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;
+    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 });
       }
-      return {
-        ok: false,
-        reason: `required materialize field "${resolved.missing}" missing for column "${colName}"`
-      };
+      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;
     }
-    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 };
+  return results;
 }
-
-// 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;
+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);
   }
-  if ("list" in field) {
-    return Array.isArray(value) && value.every((item) => matchesField(field.list, item));
+  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);
   }
-  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])})`
-      };
+  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 { 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);
+  return results;
 }
 
 // src/runtime/violations.ts
 import { getTargetDb } from "@secondlayer/shared/db";
 import { logger as logger3 } from "@secondlayer/shared/logger";
 import { sql as sql2 } from "kysely";
-var VIOLATIONS_CAP_PER_SUBGRAPH = 100;
-function jsonSafe2(value) {
-  if (typeof value === "bigint")
-    return value.toString();
-  if (value === null || value === undefined)
-    return value;
-  if (Array.isArray(value))
-    return value.map(jsonSafe2);
-  if (typeof value === "object") {
-    const out = {};
-    for (const [k, v] of Object.entries(value)) {
-      out[k] = jsonSafe2(v);
-    }
-    return out;
-  }
-  return value;
-}
-async function defaultRecordPrintViolation(input) {
-  try {
-    const db = getTargetDb();
-    const sample = jsonSafe2(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 sql2`
-			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) {
-    logger3.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) {
+function decodeFunctionArgs(args) {
   let parsed = args;
   if (typeof parsed === "string") {
     try {
@@ -1907,7 +1659,7 @@ function buildEventPayload(filter, tx, event) {
     contractId: tx.contract_id ?? null,
     functionName: tx.function_name ?? null
   };
-  const decodedArgs = decodeFunctionArgs2(tx.function_args);
+  const decodedArgs = decodeFunctionArgs(tx.function_args);
   const decodedResult = decodeRawResult(tx.raw_result);
   if (!event) {
     switch (filter.type) {
@@ -2054,7 +1806,7 @@ function buildEventPayload(filter, tx, event) {
         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),
+        args: decodeFunctionArgs(argsHex),
         arguments: argsHex,
         rawResult: typeof data.raw_result === "string" ? data.raw_result : "",
         result: decodeRawResult(data.raw_result),
@@ -2106,152 +1858,8 @@ 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 });
-    }
-  }
-  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) {
-      logger4.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) {
-      logger4.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++;
-          logger4.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++;
-          logger4.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++;
-      logger4.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/testing/harness.ts
-import { normalizeAbi as normalizeAbi2, toCamelCase as toCamelCase3 } from "@secondlayer/stacks/clarity";
 var TEST_SCHEMA_NAME = "subgraph_test";
 function defaultBlock(overrides = {}) {
   return {
@@ -2457,17 +2065,17 @@ function toContractCallPayload(row) {
     }
   };
 }
-function jsonSafe3(value) {
+function jsonSafe2(value) {
   if (typeof value === "bigint")
     return value.toString();
   if (value === null || value === undefined)
     return value;
   if (Array.isArray(value))
-    return value.map(jsonSafe3);
+    return value.map(jsonSafe2);
   if (typeof value === "object") {
     const out = {};
     for (const [k, v] of Object.entries(value)) {
-      out[k] = jsonSafe3(v);
+      out[k] = jsonSafe2(v);
     }
     return out;
   }
@@ -2533,9 +2141,8 @@ async function runSubgraphTest(input) {
   const traces = [];
   for (const [name, rows] of Object.entries(events)) {
     const filter = sources[name];
-    const handler = handlers[name] ?? handlers["*"];
-    const materialize = filter && "materialize" in filter && filter.materialize !== undefined ? filter.materialize : undefined;
-    if (typeof handler !== "function" && !materialize)
+    const handler = handlers[name];
+    if (typeof handler !== "function")
       continue;
     for (const row of rows) {
       const payload = filter?.type === "contract_call" ? toContractCallPayload(row) : toHandlerPayload(filter, row);
@@ -2556,17 +2163,7 @@ async function runSubgraphTest(input) {
       try {
         ctx.setTx(txFromRow(row));
         const event = buildEvent(filter, payload, { tx: ctx.tx });
-        if (materialize) {
-          applyMaterializeInsert(materialize, event, {
-            tx: ctx.tx,
-            block: ctx.block,
-            insert: (table, insertRow) => {
-              ctx.insert(table, insertRow);
-            }
-          }, schema);
-        } else {
-          await handler(event, ctx);
-        }
+        await handler(event, ctx);
       } catch {}
       if (trace) {
         const inserts = ctx.pendingInsertsSince(checkpoint);
@@ -2589,7 +2186,7 @@ async function runSubgraphTest(input) {
     tables.push({
       name: table,
       rows: tableRows.length,
-      ...sample ? { sampleRow: jsonSafe3(sample) } : {}
+      ...sample ? { sampleRow: jsonSafe2(sample) } : {}
     });
   }
   const fetched = Object.values(events).reduce((n, r) => n + r.length, 0);
@@ -2618,7 +2215,7 @@ async function runSubgraphTest(input) {
       matched,
       written: 0,
       tables,
-      firstEvent: firstEvent ? { ...firstEvent, data: jsonSafe3(firstEvent.data) } : undefined,
+      firstEvent: firstEvent ? { ...firstEvent, data: jsonSafe2(firstEvent.data) } : undefined,
       hint: `${matched} event${matched === 1 ? "" : "s"} matched, but NO rows were written — the shape of the field-mapping bug that ships a 0-row subgraph.${keyPart} Map only observed keys; do not invent fields.`,
       ...traceFields
     };
@@ -2632,7 +2229,7 @@ async function runSubgraphTest(input) {
       matched,
       written,
       tables,
-      firstEvent: firstEvent ? { ...firstEvent, data: jsonSafe3(firstEvent.data) } : undefined,
+      firstEvent: firstEvent ? { ...firstEvent, data: jsonSafe2(firstEvent.data) } : undefined,
       hint: `At least one matched event wrote 0 rows.${keyPart}`,
       ...traceFields
     };
@@ -2642,7 +2239,7 @@ async function runSubgraphTest(input) {
     matched,
     written,
     tables,
-    firstEvent: firstEvent ? { ...firstEvent, data: jsonSafe3(firstEvent.data) } : undefined,
+    firstEvent: firstEvent ? { ...firstEvent, data: jsonSafe2(firstEvent.data) } : undefined,
     ...traceFields
   };
 }
@@ -2654,9 +2251,8 @@ async function probeHandlers(def, samples) {
     const filter = def.sources[sample.source];
     if (!filter)
       continue;
-    const handler = def.handlers[sample.source] ?? def.handlers["*"];
-    const materialize = "materialize" in filter && filter.materialize !== undefined ? filter.materialize : undefined;
-    if (typeof handler !== "function" && !materialize)
+    const handler = def.handlers[sample.source];
+    if (typeof handler !== "function")
       continue;
     if (firstEventKeys === undefined) {
       firstEventKeys = dataKeysOf(sample.event.data);
@@ -2664,17 +2260,7 @@ async function probeHandlers(def, samples) {
     matched++;
     try {
       const event = buildEvent(filter, sample.event);
-      if (materialize) {
-        applyMaterializeInsert(materialize, event, {
-          tx: ctx.tx,
-          block: ctx.block,
-          insert: (table, row) => {
-            ctx.insert(table, row);
-          }
-        }, def.schema);
-      } else {
-        await handler(event, ctx);
-      }
+      await handler(event, ctx);
     } catch {}
   }
   const tables = Object.keys(def.schema);
@@ -2690,14 +2276,14 @@ async function probeHandlers(def, samples) {
   };
 }
 export {
-  toHandlerPayload,
-  toContractCallPayload,
-  runSubgraphTest,
-  probeHandlers,
-  createTestContext,
+  buildEvent,
   buildEventPayload,
-  buildEvent
+  createTestContext,
+  probeHandlers,
+  runSubgraphTest,
+  toContractCallPayload,
+  toHandlerPayload
 };
 
-//# debugId=BBBAFF796E747D6364756E2164756E21
+//# debugId=73BD3E2068CDEA0464756E2164756E21
 //# sourceMappingURL=index.js.map