@secondlayer/subgraphs 4.1.4 → 4.2.0

package/dist/src/runtime/processor.js

@@ -942,15 +942,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 as logger3 } from "@secondlayer/shared/logger";
+import { logger as logger4 } from "@secondlayer/shared/logger";
 import {
   clarityValueToJS,
-  deserializeCV as deserializeCV3,
+  deserializeCV as deserializeCV4,
   toCamelCase as toCamelCase2
 } from "@secondlayer/stacks/clarity";
 
+// src/print-schema.ts
+import {
+  deserializeCV as deserializeCV3
+} from "@secondlayer/stacks/clarity";
+function camelizeDataKey(str) {
+  return str.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function 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 = deserializeCV3(p.rawHex);
+        decoded++;
+        if (cv.type === "tuple")
+          tuples.push(cv);
+      } catch {}
+    }
+    const nonTuple = decoded > 0 && tuples.length === 0;
+    const fields = [];
+    if (!nonTuple) {
+      const stats = new Map;
+      for (const t of tuples) {
+        for (const [key, value] of Object.entries(t.value)) {
+          if (key === "topic")
+            continue;
+          const tree = cvToTree(value);
+          const existing = stats.get(key);
+          if (existing) {
+            existing.present++;
+            existing.tree = unify(existing.tree, tree);
+            if (value.type === "none")
+              existing.noneCount++;
+            if (value.type === "none" || value.type === "some") {
+              existing.optionalSeen = true;
+            }
+          } else {
+            stats.set(key, {
+              tree,
+              present: 1,
+              noneCount: value.type === "none" ? 1 : 0,
+              optionalSeen: value.type === "none" || value.type === "some"
+            });
+          }
+        }
+      }
+      for (const [name, st] of [...stats].sort(([a], [b]) => a.localeCompare(b))) {
+        const field = {
+          name,
+          camel_name: camelizeDataKey(name),
+          clarity_type: renderClarity(st.tree),
+          ts_type: renderTs(st.tree),
+          column_type: toColumnType(st.tree),
+          always_present: st.present === tuples.length
+        };
+        if (st.optionalSeen) {
+          field.optional_some_rate = (st.present - st.noneCount) / st.present;
+        }
+        fields.push(field);
+      }
+    }
+    out.push({
+      topic,
+      count: rows.length,
+      first_height: first,
+      last_height: last,
+      non_tuple: nonTuple,
+      fields
+    });
+  }
+  return out.sort((a, b) => b.count - a.count);
+}
+
+// src/runtime/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",
@@ -1030,24 +1694,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 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;
 }
-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 = 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)
+    });
   }
-  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") {
@@ -1111,7 +1813,7 @@ function buildContractCallInput(filter, tx) {
       return;
     try {
       const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
-      input[toCamelCase2(arg.name)] = decodeArg(arg.type, deserializeCV3(clean));
+      input[toCamelCase2(arg.name)] = decodeArg(arg.type, deserializeCV4(clean));
     } catch {}
   });
   return input;
@@ -1234,7 +1936,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
@@ -1295,363 +1997,128 @@ 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) {
-      logger3.error("Subgraph error threshold reached, skipping remaining events", {
+      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) {
-      logger3.warn("No handler found for source", {
+    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 filter = filterLookup.get(sourceName);
-    const checkpoint = ctx.opsCheckpoint();
-    try {
-      let payload;
-      if (event === null) {
-        payload = filter ? buildEventPayload(filter, tx, null) : {
-          tx: {
-            txId: tx.tx_id,
-            sender: tx.sender,
-            type: tx.type,
-            status: tx.status,
-            contractId: tx.contract_id,
-            functionName: tx.function_name
-          }
-        };
-      } else if (filter) {
-        payload = buildEventPayload(filter, tx, event);
-      } else {
-        const decoded = decodeEventData(event.data);
-        payload = {
-          ...decoded,
-          _eventId: event.id,
-          _eventType: event.type,
-          _eventIndex: event.event_index,
-          tx: {
-            txId: tx.tx_id,
-            sender: tx.sender,
-            type: tx.type,
-            status: tx.status,
-            contractId: tx.contract_id,
-            functionName: tx.function_name
-          }
-        };
-      }
-      if (event !== null && filter?.type === "print_event" && filter.topic && payload.topic !== filter.topic) {
-        continue;
-      }
-      if (event !== null && filter?.type === "print_event" && filter.prints) {
-        const printPayload = payload;
-        const verdict = validatePrintPayload(filter.prints, printPayload.topic ?? "", printPayload.data ?? {});
-        if (!verdict.ok) {
-          skipped++;
-          logger3.warn("Print payload does not match declared prints schema", {
-            subgraph: subgraph.name,
-            sourceName,
-            topic: printPayload.topic,
-            txId: tx.tx_id,
-            reason: verdict.reason
-          });
-          continue;
-        }
-      }
-      await handler(payload, ctx);
-      processed++;
-    } catch (err) {
-      ctx.rollbackTo(checkpoint);
-      errors++;
-      logger3.error("Subgraph handler error", {
-        subgraph: subgraph.name,
-        sourceName,
-        txId: tx.tx_id,
-        ...event !== null ? { eventId: event.id, eventType: event.type } : {},
-        error: getErrorMessage(err)
-      });
-    }
-  }
-  return { processed, errors, ...skipped > 0 ? { skipped } : {} };
-}
-
-// src/runtime/source-matcher.ts
-var patternCache = new Map;
-function matchAny(value, pattern) {
-  return Array.isArray(pattern) ? pattern.some((p) => matchPattern(value, p)) : matchPattern(value, pattern);
-}
-function matchPattern(value, pattern) {
-  if (!pattern.includes("*"))
-    return value === pattern;
-  let re = patternCache.get(pattern);
-  if (!re) {
-    const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-    re = new RegExp(`^${regex}$`);
-    patternCache.set(pattern, re);
-  }
-  return re.test(value);
-}
-var EMPTY_SET = new Set;
-function factoryAllows(filter, contractId, factoryContracts) {
-  if (!filter.factory)
-    return true;
-  if (!contractId)
-    return false;
-  return (factoryContracts.get(filter.factory.from) ?? EMPTY_SET).has(contractId);
-}
-function readPath(payload, path) {
-  let cur = payload;
-  for (const key of path.split(".")) {
-    if (cur === null || typeof cur !== "object")
-      return;
-    cur = cur[key];
-  }
-  return cur;
-}
-function traitAllows(filter, contractId, traitContracts) {
-  const trait = filter.trait;
-  if (!trait)
-    return true;
-  if (!contractId)
-    return false;
-  return (traitContracts.get(trait) ?? EMPTY_SET).has(contractId);
-}
-function assetContract(assetId) {
-  return assetId?.split("::")[0];
-}
-function matchFilter(filter, transactions, eventsByTx, traitContracts, factoryContracts = new Map) {
-  const results = [];
-  switch (filter.type) {
-    case "stx_transfer":
-    case "stx_mint":
-    case "stx_burn":
-    case "stx_lock": {
-      const eventType = `${filter.type}_event`;
-      for (const tx of transactions) {
-        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
-        const matched = txEvents.filter((e) => e.type === eventType);
-        if (matched.length === 0)
-          continue;
-        const filtered = matched.filter((e) => {
-          const data = e.data;
-          if (!data)
-            return false;
-          if ("sender" in filter && filter.sender) {
-            if (!matchPattern(data.sender, filter.sender))
-              return false;
-          }
-          if ("recipient" in filter && filter.recipient) {
-            if (!matchPattern(data.recipient, filter.recipient))
-              return false;
-          }
-          if ("lockedAddress" in filter && filter.lockedAddress) {
-            if (!matchPattern(data.locked_address, filter.lockedAddress))
-              return false;
-          }
-          if ("minAmount" in filter && filter.minAmount !== undefined) {
-            const amount = BigInt(data.amount ?? data.locked_amount ?? "0");
-            if (amount < filter.minAmount)
-              return false;
-          }
-          if ("maxAmount" in filter && filter.maxAmount !== undefined) {
-            const amount = BigInt(data.amount ?? "0");
-            if (amount > filter.maxAmount)
-              return false;
-          }
-          return true;
-        });
-        if (filtered.length > 0) {
-          results.push({ tx, events: filtered });
-        }
-      }
-      break;
+      });
+      continue;
     }
-    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;
+    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
           }
-          if (filter.minAmount !== undefined) {
-            const amount = BigInt(data.amount ?? "0");
-            if (amount < filter.minAmount)
-              return false;
+        };
+      } else if (filter) {
+        payload = buildEventPayload(filter, tx, event);
+      } else {
+        const decoded = decodeEventData(event.data);
+        payload = {
+          ...decoded,
+          _eventId: event.id,
+          _eventType: event.type,
+          _eventIndex: event.event_index,
+          tx: {
+            txId: tx.tx_id,
+            sender: tx.sender,
+            type: tx.type,
+            status: tx.status,
+            contractId: tx.contract_id,
+            functionName: tx.function_name
           }
-          return true;
-        });
-        if (matched.length > 0) {
-          results.push({ tx, events: matched });
-        }
+        };
       }
-      break;
-    }
-    case "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 });
-        }
+      if (event !== null && filter?.type === "print_event" && filter.topic && payload.topic !== filter.topic) {
+        continue;
       }
-      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))
+      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 (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")
+      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;
-        if (filter.deployer) {
-          if (!matchPattern(tx.sender, filter.deployer))
-            continue;
-        }
-        if (filter.contractName) {
-          const name = tx.contract_id?.split(".")[1] ?? "";
-          if (!matchPattern(name, filter.contractName))
-            continue;
-        }
-        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
-        results.push({ tx, events: txEvents });
-      }
-      break;
-    }
-    case "print_event": {
-      for (const tx of transactions) {
-        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
-        const matched = txEvents.filter((e) => {
-          if (e.type !== "smart_contract_event" && e.type !== "contract_event")
-            return false;
-          const data = e.data;
-          if (!data)
-            return false;
-          if (data.topic !== "print")
-            return false;
-          const printContractId = data.contract_identifier ?? data.contract_id;
-          if (filter.contractId) {
-            if (!printContractId || !matchAny(printContractId, filter.contractId))
-              return false;
-          }
-          if (!traitAllows(filter, printContractId, traitContracts))
-            return false;
-          if (!factoryAllows(filter, printContractId, factoryContracts))
-            return false;
-          return true;
-        });
-        if (matched.length > 0) {
-          results.push({ tx, events: matched });
         }
+        processed++;
+      } else if (handler) {
+        await handler(payload, ctx);
+        processed++;
       }
-      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 });
-      }
+    } 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 results;
+  return { processed, errors, ...skipped > 0 ? { skipped } : {} };
 }
 
 // src/runtime/block-processor.ts
-import { getTargetDb } from "@secondlayer/shared/db";
+import { getTargetDb as getTargetDb2 } from "@secondlayer/shared/db";
 import { resolveTraitContractIds } from "@secondlayer/shared/db/queries/contracts";
 import { recordGapBatch } from "@secondlayer/shared/db/queries/subgraph-gaps";
 import { advanceOperationCursor } from "@secondlayer/shared/db/queries/subgraph-operations";
@@ -1662,15 +2129,15 @@ import {
   rewindLiveProgress,
   updateSubgraphStatus
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger7 } from "@secondlayer/shared/logger";
-import { sql as sql3 } from "kysely";
+import { logger as logger8 } from "@secondlayer/shared/logger";
+import { sql as sql4 } from "kysely";
 
 // src/runtime/block-source.ts
 import { getSourceDb as getSourceDb2 } from "@secondlayer/shared/db";
 import {
   createInternalIndexHttpClient
 } from "@secondlayer/shared/index-http";
-import { logger as logger4 } from "@secondlayer/shared/logger";
+import { logger as logger5 } from "@secondlayer/shared/logger";
 
 // src/runtime/batch-loader.ts
 async function loadBlockRange(db, fromHeight, toHeight) {
@@ -1990,7 +2457,7 @@ function reconstructEvent(e) {
         type: "contract_event",
         data: {
           topic: e.payload.topic,
-          contract_identifier: e.contract_id,
+          contract_id: e.contract_id,
           value: e.payload.value,
           raw_value: e.payload.raw_value
         }
@@ -2157,7 +2624,7 @@ class FallbackBlockSource {
     try {
       return await this.primary.getTip();
     } catch (err) {
-      logger4.warn("block source primary getTip failed — using DB tap", {
+      logger5.warn("block source primary getTip failed — using DB tap", {
         error: err instanceof Error ? err.message : String(err)
       });
       return this.fallback.getTip();
@@ -2167,7 +2634,7 @@ class FallbackBlockSource {
     try {
       return await this.primary.loadBlockRange(fromHeight, toHeight);
     } catch (err) {
-      logger4.warn("block source primary loadBlockRange failed — using DB tap", {
+      logger5.warn("block source primary loadBlockRange failed — using DB tap", {
         from: fromHeight,
         to: toHeight,
         error: err instanceof Error ? err.message : String(err)
@@ -2204,7 +2671,7 @@ function resolveBlockSource(subgraph) {
     return new FallbackBlockSource(new PublicApiBlockSource(buildHttpClient(), referencedIndexEventTypes(subgraph), canSparseScan(subgraph) ? sparseProbeTargets(subgraph) : undefined, needsTransactionData(subgraph)), postgresBlockSource);
   }
   if (process.env.SUBGRAPH_SOURCE === "streams-index" && subgraph) {
-    logger4.debug("Subgraph not streams-index eligible, using DB tap", {
+    logger5.debug("Subgraph not streams-index eligible, using DB tap", {
       subgraph: subgraph.name
     });
   }
@@ -2213,7 +2680,7 @@ function resolveBlockSource(subgraph) {
 
 // src/runtime/outbox-emit.ts
 import { createHash as createHash2 } from "node:crypto";
-import { logger as logger5 } from "@secondlayer/shared/logger";
+import { logger as logger6 } from "@secondlayer/shared/logger";
 var loggedKillSwitch = false;
 var OP_VERB = {
   insert: "created",
@@ -2237,7 +2704,7 @@ function stableStringify(obj) {
 async function emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, blockHeight) {
   if (!isEmitOutboxEnabled()) {
     if (!loggedKillSwitch) {
-      logger5.warn("SECONDLAYER_EMIT_OUTBOX=false — outbox emission bypassed");
+      logger6.warn("SECONDLAYER_EMIT_OUTBOX=false — outbox emission bypassed");
       loggedKillSwitch = true;
     }
     return 0;
@@ -2282,7 +2749,7 @@ function sandboxEnabled(subgraph) {
 // src/runtime/sandbox/host.ts
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
-import { logger as logger6 } from "@secondlayer/shared/logger";
+import { logger as logger7 } from "@secondlayer/shared/logger";
 
 // src/runtime/sandbox/bundle.ts
 import esbuild from "esbuild";
@@ -2362,7 +2829,7 @@ function spawnSandboxProcess() {
           break;
         const text = decoder.decode(value, { stream: true });
         if (text.trim()) {
-          logger6.warn("Sandbox subprocess stderr", { stderr: text.trim() });
+          logger7.warn("Sandbox subprocess stderr", { stderr: text.trim() });
         }
       }
     } catch {}
@@ -2420,7 +2887,7 @@ async function ensureSandboxProcess(subgraphName, version, handlerCode) {
     try {
       await initSandboxProcess(existing.proc, subgraphName, version, handlerCode);
       existing.version = version;
-      logger6.info("Sandbox subprocess handler reloaded", {
+      logger7.info("Sandbox subprocess handler reloaded", {
         subgraph: subgraphName,
         version
       });
@@ -2428,7 +2895,7 @@ async function ensureSandboxProcess(subgraphName, version, handlerCode) {
     } catch (err) {
       existing.proc.kill();
       pool.delete(subgraphName);
-      logger6.warn("Sandbox subprocess re-init failed; respawning", {
+      logger7.warn("Sandbox subprocess re-init failed; respawning", {
         subgraph: subgraphName,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -2511,7 +2978,7 @@ async function runBlockThroughProcess(entry, subgraphName, hostCtx, block, match
     return result;
   } catch (err) {
     evictSandboxWorker(subgraphName);
-    logger6.warn("Sandbox subprocess run failed; subprocess evicted", {
+    logger7.warn("Sandbox subprocess run failed; subprocess evicted", {
       subgraph: subgraphName,
       blockHeight: block.height,
       error: err instanceof Error ? err.message : String(err)
@@ -2582,7 +3049,7 @@ async function answerRead(hostCtx, msg) {
 
 // src/runtime/subscription-state.ts
 import { listSubscriptions } from "@secondlayer/shared/db/queries/subscriptions";
-import { sql as sql2 } from "kysely";
+import { sql as sql3 } from "kysely";
 
 // src/runtime/emitter-matcher.ts
 function isPrimitive(v) {
@@ -2746,7 +3213,7 @@ class SubscriptionMatcher {
 // src/runtime/subscription-state.ts
 var matcher = new SubscriptionMatcher;
 async function refreshMatcher(db) {
-  const rows = await sql2`
+  const rows = await sql3`
 		SELECT * FROM subscriptions WHERE status = 'active'
 	`.execute(db);
   matcher.setAll(rows.rows);
@@ -2768,7 +3235,7 @@ async function resolveRoute(subgraphName, targetDb) {
     version: row?.version ?? ""
   };
   routeCache.set(subgraphName, route);
-  logger7.info("subgraph handler dispatch path resolved", {
+  logger8.info("subgraph handler dispatch path resolved", {
     subgraph: subgraphName,
     path: sandboxEnabled({ sandbox_workers: route.sandboxWorkers }) ? "sandbox" : "in-process"
   });
@@ -2792,8 +3259,8 @@ async function resolveFactoryContracts(subgraph, blockHeight, schemaName, db, tx
   for (const [discoveringSource, factory] of factories) {
     const known = new Set;
     try {
-      const rows = await sql3`
-				SELECT address FROM ${sql3.raw(`"${schemaName}"."_factory_addresses"`)}
+      const rows = await sql4`
+				SELECT address FROM ${sql4.raw(`"${schemaName}"."_factory_addresses"`)}
 				WHERE source_name = ${discoveringSource} AND block_height <= ${blockHeight}
 			`.execute(db);
       for (const row of rows.rows)
@@ -2821,8 +3288,8 @@ async function persistFactoryDiscoveries(schemaName, db, blockHeight, discovered
   if (discovered.length === 0)
     return;
   for (const { sourceName, address } of discovered) {
-    await sql3`
-			INSERT INTO ${sql3.raw(`"${schemaName}"."_factory_addresses"`)}
+    await sql4`
+			INSERT INTO ${sql4.raw(`"${schemaName}"."_factory_addresses"`)}
 				(source_name, address, block_height)
 			VALUES (${sourceName}, ${address}, ${blockHeight})
 			ON CONFLICT (source_name, address) DO NOTHING
@@ -2882,7 +3349,7 @@ async function processBlockWithRetry(subgraph, subgraphName, blockHeight, opts,
       const delay = retryDelaysMs[attempt];
       if (delay === undefined)
         break;
-      logger7.warn("Block processing failed, retrying", {
+      logger8.warn("Block processing failed, retrying", {
         subgraph: subgraphName,
         blockHeight,
         attempt: attempt + 1,
@@ -2895,7 +3362,7 @@ async function processBlockWithRetry(subgraph, subgraphName, blockHeight, opts,
   throw lastError;
 }
 async function processBlock(subgraph, subgraphName, blockHeight, opts) {
-  const targetDb = getTargetDb();
+  const targetDb = getTargetDb2();
   const blockStart = performance.now();
   const result = {
     blockHeight,
@@ -2914,7 +3381,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
   } else {
     const data = (await resolveBlockSource(subgraph).loadBlockRange(blockHeight, blockHeight)).get(blockHeight);
     if (!data) {
-      logger7.debug("Block not found or non-canonical for subgraph processing", {
+      logger8.debug("Block not found or non-canonical for subgraph processing", {
         subgraph: subgraphName,
         blockHeight
       });
@@ -2980,7 +3447,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
           { start: blockHeight, end: blockHeight, reason: "processing_error" }
         ]);
       } else {
-        logger7.warn("Block errors not recorded as a gap — no subgraphId", {
+        logger8.warn("Block errors not recorded as a gap — no subgraphId", {
           subgraph: subgraphName,
           blockHeight,
           errors: rr.errors
@@ -3053,7 +3520,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
     });
   } catch (err) {
     if (err instanceof CursorRaceLostError || err instanceof LiveCursorRaceLostError) {
-      logger7.warn("cursor race lost — block already covered", {
+      logger8.warn("cursor race lost — block already covered", {
         subgraph: subgraphName,
         blockHeight,
         error: err.message
@@ -3078,10 +3545,10 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
     try {
       const tables = Object.keys(subgraph.schema);
       for (const table of tables) {
-        const { rows } = await sql3.raw(`SELECT n_live_tup AS count FROM pg_stat_user_tables WHERE schemaname = '${schemaName}' AND relname = '${table}'`).execute(route.dataDb);
+        const { rows } = await sql4.raw(`SELECT n_live_tup AS count FROM pg_stat_user_tables WHERE schemaname = '${schemaName}' AND relname = '${table}'`).execute(route.dataDb);
         const count = Number(rows[0]?.count ?? 0);
         if (count >= 1e7) {
-          logger7.warn("Subgraph table exceeds 10M rows (estimate)", {
+          logger8.warn("Subgraph table exceeds 10M rows (estimate)", {
             subgraph: subgraphName,
             table,
             count
@@ -3089,13 +3556,13 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
         }
       }
     } catch (err) {
-      logger7.debug("Row count sample failed", {
+      logger8.debug("Row count sample failed", {
         subgraph: subgraphName,
         error: err instanceof Error ? err.message : String(err)
       });
     }
     if (journalEnabled(opts)) {
-      await sql3.raw(`DELETE FROM "${schemaName}"."_journal" WHERE "block_height" < ${blockHeight - JOURNAL_RETENTION_BLOCKS}`).execute(route.dataDb).catch(() => {});
+      await sql4.raw(`DELETE FROM "${schemaName}"."_journal" WHERE "block_height" < ${blockHeight - JOURNAL_RETENTION_BLOCKS}`).execute(route.dataDb).catch(() => {});
     }
   }
   return result;
@@ -3165,9 +3632,9 @@ class StatsAccumulator {
 }
 
 // src/runtime/catchup.ts
-import { getTargetDb as getTargetDb2, sql as sql4 } from "@secondlayer/shared/db";
+import { getTargetDb as getTargetDb3, sql as sql5 } from "@secondlayer/shared/db";
 import { getSubgraph } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger8 } from "@secondlayer/shared/logger";
+import { logger as logger9 } from "@secondlayer/shared/logger";
 
 // src/runtime/catchup-leader.ts
 import {
@@ -3297,8 +3764,8 @@ async function withSubgraphBlockLock(name, fn) {
   }
 }
 async function withSubgraphBlockAdvisoryLock(name, fn) {
-  return getTargetDb2().transaction().execute(async (lockTx) => {
-    await sql4`SELECT pg_advisory_xact_lock(hashtext(${`subgraph-block:${name}`}))`.execute(lockTx);
+  return getTargetDb3().transaction().execute(async (lockTx) => {
+    await sql5`SELECT pg_advisory_xact_lock(hashtext(${`subgraph-block:${name}`}))`.execute(lockTx);
     return fn();
   });
 }
@@ -3359,7 +3826,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
   catchingUp.add(subgraphName);
   try {
     const source = resolveBlockSource(subgraph);
-    const targetDb = getTargetDb2();
+    const targetDb = getTargetDb3();
     const subgraphRow = await getSubgraph(targetDb, subgraphName);
     if (!subgraphRow)
       return 0;
@@ -3371,7 +3838,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
     if (usesDecodedIndexPlane(subgraph)) {
       const bound = await boundSourceTip(rawTip, decoderNamesForSubgraph(subgraph));
       if (!bound.ok) {
-        logger8.warn("Subgraph catch-up stalled: missing decoder checkpoint", {
+        logger9.warn("Subgraph catch-up stalled: missing decoder checkpoint", {
           event: "subgraph_catchup_decoder_stall",
           subgraph: subgraphName,
           missing: bound.missing
@@ -3379,7 +3846,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
         return 0;
       }
       if (bound.floor !== null && bound.floor < rawTip) {
-        logger8.debug("Subgraph catch-up tip bounded by decoder progress", {
+        logger9.debug("Subgraph catch-up tip bounded by decoder progress", {
           event: "subgraph_catchup_decoder_floor",
           subgraph: subgraphName,
           rawTip,
@@ -3394,7 +3861,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
     const subgraphStart = Number(subgraphRow.start_block) || 1;
     const startBlock = Math.max(lastProcessedBlock + 1, subgraphStart);
     const totalBlocks = chainTip - lastProcessedBlock;
-    logger8.info("Subgraph catch-up starting", {
+    logger9.info("Subgraph catch-up starting", {
       subgraph: subgraphName,
       from: startBlock,
       to: chainTip,
@@ -3410,7 +3877,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
     let nextBatchPromise = batchConfig.prefetch ? source.loadBlockRange(currentHeight, prefetchedBatchEnd) : undefined;
     while (currentHeight <= chainTip) {
       if (!isCatchUpLeader()) {
-        logger8.info("Lost catch-up leadership, stopping catch-up", {
+        logger9.info("Lost catch-up leadership, stopping catch-up", {
           subgraph: subgraphName,
           processed
         });
@@ -3418,7 +3885,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
       }
       const currentRow = await getSubgraph(targetDb, subgraphName);
       if (!currentRow || currentRow.status !== "active") {
-        logger8.info("Subgraph status changed, stopping catch-up", {
+        logger9.info("Subgraph status changed, stopping catch-up", {
           subgraph: subgraphName,
           status: currentRow?.status ?? "deleted"
         });
@@ -3447,7 +3914,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
           blockData = (await source.loadBlockRange(height, height)).get(height);
         }
         if (!blockData) {
-          logger8.warn("Block missing during catch-up, deferring to next tick", {
+          logger9.warn("Block missing during catch-up, deferring to next tick", {
             subgraph: subgraphName,
             blockHeight: height
           });
@@ -3468,12 +3935,12 @@ async function catchUpSubgraph(subgraph, subgraphName) {
           });
         } catch (err) {
           if (err instanceof ReorgEpochChangedError) {
-            logger8.info("Reorg detected mid catch-up, aborting walk without writing further progress", { subgraph: subgraphName, blockHeight: height });
+            logger9.info("Reorg detected mid catch-up, aborting walk without writing further progress", { subgraph: subgraphName, blockHeight: height });
             stopCatchup = true;
             break;
           }
           const errorMsg = err instanceof Error ? err.message : String(err);
-          logger8.error("Block processing failed persistently during catch-up", {
+          logger9.error("Block processing failed persistently during catch-up", {
             subgraph: subgraphName,
             blockHeight: height,
             error: errorMsg
@@ -3492,7 +3959,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
           }
         }
         if (processed % LOG_INTERVAL === 0) {
-          logger8.info("Subgraph catch-up progress", {
+          logger9.info("Subgraph catch-up progress", {
             subgraph: subgraphName,
             processed,
             total: totalBlocks,
@@ -3508,7 +3975,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
       currentHeight = batchEnd + 1;
     }
     await stats.flush(targetDb);
-    logger8.info("Subgraph catch-up complete", {
+    logger9.info("Subgraph catch-up complete", {
       subgraph: subgraphName,
       processed
     });
@@ -3520,7 +3987,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
 
 // src/runtime/reindex.ts
 import { getErrorMessage as getErrorMessage3 } from "@secondlayer/shared";
-import { getRawClient, getTargetDb as getTargetDb3 } from "@secondlayer/shared/db";
+import { getRawClient, getTargetDb as getTargetDb4 } from "@secondlayer/shared/db";
 import {
   recordGapBatch as recordGapBatch2,
   resolveGaps
@@ -3533,11 +4000,11 @@ import {
   recordSubgraphProcessed as recordSubgraphProcessed2,
   updateSubgraphStatus as updateSubgraphStatus2
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger10 } from "@secondlayer/shared/logger";
+import { logger as logger11 } from "@secondlayer/shared/logger";
 
 // src/runtime/reindex-notify.ts
 import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
-import { logger as logger9 } from "@secondlayer/shared/logger";
+import { logger as logger10 } from "@secondlayer/shared/logger";
 async function notifyReindexComplete(db, subgraphName, stats) {
   try {
     const subgraph = await db.selectFrom("subgraphs").select(["account_id"]).where("name", "=", subgraphName).executeTakeFirst();
@@ -3548,7 +4015,7 @@ async function notifyReindexComplete(db, subgraphName, stats) {
       return;
     const resendKey = process.env.RESEND_API_KEY;
     if (!resendKey) {
-      logger9.warn("RESEND_API_KEY unset — skipping reindex-complete email", {
+      logger10.warn("RESEND_API_KEY unset — skipping reindex-complete email", {
         subgraph: subgraphName
       });
       return;
@@ -3570,14 +4037,14 @@ async function notifyReindexComplete(db, subgraphName, stats) {
     });
     if (!res.ok) {
       const text = await res.text().catch(() => "");
-      logger9.warn("reindex-complete email failed", {
+      logger10.warn("reindex-complete email failed", {
         subgraph: subgraphName,
         status: res.status,
         body: text.slice(0, 200)
       });
     }
   } catch (err) {
-    logger9.warn("reindex-complete email threw", {
+    logger10.warn("reindex-complete email threw", {
       subgraph: subgraphName,
       error: getErrorMessage2(err)
     });
@@ -3646,7 +4113,7 @@ function coalesceFailedBlocks(blocks) {
 }
 async function processBlockRange(def, opts) {
   const source = resolveBlockSource(def);
-  const targetDb = getTargetDb3();
+  const targetDb = getTargetDb4();
   const subgraphName = def.name;
   const { fromBlock, toBlock, status } = opts;
   const totalBlocks = toBlock - fromBlock + 1;
@@ -3689,7 +4156,7 @@ async function processBlockRange(def, opts) {
   while (currentHeight <= toBlock) {
     if (opts.signal?.aborted) {
       aborted = true;
-      logger10.info("Block processing aborted", {
+      logger11.info("Block processing aborted", {
         subgraph: subgraphName,
         currentBlock: currentHeight,
         reason: String(opts.signal.reason ?? "unknown")
@@ -3740,7 +4207,7 @@ async function processBlockRange(def, opts) {
         result = mayWrite ? await withSubgraphBlockWriteLock(subgraphName, runBlock) : await runBlock();
       } catch (err) {
         const errorMsg = getErrorMessage3(err);
-        logger10.error("Block processing failed persistently", {
+        logger11.error("Block processing failed persistently", {
           subgraph: subgraphName,
           blockHeight: height,
           error: errorMsg
@@ -3786,7 +4253,7 @@ async function processBlockRange(def, opts) {
         lastProgressFlushAt = now;
       }
       if (blocksProcessed % LOG_INTERVAL2 === 0) {
-        logger10.info(`${status === "reindexing" ? "Reindex" : "Backfill"} progress`, {
+        logger11.info(`${status === "reindexing" ? "Reindex" : "Backfill"} progress`, {
           subgraph: subgraphName,
           processed: blocksProcessed,
           total: totalBlocks,
@@ -3806,7 +4273,7 @@ async function processBlockRange(def, opts) {
     if (batchFailedBlocks.length > 0 && opts.subgraphId) {
       const gaps = coalesceFailedBlocks(batchFailedBlocks);
       await recordGapBatch2(targetDb, opts.subgraphId, subgraphName, gaps).catch((err) => {
-        logger10.warn("Failed to record subgraph gaps", {
+        logger11.warn("Failed to record subgraph gaps", {
           subgraph: subgraphName,
           error: err instanceof Error ? err.message : String(err)
         });
@@ -3823,7 +4290,7 @@ async function processBlockRange(def, opts) {
         } else {
           await updateSubgraphStatus2(targetDb, subgraphName, status, jumpTo - 1);
         }
-        logger10.info("Sparse skip", {
+        logger11.info("Sparse skip", {
           subgraph: subgraphName,
           from: batchEnd + 1,
           to: jumpTo - 1,
@@ -3857,7 +4324,7 @@ async function resolveBlockRange(source, def, opts) {
   }
   const bound = await boundSourceTip(rawTip, decoderNamesForSubgraph(def));
   if (!bound.ok) {
-    logger10.warn("Reindex stalled: missing decoder checkpoint", {
+    logger11.warn("Reindex stalled: missing decoder checkpoint", {
       event: "subgraph_reindex_decoder_stall",
       subgraph: def.name,
       missing: bound.missing
@@ -3865,7 +4332,7 @@ async function resolveBlockRange(source, def, opts) {
     throw new Error(`Reindex stalled: missing decoder checkpoint (${bound.missing.join(", ")})`);
   }
   if (bound.floor !== null && bound.floor < rawTip) {
-    logger10.debug("Reindex tip bounded by decoder progress", {
+    logger11.debug("Reindex tip bounded by decoder progress", {
       event: "subgraph_reindex_decoder_floor",
       subgraph: def.name,
       rawTip,
@@ -3880,16 +4347,16 @@ async function clearReindexMetadata(db, subgraphName) {
 }
 async function reindexSubgraph(def, opts) {
   const source = resolveBlockSource(def);
-  const targetDb = getTargetDb3();
+  const targetDb = getTargetDb4();
   const client = getRawClient("target");
   const subgraphName = def.name;
   const schemaName = opts?.schemaName ?? pgSchemaName(subgraphName);
   await updateSubgraphStatus2(targetDb, subgraphName, "reindexing");
-  logger10.info("Reindex starting", { subgraph: subgraphName });
+  logger11.info("Reindex starting", { subgraph: subgraphName });
   try {
     const { fromBlock, toBlock } = await resolveBlockRange(source, def, opts);
     if (fromBlock > toBlock) {
-      logger10.info("No blocks to reindex", {
+      logger11.info("No blocks to reindex", {
         subgraph: subgraphName,
         fromBlock,
         toBlock
@@ -3903,7 +4370,7 @@ async function reindexSubgraph(def, opts) {
       await client.unsafe(stmt);
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "reindexing", Math.max(0, fromBlock - 1));
-    logger10.info("Schema recreated for reindex", {
+    logger11.info("Schema recreated for reindex", {
       subgraph: subgraphName,
       cursorResetTo: Math.max(0, fromBlock - 1)
     });
@@ -3917,7 +4384,7 @@ async function reindexSubgraph(def, opts) {
       last_error_at: null,
       updated_at: new Date
     }).where("name", "=", subgraphName).execute();
-    logger10.info("Reindexing blocks", {
+    logger11.info("Reindexing blocks", {
       subgraph: subgraphName,
       fromBlock,
       toBlock,
@@ -3939,9 +4406,9 @@ async function reindexSubgraph(def, opts) {
       if (reason === "user-cancelled") {
         await updateSubgraphStatus2(targetDb, subgraphName, "active");
         await clearReindexMetadata(targetDb, subgraphName);
-        logger10.info("Reindex cancelled by user", { subgraph: subgraphName });
+        logger11.info("Reindex cancelled by user", { subgraph: subgraphName });
       } else {
-        logger10.info("Reindex interrupted by shutdown, will resume", {
+        logger11.info("Reindex interrupted by shutdown, will resume", {
           subgraph: subgraphName
         });
       }
@@ -3949,7 +4416,7 @@ async function reindexSubgraph(def, opts) {
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
-    logger10.info("Reindex complete", {
+    logger11.info("Reindex complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed,
       events: result.totalEventsProcessed,
@@ -3962,7 +4429,7 @@ async function reindexSubgraph(def, opts) {
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger10.error("Reindex failed", {
+    logger11.error("Reindex failed", {
       subgraph: subgraphName,
       error: getErrorMessage3(err)
     });
@@ -3971,7 +4438,7 @@ async function reindexSubgraph(def, opts) {
   }
 }
 async function resumeReindex(def, opts) {
-  const targetDb = getTargetDb3();
+  const targetDb = getTargetDb4();
   const subgraphName = def.name;
   const row = await targetDb.selectFrom("subgraphs").select([
     "id",
@@ -3984,7 +4451,7 @@ async function resumeReindex(def, opts) {
   const fromBlock = resolveReindexResumeBlock(row);
   const toBlock = Number(row.reindex_to_block);
   if (fromBlock == null) {
-    logger10.info("No reindex metadata, starting fresh reindex", {
+    logger11.info("No reindex metadata, starting fresh reindex", {
       subgraph: subgraphName
     });
     return reindexSubgraph(def, {
@@ -3993,12 +4460,12 @@ async function resumeReindex(def, opts) {
     });
   }
   if (fromBlock > toBlock) {
-    logger10.info("Resume: no remaining blocks", { subgraph: subgraphName });
+    logger11.info("Resume: no remaining blocks", { subgraph: subgraphName });
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
     return { processed: 0 };
   }
-  logger10.info("Resuming reindex", {
+  logger11.info("Resuming reindex", {
     subgraph: subgraphName,
     fromBlock,
     toBlock,
@@ -4020,9 +4487,9 @@ async function resumeReindex(def, opts) {
       if (reason === "user-cancelled") {
         await updateSubgraphStatus2(targetDb, subgraphName, "active");
         await clearReindexMetadata(targetDb, subgraphName);
-        logger10.info("Resume cancelled by user", { subgraph: subgraphName });
+        logger11.info("Resume cancelled by user", { subgraph: subgraphName });
       } else {
-        logger10.info("Resume interrupted by shutdown, will resume again", {
+        logger11.info("Resume interrupted by shutdown, will resume again", {
           subgraph: subgraphName
         });
       }
@@ -4030,13 +4497,13 @@ async function resumeReindex(def, opts) {
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
-    logger10.info("Resumed reindex complete", {
+    logger11.info("Resumed reindex complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger10.error("Resumed reindex failed", {
+    logger11.error("Resumed reindex failed", {
       subgraph: subgraphName,
       error: getErrorMessage3(err)
     });
@@ -4045,9 +4512,9 @@ async function resumeReindex(def, opts) {
   }
 }
 async function backfillSubgraph(def, opts) {
-  const targetDb = getTargetDb3();
+  const targetDb = getTargetDb4();
   const subgraphName = def.name;
-  logger10.info("Backfill starting", {
+  logger11.info("Backfill starting", {
     subgraph: subgraphName,
     from: opts.fromBlock,
     to: opts.toBlock
@@ -4065,17 +4532,17 @@ async function backfillSubgraph(def, opts) {
       signal: opts.signal
     });
     if (result.aborted) {
-      logger10.info("Backfill aborted", { subgraph: subgraphName });
+      logger11.info("Backfill aborted", { subgraph: subgraphName });
       return { processed: result.blocksProcessed };
     }
     const resolved = await resolveGaps(targetDb, subgraphName, opts.fromBlock, opts.toBlock).catch(() => 0);
     if (resolved > 0) {
-      logger10.info("Resolved subgraph gaps via backfill", {
+      logger11.info("Resolved subgraph gaps via backfill", {
         subgraph: subgraphName,
         resolved
       });
     }
-    logger10.info("Backfill complete", {
+    logger11.info("Backfill complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed,
       events: result.totalEventsProcessed,
@@ -4083,7 +4550,7 @@ async function backfillSubgraph(def, opts) {
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger10.error("Backfill failed", {
+    logger11.error("Backfill failed", {
       subgraph: subgraphName,
       error: getErrorMessage3(err)
     });
@@ -4093,16 +4560,16 @@ async function backfillSubgraph(def, opts) {
 
 // src/runtime/reorg.ts
 import { getErrorMessage as getErrorMessage4 } from "@secondlayer/shared";
-import { getRawClient as getRawClient2, getTargetDb as getTargetDb4 } from "@secondlayer/shared/db";
+import { getRawClient as getRawClient2, getTargetDb as getTargetDb5 } from "@secondlayer/shared/db";
 import { listSubgraphs } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger11 } from "@secondlayer/shared/logger";
-import { sql as sql5 } from "kysely";
+import { logger as logger12 } from "@secondlayer/shared/logger";
+import { sql as sql6 } from "kysely";
 async function handleSubgraphReorg(blockHeight, loadSubgraphDef) {
-  const targetDb = getTargetDb4();
+  const targetDb = getTargetDb5();
   const activeSubgraphs = (await listSubgraphs(targetDb)).filter((v) => v.status === "active");
   if (activeSubgraphs.length === 0)
     return;
-  logger11.info("Propagating reorg to subgraphs", {
+  logger12.info("Propagating reorg to subgraphs", {
     blockHeight,
     subgraphCount: activeSubgraphs.length
   });
@@ -4113,13 +4580,13 @@ async function handleSubgraphReorg(blockHeight, loadSubgraphDef) {
         continue;
       bumpReorgEpoch(sg.name);
       await withSubgraphBlockLock(sg.name, async () => {
-        await getTargetDb4().transaction().execute(async (lockTx) => {
-          await sql5`SELECT pg_advisory_xact_lock(hashtext(${`subgraph-reorg:${sg.name}`}))`.execute(lockTx);
+        await getTargetDb5().transaction().execute(async (lockTx) => {
+          await sql6`SELECT pg_advisory_xact_lock(hashtext(${`subgraph-reorg:${sg.name}`}))`.execute(lockTx);
           await reorgOneSubgraph(sg, schema, blockHeight, loadSubgraphDef);
         });
       });
     } catch (err) {
-      logger11.error("Subgraph reorg handling failed", {
+      logger12.error("Subgraph reorg handling failed", {
         subgraph: sg.name,
         blockHeight,
         error: getErrorMessage4(err)
@@ -4128,7 +4595,7 @@ async function handleSubgraphReorg(blockHeight, loadSubgraphDef) {
   }
 }
 async function reorgOneSubgraph(sg, schema, blockHeight, loadSubgraphDef) {
-  const targetDb = getTargetDb4();
+  const targetDb = getTargetDb5();
   const schemaName = sg.schema_name ?? pgSchemaName(sg.name);
   const client = getRawClient2("target");
   const tableNames = Object.keys(schema);
@@ -4157,7 +4624,7 @@ async function reorgOneSubgraph(sg, schema, blockHeight, loadSubgraphDef) {
       await tx.unsafe(`DELETE FROM "${schemaName}"."_journal" WHERE block_height >= $1`, [blockHeight]);
     });
   } else {
-    logger11.warn("Subgraph has no revert journal — falling back to height delete (accumulator rows may lose history)", { subgraph: sg.name, blockHeight });
+    logger12.warn("Subgraph has no revert journal — falling back to height delete (accumulator rows may lose history)", { subgraph: sg.name, blockHeight });
     for (const tableName of tableNames) {
       await client.unsafe(`DELETE FROM "${schemaName}"."${tableName}" WHERE "_block_height" >= $1`, [blockHeight]);
     }
@@ -4167,6 +4634,7 @@ async function reorgOneSubgraph(sg, schema, blockHeight, loadSubgraphDef) {
 				DELETE FROM "${schemaName}"."_factory_addresses" WHERE block_height >= ${Number(blockHeight)};
 			END IF;
 		END $$`);
+  await targetDb.deleteFrom("subgraph_violations").where("subgraph_name", "=", sg.name).where("block_height", ">=", blockHeight).execute();
   for (const [tableName, rows] of Object.entries(revertedByTable)) {
     if (rows.length === 0)
       continue;
@@ -4200,7 +4668,7 @@ async function reorgOneSubgraph(sg, schema, blockHeight, loadSubgraphDef) {
       }).as("row_pk"),
       eb2.val("pending").as("status")
     ]).where("subgraph_name", "=", sg.name).where("table_name", "=", tableName).where("status", "=", "active")).onConflict((oc) => oc.columns(["subscription_id", "dedup_key"]).doNothing()).execute().catch((err) => {
-      logger11.error("Failed to emit revert event for subscriptions", {
+      logger12.error("Failed to emit revert event for subscriptions", {
         event: "reorg_revert_emit_dropped",
         subgraph: sg.name,
         table: tableName,
@@ -4209,14 +4677,14 @@ async function reorgOneSubgraph(sg, schema, blockHeight, loadSubgraphDef) {
       });
     });
   }
-  logger11.info("Subgraph reorg cleanup done", {
+  logger12.info("Subgraph reorg cleanup done", {
     subgraph: sg.name,
     blockHeight,
     tablesAffected: Object.keys(revertedByTable).length
   });
   const def = await loadSubgraphDef(sg);
   await processBlock(def, sg.name, blockHeight, { reorgRewind: true });
-  logger11.info("Subgraph reorg reprocessed", {
+  logger12.info("Subgraph reorg reprocessed", {
     subgraph: sg.name,
     blockHeight
   });
@@ -4228,7 +4696,7 @@ import { hostname } from "node:os";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { getErrorMessage as getErrorMessage6 } from "@secondlayer/shared";
-import { getTargetDb as getTargetDb5 } from "@secondlayer/shared/db";
+import { getTargetDb as getTargetDb6 } from "@secondlayer/shared/db";
 import {
   cancelSubgraphOperation,
   claimSubgraphOperation,
@@ -4245,7 +4713,7 @@ import {
   pgSchemaName as pgSchemaName2,
   updateSubgraphStatus as updateSubgraphStatus3
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger13 } from "@secondlayer/shared/logger";
+import { logger as logger14 } from "@secondlayer/shared/logger";
 import {
   listen,
   sourceListenerUrl,
@@ -4257,7 +4725,7 @@ import { getErrorMessage as getErrorMessage5 } from "@secondlayer/shared";
 import {
   createInternalIndexHttpClient as createInternalIndexHttpClient2
 } from "@secondlayer/shared/index-http";
-import { logger as logger12 } from "@secondlayer/shared/logger";
+import { logger as logger13 } from "@secondlayer/shared/logger";
 var POLL_MS = Number(process.env.SUBGRAPH_REORG_POLL_MS) || 15000;
 var STARTUP_MARGIN_MS = 60 * 60 * 1000;
 async function pollReorgsOnce(http2, cursor, onReorg, handled) {
@@ -4265,13 +4733,13 @@ async function pollReorgsOnce(http2, cursor, onReorg, handled) {
   const sorted = [...reorgs].sort((a, b) => a.fork_point_height - b.fork_point_height);
   for (const r of sorted) {
     if (handled && r.id && handled.has(r.id)) {
-      logger12.info("Streams reorg already handled — skipping", {
+      logger13.info("Streams reorg already handled — skipping", {
         forkPointHeight: r.fork_point_height,
         reorgId: r.id
       });
       continue;
     }
-    logger12.info("Streams reorg — rewinding", {
+    logger13.info("Streams reorg — rewinding", {
       forkPointHeight: r.fork_point_height
     });
     await onReorg(r.fork_point_height);
@@ -4294,7 +4762,7 @@ function startStreamsReorgPoll(onReorg) {
     try {
       since = await pollReorgsOnce(http2, since, onReorg, handled);
     } catch (err) {
-      logger12.error("Streams reorg poll failed", {
+      logger13.error("Streams reorg poll failed", {
         error: getErrorMessage5(err)
       });
     }
@@ -4302,7 +4770,7 @@ function startStreamsReorgPoll(onReorg) {
       timer = setTimeout(tick, POLL_MS);
   };
   timer = setTimeout(tick, POLL_MS);
-  logger12.info("Streams reorg poll started", { pollMs: POLL_MS });
+  logger13.info("Streams reorg poll started", { pollMs: POLL_MS });
   return () => {
     running = false;
     if (timer)
@@ -4333,7 +4801,7 @@ async function catchUpAll(subgraphs, db, concurrency) {
         if (isHandlerNotFoundError(err)) {
           await updateSubgraphStatus3(db, sg.name, "error");
         }
-        logger13.error("Subgraph catch-up failed", {
+        logger14.error("Subgraph catch-up failed", {
           subgraph: sg.name,
           error: msg
         });
@@ -4373,7 +4841,7 @@ async function loadSubgraphDefinition(sg) {
   definitionCache.set(sg.name, def);
   if (prevVersion && prevVersion !== sg.version) {
     invalidateSubgraphRoute(sg.name);
-    logger13.info("Subgraph handler reloaded", {
+    logger14.info("Subgraph handler reloaded", {
       subgraph: sg.name,
       from: prevVersion,
       to: sg.version
@@ -4392,7 +4860,7 @@ function cleanupCaches(active) {
   }
 }
 async function synthesizeLegacyReindexOperations() {
-  const db = getTargetDb5();
+  const db = getTargetDb6();
   const stale = (await listSubgraphs2(db)).filter((sg) => sg.status === "reindexing");
   for (const sg of stale) {
     const active = await findActiveSubgraphOperation(db, sg.id);
@@ -4407,7 +4875,7 @@ async function synthesizeLegacyReindexOperations() {
         fromBlock: sg.reindex_from_block == null ? undefined : Number(sg.reindex_from_block),
         toBlock: sg.reindex_to_block == null ? undefined : Number(sg.reindex_to_block)
       });
-      logger13.info("Queued legacy reindex resume operation", {
+      logger14.info("Queued legacy reindex resume operation", {
         subgraph: sg.name
       });
     } catch (err) {
@@ -4421,7 +4889,7 @@ async function runSubgraphOperation(operation, signal) {
   if (operation.cancel_requested) {
     return 0;
   }
-  const db = getTargetDb5();
+  const db = getTargetDb6();
   const subgraph = await db.selectFrom("subgraphs").selectAll().where("id", "=", operation.subgraph_id).executeTakeFirst();
   if (!subgraph)
     throw new Error(`Subgraph not found: ${operation.subgraph_id}`);
@@ -4460,13 +4928,13 @@ async function runSubgraphOperation(operation, signal) {
 }
 async function startSubgraphOperationRunner(opts) {
   const concurrency = opts?.concurrency ?? DEFAULT_OPERATION_CONCURRENCY;
-  const db = getTargetDb5();
+  const db = getTargetDb6();
   const lockedBy = `${hostname()}:${process.pid}:${randomUUID()}`;
   const active = new Map;
   const activeRuns = new Map;
   let running = true;
   let draining = false;
-  logger13.info("Starting subgraph operation runner", { concurrency, lockedBy });
+  logger14.info("Starting subgraph operation runner", { concurrency, lockedBy });
   try {
     const stranded = await db.selectFrom("subgraphs").select(["id", "name", "account_id"]).where("status", "=", "reindexing").where("reindex_from_block", "is not", null).where("reindex_to_block", "is not", null).where(({ not, exists, selectFrom }) => not(exists(selectFrom("subgraph_operations").select("id").whereRef("subgraph_id", "=", "subgraphs.id").where("status", "in", ["queued", "running"])))).execute();
     for (const row of stranded) {
@@ -4477,14 +4945,14 @@ async function startSubgraphOperationRunner(opts) {
           accountId: row.account_id,
           kind: "reindex"
         });
-        logger13.info("Re-enqueued stranded reindex", { subgraph: row.name });
+        logger14.info("Re-enqueued stranded reindex", { subgraph: row.name });
       } catch (err) {
         if (!isActiveSubgraphOperationConflict(err))
           throw err;
       }
     }
   } catch (err) {
-    logger13.warn("Stranded-reindex sweep failed", {
+    logger14.warn("Stranded-reindex sweep failed", {
       error: getErrorMessage6(err)
     });
   }
@@ -4495,7 +4963,7 @@ async function startSubgraphOperationRunner(opts) {
       if (!running)
         return;
       heartbeatSubgraphOperation(db, operation.id, lockedBy).catch((err) => {
-        logger13.warn("Subgraph operation heartbeat failed", {
+        logger14.warn("Subgraph operation heartbeat failed", {
           operationId: operation.id,
           error: getErrorMessage6(err)
         });
@@ -4507,7 +4975,7 @@ async function startSubgraphOperationRunner(opts) {
           controller.abort("user-cancelled");
         }
       }).catch((err) => {
-        logger13.warn("Subgraph operation cancel poll failed", {
+        logger14.warn("Subgraph operation cancel poll failed", {
           operationId: operation.id,
           error: getErrorMessage6(err)
         });
@@ -4524,14 +4992,14 @@ async function startSubgraphOperationRunner(opts) {
         const reason = String(controller.signal.reason ?? "");
         if (controller.signal.aborted && reason === "user-cancelled") {
           await cancelSubgraphOperation(db, operation.id, lockedBy, processed);
-          logger13.info("Subgraph operation cancelled", {
+          logger14.info("Subgraph operation cancelled", {
             operationId: operation.id,
             subgraph: operation.subgraph_name
           });
           return;
         }
         if (controller.signal.aborted) {
-          logger13.info("Subgraph operation interrupted", {
+          logger14.info("Subgraph operation interrupted", {
             operationId: operation.id,
             subgraph: operation.subgraph_name,
             reason
@@ -4539,7 +5007,7 @@ async function startSubgraphOperationRunner(opts) {
           return;
         }
         await completeSubgraphOperation(db, operation.id, lockedBy, processed);
-        logger13.info("Subgraph operation completed", {
+        logger14.info("Subgraph operation completed", {
           operationId: operation.id,
           subgraph: operation.subgraph_name,
           processed
@@ -4547,7 +5015,7 @@ async function startSubgraphOperationRunner(opts) {
       } catch (err) {
         const reason = String(controller.signal.reason ?? "");
         if (controller.signal.aborted && reason === "shutdown") {
-          logger13.info("Subgraph operation interrupted by shutdown", {
+          logger14.info("Subgraph operation interrupted by shutdown", {
             operationId: operation.id,
             subgraph: operation.subgraph_name
           });
@@ -4558,7 +5026,7 @@ async function startSubgraphOperationRunner(opts) {
           return;
         }
         await failSubgraphOperation(db, operation.id, lockedBy, getErrorMessage6(err), processed);
-        logger13.error("Subgraph operation failed", {
+        logger14.error("Subgraph operation failed", {
           operationId: operation.id,
           subgraph: operation.subgraph_name,
           error: getErrorMessage6(err)
@@ -4605,20 +5073,20 @@ async function startSubgraphOperationRunner(opts) {
       controller.abort("shutdown");
     }
     await Promise.allSettled(activeRuns.values());
-    logger13.info("Subgraph operation runner stopped");
+    logger14.info("Subgraph operation runner stopped");
   };
 }
 async function startSubgraphProcessor(opts) {
   const concurrency = opts?.concurrency ?? DEFAULT_CONCURRENCY;
   let running = true;
-  logger13.info("Starting subgraph processor", { concurrency });
+  logger14.info("Starting subgraph processor", { concurrency });
   const stopOperations = await startSubgraphOperationRunner({
     concurrency: Number.parseInt(process.env.SUBGRAPH_OPERATION_CONCURRENCY ?? String(DEFAULT_OPERATION_CONCURRENCY))
   });
   const runCatchUp = async () => {
     if (!running || !isCatchUpLeader())
       return;
-    const db = getTargetDb5();
+    const db = getTargetDb6();
     const subgraphs = (await listSubgraphs2(db)).filter((v) => v.status === "active");
     cleanupCaches(subgraphs);
     await catchUpAll(subgraphs, db, concurrency);
@@ -4637,7 +5105,7 @@ async function startSubgraphProcessor(opts) {
         await handleSubgraphReorg(blockHeight, loadSubgraphDefinition);
       }
     } catch (err) {
-      logger13.error("Subgraph reorg handling failed", {
+      logger14.error("Subgraph reorg handling failed", {
         error: getErrorMessage6(err)
       });
     }
@@ -4646,7 +5114,7 @@ async function startSubgraphProcessor(opts) {
     runCatchUp();
   }, POLL_INTERVAL_MS);
   const stopStreamsReorgPoll = process.env.SUBGRAPH_SOURCE === "streams-index" ? startStreamsReorgPoll((forkHeight) => handleSubgraphReorg(forkHeight, loadSubgraphDefinition)) : undefined;
-  logger13.info("Subgraph processor ready");
+  logger14.info("Subgraph processor ready");
   return async () => {
     running = false;
     clearInterval(pollInterval);
@@ -4655,7 +5123,7 @@ async function startSubgraphProcessor(opts) {
     await stopReorgListening();
     stopStreamsReorgPoll?.();
     await stopOperations();
-    logger13.info("Subgraph processor stopped");
+    logger14.info("Subgraph processor stopped");
   };
 }
 export {
@@ -4663,5 +5131,5 @@ export {
   startSubgraphOperationRunner
 };
 
-//# debugId=0FA31971C86CC61564756E2164756E21
+//# debugId=9AD13E77BAE4758164756E2164756E21
 //# sourceMappingURL=processor.js.map