@secondlayer/subgraphs 6.4.0 → 6.5.0

package/dist/runtime/replay.js

@@ -1,9 +1,9 @@
 // src/runtime/replay.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { getTargetDb } from "@secondlayer/shared/db";
 import { getWebhook } from "@secondlayer/shared/db/queries/webhooks";
 import { logger as logger2 } from "@secondlayer/shared/logger";
-import { sql } from "kysely";
+import { sql as sql2 } from "kysely";
 
 // src/schema/utils.ts
 import { pgSchemaName } from "@secondlayer/shared/db/queries/subgraphs";
@@ -28,16 +28,405 @@ import {
 } from "@secondlayer/shared/index-http";
 import { logger } from "@secondlayer/shared/logger";
 
+// src/verification.ts
+import { createHash } from "node:crypto";
+// package.json
+var package_default = {
+  name: "@secondlayer/subgraphs",
+  version: "6.5.0",
+  description: "Describe the Stacks data you want as one TypeScript file; it fills itself and survives reorgs.",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/ryanwaits/secondlayer.git",
+    directory: "packages/subgraphs"
+  },
+  homepage: "https://github.com/ryanwaits/secondlayer/tree/main/packages/subgraphs#readme",
+  type: "module",
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./types": {
+      types: "./dist/types.d.ts",
+      import: "./dist/types.js"
+    },
+    "./schema": {
+      types: "./dist/schema/index.d.ts",
+      import: "./dist/schema/index.js"
+    },
+    "./validate": {
+      types: "./dist/validate.d.ts",
+      import: "./dist/validate.js"
+    },
+    "./verification": {
+      types: "./dist/verification.d.ts",
+      import: "./dist/verification.js"
+    },
+    "./runtime/replay": {
+      types: "./dist/runtime/replay.d.ts",
+      import: "./dist/runtime/replay.js"
+    },
+    "./runtime/emitter": {
+      types: "./dist/runtime/emitter.d.ts",
+      import: "./dist/runtime/emitter.js"
+    },
+    "./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"],
+  scripts: {
+    build: "bunup",
+    dev: "bunup --watch",
+    test: "bun test",
+    typecheck: "tsc --noEmit",
+    prepublishOnly: "bun run build"
+  },
+  dependencies: {
+    "@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: {
+    access: "public"
+  }
+};
+
+// src/verification.ts
+var SUBGRAPHS_RUNTIME = `@secondlayer/subgraphs@${package_default.version}`;
+var FORBIDDEN_GLOBALS = {
+  Date: "wall-clock time differs per run",
+  performance: "timers differ per run",
+  process: "host environment differs per run",
+  fetch: "network reads are not chain inputs",
+  crypto: "randomness differs per run",
+  setTimeout: "scheduling order differs per run",
+  setInterval: "scheduling order differs per run",
+  setImmediate: "scheduling order differs per run",
+  clearTimeout: "scheduling order differs per run",
+  clearInterval: "scheduling order differs per run",
+  queueMicrotask: "scheduling order differs per run",
+  WeakRef: "garbage collection timing differs per run",
+  FinalizationRegistry: "garbage collection timing differs per run",
+  Atomics: "shared memory is not single-threaded",
+  SharedArrayBuffer: "shared memory is not single-threaded",
+  Intl: "locale and time zone data differ per host",
+  Temporal: "locale and time zone data differ per host",
+  eval: "generated code hides inputs from the scan",
+  WebAssembly: "compiled code hides inputs from the scan",
+  ShadowRealm: "a nested realm escapes the allow-list",
+  require: "imports must be bundled into the handler"
+};
+var ALLOWED_GLOBALS = [
+  "undefined",
+  "NaN",
+  "Infinity",
+  "globalThis",
+  "isNaN",
+  "isFinite",
+  "parseInt",
+  "parseFloat",
+  "decodeURI",
+  "decodeURIComponent",
+  "encodeURI",
+  "encodeURIComponent",
+  "escape",
+  "unescape",
+  "Object",
+  "Function",
+  "Array",
+  "Number",
+  "Boolean",
+  "String",
+  "Symbol",
+  "BigInt",
+  "Math",
+  "JSON",
+  "Reflect",
+  "Proxy",
+  "Promise",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "RegExp",
+  "Iterator",
+  "DisposableStack",
+  "AsyncDisposableStack",
+  "Error",
+  "AggregateError",
+  "SuppressedError",
+  "EvalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError",
+  "ArrayBuffer",
+  "DataView",
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Uint16Array",
+  "Int32Array",
+  "Uint32Array",
+  "Float16Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  "TextEncoder",
+  "TextDecoder",
+  "atob",
+  "btoa",
+  "console"
+];
+var ALLOWED_MATH = [
+  "abs",
+  "min",
+  "max",
+  "floor",
+  "ceil",
+  "trunc",
+  "sign",
+  "round",
+  "E",
+  "LN10",
+  "LN2",
+  "LOG10E",
+  "LOG2E",
+  "PI",
+  "SQRT1_2",
+  "SQRT2"
+];
+var LOCALE_METHODS = [
+  "toLocaleString",
+  "toLocaleDateString",
+  "toLocaleTimeString",
+  "toLocaleUpperCase",
+  "toLocaleLowerCase",
+  "localeCompare"
+];
+function formatFinding(f) {
+  return `${f.file}:${f.line}:${f.column} ${f.name}: ${f.reason}`;
+}
+var STATE_SOURCE_TYPES = new Set([
+  "var_set",
+  "map_set",
+  "map_delete"
+]);
+var LEVEL_RANK = { state: 0, events: 1, none: 2 };
+var MAX_LISTED_FINDINGS = 10;
+function deriveVerification(def, findings = []) {
+  let level = "state";
+  const raise = (to) => {
+    if (LEVEL_RANK[to] > LEVEL_RANK[level])
+      level = to;
+  };
+  const reasons = [];
+  for (const [name, source] of Object.entries(def.sources ?? {})) {
+    const filter = source;
+    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`);
+    }
+  }
+  if (def.backfillMode === "concurrent") {
+    raise("none");
+    reasons.push("backfillMode concurrent: tip-first order is not chain order");
+  }
+  if (findings.some((f) => f.kind === "needs-events"))
+    raise("events");
+  for (const f of findings.slice(0, MAX_LISTED_FINDINGS)) {
+    reasons.push(f.kind === "needs-events" ? `${formatFinding(f)} (needs event proofs)` : formatFinding(f));
+  }
+  if (findings.length > MAX_LISTED_FINDINGS) {
+    reasons.push(`…and ${findings.length - MAX_LISTED_FINDINGS} more handler findings`);
+  }
+  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)"
+    ] : []
+  };
+}
+function isDeterminismViolation(v) {
+  return v.level === "state" && v.reasons.length > 0;
+}
+function sha256(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+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 JSON.stringify(fields);
+}
+function computePin(input) {
+  return sha256(pinPreimage(input));
+}
+
 // src/runtime/batch-loader.ts
+import { sql } 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) {
@@ -69,24 +458,265 @@ 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 ? sql`AND (${sql.join(feed.contracts.map((c) => sql`starts_with(key, ${`vm::${c}::`})`), sql` OR `)})` : sql``;
+  const { rows } = await sql`
+		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 {
   VM_NODE_TO_STORED_TYPE
 } from "@secondlayer/shared";
 
+// src/runtime/realm.ts
+import vm from "node:vm";
+class NondeterminismError extends Error {
+  name = "NondeterminismError";
+}
+
+class HandlerReadError extends Error {
+  name = "HandlerReadError";
+}
+function abortsBlock(err) {
+  return err instanceof NondeterminismError || err instanceof HandlerReadError;
+}
+var HOST_GLOBALS = [
+  "ArrayBuffer",
+  "DataView",
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Uint16Array",
+  "Int32Array",
+  "Uint32Array",
+  "Float16Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  "TextEncoder",
+  "TextDecoder",
+  "atob",
+  "btoa"
+];
+function forbid(name, reason) {
+  return () => {
+    throw new NondeterminismError(`${name}: ${reason}`);
+  };
+}
+function createRealm() {
+  const host = globalThis;
+  const sandbox = Object.create(null);
+  for (const name of HOST_GLOBALS) {
+    if (host[name] !== undefined)
+      sandbox[name] = host[name];
+  }
+  const context = vm.createContext(sandbox, {
+    name: "subgraph-handler",
+    codeGeneration: { strings: false, wasm: false }
+  });
+  const g = vm.runInContext("globalThis", context);
+  const allowed = new Set(ALLOWED_GLOBALS);
+  for (const name of Object.getOwnPropertyNames(g)) {
+    if (!allowed.has(name))
+      delete g[name];
+  }
+  for (const [name, reason] of Object.entries(FORBIDDEN_GLOBALS)) {
+    Object.defineProperty(g, name, { get: forbid(name, reason) });
+  }
+  const realmMath = g.Math;
+  const safeMath = {};
+  const allowedMath = new Set(ALLOWED_MATH);
+  for (const key of Object.getOwnPropertyNames(realmMath)) {
+    if (allowedMath.has(key))
+      safeMath[key] = realmMath[key];
+    else
+      Object.defineProperty(safeMath, key, {
+        get: forbid(`Math.${key}`, key === "random" ? "randomness differs per run" : "result is engine-approximated")
+      });
+  }
+  Object.defineProperty(g, "Math", { value: Object.freeze(safeMath) });
+  for (const ctor of ["String", "Number", "BigInt", "Array", "Object"]) {
+    const proto = g[ctor].prototype;
+    for (const method of LOCALE_METHODS) {
+      if (Object.prototype.hasOwnProperty.call(proto, method)) {
+        Object.defineProperty(proto, method, {
+          value: forbid(method, "output depends on the host's locale data")
+        });
+      }
+    }
+  }
+  Object.preventExtensions(g);
+  return context;
+}
+function checkRowValues(where, values) {
+  for (const [col, value] of Object.entries(values)) {
+    checkValue(value, `${where}.${col}`);
+  }
+}
+function checkValue(value, path) {
+  switch (typeof value) {
+    case "number":
+      if (!Number.isSafeInteger(value)) {
+        throw new TypeError(`${path}: ${value} is not a safe integer; verifiable subgraphs store bigint or integers only`);
+      }
+      return;
+    case "function":
+    case "symbol":
+      throw new TypeError(`${path}: a ${typeof value} is not a row value`);
+    case "object":
+      if (value === null || ArrayBuffer.isView(value))
+        return;
+      if (Array.isArray(value)) {
+        value.forEach((v, i) => checkValue(v, `${path}[${i}]`));
+        return;
+      }
+      for (const [k, v] of Object.entries(value))
+        checkValue(v, `${path}.${k}`);
+      return;
+    default:
+      return;
+  }
+}
+function deterministicContext(ctx, schema) {
+  let pendingReads = 0;
+  const knownTable = (table) => {
+    if (!Object.prototype.hasOwnProperty.call(schema, table)) {
+      throw new Error(`Table "${table}" not found in subgraph schema`);
+    }
+  };
+  const guard = (op) => {
+    if (pendingReads > 0) {
+      throw new NondeterminismError(`ctx.${op} while a ctx read is pending: concurrent ctx calls order writes by database latency; await each read before the next call`);
+    }
+  };
+  const read = async (op, run) => {
+    guard(op);
+    pendingReads++;
+    try {
+      return await run();
+    } catch (err) {
+      if (err instanceof NondeterminismError)
+        throw err;
+      throw new HandlerReadError(`ctx.${op} failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    } finally {
+      pendingReads--;
+    }
+  };
+  return {
+    get block() {
+      return ctx.block;
+    },
+    get tx() {
+      return ctx.tx;
+    },
+    get client() {
+      throw new NondeterminismError("ctx.client: contract reads need re-execution proofs");
+    },
+    insert(table, row) {
+      guard("insert");
+      checkRowValues(`insert ${table}`, row);
+      ctx.insert(table, row);
+    },
+    update(table, where, set) {
+      guard("update");
+      checkRowValues(`update ${table}`, where);
+      checkRowValues(`update ${table}`, set);
+      ctx.update(table, where, set);
+    },
+    upsert(table, key, row) {
+      guard("upsert");
+      checkRowValues(`upsert ${table}`, key);
+      checkRowValues(`upsert ${table}`, row);
+      ctx.upsert(table, key, row);
+    },
+    delete(table, where) {
+      guard("delete");
+      ctx.delete(table, where);
+    },
+    increment(table, key, deltas) {
+      guard("increment");
+      checkRowValues(`increment ${table}`, key);
+      checkRowValues(`increment ${table}`, deltas);
+      ctx.increment(table, key, deltas);
+    },
+    findOne: (table, where) => {
+      knownTable(table);
+      return read("findOne", () => ctx.findOne(table, where));
+    },
+    findMany: (table, ...rest) => {
+      knownTable(table);
+      return read("findMany", () => ctx.findMany(table, ...rest));
+    }
+  };
+}
+var realmDefinitions = new WeakSet;
+async function loadDeterministicDefinition(handlerCode) {
+  const { transform } = await import("esbuild");
+  const { code } = await transform(handlerCode, {
+    format: "cjs",
+    loader: "js",
+    logLevel: "silent"
+  });
+  const context = createRealm();
+  const evaluate = vm.runInContext(`(function (module, exports) {
+${code}
+})`, context, { filename: "handler.js" });
+  const mod = { exports: {} };
+  evaluate(mod, mod.exports);
+  const def = mod.exports.default ?? mod.exports;
+  const sources = structuredClone(def.sources);
+  const schema = structuredClone(def.schema);
+  const facades = new WeakMap;
+  const handlers = {};
+  for (const [name, handler] of Object.entries(def.handlers ?? {})) {
+    handlers[name] = (event, ctx) => {
+      let facade = facades.get(ctx);
+      if (!facade) {
+        facade = deterministicContext(ctx, schema);
+        facades.set(ctx, facade);
+      }
+      return handler(event, facade);
+    };
+  }
+  const loaded = { ...def, sources, schema, handlers };
+  realmDefinitions.add(loaded);
+  return loaded;
+}
+
 // src/runtime/reconstruct.ts
 function isoToUnixSeconds(iso) {
   if (!iso)
@@ -282,14 +912,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 getSourceDb().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 getSourceDb().selectFrom("index_progress").selectAll().where("network", "=", process.env.NETWORK ?? "mainnet").executeTakeFirst();
     return progress ? Number(progress.highest_seen_block) : 0;
   }
   loadBlockRange(fromHeight, toHeight) {
-    return loadBlockRange(getSourceDb(), fromHeight, toHeight);
+    return loadBlockRange(getSourceDb(), fromHeight, toHeight, {
+      stateWrites: this.feed
+    });
   }
 }
 var EVENT_FILTER_TO_INDEX_TYPE = {
@@ -375,15 +1030,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 }];
     });
@@ -406,10 +1064,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;
@@ -435,13 +1094,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() {
@@ -1097,7 +1798,7 @@ function __setReplayInFlightForTest(webhookId, inFlight) {
 }
 function replayDedupKey(subgraphName, tableName, row, replayId) {
   const canonical = `replay:${replayId}:${subgraphName}:${tableName}:${stableStringify(row)}`;
-  return createHash("sha256").update(canonical).digest("hex").slice(0, 32);
+  return createHash2("sha256").update(canonical).digest("hex").slice(0, 32);
 }
 function stableStringify(obj) {
   const keys = Object.keys(obj).sort();
@@ -1108,7 +1809,7 @@ function stableStringify(obj) {
 }
 function deterministicReplayId(webhookId, fromBlock, toBlock, suffix) {
   const canonical = `${webhookId}:${fromBlock}:${toBlock}${suffix ? `:${suffix}` : ""}`;
-  return createHash("sha256").update(canonical).digest("hex").slice(0, 16);
+  return createHash2("sha256").update(canonical).digest("hex").slice(0, 16);
 }
 async function resolveSchemaName(db, subgraphName) {
   const row = await db.selectFrom("subgraphs").select("schema_name").where("name", "=", subgraphName).executeTakeFirst();
@@ -1148,12 +1849,12 @@ async function replayWebhook(input) {
     let enqueued = 0;
     let lastId = 0n;
     while (true) {
-      const { rows } = await sql`SELECT * FROM ${sql.raw(`"${schema}"."${tableName}"`)}
-				WHERE _block_height >= ${sql.lit(input.fromBlock)}
-					AND _block_height <= ${sql.lit(input.toBlock)}
-					AND _id > ${sql.lit(lastId)}
+      const { rows } = await sql2`SELECT * FROM ${sql2.raw(`"${schema}"."${tableName}"`)}
+				WHERE _block_height >= ${sql2.lit(input.fromBlock)}
+					AND _block_height <= ${sql2.lit(input.toBlock)}
+					AND _id > ${sql2.lit(lastId)}
 				ORDER BY _id ASC
-				LIMIT ${sql.lit(BATCH_SIZE)}`.execute(db);
+				LIMIT ${sql2.lit(BATCH_SIZE)}`.execute(db);
       if (rows.length === 0)
         break;
       scanned += rows.length;
@@ -1237,5 +1938,5 @@ export {
   replayWebhook
 };
 
-//# debugId=82CDE01A57BAF7CC64756E2164756E21
+//# debugId=AEC33CA4613E4B7264756E2164756E21
 //# sourceMappingURL=replay.js.map