@secondlayer/subgraphs 6.4.0 → 6.5.0

package/dist/index.js

@@ -787,7 +787,7 @@ import { createHash } from "node:crypto";
 // package.json
 var package_default = {
   name: "@secondlayer/subgraphs",
-  version: "6.4.0",
+  version: "6.5.0",
   description: "Describe the Stacks data you want as one TypeScript file; it fills itself and survives reorgs.",
   license: "MIT",
   repository: {
@@ -831,6 +831,10 @@ var package_default = {
     "./testing": {
       types: "./dist/testing/index.d.ts",
       import: "./dist/testing/index.js"
+    },
+    "./verify": {
+      types: "./dist/verify/index.d.ts",
+      import: "./dist/verify/index.js"
     }
   },
   files: ["dist"],
@@ -842,14 +846,16 @@ var package_default = {
     prepublishOnly: "bun run build"
   },
   dependencies: {
-    "@secondlayer/shared": "^11.22.0",
-    "@secondlayer/stacks": "^6.1.0",
+    "@secondlayer/shared": "^11.23.0",
+    "@secondlayer/stacks": "^6.2.0",
+    "@secondlayer/verify": "^0.3.0",
     esbuild: "^0.28.2",
     kysely: "0.28.17",
     zod: "^4.3.6"
   },
   devDependencies: {
     "@types/bun": "latest",
+    bunup: "0.16.32",
     typescript: "^5"
   },
   publishConfig: {
@@ -979,7 +985,6 @@ function formatFinding(f) {
 var STATE_SOURCE_TYPES = new Set([
   "var_set",
   "map_set",
-  "map_insert",
   "map_delete"
 ]);
 var LEVEL_RANK = { state: 0, events: 1, none: 2 };
@@ -996,6 +1001,9 @@ function deriveVerification(def, findings = []) {
     if (filter.trait) {
       raise("none");
       reasons.push(`source "${name}": trait scope needs a proven contract registry`);
+    } else if (filter.type === "map_insert") {
+      raise("events");
+      reasons.push(`map_insert source "${name}": map_insert vs map_set needs event proofs`);
     } else if (!STATE_SOURCE_TYPES.has(filter.type)) {
       raise("events");
       reasons.push(`${filter.type} source "${name}" needs event proofs`);
@@ -1013,14 +1021,12 @@ function deriveVerification(def, findings = []) {
   if (findings.length > MAX_LISTED_FINDINGS) {
     reasons.push(`…and ${findings.length - MAX_LISTED_FINDINGS} more handler findings`);
   }
-  const writesMapInsert = Object.values(def.sources ?? {}).some((s) => s.type === "map_insert");
   return {
     level,
     reasons,
     unproven: reasons.length === 0 ? [
       "tx attribution of writes: event.tx, _tx_id (needs event proofs)",
-      "intermediate writes within a block (needs event proofs)",
-      ...writesMapInsert ? ["map_insert vs map_set (needs event proofs)"] : []
+      "intermediate writes within a block (needs event proofs)"
     ] : []
   };
 }
@@ -1030,15 +1036,18 @@ function isDeterminismViolation(v) {
 function sha256(input) {
   return createHash("sha256").update(input).digest("hex");
 }
-function computePin(input) {
-  const canonical = JSON.stringify({
+function pinPreimage(input) {
+  const fields = {
     handlerHash: sha256(input.handlerCode),
     network: input.network,
     runtime: input.runtime ?? SUBGRAPHS_RUNTIME,
     schemaHash: input.schemaHash,
     startBlock: input.startBlock ?? null
-  });
-  return sha256(canonical);
+  };
+  return JSON.stringify(fields);
+}
+function computePin(input) {
+  return sha256(pinPreimage(input));
 }
 // src/runtime/realm.ts
 import vm from "node:vm";
@@ -1049,6 +1058,9 @@ class NondeterminismError extends Error {
 class HandlerReadError extends Error {
   name = "HandlerReadError";
 }
+function abortsBlock(err) {
+  return err instanceof NondeterminismError || err instanceof HandlerReadError;
+}
 var HOST_GLOBALS = [
   "ArrayBuffer",
   "DataView",
@@ -1220,6 +1232,7 @@ function deterministicContext(ctx, schema) {
     }
   };
 }
+var realmDefinitions = new WeakSet;
 async function loadDeterministicDefinition(handlerCode) {
   const { transform } = await import("esbuild");
   const { code } = await transform(handlerCode, {
@@ -1248,7 +1261,9 @@ ${code}
       return handler(event, facade);
     };
   }
-  return { ...def, sources, schema, handlers };
+  const loaded = { ...def, sources, schema, handlers };
+  realmDefinitions.add(loaded);
+  return loaded;
 }
 // src/schema/generator.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -2000,12 +2015,14 @@ function renderDeployPlan(def, schemaName) {
 async function deploySchema(db, def, handlerPath, opts) {
   validateSubgraphDefinition(def);
   const { statements, hash } = generateSubgraphSQL(def, opts?.schemaName);
-  const pin = opts?.handlerCode != null ? computePin({
+  const pinInput = opts?.handlerCode != null ? {
     schemaHash: hash,
     handlerCode: opts.handlerCode,
     startBlock: def.startBlock,
     network: opts.network ?? process.env.NETWORK ?? "mainnet"
-  }) : null;
+  } : null;
+  const pin = pinInput ? computePin(pinInput) : null;
+  const preimage = pinInput ? pinPreimage(pinInput) : null;
   const identity = pin ? { pin } : {};
   const { getSubgraph, registerSubgraph } = await import("@secondlayer/shared/db/queries/subgraphs");
   const ddlDb = db;
@@ -2031,6 +2048,7 @@ async function deploySchema(db, def, handlerPath, opts) {
     schemaName,
     startBlock: def.startBlock,
     pin,
+    pinPreimage: preimage,
     verification: opts?.verification ?? null
   };
   if (existing) {
@@ -2059,6 +2077,7 @@ async function deploySchema(db, def, handlerPath, opts) {
         handlerCode: opts?.handlerCode,
         sourceCode: opts?.sourceCode,
         pin,
+        pinPreimage: preimage,
         verification: opts?.verification ?? null
       });
       return {
@@ -2263,15 +2282,136 @@ import {
 import { logger as logger2 } from "@secondlayer/shared/logger";
 
 // src/runtime/batch-loader.ts
+import { sql as sql2 } from "kysely";
+
+// src/runtime/state-writes.ts
+var DATA_MAP = "0";
+var VARIABLE = "1";
+var HEX = /^(?:[0-9a-f]{2})+$/;
+function parseStateWriteKey(key) {
+  if (!key.startsWith("vm::"))
+    return null;
+  const parts = key.slice(4).split("::");
+  const [contractId, store] = parts;
+  if (!contractId?.includes("."))
+    return null;
+  if (store === DATA_MAP && parts.length === 4) {
+    const [, , map, rawKey] = parts;
+    if (!map || !rawKey || !HEX.test(rawKey))
+      return null;
+    return { contractId, kind: "map", map, rawKey };
+  }
+  if (store === VARIABLE && parts.length === 3 && parts[2]) {
+    return { contractId, kind: "var", varName: parts[2] };
+  }
+  return null;
+}
+var utf8 = new TextDecoder("utf-8", { fatal: true });
+function storedValue(w) {
+  const h = w.value_hex.startsWith("0x") ? w.value_hex.slice(2) : w.value_hex;
+  const bytes = new Uint8Array(h.length / 2);
+  for (let i = 0;i < bytes.length; i++) {
+    bytes[i] = Number.parseInt(h.slice(i * 2, i * 2 + 2), 16);
+  }
+  let value;
+  try {
+    value = utf8.decode(bytes);
+  } catch {
+    throw new Error(`state write ${w.ordinal} value is not UTF-8 hex`);
+  }
+  value = value.toLowerCase();
+  if (!HEX.test(value)) {
+    throw new Error(`state write ${w.ordinal} value is not a Clarity value`);
+  }
+  return value;
+}
+function writeEvent(w) {
+  const key = parseStateWriteKey(w.key);
+  if (!key)
+    return null;
+  const value = storedValue(w);
+  if (key.kind === "var") {
+    return {
+      type: "var_set",
+      data: {
+        contract_identifier: key.contractId,
+        var_name: key.varName,
+        raw_value: `0x${value}`
+      }
+    };
+  }
+  const base = {
+    contract_identifier: key.contractId,
+    map_name: key.map,
+    raw_key: `0x${key.rawKey}`
+  };
+  if (value === "09")
+    return { type: "map_delete", data: base };
+  if (value.startsWith("0a")) {
+    return {
+      type: "map_set",
+      data: { ...base, raw_value: `0x${value.slice(2)}` }
+    };
+  }
+  throw new Error(`state write ${w.ordinal} map value is neither (some v) nor none`);
+}
+function stateWriteEvents(writes, txByIndex) {
+  const txs = new Map;
+  const vmEvents = [];
+  for (const w of [...writes].sort((a, b) => a.ordinal - b.ordinal)) {
+    const event = writeEvent(w);
+    if (!event)
+      continue;
+    let tx = txs.get(w.tx_index);
+    if (!tx) {
+      if (w.tx_index === null) {
+        tx = { tx_id: "", type: "block", sender: "", status: "success" };
+      } else {
+        const real = txByIndex.get(w.tx_index);
+        if (!real) {
+          throw new Error(`state write ${w.ordinal} names tx_index ${w.tx_index} the block does not have`);
+        }
+        tx = real;
+      }
+      tx = { ...tx, tx_index: 0 };
+      txs.set(w.tx_index, tx);
+    }
+    vmEvents.push({
+      id: vmEventId(tx.tx_id || "block", w.ordinal),
+      tx_id: tx.tx_id,
+      type: event.type,
+      event_index: w.ordinal,
+      data: event.data,
+      clock: "vm"
+    });
+  }
+  return { txs: [...txs.values()], vmEvents };
+}
+
+// src/runtime/batch-loader.ts
+function stateWriteBlocks(writesByHeight, txsByHeight) {
+  const out = new Map;
+  for (const [height, writes] of writesByHeight) {
+    const txByIndex = new Map;
+    for (const tx of txsByHeight.get(height) ?? []) {
+      if (tx.tx_index !== undefined)
+        txByIndex.set(tx.tx_index, tx);
+    }
+    out.set(height, stateWriteEvents(writes, txByIndex));
+  }
+  return out;
+}
 function vmEventId(txId, vmEventIndex) {
   return `${txId}#vm:${vmEventIndex}`;
 }
-async function loadBlockRange(db, fromHeight, toHeight) {
-  const [blocks, txs, events, vmRows] = await Promise.all([
+async function loadBlockRange(db, fromHeight, toHeight, opts = {}) {
+  const feed = opts.stateWrites;
+  const [blocks, txs, events, vmRows, writeRows] = 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()
+    feed ? Promise.resolve([]) : db.selectFrom("vm_events").selectAll().where("block_height", ">=", fromHeight).where("block_height", "<=", toHeight).orderBy("ordinal", "asc").execute(),
+    feed ? loadStateWrites(db, fromHeight, toHeight, feed) : Promise.resolve([])
   ]);
   const txsByHeight = new Map;
   for (const tx of txs) {
@@ -2303,18 +2443,42 @@ async function loadBlockRange(db, fromHeight, toHeight) {
     });
     vmByHeight.set(h, list);
   }
+  const writesByHeight = new Map;
+  for (const row of writeRows) {
+    const h = Number(row.block_height);
+    const list = writesByHeight.get(h) ?? [];
+    list.push({
+      ordinal: Number(row.ordinal),
+      tx_index: row.tx_index === null ? null : Number(row.tx_index),
+      key: row.key,
+      value_hex: row.value_hex
+    });
+    writesByHeight.set(h, list);
+  }
+  const named = stateWriteBlocks(writesByHeight, txsByHeight);
   const result = new Map;
   for (const block of blocks) {
     const h = Number(block.height);
+    const fed = named.get(h);
     result.set(h, {
       block,
-      txs: txsByHeight.get(h) ?? [],
+      txs: feed ? fed?.txs ?? [] : txsByHeight.get(h) ?? [],
       events: eventsByHeight.get(h) ?? [],
-      vmEvents: vmByHeight.get(h) ?? []
+      vmEvents: feed ? fed?.vmEvents ?? [] : vmByHeight.get(h) ?? []
     });
   }
   return result;
 }
+async function loadStateWrites(db, fromHeight, toHeight, feed) {
+  const scope = feed.contracts ? sql2`AND (${sql2.join(feed.contracts.map((c) => sql2`starts_with(key, ${`vm::${c}::`})`), sql2` OR `)})` : sql2``;
+  const { rows } = await sql2`
+		SELECT block_height, ordinal, tx_index, key, value_hex
+		FROM state_writes
+		WHERE block_height >= ${fromHeight} AND block_height <= ${toHeight} ${scope}
+		ORDER BY block_height, ordinal
+	`.execute(db);
+  return rows;
+}
 
 // src/runtime/observer-http-source.ts
 import {
@@ -2516,14 +2680,39 @@ function sparseProbeTargets(subgraph) {
   }
   return targets;
 }
-
+var COVERAGE_TTL_MS = 60000;
+function cachedCoverage(read, ttlMs = COVERAGE_TTL_MS) {
+  let cached;
+  const coverage = () => {
+    const now = Date.now();
+    if (!cached || now - cached.at > ttlMs) {
+      cached = { at: now, value: read().catch(() => null) };
+    }
+    return cached.value;
+  };
+  return Object.assign(coverage, {
+    forget: () => {
+      cached = undefined;
+    }
+  });
+}
+var dbStateWritesCoverage = cachedCoverage(async () => {
+  const row = await getSourceDb2().selectFrom("state_writes").select("block_height").orderBy("block_height", "asc").limit(1).executeTakeFirst();
+  return row ? Number(row.block_height) : null;
+});
 class PostgresBlockSource {
+  feed;
+  constructor(feed) {
+    this.feed = feed;
+  }
   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);
+    return loadBlockRange(getSourceDb2(), fromHeight, toHeight, {
+      stateWrites: this.feed
+    });
   }
 }
 var EVENT_FILTER_TO_INDEX_TYPE = {
@@ -2609,15 +2798,18 @@ class PublicApiBlockSource {
   eventTypes;
   probeTargets;
   needsTransactions;
-  constructor(http, eventTypes, probeTargets, needsTransactions = true) {
+  feed;
+  constructor(http, eventTypes, probeTargets, needsTransactions = true, feed) {
     this.http = http;
     this.eventTypes = eventTypes;
     this.probeTargets = probeTargets;
     this.needsTransactions = needsTransactions;
+    this.feed = feed;
   }
   walkTargets() {
     const scoped = this.needsTransactions ? undefined : this.probeTargets;
-    return this.eventTypes.flatMap((eventType) => {
+    const types = this.feed ? this.eventTypes.filter((t) => !VM_INDEX_EVENT_TYPES.has(t)) : this.eventTypes;
+    return types.flatMap((eventType) => {
       const own = scoped?.filter((t) => t.eventType === eventType);
       return own?.length ? own : [{ eventType }];
     });
@@ -2640,10 +2832,11 @@ class PublicApiBlockSource {
   }
   async loadBlockRange(fromHeight, toHeight) {
     const withTx = !this.needsTransactions;
-    const [blocks, txRows, eventLists] = await Promise.all([
+    const [blocks, txRows, eventLists, writes] = await Promise.all([
       this.http.walkBlocks(fromHeight, toHeight),
       this.needsTransactions ? this.http.walkTransactions(fromHeight, toHeight) : Promise.resolve([]),
-      Promise.all(this.walkTargets().map((t) => this.http.walkEvents(t.eventType, fromHeight, toHeight, withTx, t.contractId)))
+      Promise.all(this.walkTargets().map((t) => this.http.walkEvents(t.eventType, fromHeight, toHeight, withTx, t.contractId))),
+      this.feed ? this.walkWrites(fromHeight, toHeight, this.feed) : null
     ]);
     const events = dedupeEvents(eventLists.flat());
     const map = new Map;
@@ -2669,13 +2862,55 @@ class PublicApiBlockSource {
         bd.events.push(reconstructEvent(e));
       }
     }
+    if (writes) {
+      for (const [height, fed] of writes) {
+        const bd = map.get(height);
+        if (!bd)
+          continue;
+        bd.txs.push(...fed.txs);
+        bd.vmEvents = fed.vmEvents;
+      }
+    }
     for (const bd of map.values()) {
-      bd.txs.sort((a, b) => a.tx_index - b.tx_index);
+      bd.txs.sort((a, b) => (a.tx_index ?? 0) - (b.tx_index ?? 0));
       bd.events.sort((a, b) => a.event_index - b.event_index);
       bd.vmEvents?.sort((a, b) => a.event_index - b.event_index);
     }
     return map;
   }
+  async walkWrites(fromHeight, toHeight, feed) {
+    const walks = await Promise.all((feed.contracts ?? [undefined]).map((c) => this.http.walkStateWrites(fromHeight, toHeight, c)));
+    const writesByHeight = new Map;
+    const txsByHeight = new Map;
+    for (const row of walks.flat()) {
+      const writes = writesByHeight.get(row.block_height) ?? new Map;
+      writes.set(row.ordinal, row);
+      writesByHeight.set(row.block_height, writes);
+      const tx = writeTx(row);
+      if (tx) {
+        const txs = txsByHeight.get(row.block_height) ?? new Map;
+        txs.set(row.tx_index, tx);
+        txsByHeight.set(row.block_height, txs);
+      }
+    }
+    return stateWriteBlocks(new Map([...writesByHeight].map(([h, w]) => [
+      h,
+      [...w.values()].sort((a, b) => a.ordinal - b.ordinal)
+    ])), new Map([...txsByHeight].map(([h, t]) => [h, [...t.values()]])));
+  }
+}
+function writeTx(row) {
+  if (row.tx_index === null || !row.tx_id)
+    return null;
+  return {
+    tx_id: row.tx_id,
+    tx_index: row.tx_index,
+    type: row.tx_type ?? "",
+    sender: row.tx_sender ?? "",
+    status: row.tx_status ?? "",
+    contract_id: row.tx_contract_id ?? null,
+    function_name: row.tx_function_name ?? null
+  };
 }
 var postgresBlockSource = new PostgresBlockSource;
 function buildHttpClient() {
@@ -2713,5 +2948,5 @@ export {
   validateSubgraphDefinition
 };
 
-//# debugId=BDCC478FBE9DE96064756E2164756E21
+//# debugId=411D5E1C7A6D7DEB64756E2164756E21
 //# sourceMappingURL=index.js.map