@secondlayer/subgraphs 4.4.1 → 5.0.1

package/dist/index.js

@@ -0,0 +1,2151 @@
+// src/define.ts
+function defineSubgraph(def) {
+  return def;
+}
+function defineSchema(schema) {
+  return schema;
+}
+// src/validate.ts
+import { z } from "zod";
+var SubgraphNameSchema = z.string().min(1).max(63).regex(/^[a-z][a-z0-9-]*$/, "Must start with lowercase letter, contain only lowercase alphanumeric and hyphens");
+var SqlIdentifierSchema = z.string().min(1).max(63).regex(/^[a-z_][a-z0-9_]*$/i, "Must be a valid SQL identifier: start with a letter or underscore, then letters/digits/underscores only");
+var ColumnTypeSchema = z.enum([
+  "text",
+  "uint",
+  "int",
+  "principal",
+  "boolean",
+  "timestamp",
+  "jsonb"
+]);
+var PrintFieldSchema = z.lazy(() => z.union([
+  ColumnTypeSchema,
+  z.object({ type: PrintFieldSchema, optional: z.literal(true) }),
+  z.object({ tuple: z.record(z.string(), PrintFieldSchema) }),
+  z.object({ list: PrintFieldSchema })
+]));
+var AbiTypeSchema = z.lazy(() => z.union([
+  z.string(),
+  z.object({ buff: z.object({ length: z.number() }) }),
+  z.object({ "string-ascii": z.object({ length: z.number() }) }),
+  z.object({ "string-utf8": z.object({ length: z.number() }) }),
+  z.object({ optional: AbiTypeSchema }),
+  z.object({
+    list: z.object({ type: AbiTypeSchema, length: z.number() })
+  }),
+  z.object({
+    tuple: z.array(z.object({ name: z.string(), type: AbiTypeSchema }))
+  }),
+  z.object({
+    response: z.object({ ok: AbiTypeSchema, error: AbiTypeSchema })
+  })
+]));
+var AbiContractSchema = z.object({
+  functions: z.array(z.object({
+    name: z.string(),
+    access: z.enum(["public", "read-only", "private"], {
+      message: "ABI access must be public | read-only | private — a raw Hiro/Clarinet ABI uses `read_only`. Normalize it first: normalizeAbi() from @secondlayer/stacks/clarity."
+    }),
+    args: z.array(z.object({ name: z.string(), type: AbiTypeSchema })),
+    outputs: AbiTypeSchema
+  })),
+  maps: z.array(z.unknown()).optional(),
+  variables: z.array(z.unknown()).optional(),
+  fungible_tokens: z.array(z.unknown()).optional(),
+  non_fungible_tokens: z.array(z.unknown()).optional(),
+  implemented_traits: z.array(z.unknown()).optional(),
+  defined_traits: z.array(z.unknown()).optional()
+});
+var SubgraphColumnSchema = z.object({
+  type: ColumnTypeSchema,
+  nullable: z.boolean().optional(),
+  indexed: z.boolean().optional(),
+  search: z.boolean().optional(),
+  default: z.union([z.string(), z.number(), z.boolean()]).optional()
+});
+var SubgraphTableSchema = z.object({
+  columns: z.record(SqlIdentifierSchema, SubgraphColumnSchema).refine((c) => Object.keys(c).length > 0, "Table must have at least one column"),
+  indexes: z.array(z.array(SqlIdentifierSchema)).optional(),
+  uniqueKeys: z.array(z.array(SqlIdentifierSchema)).optional()
+});
+var SubgraphSchemaSchema = z.record(SqlIdentifierSchema, SubgraphTableSchema).refine((s) => Object.keys(s).length > 0, "Schema must have at least one table");
+var VALID_FILTER_TYPES = [
+  "stx_transfer",
+  "stx_mint",
+  "stx_burn",
+  "stx_lock",
+  "ft_transfer",
+  "ft_mint",
+  "ft_burn",
+  "nft_transfer",
+  "nft_mint",
+  "nft_burn",
+  "contract_call",
+  "contract_deploy",
+  "print_event",
+  "nested_contract_call",
+  "var_set",
+  "map_set",
+  "map_insert",
+  "map_delete"
+];
+var contractIdField = z.union([
+  z.string(),
+  z.array(z.string()).min(1).max(20)
+]);
+var traitScope = { trait: z.string().optional() };
+var factoryScope = {
+  factory: z.object({ from: z.string().min(1), field: z.string().min(1) }).strict().optional()
+};
+var amountRange = {
+  minAmount: z.bigint().optional(),
+  maxAmount: z.bigint().optional()
+};
+var SubgraphFilterUnion = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("stx_transfer"),
+    sender: z.string().optional(),
+    recipient: z.string().optional(),
+    ...amountRange
+  }).strict(),
+  z.object({
+    type: z.literal("stx_mint"),
+    recipient: z.string().optional(),
+    minAmount: z.bigint().optional()
+  }).strict(),
+  z.object({
+    type: z.literal("stx_burn"),
+    sender: z.string().optional(),
+    minAmount: z.bigint().optional()
+  }).strict(),
+  z.object({
+    type: z.literal("stx_lock"),
+    lockedAddress: z.string().optional(),
+    minAmount: z.bigint().optional()
+  }).strict(),
+  z.object({
+    type: z.literal("ft_transfer"),
+    assetIdentifier: z.string().optional(),
+    sender: z.string().optional(),
+    recipient: z.string().optional(),
+    minAmount: z.bigint().optional(),
+    ...traitScope
+  }).strict(),
+  z.object({
+    type: z.literal("ft_mint"),
+    assetIdentifier: z.string().optional(),
+    recipient: z.string().optional(),
+    minAmount: z.bigint().optional(),
+    ...traitScope
+  }).strict(),
+  z.object({
+    type: z.literal("ft_burn"),
+    assetIdentifier: z.string().optional(),
+    sender: z.string().optional(),
+    minAmount: z.bigint().optional(),
+    ...traitScope
+  }).strict(),
+  z.object({
+    type: z.literal("nft_transfer"),
+    assetIdentifier: z.string().optional(),
+    sender: z.string().optional(),
+    recipient: z.string().optional(),
+    ...traitScope
+  }).strict(),
+  z.object({
+    type: z.literal("nft_mint"),
+    assetIdentifier: z.string().optional(),
+    recipient: z.string().optional(),
+    ...traitScope
+  }).strict(),
+  z.object({
+    type: z.literal("nft_burn"),
+    assetIdentifier: z.string().optional(),
+    sender: z.string().optional(),
+    ...traitScope
+  }).strict(),
+  z.object({
+    type: z.literal("contract_call"),
+    contractId: contractIdField.optional(),
+    functionName: z.string().optional(),
+    caller: z.string().optional(),
+    abi: AbiContractSchema.optional(),
+    ...traitScope,
+    ...factoryScope
+  }).strict(),
+  z.object({
+    type: z.literal("contract_deploy"),
+    deployer: z.string().optional(),
+    contractName: z.string().optional()
+  }).strict(),
+  z.object({
+    type: z.literal("print_event"),
+    contractId: contractIdField.optional(),
+    topic: z.string().optional(),
+    prints: z.record(z.string(), z.record(z.string(), PrintFieldSchema)).optional(),
+    ...traitScope,
+    ...factoryScope
+  }).strict(),
+  z.object({
+    type: z.literal("nested_contract_call"),
+    contractId: contractIdField.optional(),
+    functionName: z.string().optional(),
+    caller: z.string().optional(),
+    sender: z.string().optional(),
+    ...traitScope,
+    ...factoryScope
+  }).strict(),
+  z.object({
+    type: z.literal("var_set"),
+    contractId: contractIdField.optional(),
+    varName: z.string().optional(),
+    ...traitScope,
+    ...factoryScope
+  }).strict(),
+  z.object({
+    type: z.literal("map_set"),
+    contractId: contractIdField.optional(),
+    map: z.string().optional(),
+    ...traitScope,
+    ...factoryScope
+  }).strict(),
+  z.object({
+    type: z.literal("map_insert"),
+    contractId: contractIdField.optional(),
+    map: z.string().optional(),
+    ...traitScope,
+    ...factoryScope
+  }).strict(),
+  z.object({
+    type: z.literal("map_delete"),
+    contractId: contractIdField.optional(),
+    map: z.string().optional(),
+    ...traitScope,
+    ...factoryScope
+  }).strict()
+]);
+var SubgraphFilterSchema = SubgraphFilterUnion;
+function hasPinnedContractId(contractId) {
+  if (typeof contractId === "string")
+    return contractId.length > 0;
+  if (Array.isArray(contractId))
+    return contractId.length > 0;
+  return false;
+}
+function refineDeployGates(def, ctx) {
+  for (const [name, filter] of Object.entries(def.sources)) {
+    if (filter.type === "print_event") {
+      const pinned = hasPinnedContractId(filter.contractId) && !filter.trait;
+      if (pinned) {
+        const prints = filter.prints;
+        if (prints === undefined || typeof prints !== "object" || Object.keys(prints).length === 0) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["sources", name, "prints"],
+            message: `print_event source "${name}" has no prints map — field names would be untyped and empty tables would typecheck. Declare prints from index_print_schema / create --from-contract.`
+          });
+        }
+      }
+    }
+    if (filter.type === "contract_call" && filter.functionName !== undefined) {
+      if (filter.abi === undefined) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["sources", name, "abi"],
+          message: `contract_call source "${name}" has functionName but no abi. \`secondlayer subgraphs deploy\` fills it in from the deployed contract; otherwise pass abi (normalizeAbi() from @secondlayer/stacks/clarity).`
+        });
+      }
+    }
+  }
+  for (const name of Object.keys(def.sources)) {
+    if (def.handlers[name] == null) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["handlers", name],
+        message: `source "${name}" has no handler. Add handlers.${name}, or its events are skipped and the table stays empty.`
+      });
+    }
+  }
+}
+var SubgraphDefinitionSchema = z.object({
+  name: SubgraphNameSchema,
+  description: z.string().optional(),
+  startBlock: z.number().int().nonnegative().optional(),
+  backfillMode: z.enum(["blocking", "concurrent"]).optional(),
+  sources: z.record(z.string(), SubgraphFilterSchema).refine((s) => Object.keys(s).length > 0, "Must have at least one source"),
+  schema: SubgraphSchemaSchema,
+  handlers: z.record(z.string(), z.any())
+}).superRefine((def, ctx) => {
+  refineDeployGates(def, ctx);
+});
+function validateSubgraphDefinition(def) {
+  return SubgraphDefinitionSchema.parse(def);
+}
+function filterFieldsByType() {
+  const options = SubgraphFilterUnion?._def?.options ?? [];
+  const out = [];
+  for (const option of options) {
+    const shape = option?.shape ?? option?._def?.shape;
+    if (!shape)
+      continue;
+    const literal = shape.type?._def?.values?.[0] ?? shape.type?._def?.value ?? undefined;
+    if (typeof literal !== "string")
+      continue;
+    out.push({
+      type: literal,
+      fields: Object.keys(shape).filter((k) => k !== "type")
+    });
+  }
+  return out;
+}
+// src/print-schema.ts
+import {
+  deserializeCV
+} 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 = deserializeCV(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/chain-read.ts
+import { getSourceDb } from "@secondlayer/shared/db";
+import { logger } from "@secondlayer/shared/logger";
+import { http, createPublicClient } from "@secondlayer/stacks";
+import {
+  ContractResponseError,
+  buildFunctionArgs,
+  isResponseOutput,
+  readContract
+} from "@secondlayer/stacks/actions";
+import {
+  clarityValueToJSUntyped,
+  deserializeCV as deserializeCV2,
+  normalizeAbi,
+  serializeCV,
+  toCamelCase
+} from "@secondlayer/stacks/clarity";
+function readContractAt(ctx, contractId, abi, options) {
+  return ctx.client.contract(contractId, abi, options);
+}
+
+class ChainReadError extends Error {
+  name = "ChainReadError";
+}
+function nodeClient(rpcUrl) {
+  return createPublicClient({
+    transport: http(rpcUrl, { retryCount: 0, timeout: 1e4 })
+  });
+}
+
+class ConcurrencyGate {
+  limit;
+  active = 0;
+  queue = [];
+  constructor(limit) {
+    this.limit = limit;
+  }
+  async run(fn) {
+    if (this.active >= this.limit) {
+      await new Promise((resolve) => this.queue.push(resolve));
+    }
+    this.active++;
+    try {
+      return await fn();
+    } finally {
+      this.active--;
+      this.queue.shift()?.();
+    }
+  }
+}
+var DEFAULT_MAX_CONCURRENT_READS = 4;
+function maxConcurrentReads() {
+  const raw = process.env.SUBGRAPH_CHAIN_READ_CONCURRENCY;
+  const parsed = raw ? Number.parseInt(raw, 10) : Number.NaN;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_CONCURRENT_READS;
+}
+var gate = new ConcurrencyGate(maxConcurrentReads());
+function hashArgs(args) {
+  const serialized = args.map((arg) => serializeCV(arg)).join(",");
+  return Bun.hash(serialized).toString(16);
+}
+function findFunction(abi, name) {
+  const fn = abi.functions.find((f) => f.name === name);
+  if (!fn) {
+    throw new ChainReadError(`No function "${name}" in the supplied ABI.`);
+  }
+  if (fn.access !== "read-only") {
+    throw new ChainReadError(`"${name}" is ${fn.access}, not read-only — a handler cannot call it.`);
+  }
+  return fn;
+}
+function createChainReadClient(ctx) {
+  const readValue = async (contractId, abi, functionName, args, options) => {
+    const rpcUrl = ctx.rpcUrl ?? process.env.STACKS_NODE_RPC_URL;
+    if (!rpcUrl) {
+      throw new ChainReadError("ctx.client needs a Stacks node: set STACKS_NODE_RPC_URL on the subgraph processor.");
+    }
+    const constant = options.cache === "contract-constant";
+    if (!constant && !ctx.indexBlockHash) {
+      throw new ChainReadError(`Block ${ctx.blockHeight} has no index_block_hash, so a read cannot be pinned to it. Reading at the node's tip would make this handler non-deterministic (the same reindex would produce different rows). Re-ingest the block, or pass cache: "contract-constant" if the value genuinely cannot change.`);
+    }
+    const fn = findFunction(abi, functionName);
+    const clarityArgs = buildFunctionArgs(fn, args);
+    const db = ctx.db ?? getSourceDb();
+    const argsHash = hashArgs(clarityArgs);
+    const pinnedTo = constant ? null : ctx.indexBlockHash;
+    const cached = await db.selectFrom("chain_read_cache").select("result_hex").where("contract_id", "=", contractId).where("function_name", "=", fn.name).where("args_hash", "=", argsHash).where((eb) => pinnedTo === null ? eb("index_block_hash", "is", null) : eb("index_block_hash", "=", pinnedTo)).executeTakeFirst();
+    const resultHex = cached?.result_hex ?? await gate.run(async () => {
+      if (!ctx.indexBlockHash) {
+        logger.warn("Chain read is not pinned to a block (no index_block_hash)", {
+          contractId,
+          functionName: fn.name,
+          blockHeight: ctx.blockHeight,
+          note: 'cache: "contract-constant" asserts this value cannot change; the node answered at its own tip'
+        });
+      }
+      const value = await readContract(nodeClient(rpcUrl), {
+        contract: contractId,
+        functionName: fn.name,
+        args: clarityArgs,
+        tip: ctx.indexBlockHash ?? undefined
+      });
+      return serializeCV(value);
+    });
+    if (!cached) {
+      await db.insertInto("chain_read_cache").values({
+        contract_id: contractId,
+        function_name: fn.name,
+        args_hash: argsHash,
+        index_block_hash: pinnedTo,
+        block_height: constant ? null : ctx.blockHeight,
+        result_hex: resultHex
+      }).onConflict((oc) => oc.doNothing()).execute();
+    }
+    const value = deserializeCV2(resultHex);
+    const js = clarityValueToJSUntyped(fn.outputs, value);
+    if (isResponseOutput(fn.outputs)) {
+      const response = js;
+      if ("ok" in response)
+        return response.ok;
+      throw new ContractResponseError(`${contractId}::${fn.name} returned an err response.`, response.err);
+    }
+    return js;
+  };
+  return {
+    contract(contractId, rawAbi, options = {}) {
+      const abi = normalizeAbi(rawAbi);
+      const camelToKebab = new Map;
+      for (const fn of abi.functions) {
+        camelToKebab.set(toCamelCase(fn.name), fn.name);
+      }
+      const read = new Proxy({}, {
+        get(_target, prop) {
+          const fnName = camelToKebab.get(prop) ?? prop;
+          return (args = {}) => readValue(contractId, abi, fnName, args, options);
+        }
+      });
+      return { read };
+    }
+  };
+}
+// src/schema/generator.ts
+import { createHash } from "node:crypto";
+
+// src/schema/utils.ts
+import { pgSchemaName } from "@secondlayer/shared/db/queries/subgraphs";
+function quotePgIdent(name) {
+  if (/^[a-z_][a-z0-9_]*$/i.test(name))
+    return name;
+  return `"${name.replace(/"/g, '""')}"`;
+}
+function snakeToCamel(name) {
+  return name.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function pascalCase(name) {
+  const camel = snakeToCamel(name);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+
+// src/schema/generator.ts
+var TYPE_MAP = {
+  text: "TEXT",
+  uint: "NUMERIC",
+  int: "NUMERIC",
+  principal: "TEXT",
+  boolean: "BOOLEAN",
+  timestamp: "TIMESTAMPTZ",
+  jsonb: "JSONB"
+};
+var MAX_IDENT_BYTES = 63;
+function safeIndexName(name) {
+  if (name.length <= MAX_IDENT_BYTES)
+    return name;
+  const hash = createHash("sha256").update(name).digest("hex").slice(0, 8);
+  return `${name.slice(0, MAX_IDENT_BYTES - hash.length - 1)}_${hash}`;
+}
+function emitIndexedColumnIndexDDL(schemaName, tableName, colName, opts) {
+  const concurrently = opts?.concurrently ? " CONCURRENTLY" : "";
+  const qualified = `${quotePgIdent(schemaName)}.${quotePgIdent(tableName)}`;
+  const plain = `idx_${schemaName}_${tableName}_${colName}`;
+  const composite = safeIndexName(`idx_${schemaName}_${tableName}_${colName}_id`);
+  const col = quotePgIdent(colName);
+  const id = quotePgIdent("_id");
+  return {
+    create: [
+      `CREATE INDEX${concurrently} IF NOT EXISTS ${quotePgIdent(plain)} ON ${qualified} (${col})`,
+      `CREATE INDEX${concurrently} IF NOT EXISTS ${quotePgIdent(composite)} ON ${qualified} (${col}, ${id})`
+    ],
+    drop: [
+      `DROP INDEX${concurrently} IF EXISTS ${quotePgIdent(schemaName)}.${quotePgIdent(plain)}`,
+      `DROP INDEX${concurrently} IF EXISTS ${quotePgIdent(schemaName)}.${quotePgIdent(composite)}`
+    ]
+  };
+}
+function escapeLiteralDefault(value) {
+  if (value === null || value === undefined)
+    return "NULL";
+  if (typeof value === "number" || typeof value === "bigint")
+    return String(value);
+  if (typeof value === "boolean")
+    return value ? "TRUE" : "FALSE";
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+function tableNeedsTrgm(tableDef) {
+  return Object.values(tableDef.columns).some((col) => col.search);
+}
+function emitTableDDL(schemaName, tableName, tableDef) {
+  const qualifiedName = `${quotePgIdent(schemaName)}.${quotePgIdent(tableName)}`;
+  const statements = [];
+  const columnDefs = [
+    "_id BIGSERIAL PRIMARY KEY",
+    "_block_height BIGINT NOT NULL",
+    "_tx_id TEXT NOT NULL",
+    "_created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()"
+  ];
+  for (const [colName, col] of Object.entries(tableDef.columns)) {
+    const sqlType = TYPE_MAP[col.type];
+    const nullable = col.nullable ? "" : " NOT NULL";
+    let colDef = `${quotePgIdent(colName)} ${sqlType}${nullable}`;
+    if (col.default !== undefined) {
+      colDef += ` DEFAULT ${escapeLiteralDefault(col.default)}`;
+    }
+    if (col.type === "uint") {
+      colDef += ` CHECK (${quotePgIdent(colName)} >= 0)`;
+    }
+    columnDefs.push(colDef);
+  }
+  statements.push(`CREATE TABLE IF NOT EXISTS ${qualifiedName} (
+  ${columnDefs.join(`,
+  `)}
+)`);
+  statements.push(`CREATE INDEX IF NOT EXISTS ${quotePgIdent(`idx_${schemaName}_${tableName}_block_height`)} ON ${qualifiedName} (_block_height)`);
+  statements.push(`CREATE INDEX IF NOT EXISTS ${quotePgIdent(`idx_${schemaName}_${tableName}_tx_id`)} ON ${qualifiedName} (_tx_id)`);
+  for (const [colName, col] of Object.entries(tableDef.columns)) {
+    if (col.indexed) {
+      statements.push(...emitIndexedColumnIndexDDL(schemaName, tableName, colName).create);
+    }
+  }
+  for (const [colName, col] of Object.entries(tableDef.columns)) {
+    if (col.search) {
+      statements.push(`CREATE INDEX IF NOT EXISTS ${quotePgIdent(`idx_${schemaName}_${tableName}_${colName}_trgm`)} ON ${qualifiedName} USING gin (${quotePgIdent(colName)} gin_trgm_ops)`);
+    }
+  }
+  if (tableDef.indexes) {
+    for (let i = 0;i < tableDef.indexes.length; i++) {
+      const cols = tableDef.indexes[i];
+      const idxName = quotePgIdent(`idx_${schemaName}_${tableName}_composite_${i}`);
+      statements.push(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.map(quotePgIdent).join(", ")})`);
+    }
+  }
+  if (tableDef.uniqueKeys) {
+    for (let i = 0;i < tableDef.uniqueKeys.length; i++) {
+      const cols = tableDef.uniqueKeys[i];
+      const constraintName = quotePgIdent(`uq_${schemaName}_${tableName}_${cols.join("_")}`);
+      statements.push(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.map(quotePgIdent).join(", ")})`);
+    }
+  }
+  return statements;
+}
+function emitJournalDDL(schemaName) {
+  return [
+    `CREATE TABLE IF NOT EXISTS ${schemaName}._journal (
+  _jid BIGSERIAL PRIMARY KEY,
+  block_height BIGINT NOT NULL,
+  table_name TEXT NOT NULL,
+  row_key JSONB NOT NULL,
+  prev_row JSONB,
+  _created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+)`,
+    `CREATE INDEX IF NOT EXISTS idx_${schemaName}_journal_height ON ${schemaName}._journal (block_height)`
+  ];
+}
+function emitFactoryDDL(schemaName) {
+  return [
+    `CREATE TABLE IF NOT EXISTS ${schemaName}._factory_addresses (
+  source_name TEXT NOT NULL,
+  address TEXT NOT NULL,
+  block_height BIGINT NOT NULL,
+  _created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  PRIMARY KEY (source_name, address)
+)`,
+    `CREATE INDEX IF NOT EXISTS idx_${schemaName}_factory_height ON ${schemaName}._factory_addresses (block_height)`
+  ];
+}
+function generateSubgraphSQL(def, schemaNameOverride) {
+  const schemaName = schemaNameOverride ?? pgSchemaName(def.name);
+  const statements = [];
+  const needsTrgm = Object.values(def.schema).some((table) => Object.values(table.columns).some((col) => col.search));
+  if (needsTrgm) {
+    statements.push("CREATE EXTENSION IF NOT EXISTS pg_trgm");
+  }
+  statements.push(`CREATE SCHEMA IF NOT EXISTS ${schemaName}`);
+  for (const [tableName, tableDef] of Object.entries(def.schema)) {
+    statements.push(...emitTableDDL(schemaName, tableName, tableDef));
+  }
+  statements.push(...emitJournalDDL(schemaName));
+  if (Object.values(def.sources ?? {}).some((src) => src.factory !== undefined)) {
+    statements.push(...emitFactoryDDL(schemaName));
+  }
+  const hashInput = JSON.stringify({
+    name: def.name,
+    schema: def.schema,
+    sources: def.sources
+  }, (_key, value) => typeof value === "bigint" ? value.toString() : value);
+  const hash = createHash("sha256").update(hashInput).digest("hex");
+  return { statements, hash };
+}
+// src/schema/prisma.ts
+var PRISMA_TYPE = {
+  uint: { type: "Decimal", db: "@db.Numeric" },
+  int: { type: "Decimal", db: "@db.Numeric" },
+  text: { type: "String" },
+  principal: { type: "String" },
+  boolean: { type: "Boolean" },
+  timestamp: { type: "DateTime", db: "@db.Timestamptz" },
+  jsonb: { type: "Json" }
+};
+var SYSTEM_FIELDS = [
+  { field: "id", col: "_id", line: "BigInt   @id @default(autoincrement())" },
+  { field: "blockHeight", col: "_block_height", line: "BigInt" },
+  { field: "txId", col: "_tx_id", line: "String" },
+  {
+    field: "createdAt",
+    col: "_created_at",
+    line: "DateTime @default(now()) @db.Timestamptz"
+  }
+];
+function quotePrismaDefault(value) {
+  if (typeof value === "string")
+    return `@default("${value.replace(/"/g, "\\\"")}")`;
+  return `@default(${value})`;
+}
+function renderTable(tableName, table) {
+  const lines = [];
+  for (const sys of SYSTEM_FIELDS) {
+    lines.push(`  ${sys.field} ${sys.line} @map("${sys.col}")`);
+  }
+  for (const [colName, col] of Object.entries(table.columns)) {
+    const field = snakeToCamel(colName);
+    const mapped = PRISMA_TYPE[col.type];
+    const optional = col.nullable ? "?" : "";
+    const attrs = [];
+    if (field !== colName)
+      attrs.push(`@map("${colName}")`);
+    if (col.default !== undefined)
+      attrs.push(quotePrismaDefault(col.default));
+    if (mapped.db)
+      attrs.push(mapped.db);
+    lines.push(`  ${field} ${mapped.type}${optional}${attrs.length ? ` ${attrs.join(" ")}` : ""}`);
+  }
+  const block = [];
+  for (const [colName, col] of Object.entries(table.columns)) {
+    if (col.indexed)
+      block.push(`  @@index([${snakeToCamel(colName)}])`);
+  }
+  for (const cols of table.indexes ?? []) {
+    block.push(`  @@index([${cols.map(snakeToCamel).join(", ")}])`);
+  }
+  for (const cols of table.uniqueKeys ?? []) {
+    block.push(`  @@unique([${cols.map(snakeToCamel).join(", ")}])`);
+  }
+  block.push(`  @@map("${tableName}")`);
+  return `model ${pascalCase(tableName)} {
+${lines.join(`
+`)}
+
+${block.join(`
+`)}
+}`;
+}
+function generatePrismaSchema(def, opts = {}) {
+  const schemaName = opts.schemaName ?? pgSchemaName(def.name);
+  const env = opts.datasourceEnv ?? "DATABASE_URL";
+  const header = [
+    `// Generated by \`sl codegen subgraph --target prisma\` from subgraph "${def.name}". Do not edit by hand.`,
+    "",
+    "datasource db {",
+    '  provider = "postgresql"',
+    `  url      = env("${env}")`,
+    `  schemas  = ["${schemaName}"]`,
+    "}",
+    "",
+    "generator client {",
+    '  provider        = "prisma-client-js"',
+    '  previewFeatures = ["multiSchema"]',
+    "}"
+  ].join(`
+`);
+  const modelBlocks = Object.entries(def.schema).map(([tableName, table]) => {
+    const body = renderTable(tableName, table);
+    return body.replace(/\n}$/, `
+  @@schema("${schemaName}")
+}`);
+  });
+  if (opts.modelsOnly)
+    return `${modelBlocks.join(`
+
+`)}
+`;
+  return `${header}
+
+${modelBlocks.join(`
+
+`)}
+`;
+}
+// src/schema/drizzle.ts
+var DRIZZLE_BUILDER = {
+  uint: (c) => `numeric("${c}")`,
+  int: (c) => `numeric("${c}")`,
+  text: (c) => `text("${c}")`,
+  principal: (c) => `text("${c}")`,
+  boolean: (c) => `boolean("${c}")`,
+  timestamp: (c) => `timestamp("${c}", { withTimezone: true })`,
+  jsonb: (c) => `jsonb("${c}")`
+};
+var BUILDERS_USED = {
+  uint: "numeric",
+  int: "numeric",
+  text: "text",
+  principal: "text",
+  boolean: "boolean",
+  timestamp: "timestamp",
+  jsonb: "jsonb"
+};
+function literalDefault(value) {
+  return typeof value === "string" ? `"${value.replace(/"/g, "\\\"")}"` : `${value}`;
+}
+function renderTable2(varName, tableName, table) {
+  const cols = [
+    `  id: bigserial("_id", { mode: "bigint" }).primaryKey(),`,
+    `  blockHeight: bigint("_block_height", { mode: "bigint" }).notNull(),`,
+    `  txId: text("_tx_id").notNull(),`,
+    `  createdAt: timestamp("_created_at", { withTimezone: true }).notNull().defaultNow(),`
+  ];
+  for (const [colName, col] of Object.entries(table.columns)) {
+    let line = `  ${snakeToCamel(colName)}: ${DRIZZLE_BUILDER[col.type](colName)}`;
+    if (!col.nullable)
+      line += ".notNull()";
+    if (col.default !== undefined)
+      line += `.default(${literalDefault(col.default)})`;
+    cols.push(`${line},`);
+  }
+  const extras = [];
+  for (const [colName, col] of Object.entries(table.columns)) {
+    if (col.indexed) {
+      const f = snakeToCamel(colName);
+      extras.push(`    ${f}Idx: index("idx_${tableName}_${colName}").on(t.${f})`);
+    }
+  }
+  table.indexes?.forEach((idxCols, i) => {
+    const on = idxCols.map((c) => `t.${snakeToCamel(c)}`).join(", ");
+    extras.push(`    idx${i}: index("idx_${tableName}_${i}").on(${on})`);
+  });
+  table.uniqueKeys?.forEach((uqCols, i) => {
+    const on = uqCols.map((c) => `t.${snakeToCamel(c)}`).join(", ");
+    extras.push(`    uq${i}: uniqueIndex("uq_${tableName}_${i}").on(${on})`);
+  });
+  const extrasBlock = extras.length ? `, (t) => ({
+${extras.join(`,
+`)},
+  })` : "";
+  return `export const ${varName} = sg.table("${tableName}", {
+${cols.join(`
+`)}
+}${extrasBlock});`;
+}
+function generateDrizzleSchema(def, opts = {}) {
+  const schemaName = opts.schemaName ?? pgSchemaName(def.name);
+  const used = new Set(["bigserial", "bigint", "text", "timestamp"]);
+  let needsIndex = false;
+  let needsUnique = false;
+  for (const table of Object.values(def.schema)) {
+    for (const col of Object.values(table.columns))
+      used.add(BUILDERS_USED[col.type]);
+    if (Object.values(table.columns).some((c) => c.indexed) || table.indexes?.length)
+      needsIndex = true;
+    if (table.uniqueKeys?.length)
+      needsUnique = true;
+  }
+  if (needsIndex)
+    used.add("index");
+  if (needsUnique)
+    used.add("uniqueIndex");
+  used.add("pgSchema");
+  const imports = `import { ${[...used].sort().join(", ")} } from "drizzle-orm/pg-core";`;
+  const tables = Object.entries(def.schema).map(([name, table]) => renderTable2(snakeToCamel(name), name, table));
+  const typeExports = Object.keys(def.schema).map((name) => `export type ${pascalCase(name)} = typeof ${snakeToCamel(name)}.$inferSelect;`);
+  return [
+    `// Generated by \`sl codegen subgraph --target drizzle\` from subgraph "${def.name}". Do not edit by hand.`,
+    imports,
+    "",
+    `export const sg = pgSchema("${schemaName}");`,
+    "",
+    tables.join(`
+
+`),
+    "",
+    typeExports.join(`
+`),
+    ""
+  ].join(`
+`);
+}
+// src/schema/kysely.ts
+var KYSELY_TYPE = {
+  uint: "string",
+  int: "string",
+  text: "string",
+  principal: "string",
+  boolean: "boolean",
+  timestamp: "Date",
+  jsonb: "unknown"
+};
+var SYSTEM_FIELDS2 = [
+  { col: "_id", type: "Generated<string>" },
+  { col: "_block_height", type: "string" },
+  { col: "_tx_id", type: "string" },
+  { col: "_created_at", type: "Generated<Date>" }
+];
+function renderTable3(tableName, table) {
+  const lines = SYSTEM_FIELDS2.map((f) => `  ${f.col}: ${f.type};`);
+  for (const [colName, col] of Object.entries(table.columns)) {
+    let type = KYSELY_TYPE[col.type];
+    if (col.nullable)
+      type = `${type} | null`;
+    if (col.default !== undefined)
+      type = `Generated<${type}>`;
+    lines.push(`  ${colName}: ${type};`);
+  }
+  return `export interface ${pascalCase(tableName)} {
+${lines.join(`
+`)}
+}`;
+}
+function generateKyselySchema(def, opts = {}) {
+  const schemaName = opts.schemaName ?? pgSchemaName(def.name);
+  const interfaces = Object.entries(def.schema).map(([name, table]) => renderTable3(name, table));
+  const dbEntries = Object.keys(def.schema).map((name) => `  "${schemaName}.${name}": ${pascalCase(name)};`);
+  const dbRegistry = `export interface DB {
+${dbEntries.join(`
+`)}
+}`;
+  const rowExports = Object.keys(def.schema).map((name) => `export type ${pascalCase(name)}Row = Selectable<${pascalCase(name)}>;`);
+  return [
+    `// Generated by \`sl codegen subgraph --target kysely\` from subgraph "${def.name}". Do not edit by hand.`,
+    `import type { Generated, Selectable } from "kysely";`,
+    "",
+    interfaces.join(`
+
+`),
+    "",
+    dbRegistry,
+    "",
+    rowExports.join(`
+`),
+    ""
+  ].join(`
+`);
+}
+// src/schema/index-codegen.ts
+import {
+  SOURCE_READ_PKS,
+  SOURCE_READ_TYPES
+} from "@secondlayer/shared/db";
+function selectTables(opts) {
+  const all = SOURCE_READ_TYPES;
+  const names = opts.tables ?? Object.keys(all);
+  return names.map((name) => {
+    const cols = all[name];
+    if (!cols) {
+      throw new Error(`Unknown Index table "${name}". Known: ${Object.keys(all).sort().join(", ")}`);
+    }
+    return [name, cols];
+  });
+}
+var KYSELY_TYPE2 = {
+  text: "string",
+  int: "number",
+  boolean: "boolean",
+  timestamp: "Date",
+  jsonb: "unknown"
+};
+function generateKysely(entries, schemaName) {
+  const interfaces = entries.map(([table, cols]) => {
+    const lines = Object.entries(cols).map(([col, def]) => {
+      const type = def.nullable ? `${KYSELY_TYPE2[def.type]} | null` : KYSELY_TYPE2[def.type];
+      return `  ${col}: ${type};`;
+    });
+    return `export interface ${pascalCase(table)} {
+${lines.join(`
+`)}
+}`;
+  });
+  const dbEntries = entries.map(([table]) => {
+    const key = schemaName ? `${schemaName}.${table}` : table;
+    return `  "${key}": ${pascalCase(table)};`;
+  });
+  const rows = entries.map(([table]) => `export type ${pascalCase(table)}Row = Selectable<${pascalCase(table)}>;`);
+  return [
+    "// Generated by `sl codegen index --target kysely`. Do not edit by hand.",
+    `import type { Selectable } from "kysely";`,
+    "",
+    interfaces.join(`
+
+`),
+    "",
+    `export interface IndexDB {
+${dbEntries.join(`
+`)}
+}`,
+    "",
+    rows.join(`
+`),
+    ""
+  ].join(`
+`);
+}
+var DRIZZLE_BUILDER2 = {
+  text: (c) => `text("${c}")`,
+  int: (c) => `integer("${c}")`,
+  boolean: (c) => `boolean("${c}")`,
+  timestamp: (c) => `timestamp("${c}", { withTimezone: true })`,
+  jsonb: (c) => `jsonb("${c}")`
+};
+var DRIZZLE_BUILDER_NAME = {
+  text: "text",
+  int: "integer",
+  boolean: "boolean",
+  timestamp: "timestamp",
+  jsonb: "jsonb"
+};
+function generateDrizzle(entries, schemaName) {
+  const used = new Set;
+  for (const [, cols] of entries)
+    for (const def of Object.values(cols))
+      used.add(DRIZZLE_BUILDER_NAME[def.type]);
+  if (schemaName)
+    used.add("pgSchema");
+  else
+    used.add("pgTable");
+  const tableFn = schemaName ? "sg.table" : "pgTable";
+  const tables = entries.map(([table, cols]) => {
+    const lines = Object.entries(cols).map(([col, def]) => {
+      let line = `  ${snakeToCamel(col)}: ${DRIZZLE_BUILDER2[def.type](col)}`;
+      if (!def.nullable)
+        line += ".notNull()";
+      return `${line},`;
+    });
+    return `export const ${snakeToCamel(table)} = ${tableFn}("${table}", {
+${lines.join(`
+`)}
+});`;
+  });
+  const rows = entries.map(([table]) => `export type ${pascalCase(table)} = typeof ${snakeToCamel(table)}.$inferSelect;`);
+  return [
+    "// Generated by `sl codegen index --target drizzle`. Do not edit by hand.",
+    `import { ${[...used].sort().join(", ")} } from "drizzle-orm/pg-core";`,
+    "",
+    ...schemaName ? [`export const sg = pgSchema("${schemaName}");`, ""] : [],
+    tables.join(`
+
+`),
+    "",
+    rows.join(`
+`),
+    ""
+  ].join(`
+`);
+}
+var JSON_SCHEMA_TYPE = {
+  text: { type: "string" },
+  int: { type: "integer" },
+  boolean: { type: "boolean" },
+  timestamp: { type: "string", format: "date-time" },
+  jsonb: {}
+};
+function generateJsonSchema(entries) {
+  const defs = {};
+  for (const [table, cols] of entries) {
+    const properties = {};
+    const required = [];
+    for (const [col, def] of Object.entries(cols)) {
+      const base = JSON_SCHEMA_TYPE[def.type];
+      if (def.nullable && "type" in base) {
+        properties[col] = { ...base, type: [base.type, "null"] };
+      } else {
+        properties[col] = { ...base };
+        if (!def.nullable)
+          required.push(col);
+      }
+    }
+    defs[pascalCase(table)] = {
+      type: "object",
+      properties,
+      required,
+      additionalProperties: false
+    };
+  }
+  return `${JSON.stringify({
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    title: "Secondlayer Index domain",
+    $defs: defs
+  }, null, 2)}
+`;
+}
+var PRISMA_TYPE2 = {
+  text: { type: "String" },
+  int: { type: "Int" },
+  boolean: { type: "Boolean" },
+  timestamp: { type: "DateTime", db: "@db.Timestamptz" },
+  jsonb: { type: "Json" }
+};
+function generatePrisma(entries, schemaName, datasourceEnv) {
+  const pks = SOURCE_READ_PKS;
+  const skipped = [];
+  const models = [];
+  for (const [table, cols] of entries) {
+    const pk = pks[table];
+    if (!pk) {
+      skipped.push(table);
+      continue;
+    }
+    const single = pk.length === 1 ? pk[0] : null;
+    const lines = Object.entries(cols).map(([col, def]) => {
+      const field = snakeToCamel(col);
+      const mapped = PRISMA_TYPE2[def.type];
+      const attrs = [];
+      if (single === col)
+        attrs.push("@id");
+      if (field !== col)
+        attrs.push(`@map("${col}")`);
+      if (mapped.db)
+        attrs.push(mapped.db);
+      const optional = def.nullable ? "?" : "";
+      return `  ${field} ${mapped.type}${optional}${attrs.length ? ` ${attrs.join(" ")}` : ""}`;
+    });
+    const block = [];
+    if (!single) {
+      block.push(`  @@id([${pk.map(snakeToCamel).join(", ")}])`);
+    }
+    block.push(`  @@map("${table}")`);
+    if (schemaName)
+      block.push(`  @@schema("${schemaName}")`);
+    models.push(`model ${pascalCase(table)} {
+${lines.join(`
+`)}
+
+${block.join(`
+`)}
+}`);
+  }
+  const header = [
+    "// Generated by `sl codegen index --target prisma`. Do not edit by hand.",
+    ...skipped.length ? [
+      `// Omitted (no read-set primary key, query via another target): ${skipped.join(", ")}`
+    ] : [],
+    "",
+    "datasource db {",
+    '  provider = "postgresql"',
+    `  url      = env("${datasourceEnv}")`,
+    ...schemaName ? [`  schemas  = ["${schemaName}"]`] : [],
+    "}",
+    "",
+    "generator client {",
+    '  provider        = "prisma-client-js"',
+    ...schemaName ? ['  previewFeatures = ["multiSchema"]'] : [],
+    "}"
+  ].join(`
+`);
+  return `${header}
+
+${models.join(`
+
+`)}
+`;
+}
+function generateIndexSchema(target, opts = {}) {
+  const entries = selectTables(opts);
+  switch (target) {
+    case "prisma":
+      return generatePrisma(entries, opts.schemaName, opts.datasourceEnv ?? "DATABASE_URL");
+    case "kysely":
+      return generateKysely(entries, opts.schemaName);
+    case "drizzle":
+      return generateDrizzle(entries, opts.schemaName);
+    case "json-schema":
+      return generateJsonSchema(entries);
+    default:
+      throw new Error(`Unsupported Index codegen target "${target}".`);
+  }
+}
+var INDEX_CODEGEN_TABLES = Object.keys(SOURCE_READ_TYPES);
+// src/schema/deployer.ts
+import { sql } from "kysely";
+function toJsonSafe(obj) {
+  return JSON.parse(JSON.stringify(obj, (_key, value) => typeof value === "bigint" ? value.toString() : value));
+}
+function columnDataShape(col) {
+  const { indexed, search, ...rest } = col ?? {};
+  return JSON.stringify(rest, Object.keys(rest).sort());
+}
+function diffKeyLists(existing, incoming) {
+  const key = (cols) => JSON.stringify(cols);
+  const existingSet = new Set((existing ?? []).map(key));
+  const incomingSet = new Set((incoming ?? []).map(key));
+  return {
+    added: (incoming ?? []).filter((cols) => !existingSet.has(key(cols))).map((cols) => [...cols]),
+    removed: (existing ?? []).filter((cols) => !incomingSet.has(key(cols))).map((cols) => [...cols])
+  };
+}
+function diffSchema(existing, incoming) {
+  const existingTables = new Set(Object.keys(existing));
+  const incomingTables = new Set(Object.keys(incoming));
+  const addedTables = [...incomingTables].filter((t) => !existingTables.has(t));
+  const removedTables = [...existingTables].filter((t) => !incomingTables.has(t));
+  const tables = {};
+  const constraints = {};
+  for (const tableName of incomingTables) {
+    if (!existingTables.has(tableName))
+      continue;
+    const existingTable = existing[tableName];
+    const incomingTable = incoming[tableName];
+    const existingCols = existingTable?.columns;
+    const incomingCols = incomingTable?.columns;
+    const existingKeys = new Set(Object.keys(existingCols));
+    const incomingKeys = new Set(Object.keys(incomingCols));
+    const common = [...incomingKeys].filter((k) => existingKeys.has(k));
+    const sortedStringify = (o) => JSON.stringify(o, Object.keys(o).sort());
+    tables[tableName] = {
+      added: [...incomingKeys].filter((k) => !existingKeys.has(k)),
+      removed: [...existingKeys].filter((k) => !incomingKeys.has(k)),
+      changed: common.filter((k) => columnDataShape(existingCols[k]) !== columnDataShape(incomingCols[k])),
+      indexChanged: common.filter((k) => columnDataShape(existingCols[k]) === columnDataShape(incomingCols[k]) && sortedStringify(existingCols[k]) !== sortedStringify(incomingCols[k]))
+    };
+    const uq = diffKeyLists(existingTable?.uniqueKeys, incomingTable?.uniqueKeys);
+    const ix = diffKeyLists(existingTable?.indexes, incomingTable?.indexes);
+    constraints[tableName] = {
+      addedUniqueKeys: uq.added,
+      removedUniqueKeys: uq.removed,
+      addedIndexes: ix.added,
+      removedIndexes: ix.removed
+    };
+  }
+  return { addedTables, removedTables, tables, constraints };
+}
+function hasBreakingChanges(diff) {
+  const reasons = [];
+  if (diff.removedTables.length > 0) {
+    reasons.push(`removed tables: [${diff.removedTables.join(", ")}]`);
+  }
+  for (const [table, colDiff] of Object.entries(diff.tables)) {
+    if (colDiff.removed.length > 0) {
+      reasons.push(`${table}: removed columns [${colDiff.removed.join(", ")}]`);
+    }
+    if (colDiff.changed.length > 0) {
+      reasons.push(`${table}: changed columns [${colDiff.changed.join(", ")}]`);
+    }
+  }
+  for (const [table, conDiff] of Object.entries(diff.constraints ?? {})) {
+    if (conDiff.removedUniqueKeys.length > 0) {
+      reasons.push(`${table}: removed uniqueKeys [${conDiff.removedUniqueKeys.map((cols) => `(${cols.join(", ")})`).join(", ")}]`);
+    }
+  }
+  return { breaking: reasons.length > 0, reasons };
+}
+function bumpPatch(version) {
+  const parts = version.split(".");
+  if (parts.length !== 3)
+    return "1.0.1";
+  const patch = Number.parseInt(parts[2] ?? "0", 10);
+  return `${parts[0]}.${parts[1]}.${Number.isNaN(patch) ? 1 : patch + 1}`;
+}
+function toDeployDiff(diff, reasons) {
+  return {
+    addedTables: diff?.addedTables ?? [],
+    removedTables: diff?.removedTables ?? [],
+    addedColumns: diff ? Object.fromEntries(Object.entries(diff.tables).filter(([, c]) => c.added.length > 0).map(([t, c]) => [t, c.added])) : {},
+    breakingChanges: reasons
+  };
+}
+function renderDeployPlan(def, schemaName) {
+  validateSubgraphDefinition(def);
+  const { statements } = generateSubgraphSQL(def, schemaName);
+  const schema = schemaName ?? pgSchemaName(def.name);
+  const dropStatement = `DROP SCHEMA IF EXISTS "${schema}" CASCADE;`;
+  return { schemaName: schema, dropStatement, statements };
+}
+async function deploySchema(db, def, handlerPath, opts) {
+  validateSubgraphDefinition(def);
+  const { statements, hash } = generateSubgraphSQL(def, opts?.schemaName);
+  const { getSubgraph, registerSubgraph } = await import("@secondlayer/shared/db/queries/subgraphs");
+  const ddlDb = db;
+  const existing = await getSubgraph(db, def.name, opts?.accountId);
+  const schemaName = opts?.schemaName ?? pgSchemaName(def.name);
+  const newVersion = existing ? bumpPatch(existing.version) : "1.0.0";
+  const regData = {
+    name: def.name,
+    version: newVersion,
+    definition: toJsonSafe({
+      name: def.name,
+      description: def.description,
+      startBlock: def.startBlock,
+      sources: def.sources,
+      schema: def.schema
+    }),
+    schemaHash: hash,
+    handlerPath,
+    apiKeyId: opts?.apiKeyId,
+    accountId: opts?.accountId,
+    handlerCode: opts?.handlerCode,
+    sourceCode: opts?.sourceCode,
+    schemaName,
+    startBlock: def.startBlock
+  };
+  if (existing) {
+    const schemaExists = await sql`
+			SELECT EXISTS (
+				SELECT 1 FROM information_schema.schemata
+				WHERE schema_name = ${schemaName}
+			) AS "exists"
+		`.execute(ddlDb).then((r) => r.rows[0]?.exists ?? false);
+    if (!schemaExists) {
+      for (const stmt of statements) {
+        await sql.raw(stmt).execute(ddlDb);
+      }
+      const sg = await registerSubgraph(db, regData);
+      return { action: "reindexed", subgraphId: sg.id, version: newVersion };
+    }
+    if (existing.schema_hash === hash && !opts?.forceReindex) {
+      const handlerChanged = opts?.handlerCode != null && opts.handlerCode !== existing.handler_code;
+      const { updateSubgraphHandlerPath } = await import("@secondlayer/shared/db/queries/subgraphs");
+      await updateSubgraphHandlerPath(db, def.name, handlerPath, {
+        handlerCode: opts?.handlerCode,
+        sourceCode: opts?.sourceCode
+      });
+      return {
+        action: handlerChanged ? "handler_updated" : "unchanged",
+        subgraphId: existing.id,
+        version: existing.version,
+        ...handlerChanged ? {
+          warnings: [
+            "handler changed but schema did not: new logic applies from the current tip only. Rows already indexed were computed by the previous handler. To recompute history, redeploy with --reindex (or backfill a range)."
+          ]
+        } : {}
+      };
+    }
+    if (existing.schema_hash === hash && opts?.forceReindex) {
+      await sql.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(ddlDb);
+      for (const stmt of statements) {
+        await sql.raw(stmt).execute(ddlDb);
+      }
+      const sg = await registerSubgraph(db, regData);
+      return { action: "reindexed", subgraphId: sg.id, version: newVersion };
+    }
+    if (existing.definition.schema) {
+      const diff = diffSchema(existing.definition.schema, def.schema);
+      const { breaking, reasons } = hasBreakingChanges(diff);
+      if (breaking || opts?.forceReindex) {
+        await sql.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(ddlDb);
+        for (const stmt of statements) {
+          await sql.raw(stmt).execute(ddlDb);
+        }
+        const sg = await registerSubgraph(db, regData);
+        const deployDiff = toDeployDiff(diff, reasons);
+        return {
+          action: "reindexed",
+          subgraphId: sg.id,
+          version: newVersion,
+          diff: deployDiff
+        };
+      }
+      const addedDefs = diff.addedTables.map((tableName) => ({ tableName, tableDef: def.schema[tableName] })).filter((t) => t.tableDef !== undefined);
+      if (addedDefs.some(({ tableDef }) => tableNeedsTrgm(tableDef))) {
+        await sql.raw("CREATE EXTENSION IF NOT EXISTS pg_trgm").execute(ddlDb);
+      }
+      for (const { tableName, tableDef } of addedDefs) {
+        for (const stmt of emitTableDDL(schemaName, tableName, tableDef)) {
+          await sql.raw(stmt).execute(ddlDb);
+        }
+      }
+      for (const [tableName, colDiff] of Object.entries(diff.tables)) {
+        if (colDiff.added.length === 0)
+          continue;
+        const qualifiedName = `${schemaName}.${tableName}`;
+        const tableDef = def.schema[tableName];
+        if (!tableDef)
+          continue;
+        for (const colName of colDiff.added) {
+          const col = tableDef.columns[colName];
+          if (!col)
+            continue;
+          const sqlType = TYPE_MAP[col.type];
+          if (!sqlType)
+            continue;
+          const nullable = col.nullable ? "" : ` NOT NULL DEFAULT ${getDefault(col.type)}`;
+          await sql.raw(`ALTER TABLE ${qualifiedName} ADD COLUMN ${colName} ${sqlType}${nullable}`).execute(ddlDb);
+          if (col.indexed) {
+            for (const stmt of emitIndexedColumnIndexDDL(schemaName, tableName, colName).create) {
+              await sql.raw(stmt).execute(ddlDb);
+            }
+          }
+          if (col.search) {
+            await sql.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName}_trgm ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`).execute(ddlDb);
+          }
+        }
+      }
+      const existingSchema = existing.definition.schema;
+      const flagFlips = {};
+      const needsTrgmForFlips = Object.entries(diff.tables).some(([tableName, colDiff]) => colDiff.indexChanged.some((colName) => def.schema[tableName]?.columns[colName]?.search && !existingSchema[tableName]?.columns[colName]?.search));
+      if (needsTrgmForFlips) {
+        await sql.raw("CREATE EXTENSION IF NOT EXISTS pg_trgm").execute(ddlDb);
+      }
+      for (const [tableName, colDiff] of Object.entries(diff.tables)) {
+        if (colDiff.indexChanged.length === 0)
+          continue;
+        flagFlips[tableName] = colDiff.indexChanged;
+        const qualifiedName = `${schemaName}.${tableName}`;
+        for (const colName of colDiff.indexChanged) {
+          const was = existingSchema[tableName]?.columns[colName];
+          const now = def.schema[tableName]?.columns[colName];
+          if (!now)
+            continue;
+          const trgmIdx = `idx_${schemaName}_${tableName}_${colName}_trgm`;
+          const indexedIdx = emitIndexedColumnIndexDDL(schemaName, tableName, colName, { concurrently: true });
+          if (now.indexed && !was?.indexed) {
+            for (const stmt of indexedIdx.create) {
+              await sql.raw(stmt).execute(ddlDb);
+            }
+          } else if (!now.indexed && was?.indexed) {
+            for (const stmt of indexedIdx.drop) {
+              await sql.raw(stmt).execute(ddlDb);
+            }
+          }
+          if (now.search && !was?.search) {
+            await sql.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${trgmIdx} ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`).execute(ddlDb);
+          } else if (!now.search && was?.search) {
+            await sql.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${trgmIdx}`).execute(ddlDb);
+          }
+        }
+      }
+      const addedUq = {};
+      for (const [tableName, conDiff] of Object.entries(diff.constraints)) {
+        const qualifiedName = `${schemaName}.${tableName}`;
+        for (const cols of conDiff.addedUniqueKeys) {
+          const constraintName = `uq_${schemaName}_${tableName}_${cols.join("_")}`;
+          const exists = await sql`
+						SELECT EXISTS (
+							SELECT 1 FROM pg_constraint
+							WHERE conname = ${constraintName}
+						) AS "exists"
+					`.execute(ddlDb).then((r) => r.rows[0]?.exists ?? false);
+          if (!exists) {
+            await sql.raw(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.join(", ")})`).execute(ddlDb);
+          }
+          addedUq[tableName] = [...addedUq[tableName] ?? [], cols];
+        }
+        for (const cols of conDiff.addedIndexes) {
+          const i = (def.schema[tableName]?.indexes ?? []).findIndex((entry) => JSON.stringify(entry) === JSON.stringify(cols));
+          const idxName = `idx_${schemaName}_${tableName}_composite_${i}`;
+          await sql.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.join(", ")})`).execute(ddlDb);
+        }
+        for (const cols of conDiff.removedIndexes) {
+          const i = (existingSchema[tableName]?.indexes ?? []).findIndex((entry) => JSON.stringify(entry) === JSON.stringify(cols));
+          if (i < 0)
+            continue;
+          const idxName = `idx_${schemaName}_${tableName}_composite_${i}`;
+          await sql.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${idxName}`).execute(ddlDb);
+        }
+      }
+      const sg = await registerSubgraph(db, regData);
+      const addedCols = {};
+      for (const [t, colDiff] of Object.entries(diff.tables)) {
+        if (colDiff.added.length > 0)
+          addedCols[t] = colDiff.added;
+      }
+      const deployDiff = {
+        addedTables: diff.addedTables,
+        removedTables: [],
+        addedColumns: addedCols,
+        breakingChanges: [],
+        ...Object.keys(flagFlips).length > 0 ? { indexChanges: flagFlips } : {},
+        ...Object.keys(addedUq).length > 0 ? { addedUniqueKeys: addedUq } : {}
+      };
+      return {
+        action: "updated",
+        subgraphId: sg.id,
+        version: newVersion,
+        diff: deployDiff
+      };
+    }
+  }
+  for (const stmt of statements) {
+    await sql.raw(stmt).execute(ddlDb);
+  }
+  const sg = await registerSubgraph(db, regData);
+  return { action: "created", subgraphId: sg.id, version: newVersion };
+}
+function getDefault(type) {
+  switch (type) {
+    case "text":
+    case "principal":
+      return "''";
+    case "uint":
+    case "int":
+      return "0";
+    case "boolean":
+      return "false";
+    case "timestamp":
+      return "NOW()";
+    case "jsonb":
+      return "'{}'";
+    default:
+      return "''";
+  }
+}
+// src/runtime/block-source.ts
+import { getSourceDb as getSourceDb2 } from "@secondlayer/shared/db";
+import {
+  createInternalIndexHttpClient
+} from "@secondlayer/shared/index-http";
+import { logger as logger2 } from "@secondlayer/shared/logger";
+
+// src/runtime/batch-loader.ts
+function vmEventId(txId, vmEventIndex) {
+  return `${txId}#vm:${vmEventIndex}`;
+}
+async function loadBlockRange(db, fromHeight, toHeight) {
+  const [blocks, txs, events, vmRows] = await Promise.all([
+    db.selectFrom("blocks").selectAll().where("height", ">=", fromHeight).where("height", "<=", toHeight).where("canonical", "=", true).execute(),
+    db.selectFrom("transactions").selectAll().where("block_height", ">=", fromHeight).where("block_height", "<=", toHeight).execute(),
+    db.selectFrom("events").selectAll().where("block_height", ">=", fromHeight).where("block_height", "<=", toHeight).execute(),
+    db.selectFrom("vm_events").selectAll().where("block_height", ">=", fromHeight).where("block_height", "<=", toHeight).orderBy("ordinal", "asc").execute()
+  ]);
+  const txsByHeight = new Map;
+  for (const tx of txs) {
+    const h = Number(tx.block_height);
+    const list = txsByHeight.get(h) ?? [];
+    list.push(tx);
+    txsByHeight.set(h, list);
+  }
+  const eventsByHeight = new Map;
+  for (const evt of events) {
+    const h = Number(evt.block_height);
+    const list = eventsByHeight.get(h) ?? [];
+    list.push(evt);
+    eventsByHeight.set(h, list);
+  }
+  const vmByHeight = new Map;
+  for (const row of vmRows) {
+    const h = Number(row.block_height);
+    const list = vmByHeight.get(h) ?? [];
+    list.push({
+      id: vmEventId(row.tx_id, Number(row.ordinal)),
+      tx_id: row.tx_id,
+      block_height: h,
+      event_index: Number(row.ordinal),
+      type: row.type,
+      data: row.data,
+      created_at: row.created_at,
+      clock: "vm"
+    });
+    vmByHeight.set(h, list);
+  }
+  const result = new Map;
+  for (const block of blocks) {
+    const h = Number(block.height);
+    result.set(h, {
+      block,
+      txs: txsByHeight.get(h) ?? [],
+      events: eventsByHeight.get(h) ?? [],
+      vmEvents: vmByHeight.get(h) ?? []
+    });
+  }
+  return result;
+}
+
+// src/runtime/observer-http-source.ts
+import {
+  VM_NODE_TO_STORED_TYPE
+} from "@secondlayer/shared";
+
+// src/runtime/reconstruct.ts
+function isoToUnixSeconds(iso) {
+  if (!iso)
+    return 0;
+  return Math.floor(new Date(iso).getTime() / 1000);
+}
+function reconstructBlock(b) {
+  return {
+    height: b.block_height,
+    hash: b.block_hash,
+    parent_hash: b.parent_hash,
+    burn_block_height: b.burn_block_height,
+    burn_block_hash: b.burn_block_hash,
+    index_block_hash: b.index_block_hash ?? null,
+    timestamp: isoToUnixSeconds(b.block_time),
+    canonical: true,
+    created_at: new Date(0)
+  };
+}
+function reconstructTransaction(t) {
+  return {
+    tx_id: t.tx_id,
+    block_height: t.block_height,
+    tx_index: t.tx_index,
+    type: t.tx_type,
+    sender: t.sender,
+    status: t.status,
+    contract_id: t.contract_call?.contract_id ?? t.smart_contract?.contract_id ?? null,
+    function_name: t.contract_call?.function_name ?? null,
+    function_args: t.contract_call?.function_args_hex ?? [],
+    raw_result: t.contract_call?.result_hex ?? null,
+    raw_tx: "",
+    created_at: new Date(0)
+  };
+}
+function reconstructTxFromEventRow(e) {
+  return {
+    tx_id: e.tx_id,
+    block_height: e.block_height,
+    tx_index: e.tx_index ?? 0,
+    type: e.tx_type ?? "",
+    sender: e.tx_sender ?? "",
+    status: e.tx_status ?? "success",
+    contract_id: e.tx_contract_id ?? null,
+    function_name: e.tx_function_name ?? null,
+    function_args: [],
+    raw_result: null,
+    raw_tx: "",
+    created_at: new Date(0)
+  };
+}
+function reconstructEvent(e) {
+  const base = {
+    id: `${e.tx_id}#${e.event_index}`,
+    tx_id: e.tx_id,
+    block_height: e.block_height,
+    event_index: e.event_index,
+    created_at: new Date(0)
+  };
+  switch (e.event_type) {
+    case "ft_transfer":
+    case "ft_mint":
+    case "ft_burn":
+      return {
+        ...base,
+        type: `${e.event_type}_event`,
+        data: {
+          asset_identifier: e.asset_identifier,
+          sender: e.sender,
+          recipient: e.recipient,
+          amount: e.amount
+        }
+      };
+    case "nft_transfer":
+    case "nft_mint":
+    case "nft_burn":
+      return {
+        ...base,
+        type: `${e.event_type}_event`,
+        data: {
+          asset_identifier: e.asset_identifier,
+          sender: e.sender,
+          recipient: e.recipient,
+          raw_value: e.value
+        }
+      };
+    case "stx_transfer":
+    case "stx_mint":
+    case "stx_burn":
+      return {
+        ...base,
+        type: `${e.event_type}_event`,
+        data: {
+          sender: e.sender,
+          recipient: e.recipient,
+          amount: e.amount,
+          ...e.event_type === "stx_transfer" ? { memo: e.memo ?? "" } : {}
+        }
+      };
+    case "stx_lock":
+      return {
+        ...base,
+        type: "stx_lock_event",
+        data: {
+          locked_address: e.sender,
+          locked_amount: e.amount,
+          unlock_height: e.payload.unlock_height
+        }
+      };
+    case "print":
+      return {
+        ...base,
+        type: "contract_event",
+        data: {
+          topic: e.payload.topic,
+          contract_id: e.contract_id,
+          value: e.payload.value,
+          raw_value: e.payload.raw_value
+        }
+      };
+    case "nested_contract_call":
+    case "var_set":
+    case "map_set":
+    case "map_insert":
+    case "map_delete":
+      return {
+        ...base,
+        id: vmEventId(e.tx_id, e.event_index),
+        clock: "vm",
+        type: e.event_type,
+        data: {
+          contract_identifier: e.contract_id,
+          ..."payload" in e && e.payload && typeof e.payload === "object" ? e.payload : {},
+          sender: "sender" in e ? e.sender : undefined,
+          caller: "caller" in e ? e.caller : undefined,
+          function_name: "function_name" in e ? e.function_name : undefined,
+          function_args: "function_args" in e ? e.function_args : undefined,
+          raw_result: "raw_result" in e ? e.raw_result : undefined,
+          map_name: "map" in e ? e.map : undefined,
+          var_name: "var_name" in e ? e.var_name : undefined,
+          raw_key: "raw_key" in e ? e.raw_key : undefined,
+          raw_value: "raw_value" in e ? e.raw_value : undefined
+        }
+      };
+  }
+}
+
+// src/runtime/block-source.ts
+function canSparseScan(subgraph) {
+  if (Array.isArray(subgraph.sources))
+    return false;
+  const filters = sourceFilters(subgraph);
+  if (filters.length === 0)
+    return false;
+  return filters.every((f) => Boolean(EVENT_FILTER_TO_INDEX_TYPE[f.type]));
+}
+function sparseProbeTargets(subgraph) {
+  const targets = new Map;
+  for (const f of sourceFilters(subgraph)) {
+    const eventType = EVENT_FILTER_TO_INDEX_TYPE[f.type];
+    if (!eventType)
+      continue;
+    const scoped = f;
+    const contractId = scoped.contractId ?? scoped.assetIdentifier?.split("::")[0];
+    const key = `${eventType}|${contractId ?? ""}`;
+    targets.set(key, { eventType, ...contractId ? { contractId } : {} });
+  }
+  return [...targets.values()];
+}
+
+class PostgresBlockSource {
+  async getTip() {
+    const progress = await getSourceDb2().selectFrom("index_progress").selectAll().where("network", "=", process.env.NETWORK ?? "mainnet").executeTakeFirst();
+    return progress ? Number(progress.highest_seen_block) : 0;
+  }
+  loadBlockRange(fromHeight, toHeight) {
+    return loadBlockRange(getSourceDb2(), fromHeight, toHeight);
+  }
+}
+var EVENT_FILTER_TO_INDEX_TYPE = {
+  stx_transfer: "stx_transfer",
+  stx_mint: "stx_mint",
+  stx_burn: "stx_burn",
+  stx_lock: "stx_lock",
+  ft_transfer: "ft_transfer",
+  ft_mint: "ft_mint",
+  ft_burn: "ft_burn",
+  nft_transfer: "nft_transfer",
+  nft_mint: "nft_mint",
+  nft_burn: "nft_burn",
+  print_event: "print",
+  nested_contract_call: "nested_contract_call",
+  var_set: "var_set",
+  map_set: "map_set",
+  map_insert: "map_insert",
+  map_delete: "map_delete"
+};
+var TX_SOURCE_TYPES = new Set(["contract_call", "contract_deploy"]);
+var VM_INDEX_EVENT_TYPES = new Set([
+  "nested_contract_call",
+  "var_set",
+  "map_set",
+  "map_insert",
+  "map_delete"
+]);
+var CLASSIC_INDEX_EVENT_TYPES = [
+  ...new Set(Object.values(EVENT_FILTER_TO_INDEX_TYPE))
+].filter((t) => !VM_INDEX_EVENT_TYPES.has(t));
+function sourceFilters(subgraph) {
+  const sources = subgraph.sources;
+  return Array.isArray(sources) ? sources : Object.values(sources);
+}
+function synthesizeTxsFromEvents(events) {
+  const byId = new Map;
+  for (const e of events) {
+    if (!byId.has(e.tx_id))
+      byId.set(e.tx_id, reconstructTxFromEventRow(e));
+  }
+  return [...byId.values()];
+}
+function indexEventTypesForFilterTypes(filterTypes) {
+  const types = new Set;
+  if (filterTypes.some((t) => TX_SOURCE_TYPES.has(t))) {
+    for (const t of CLASSIC_INDEX_EVENT_TYPES)
+      types.add(t);
+  }
+  for (const t of filterTypes) {
+    const indexType = EVENT_FILTER_TO_INDEX_TYPE[t];
+    if (indexType)
+      types.add(indexType);
+  }
+  return [...types];
+}
+class PublicApiBlockSource {
+  http;
+  eventTypes;
+  probeTargets;
+  needsTransactions;
+  constructor(http, eventTypes, probeTargets, needsTransactions = true) {
+    this.http = http;
+    this.eventTypes = eventTypes;
+    this.probeTargets = probeTargets;
+    this.needsTransactions = needsTransactions;
+  }
+  async nextDataHeight(afterHeight, untilHeight) {
+    if (!this.probeTargets?.length)
+      return afterHeight + 1;
+    const hits = await Promise.all(this.probeTargets.map((t) => this.http.firstEventHeight(t.eventType, afterHeight + 1, untilHeight, t.contractId)));
+    const found = hits.filter((h) => h !== null);
+    return found.length ? Math.min(...found) : null;
+  }
+  getTip() {
+    if (this.eventTypes.some((t) => VM_INDEX_EVENT_TYPES.has(t))) {
+      return this.http.getIndexSourceTip();
+    }
+    return this.http.getIndexTip();
+  }
+  async loadBlockRange(fromHeight, toHeight) {
+    const withTx = !this.needsTransactions;
+    const [blocks, txRows, eventLists] = await Promise.all([
+      this.http.walkBlocks(fromHeight, toHeight),
+      this.needsTransactions ? this.http.walkTransactions(fromHeight, toHeight) : Promise.resolve([]),
+      Promise.all(this.eventTypes.map((t) => this.http.walkEvents(t, fromHeight, toHeight, withTx)))
+    ]);
+    const map = new Map;
+    for (const b of blocks) {
+      map.set(b.block_height, {
+        block: reconstructBlock(b),
+        txs: [],
+        events: []
+      });
+    }
+    const txs = this.needsTransactions ? txRows.map(reconstructTransaction) : synthesizeTxsFromEvents(eventLists.flat());
+    for (const t of txs) {
+      map.get(t.block_height)?.txs.push(t);
+    }
+    for (const list of eventLists) {
+      for (const e of list) {
+        const bd = map.get(e.block_height);
+        if (!bd)
+          continue;
+        if (VM_INDEX_EVENT_TYPES.has(e.event_type)) {
+          bd.vmEvents ??= [];
+          bd.vmEvents.push(reconstructEvent(e));
+        } else {
+          bd.events.push(reconstructEvent(e));
+        }
+      }
+    }
+    for (const bd of map.values()) {
+      bd.txs.sort((a, b) => a.tx_index - b.tx_index);
+      bd.events.sort((a, b) => a.event_index - b.event_index);
+      bd.vmEvents?.sort((a, b) => a.event_index - b.event_index);
+    }
+    return map;
+  }
+}
+var postgresBlockSource = new PostgresBlockSource;
+function buildHttpClient() {
+  return createInternalIndexHttpClient();
+}
+export {
+  ChainReadError,
+  camelizeKeys,
+  canSparseScan,
+  defineSchema,
+  defineSubgraph,
+  deploySchema,
+  diffSchema,
+  filterFieldsByType,
+  generateDrizzleSchema,
+  generateIndexSchema,
+  generateKyselySchema,
+  generatePrismaSchema,
+  generateSubgraphSQL,
+  hasBreakingChanges,
+  inferPrintTopics,
+  pgSchemaName,
+  readContractAt,
+  renderDeployPlan,
+  sparseProbeTargets,
+  validateSubgraphDefinition
+};
+
+//# debugId=70F01B0F3E28D11B64756E2164756E21
+//# sourceMappingURL=index.js.map