@secondlayer/subgraphs 4.1.4 → 4.2.0

package/dist/src/runtime/runner.js

@@ -32,15 +32,679 @@ function decodeFunctionArgs(args) {
   return args.map(decodeClarityValue);
 }
 
+// src/runtime/source-matcher.ts
+var patternCache = new Map;
+function matchAny(value, pattern) {
+  return Array.isArray(pattern) ? pattern.some((p) => matchPattern(value, p)) : matchPattern(value, pattern);
+}
+function matchPattern(value, pattern) {
+  if (!pattern.includes("*"))
+    return value === pattern;
+  let re = patternCache.get(pattern);
+  if (!re) {
+    const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    re = new RegExp(`^${regex}$`);
+    patternCache.set(pattern, re);
+  }
+  return re.test(value);
+}
+var EMPTY_SET = new Set;
+function factoryAllows(filter, contractId, factoryContracts) {
+  if (!filter.factory)
+    return true;
+  if (!contractId)
+    return false;
+  return (factoryContracts.get(filter.factory.from) ?? EMPTY_SET).has(contractId);
+}
+function readPath(payload, path) {
+  let cur = payload;
+  for (const key of path.split(".")) {
+    if (cur === null || typeof cur !== "object")
+      return;
+    cur = cur[key];
+  }
+  return cur;
+}
+function traitAllows(filter, contractId, traitContracts) {
+  const trait = filter.trait;
+  if (!trait)
+    return true;
+  if (!contractId)
+    return false;
+  return (traitContracts.get(trait) ?? EMPTY_SET).has(contractId);
+}
+function assetContract(assetId) {
+  return assetId?.split("::")[0];
+}
+function printContractId(data) {
+  if (!data)
+    return;
+  const id = (typeof data.contract_identifier === "string" ? data.contract_identifier : undefined) ?? (typeof data.contract_id === "string" ? data.contract_id : undefined);
+  return id || undefined;
+}
+function matchFilter(filter, transactions, eventsByTx, traitContracts, factoryContracts = new Map) {
+  const results = [];
+  switch (filter.type) {
+    case "stx_transfer":
+    case "stx_mint":
+    case "stx_burn":
+    case "stx_lock": {
+      const eventType = `${filter.type}_event`;
+      for (const tx of transactions) {
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        const matched = txEvents.filter((e) => e.type === eventType);
+        if (matched.length === 0)
+          continue;
+        const filtered = matched.filter((e) => {
+          const data = e.data;
+          if (!data)
+            return false;
+          if ("sender" in filter && filter.sender) {
+            if (!matchPattern(data.sender, filter.sender))
+              return false;
+          }
+          if ("recipient" in filter && filter.recipient) {
+            if (!matchPattern(data.recipient, filter.recipient))
+              return false;
+          }
+          if ("lockedAddress" in filter && filter.lockedAddress) {
+            if (!matchPattern(data.locked_address, filter.lockedAddress))
+              return false;
+          }
+          if ("minAmount" in filter && filter.minAmount !== undefined) {
+            const amount = BigInt(data.amount ?? data.locked_amount ?? "0");
+            if (amount < filter.minAmount)
+              return false;
+          }
+          if ("maxAmount" in filter && filter.maxAmount !== undefined) {
+            const amount = BigInt(data.amount ?? "0");
+            if (amount > filter.maxAmount)
+              return false;
+          }
+          return true;
+        });
+        if (filtered.length > 0) {
+          results.push({ tx, events: filtered });
+        }
+      }
+      break;
+    }
+    case "ft_transfer":
+    case "ft_mint":
+    case "ft_burn": {
+      const eventType = `${filter.type}_event`;
+      for (const tx of transactions) {
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        const matched = txEvents.filter((e) => {
+          if (e.type !== eventType)
+            return false;
+          const data = e.data;
+          if (!data)
+            return false;
+          if (filter.assetIdentifier) {
+            const assetId = data.asset_identifier;
+            if (!assetId || !matchPattern(assetId, filter.assetIdentifier))
+              return false;
+          }
+          if (!traitAllows(filter, assetContract(data.asset_identifier), traitContracts))
+            return false;
+          if ("sender" in filter && filter.sender) {
+            if (!matchPattern(data.sender, filter.sender))
+              return false;
+          }
+          if ("recipient" in filter && filter.recipient) {
+            if (!matchPattern(data.recipient, filter.recipient))
+              return false;
+          }
+          if (filter.minAmount !== undefined) {
+            const amount = BigInt(data.amount ?? "0");
+            if (amount < filter.minAmount)
+              return false;
+          }
+          return true;
+        });
+        if (matched.length > 0) {
+          results.push({ tx, events: matched });
+        }
+      }
+      break;
+    }
+    case "nft_transfer":
+    case "nft_mint":
+    case "nft_burn": {
+      const eventType = `${filter.type}_event`;
+      for (const tx of transactions) {
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        const matched = txEvents.filter((e) => {
+          if (e.type !== eventType)
+            return false;
+          const data = e.data;
+          if (!data)
+            return false;
+          if (filter.assetIdentifier) {
+            const assetId = data.asset_identifier;
+            if (!assetId || !matchPattern(assetId, filter.assetIdentifier))
+              return false;
+          }
+          if (!traitAllows(filter, assetContract(data.asset_identifier), traitContracts))
+            return false;
+          if ("sender" in filter && filter.sender) {
+            if (!matchPattern(data.sender, filter.sender))
+              return false;
+          }
+          if ("recipient" in filter && filter.recipient) {
+            if (!matchPattern(data.recipient, filter.recipient))
+              return false;
+          }
+          return true;
+        });
+        if (matched.length > 0) {
+          results.push({ tx, events: matched });
+        }
+      }
+      break;
+    }
+    case "contract_call": {
+      for (const tx of transactions) {
+        if (tx.type !== "contract_call")
+          continue;
+        if (filter.contractId) {
+          if (!tx.contract_id || !matchAny(tx.contract_id, filter.contractId))
+            continue;
+        }
+        if (!factoryAllows(filter, tx.contract_id, factoryContracts))
+          continue;
+        if (filter.functionName) {
+          if (!tx.function_name || !matchPattern(tx.function_name, filter.functionName))
+            continue;
+        }
+        if (filter.caller) {
+          if (!matchPattern(tx.sender, filter.caller))
+            continue;
+        }
+        if (!traitAllows(filter, tx.contract_id, traitContracts))
+          continue;
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        results.push({ tx, events: txEvents });
+      }
+      break;
+    }
+    case "contract_deploy": {
+      for (const tx of transactions) {
+        if (tx.type !== "smart_contract")
+          continue;
+        if (filter.deployer) {
+          if (!matchPattern(tx.sender, filter.deployer))
+            continue;
+        }
+        if (filter.contractName) {
+          const name = tx.contract_id?.split(".")[1] ?? "";
+          if (!matchPattern(name, filter.contractName))
+            continue;
+        }
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        results.push({ tx, events: txEvents });
+      }
+      break;
+    }
+    case "print_event": {
+      for (const tx of transactions) {
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        const matched = txEvents.filter((e) => {
+          if (e.type !== "smart_contract_event" && e.type !== "contract_event")
+            return false;
+          const data = e.data;
+          if (!data)
+            return false;
+          if (data.topic !== "print")
+            return false;
+          const contractId = printContractId(data);
+          if (filter.contractId) {
+            if (!contractId || !matchAny(contractId, filter.contractId))
+              return false;
+          }
+          if (!traitAllows(filter, contractId, traitContracts))
+            return false;
+          if (!factoryAllows(filter, contractId, factoryContracts))
+            return false;
+          return true;
+        });
+        if (matched.length > 0) {
+          results.push({ tx, events: matched });
+        }
+      }
+      break;
+    }
+  }
+  return results;
+}
+function matchSources(sources, transactions, events, traitContracts = new Map, factoryContracts = new Map) {
+  const eventsByTx = new Map;
+  for (const event of events) {
+    const list = eventsByTx.get(event.tx_id) ?? [];
+    list.push(event);
+    eventsByTx.set(event.tx_id, list);
+  }
+  const seen = new Set;
+  const results = [];
+  for (const [sourceName, filter] of Object.entries(sources)) {
+    const matches = matchFilter(filter, transactions, eventsByTx, traitContracts, factoryContracts);
+    for (const match of matches) {
+      const dedupeKey = `${match.tx.tx_id}:${sourceName}`;
+      if (!seen.has(dedupeKey)) {
+        seen.add(dedupeKey);
+        results.push({ ...match, sourceName });
+      }
+    }
+  }
+  return results;
+}
+
 // src/runtime/runner.ts
 import { getErrorMessage } from "@secondlayer/shared";
-import { logger } from "@secondlayer/shared/logger";
+import { logger as logger2 } from "@secondlayer/shared/logger";
 import {
   clarityValueToJS,
-  deserializeCV as deserializeCV2,
+  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",
@@ -120,24 +784,62 @@ function validatePrintPayload(prints, topic, data) {
   return matchesTopic(declared, data);
 }
 
-// src/runtime/runner.ts
-var DEFAULT_ERROR_THRESHOLD = 50;
-function camelCase(str) {
-  return str.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+// 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;
 }
-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[camelCase(k)] = camelizeKeys(v);
+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)
+    });
   }
-  return result;
 }
+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") {
@@ -201,7 +903,7 @@ function buildContractCallInput(filter, tx) {
       return;
     try {
       const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
-      input[toCamelCase(arg.name)] = decodeArg(arg.type, deserializeCV2(clean));
+      input[toCamelCase(arg.name)] = decodeArg(arg.type, deserializeCV3(clean));
     } catch {}
   });
   return input;
@@ -324,7 +1026,7 @@ function buildEventPayload(filter, tx, event) {
       const { topic: _, ...rest } = clarityObj ?? {};
       const data = Object.keys(rest).length > 0 ? camelizeKeys(rest) : rawValue && typeof rawValue !== "object" ? rawValue : {};
       return {
-        contractId: decoded.contract_identifier ?? tx.contract_id ?? "",
+        contractId: printContractId(decoded) ?? tx.contract_id ?? "",
         topic,
         data: data ?? {},
         tx: txMeta
@@ -385,16 +1087,18 @@ async function runHandlers(subgraph, matched, ctx, opts) {
   units.sort((a, b) => (a.tx.tx_index ?? 0) - (b.tx.tx_index ?? 0) || (a.event?.event_index ?? -1) - (b.event?.event_index ?? -1));
   for (const { tx, event, sourceName } of units) {
     if (errors >= threshold) {
-      logger.error("Subgraph error threshold reached, skipping remaining events", {
+      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) {
-      logger.warn("No handler found for source", {
+    if (!handler && !materialize) {
+      logger2.warn("No handler found for source", {
         subgraph: subgraph.name,
         sourceName,
         txId: tx.tx_id
@@ -409,7 +1113,6 @@ async function runHandlers(subgraph, matched, ctx, opts) {
       contractId: tx.contract_id ?? null,
       functionName: tx.function_name ?? null
     });
-    const filter = filterLookup.get(sourceName);
     const checkpoint = ctx.opsCheckpoint();
     try {
       let payload;
@@ -451,22 +1154,48 @@ async function runHandlers(subgraph, matched, ctx, opts) {
         const verdict = validatePrintPayload(filter.prints, printPayload.topic ?? "", printPayload.data ?? {});
         if (!verdict.ok) {
           skipped++;
-          logger.warn("Print payload does not match declared prints schema", {
+          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++;
       }
-      await handler(payload, ctx);
-      processed++;
     } catch (err) {
       ctx.rollbackTo(checkpoint);
       errors++;
-      logger.error("Subgraph handler error", {
+      logger2.error("Subgraph handler error", {
         subgraph: subgraph.name,
         sourceName,
         txId: tx.tx_id,
@@ -483,5 +1212,5 @@ export {
   buildContractCallInput
 };
 
-//# debugId=5FE61480B3DD60C064756E2164756E21
+//# debugId=B6BA5F58B8903CEC64756E2164756E21
 //# sourceMappingURL=runner.js.map