@secondlayer/cli 19.1.2 → 19.2.0

package/dist/cli.js

@@ -16258,7 +16258,7 @@ var CLARINET_SDK_INSTALL_HINT = "This command needs @stacks/clarinet-sdk. Instal
 var init_clarinet = () => {};
 
 // src/utils/config.ts
-import { randomBytes } from "node:crypto";
+import { randomBytes as randomBytes2 } from "node:crypto";
 import { promises as fs2 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { tmpdir as tmpdir3 } from "node:os";
@@ -16300,7 +16300,7 @@ async function loadConfig(configPath) {
       target: "node18",
       loader: "ts"
     });
-    const tempPath = path.join(tmpdir3(), `secondlayer-config-${randomBytes(4).toString("hex")}.mjs`);
+    const tempPath = path.join(tmpdir3(), `secondlayer-config-${randomBytes2(4).toString("hex")}.mjs`);
     await fs2.writeFile(tempPath, result.code);
     try {
       const fileUrl = pathToFileURL(tempPath).href;
@@ -16442,10 +16442,10 @@ var require_ansis = __commonJS(function(exports, module) {
 });
 
 // ../../node_modules/ansis/index.mjs
-var import__2, Ansis, fg, bg, rgb, bgRgb, hex, bgHex, reset, inverse, hidden, visible, bold2, dim2, italic, underline, strikethrough, black, red2, green2, yellow2, blue2, magenta, cyan2, white, gray, redBright, greenBright, yellowBright, blueBright, magentaBright, cyanBright, whiteBright, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bgGray, bgRedBright, bgGreenBright, bgYellowBright, bgBlueBright, bgMagentaBright, bgCyanBright, bgWhiteBright;
+var import__2, Ansis, fg, bg, rgb, bgRgb, hex2, bgHex, reset, inverse, hidden, visible, bold2, dim2, italic, underline, strikethrough, black, red2, green2, yellow2, blue2, magenta, cyan2, white, gray, redBright, greenBright, yellowBright, blueBright, magentaBright, cyanBright, whiteBright, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bgGray, bgRedBright, bgGreenBright, bgYellowBright, bgBlueBright, bgMagentaBright, bgCyanBright, bgWhiteBright;
 var init_ansis = __esm(() => {
   import__2 = __toESM(require_ansis(), 1);
-  ({ Ansis, fg, bg, rgb, bgRgb, hex, bgHex, reset, inverse, hidden, visible, bold: bold2, dim: dim2, italic, underline, strikethrough, black, red: red2, green: green2, yellow: yellow2, blue: blue2, magenta, cyan: cyan2, white, gray, redBright, greenBright, yellowBright, blueBright, magentaBright, cyanBright, whiteBright, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bgGray, bgRedBright, bgGreenBright, bgYellowBright, bgBlueBright, bgMagentaBright, bgCyanBright, bgWhiteBright } = import__2.default);
+  ({ Ansis, fg, bg, rgb, bgRgb, hex: hex2, bgHex, reset, inverse, hidden, visible, bold: bold2, dim: dim2, italic, underline, strikethrough, black, red: red2, green: green2, yellow: yellow2, blue: blue2, magenta, cyan: cyan2, white, gray, redBright, greenBright, yellowBright, blueBright, magentaBright, cyanBright, whiteBright, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bgGray, bgRedBright, bgGreenBright, bgYellowBright, bgBlueBright, bgMagentaBright, bgCyanBright, bgWhiteBright } = import__2.default);
 });
 
 // ../../node_modules/@antfu/ni/node_modules/package-manager-detector/dist/constants.mjs
@@ -16630,7 +16630,7 @@ var init_dist3 = __esm(() => {
 // ../../node_modules/tinyexec/dist/main.js
 import { createRequire as e } from "module";
 import { spawn as t } from "node:child_process";
-import { delimiter as n, dirname as r, normalize as i, resolve as a2 } from "node:path";
+import { delimiter as n2, dirname as r, normalize as i, resolve as a2 } from "node:path";
 import { cwd as o } from "node:process";
 import { PassThrough as s } from "node:stream";
 import c from "node:readline";
@@ -16649,7 +16649,7 @@ function x(e) {
   return b;
 }
 function S(e, t) {
-  const i = t.value.split(n);
+  const i = t.value.split(n2);
   let o = e;
   let s;
   do {
@@ -16659,7 +16659,7 @@ function S(e, t) {
   } while (o !== s);
   return {
     key: t.key,
-    value: i.join(n)
+    value: i.join(n2)
   };
 }
 function C(e, t) {
@@ -23945,19 +23945,19 @@ class c2 {
   }
 }
 function i2() {
-  return this[n2].next();
+  return this[n3].next();
 }
 function o2(r) {
-  return this[n2].return(r);
+  return this[n3].return(r);
 }
 function h2({ preventCancel: r = false } = {}) {
   const e = this.getReader(), t = new c2(e, r), s = Object.create(u2);
-  return s[n2] = t, s;
+  return s[n3] = t, s;
 }
-var a3, n2, u2;
+var a3, n3, u2;
 var init_asyncIterator = __esm(() => {
   a3 = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {}).prototype);
-  n2 = Symbol();
+  n3 = Symbol();
   Object.defineProperty(i2, "name", { value: "next" });
   Object.defineProperty(o2, "name", { value: "return" });
   u2 = Object.create(a3, {
@@ -29053,13 +29053,13 @@ import { createHash as createHash3 } from "node:crypto";
 import {
   mkdir as mkdir2,
   open,
-  readFile as readFile3,
+  readFile as readFile4,
   stat,
   unlink as unlink3,
   writeFile as writeFile4
 } from "node:fs/promises";
 async function readJsonFile(path) {
-  const text = await readFile3(path, "utf-8");
+  const text = await readFile4(path, "utf-8");
   return JSON.parse(text);
 }
 async function writeTextFile(path, content) {
@@ -29440,7 +29440,7 @@ var init_git_status = () => {};
 
 // ../../node_modules/typescript/lib/typescript.js
 var require_typescript = __commonJS(function(exports, module) {
-  var __dirname = "/Users/ryan/projects/secondlayer/node_modules/typescript/lib", __filename = "/Users/ryan/projects/secondlayer/node_modules/typescript/lib/typescript.js";
+  var __dirname = "/Users/ryan/projects/secondlayer/.claude/worktrees/release/node_modules/typescript/lib", __filename = "/Users/ryan/projects/secondlayer/.claude/worktrees/release/node_modules/typescript/lib/typescript.js";
   /*! *****************************************************************************
   Copyright (c) Microsoft Corporation. All rights reserved.
   Licensed under the Apache License, Version 2.0 (the "License"); you may not use
@@ -198798,6 +198798,9 @@ import {
   generatePrintSchemaSubgraph as generatePrintSchemaSubgraph2,
   generateTraitSubgraph as generateTraitSubgraph2
 } from "@secondlayer/scaffold";
+import {
+  billingPausedCode
+} from "@secondlayer/shared/schemas";
 import { TRAIT_STANDARDS } from "@secondlayer/stacks/clarity";
 function webhookHint(apiUrl, name, firstTable) {
   if (!firstTable || isMerchantUrl(apiUrl))
@@ -199150,6 +199153,10 @@ function formatOperationRange(op) {
     return "whole subgraph";
   return `${op.fromBlock ?? "start"} → ${op.toBlock ?? "tip"}`;
 }
+function formatSubgraphStatus(status, lastError) {
+  const code = billingPausedCode(lastError);
+  return code ? `${status} (paused: ${code.replace(/_/g, " ")})` : status;
+}
 function formatOperationProgress(progress) {
   if (progress === null)
     return "—";
@@ -199668,7 +199675,10 @@ ${data.length} subgraph(s) total`));
       console.log(formatKeyValue([
         ["Name", subgraph.name],
         ["Version", subgraph.version],
-        ["Status", subgraph.status],
+        [
+          "Status",
+          formatSubgraphStatus(subgraph.status, subgraph.health.lastError)
+        ],
         ["Sync", syncDisplay.line],
         [syncDisplay.remainingLabel, syncDisplay.remaining],
         ["Integrity", integrity],
@@ -200238,7 +200248,7 @@ function client() {
     apiKey: resolveDataPlaneKey()
   });
 }
-function fail(action, err) {
+function fail2(action, err) {
   const message = err instanceof Error ? err.message : String(err);
   error(`Failed to ${action}: ${message}`);
   if (/\b403\b/.test(message) || /forbidden/i.test(message)) {
@@ -200291,7 +200301,7 @@ function registerIndexCommand(program) {
         recipient: o.recipient
       }), o.json);
     } catch (err) {
-      fail("list ft transfers", err);
+      fail2("list ft transfers", err);
     }
   });
   rangeFlags(index.command("nft-transfers")).description("List decoded SIP-009 non-fungible-token transfers").option("--sender <principal>", "Filter by sender").option("--recipient <principal>", "Filter by recipient").option("--asset-identifier <id>", "Filter by asset identifier").action(async (o) => {
@@ -200303,7 +200313,7 @@ function registerIndexCommand(program) {
         assetIdentifier: o.assetIdentifier
       }), o.json);
     } catch (err) {
-      fail("list nft transfers", err);
+      fail2("list nft transfers", err);
     }
   });
   rangeFlags(index.command("events")).description("List decoded events by type (stx_*, ft/nft mint/burn, print, …)").option("--event-type <type>", `decoded event type (${VALID_INDEX_TYPES.join(", ")})`).option("--types <type>", "alias for --event-type, ONE value (the Streams spelling)").option("--sender <principal>", "Filter by sender").option("--recipient <principal>", "Filter by recipient").option("--asset-identifier <id>", "Filter by asset identifier").action(async (o) => {
@@ -200316,7 +200326,7 @@ function registerIndexCommand(program) {
         assetIdentifier: o.assetIdentifier
       }), o.json);
     } catch (err) {
-      fail("list events", err);
+      fail2("list events", err);
     }
   });
   rangeFlags(index.command("contract-calls")).description("List decoded contract calls (function, args, result)").option("--function-name <name>", "Filter by called function").option("--sender <principal>", "Filter by caller").action(async (o) => {
@@ -200327,21 +200337,21 @@ function registerIndexCommand(program) {
         sender: o.sender
       }), o.json);
     } catch (err) {
-      fail("list contract calls", err);
+      fail2("list contract calls", err);
     }
   });
   heightFlags(index.command("canonical")).description("List the canonical Stacks block sequence (height + hash)").action(async (o) => {
     try {
       emit(await client().canonical.list(heightParams(o)), o.json);
     } catch (err) {
-      fail("list canonical blocks", err);
+      fail2("list canonical blocks", err);
     }
   });
   const blocks = heightFlags(index.command("blocks")).description("List decoded blocks (run `blocks get <ref>` for one block)").action(async (o) => {
     try {
       emit(await client().blocks.list(heightParams(o)), o.json);
     } catch (err) {
-      fail("list blocks", err);
+      fail2("list blocks", err);
     }
   });
   blocks.command("get <ref>").description("Get a single block by height or block hash").option("--json", "Print as JSON").action(async (ref, o) => {
@@ -200349,7 +200359,7 @@ function registerIndexCommand(program) {
       const block = await client().blocks.get(/^\d+$/.test(ref) ? Number.parseInt(ref, 10) : ref);
       emitOne(block, `block ${ref}`, o.json);
     } catch (err) {
-      fail("get block", err);
+      fail2("get block", err);
     }
   });
   const transactions = rangeFlags(index.command("transactions")).description("List decoded transactions (run `transactions get <txId>` for one)").option("--type <type>", "Filter by transaction type").option("--sender <principal>", "Filter by sender").action(async (o) => {
@@ -200360,14 +200370,14 @@ function registerIndexCommand(program) {
         sender: o.sender
       }), o.json);
     } catch (err) {
-      fail("list transactions", err);
+      fail2("list transactions", err);
     }
   });
   transactions.command("get <txId>").description("Get a single transaction by tx_id").option("--json", "Print as JSON").action(async (txId, o) => {
     try {
       emitOne(await client().transactions.get(txId), `tx ${txId}`, o.json);
     } catch (err) {
-      fail("get transaction", err);
+      fail2("get transaction", err);
     }
   });
   heightFlags(index.command("stacking")).description("List decoded PoX-4 stacking actions").option("--function-name <name>", "Filter by PoX function name").option("--stacker <principal>", "Filter by stacker").option("--caller <principal>", "Filter by caller").action(async (o) => {
@@ -200379,7 +200389,7 @@ function registerIndexCommand(program) {
         caller: o.caller
       }), o.json);
     } catch (err) {
-      fail("list stacking actions", err);
+      fail2("list stacking actions", err);
     }
   });
   const mempool = index.command("mempool").description("List pending mempool transactions (run `mempool get <txId>` for one)").option("--contract-id <id>", "Filter to pending calls to a contract").option("--function-name <name>", "Filter to pending calls to a function").option("--sender <principal>", "Filter by sender").option("--type <type>", "Filter by transaction type").option("--cursor <cursor>", "Resume token from a previous next_cursor").option("--limit <n>", "Rows per page").option("--json", "Print the full envelope as JSON").action(async (o) => {
@@ -200393,14 +200403,14 @@ function registerIndexCommand(program) {
         limit: o.limit ? Number.parseInt(o.limit, 10) : undefined
       }), o.json);
     } catch (err) {
-      fail("list mempool", err);
+      fail2("list mempool", err);
     }
   });
   mempool.command("get <txId>").description("Get a single pending transaction by tx_id (404 once mined)").option("--json", "Print as JSON").action(async (txId, o) => {
     try {
       emitOne(await client().mempool.get(txId), `pending tx ${txId}`, o.json);
     } catch (err) {
-      fail("get mempool tx", err);
+      fail2("get mempool tx", err);
     }
   });
 }
@@ -201459,10 +201469,10 @@ function Connection(options, queues = {}, { onopen = noop5, onend = noop5, onclo
   async function SASLContinue(x) {
     const res = x.toString("utf8", 9).split(",").reduce((acc, x) => (acc[x[0]] = x.slice(2), acc), {});
     const saltedPassword = await crypto2.pbkdf2Sync(await Pass(), Buffer.from(res.s, "base64"), parseInt(res.i), 32, "sha256");
-    const clientKey = await hmac(saltedPassword, "Client Key");
+    const clientKey = await hmac2(saltedPassword, "Client Key");
     const auth = "n=*,r=" + nonce + "," + "r=" + res.r + ",s=" + res.s + ",i=" + res.i + ",c=biws,r=" + res.r;
-    serverSignature = (await hmac(await hmac(saltedPassword, "Server Key"), auth)).toString("base64");
-    const payload = "c=biws,r=" + res.r + ",p=" + xor(clientKey, Buffer.from(await hmac(await sha256(clientKey), auth))).toString("base64");
+    serverSignature = (await hmac2(await hmac2(saltedPassword, "Server Key"), auth)).toString("base64");
+    const payload = "c=biws,r=" + res.r + ",p=" + xor(clientKey, Buffer.from(await hmac2(await sha2562(clientKey), auth))).toString("base64");
     write(bytes_default().p().str(payload).end());
   }
   function SASLFinal(x) {
@@ -201681,10 +201691,10 @@ function parseError(x) {
 function md5(x) {
   return crypto2.createHash("md5").update(x).digest("hex");
 }
-function hmac(key, x) {
+function hmac2(key, x) {
   return crypto2.createHmac("sha256", key).update(x).digest();
 }
-function sha256(x) {
+function sha2562(x) {
   return crypto2.createHash("sha256").update(x).digest();
 }
 function xor(a, b) {
@@ -202516,7 +202526,7 @@ var {
 // package.json
 var package_default = {
   name: "@secondlayer/cli",
-  version: "19.1.2",
+  version: "19.2.0",
   description: "Run a Stacks index on your own hardware — set it up, restore verified history, and keep it current.",
   repository: {
     type: "git",
@@ -202555,10 +202565,10 @@ var package_default = {
     "@inquirer/prompts": "^8.2.0",
     "@secondlayer/bundler": "^0.6.1",
     "@secondlayer/scaffold": "^1.6.1",
-    "@secondlayer/sdk": "^14.2.0",
-    "@secondlayer/shared": "^11.19.2",
+    "@secondlayer/sdk": "^14.3.0",
+    "@secondlayer/shared": "^11.20.0",
     "@secondlayer/stacks": "^6.1.1",
-    "@secondlayer/subgraphs": "^6.3.5",
+    "@secondlayer/subgraphs": "^6.3.6",
     esbuild: "^0.28.2",
     "smol-toml": "^1.8.0",
     zod: "^4.3.6"
@@ -202573,6 +202583,7 @@ var package_default = {
   },
   devDependencies: {
     "@antfu/ni": "^24.4.0",
+    "@secondlayer/verify": "workspace:*",
     "@stacks/clarinet-sdk": "3.21.1",
     "@types/bun": "^1.1.14",
     chalk: "^5.3.0",
@@ -203990,6 +204001,4288 @@ import {
 import { getDb as getDb3 } from "@secondlayer/shared/db";
 init_output();
 init_resolve_auth();
+
+// src/commands/verify-block.ts
+import { readFile as readFile3 } from "node:fs/promises";
+
+// ../../node_modules/@noble/hashes/utils.js
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function anumber(n, title = "") {
+  if (!Number.isSafeInteger(n) || n < 0) {
+    const prefix = title && `"${title}" `;
+    throw new Error(`${prefix}expected integer >= 0, got ${n}`);
+  }
+}
+function abytes(value, length, title = "") {
+  const bytes = isBytes(value);
+  const len = value?.length;
+  const needsLen = length !== undefined;
+  if (!bytes || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+  }
+  return value;
+}
+function ahash(h) {
+  if (typeof h !== "function" || typeof h.create !== "function")
+    throw new Error("Hash must wrapped by utils.createHasher");
+  anumber(h.outputLen);
+  anumber(h.blockLen);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out, undefined, "digestInto() output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error('"digestInto() output" expected to be of length >=' + min);
+  }
+}
+function clean(...arrays) {
+  for (let i = 0;i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+function rotl(word, shift) {
+  return word << shift | word >>> 32 - shift >>> 0;
+}
+var hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
+var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  abytes(bytes);
+  if (hasHexBuiltin)
+    return bytes.toHex();
+  let hex = "";
+  for (let i = 0;i < bytes.length; i++) {
+    hex += hexes[bytes[i]];
+  }
+  return hex;
+}
+var asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function asciiToBase16(ch) {
+  if (ch >= asciis._0 && ch <= asciis._9)
+    return ch - asciis._0;
+  if (ch >= asciis.A && ch <= asciis.F)
+    return ch - (asciis.A - 10);
+  if (ch >= asciis.a && ch <= asciis.f)
+    return ch - (asciis.a - 10);
+  return;
+}
+function hexToBytes(hex) {
+  if (typeof hex !== "string")
+    throw new Error("hex string expected, got " + typeof hex);
+  if (hasHexBuiltin)
+    return Uint8Array.fromHex(hex);
+  const hl = hex.length;
+  const al = hl / 2;
+  if (hl % 2)
+    throw new Error("hex string expected, got unpadded hex of length " + hl);
+  const array = new Uint8Array(al);
+  for (let ai = 0, hi = 0;ai < al; ai++, hi += 2) {
+    const n1 = asciiToBase16(hex.charCodeAt(hi));
+    const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+    if (n1 === undefined || n2 === undefined) {
+      const char = hex[hi] + hex[hi + 1];
+      throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+    }
+    array[ai] = n1 * 16 + n2;
+  }
+  return array;
+}
+function concatBytes(...arrays) {
+  let sum = 0;
+  for (let i = 0;i < arrays.length; i++) {
+    const a = arrays[i];
+    abytes(a);
+    sum += a.length;
+  }
+  const res = new Uint8Array(sum);
+  for (let i = 0, pad = 0;i < arrays.length; i++) {
+    const a = arrays[i];
+    res.set(a, pad);
+    pad += a.length;
+  }
+  return res;
+}
+function createHasher(hashCons, info = {}) {
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(undefined);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+function randomBytes(bytesLength = 32) {
+  const cr = typeof globalThis === "object" ? globalThis.crypto : null;
+  if (typeof cr?.getRandomValues !== "function")
+    throw new Error("crypto.getRandomValues must be defined");
+  return cr.getRandomValues(new Uint8Array(bytesLength));
+}
+var oidNist = (suffix) => ({
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+});
+
+// ../../node_modules/@noble/hashes/_md.js
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+
+class HashMD {
+  blockLen;
+  outputLen;
+  padOffset;
+  isLE;
+  buffer;
+  view;
+  finished = false;
+  length = 0;
+  pos = 0;
+  destroyed = false;
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0;pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (;blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos;i < blockLen; i++)
+      buffer[i] = 0;
+    view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0;i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to ||= new this.constructor;
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// ../../node_modules/@noble/hashes/_u64.js
+var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+var _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+  const len = lst.length;
+  let Ah = new Uint32Array(len);
+  let Al = new Uint32Array(len);
+  for (let i = 0;i < len; i++) {
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
+  }
+  return [Ah, Al];
+}
+var shrSH = (h, _l, s) => h >>> s;
+var shrSL = (h, l, s) => h << 32 - s | l >>> s;
+var rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+var rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+function add(Ah, Al, Bh, Bl) {
+  const l = (Al >>> 0) + (Bl >>> 0);
+  return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
+}
+var add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+var add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+
+// ../../node_modules/@noble/hashes/sha2.js
+var SHA256_K = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+
+class SHA2_32B extends HashMD {
+  constructor(outputLen) {
+    super(64, outputLen, 8, false);
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0;i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16;i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0;i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+}
+
+class _SHA256 extends SHA2_32B {
+  A = SHA256_IV[0] | 0;
+  B = SHA256_IV[1] | 0;
+  C = SHA256_IV[2] | 0;
+  D = SHA256_IV[3] | 0;
+  E = SHA256_IV[4] | 0;
+  F = SHA256_IV[5] | 0;
+  G = SHA256_IV[6] | 0;
+  H = SHA256_IV[7] | 0;
+  constructor() {
+    super(32);
+  }
+}
+var K512 = /* @__PURE__ */ (() => split([
+  "0x428a2f98d728ae22",
+  "0x7137449123ef65cd",
+  "0xb5c0fbcfec4d3b2f",
+  "0xe9b5dba58189dbbc",
+  "0x3956c25bf348b538",
+  "0x59f111f1b605d019",
+  "0x923f82a4af194f9b",
+  "0xab1c5ed5da6d8118",
+  "0xd807aa98a3030242",
+  "0x12835b0145706fbe",
+  "0x243185be4ee4b28c",
+  "0x550c7dc3d5ffb4e2",
+  "0x72be5d74f27b896f",
+  "0x80deb1fe3b1696b1",
+  "0x9bdc06a725c71235",
+  "0xc19bf174cf692694",
+  "0xe49b69c19ef14ad2",
+  "0xefbe4786384f25e3",
+  "0x0fc19dc68b8cd5b5",
+  "0x240ca1cc77ac9c65",
+  "0x2de92c6f592b0275",
+  "0x4a7484aa6ea6e483",
+  "0x5cb0a9dcbd41fbd4",
+  "0x76f988da831153b5",
+  "0x983e5152ee66dfab",
+  "0xa831c66d2db43210",
+  "0xb00327c898fb213f",
+  "0xbf597fc7beef0ee4",
+  "0xc6e00bf33da88fc2",
+  "0xd5a79147930aa725",
+  "0x06ca6351e003826f",
+  "0x142929670a0e6e70",
+  "0x27b70a8546d22ffc",
+  "0x2e1b21385c26c926",
+  "0x4d2c6dfc5ac42aed",
+  "0x53380d139d95b3df",
+  "0x650a73548baf63de",
+  "0x766a0abb3c77b2a8",
+  "0x81c2c92e47edaee6",
+  "0x92722c851482353b",
+  "0xa2bfe8a14cf10364",
+  "0xa81a664bbc423001",
+  "0xc24b8b70d0f89791",
+  "0xc76c51a30654be30",
+  "0xd192e819d6ef5218",
+  "0xd69906245565a910",
+  "0xf40e35855771202a",
+  "0x106aa07032bbd1b8",
+  "0x19a4c116b8d2d0c8",
+  "0x1e376c085141ab53",
+  "0x2748774cdf8eeb99",
+  "0x34b0bcb5e19b48a8",
+  "0x391c0cb3c5c95a63",
+  "0x4ed8aa4ae3418acb",
+  "0x5b9cca4f7763e373",
+  "0x682e6ff3d6b2b8a3",
+  "0x748f82ee5defb2fc",
+  "0x78a5636f43172f60",
+  "0x84c87814a1f0ab72",
+  "0x8cc702081a6439ec",
+  "0x90befffa23631e28",
+  "0xa4506cebde82bde9",
+  "0xbef9a3f7b2c67915",
+  "0xc67178f2e372532b",
+  "0xca273eceea26619c",
+  "0xd186b8c721c0c207",
+  "0xeada7dd6cde0eb1e",
+  "0xf57d4f7fee6ed178",
+  "0x06f067aa72176fba",
+  "0x0a637dc5a2c898a6",
+  "0x113f9804bef90dae",
+  "0x1b710b35131c471b",
+  "0x28db77f523047d84",
+  "0x32caab7b40c72493",
+  "0x3c9ebe0a15c9bebc",
+  "0x431d67c49c100d4c",
+  "0x4cc5d4becb3e42b6",
+  "0x597f299cfc657e2a",
+  "0x5fcb6fab3ad6faec",
+  "0x6c44198c4a475817"
+].map((n) => BigInt(n))))();
+var SHA512_Kh = /* @__PURE__ */ (() => K512[0])();
+var SHA512_Kl = /* @__PURE__ */ (() => K512[1])();
+var SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
+var SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
+
+class SHA2_64B extends HashMD {
+  constructor(outputLen) {
+    super(128, outputLen, 16, false);
+  }
+  get() {
+    const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+    return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
+  }
+  set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+    this.Ah = Ah | 0;
+    this.Al = Al | 0;
+    this.Bh = Bh | 0;
+    this.Bl = Bl | 0;
+    this.Ch = Ch | 0;
+    this.Cl = Cl | 0;
+    this.Dh = Dh | 0;
+    this.Dl = Dl | 0;
+    this.Eh = Eh | 0;
+    this.El = El | 0;
+    this.Fh = Fh | 0;
+    this.Fl = Fl | 0;
+    this.Gh = Gh | 0;
+    this.Gl = Gl | 0;
+    this.Hh = Hh | 0;
+    this.Hl = Hl | 0;
+  }
+  process(view, offset) {
+    for (let i = 0;i < 16; i++, offset += 4) {
+      SHA512_W_H[i] = view.getUint32(offset);
+      SHA512_W_L[i] = view.getUint32(offset += 4);
+    }
+    for (let i = 16;i < 80; i++) {
+      const W15h = SHA512_W_H[i - 15] | 0;
+      const W15l = SHA512_W_L[i - 15] | 0;
+      const s0h = rotrSH(W15h, W15l, 1) ^ rotrSH(W15h, W15l, 8) ^ shrSH(W15h, W15l, 7);
+      const s0l = rotrSL(W15h, W15l, 1) ^ rotrSL(W15h, W15l, 8) ^ shrSL(W15h, W15l, 7);
+      const W2h = SHA512_W_H[i - 2] | 0;
+      const W2l = SHA512_W_L[i - 2] | 0;
+      const s1h = rotrSH(W2h, W2l, 19) ^ rotrBH(W2h, W2l, 61) ^ shrSH(W2h, W2l, 6);
+      const s1l = rotrSL(W2h, W2l, 19) ^ rotrBL(W2h, W2l, 61) ^ shrSL(W2h, W2l, 6);
+      const SUMl = add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+      const SUMh = add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
+      SHA512_W_H[i] = SUMh | 0;
+      SHA512_W_L[i] = SUMl | 0;
+    }
+    let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+    for (let i = 0;i < 80; i++) {
+      const sigma1h = rotrSH(Eh, El, 14) ^ rotrSH(Eh, El, 18) ^ rotrBH(Eh, El, 41);
+      const sigma1l = rotrSL(Eh, El, 14) ^ rotrSL(Eh, El, 18) ^ rotrBL(Eh, El, 41);
+      const CHIh = Eh & Fh ^ ~Eh & Gh;
+      const CHIl = El & Fl ^ ~El & Gl;
+      const T1ll = add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+      const T1h = add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+      const T1l = T1ll | 0;
+      const sigma0h = rotrSH(Ah, Al, 28) ^ rotrBH(Ah, Al, 34) ^ rotrBH(Ah, Al, 39);
+      const sigma0l = rotrSL(Ah, Al, 28) ^ rotrBL(Ah, Al, 34) ^ rotrBL(Ah, Al, 39);
+      const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
+      const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
+      Hh = Gh | 0;
+      Hl = Gl | 0;
+      Gh = Fh | 0;
+      Gl = Fl | 0;
+      Fh = Eh | 0;
+      Fl = El | 0;
+      ({ h: Eh, l: El } = add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+      Dh = Ch | 0;
+      Dl = Cl | 0;
+      Ch = Bh | 0;
+      Cl = Bl | 0;
+      Bh = Ah | 0;
+      Bl = Al | 0;
+      const All = add3L(T1l, sigma0l, MAJl);
+      Ah = add3H(All, T1h, sigma0h, MAJh);
+      Al = All | 0;
+    }
+    ({ h: Ah, l: Al } = add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+    ({ h: Bh, l: Bl } = add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+    ({ h: Ch, l: Cl } = add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+    ({ h: Dh, l: Dl } = add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+    ({ h: Eh, l: El } = add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+    ({ h: Fh, l: Fl } = add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+    ({ h: Gh, l: Gl } = add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+    ({ h: Hh, l: Hl } = add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+    this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+  }
+  roundClean() {
+    clean(SHA512_W_H, SHA512_W_L);
+  }
+  destroy() {
+    clean(this.buffer);
+    this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+}
+var T256_IV = /* @__PURE__ */ Uint32Array.from([
+  573645204,
+  4230739756,
+  2673172387,
+  3360449730,
+  596883563,
+  1867755857,
+  2520282905,
+  1497426621,
+  2519219938,
+  2827943907,
+  3193839141,
+  1401305490,
+  721525244,
+  746961066,
+  246885852,
+  2177182882
+]);
+class _SHA512_256 extends SHA2_64B {
+  Ah = T256_IV[0] | 0;
+  Al = T256_IV[1] | 0;
+  Bh = T256_IV[2] | 0;
+  Bl = T256_IV[3] | 0;
+  Ch = T256_IV[4] | 0;
+  Cl = T256_IV[5] | 0;
+  Dh = T256_IV[6] | 0;
+  Dl = T256_IV[7] | 0;
+  Eh = T256_IV[8] | 0;
+  El = T256_IV[9] | 0;
+  Fh = T256_IV[10] | 0;
+  Fl = T256_IV[11] | 0;
+  Gh = T256_IV[12] | 0;
+  Gl = T256_IV[13] | 0;
+  Hh = T256_IV[14] | 0;
+  Hl = T256_IV[15] | 0;
+  constructor() {
+    super(32);
+  }
+}
+var sha256 = /* @__PURE__ */ createHasher(() => new _SHA256, /* @__PURE__ */ oidNist(1));
+var sha512_256 = /* @__PURE__ */ createHasher(() => new _SHA512_256, /* @__PURE__ */ oidNist(6));
+
+// ../verify/src/bytes.ts
+var hex = (b) => bytesToHex(b);
+var unhex = (s) => hexToBytes(s.startsWith("0x") ? s.slice(2) : s);
+var concat = (parts) => concatBytes(...parts);
+var bytesEqual = (a, b) => {
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0;i < a.length; i++)
+    if (a[i] !== b[i])
+      return false;
+  return true;
+};
+var hashAll = (parts) => {
+  const h = sha512_256.create();
+  for (const p of parts)
+    h.update(p);
+  return h.digest();
+};
+
+class Reader {
+  buf;
+  pos = 0;
+  constructor(buf) {
+    this.buf = buf;
+  }
+  bytes(n) {
+    if (n < 0 || this.pos + n > this.buf.length)
+      throw new Error(`unexpected end of input at ${this.pos} reading ${n}`);
+    const out = this.buf.subarray(this.pos, this.pos + n);
+    this.pos += n;
+    return out;
+  }
+  view(n) {
+    const b = this.bytes(n);
+    return new DataView(b.buffer, b.byteOffset, n);
+  }
+  u8 = () => this.bytes(1)[0];
+  u16 = () => this.view(2).getUint16(0);
+  u32 = () => this.view(4).getUint32(0);
+  u64 = () => this.view(8).getBigUint64(0);
+  i64 = () => this.view(8).getBigInt64(0);
+  vec(item, max) {
+    const n = this.u32();
+    if (n > max)
+      throw new Error(`vec length ${n} exceeds ${max}`);
+    return Array.from({ length: n }, item);
+  }
+  get done() {
+    return this.pos === this.buf.length;
+  }
+}
+// ../verify/src/header.ts
+var NAKAMOTO_BLOCK_VERSION_EPOCH_4 = 1;
+var MAX_SIGNERS = 4000;
+var MAX_PROBLEMATIC_TXS = 1 << 16;
+function parseNakamotoHeader(raw) {
+  const r = new Reader(raw);
+  const version = r.u8();
+  const chainLength = r.u64();
+  const burnSpent = r.u64();
+  const consensusHash = r.bytes(20);
+  const parentBlockId = r.bytes(32);
+  const txMerkleRoot = r.bytes(32);
+  const stateIndexRoot = r.bytes(32);
+  const timestamp = r.u64();
+  const minerSignature = r.bytes(65);
+  const sigStart = r.pos;
+  const signerSignatures = r.vec(() => r.bytes(65), MAX_SIGNERS);
+  const sigEnd = r.pos;
+  const bits = r.u16();
+  if (bits === 0 || bits > MAX_SIGNERS)
+    throw new Error(`bad pox_treatment length ${bits}`);
+  const bitBytes = Math.ceil(bits / 8);
+  if (r.u32() !== bitBytes)
+    throw new Error("bad pox_treatment data length");
+  r.bytes(bitBytes);
+  if ((version & 127) >= NAKAMOTO_BLOCK_VERSION_EPOCH_4) {
+    r.vec(() => r.bytes(5), MAX_PROBLEMATIC_TXS);
+  }
+  const end = r.pos;
+  return {
+    version,
+    chainLength,
+    burnSpent,
+    consensusHash,
+    parentBlockId,
+    txMerkleRoot,
+    stateIndexRoot,
+    timestamp,
+    minerSignature,
+    signerSignatures,
+    signerSighashPreimage: concat([
+      raw.subarray(0, sigStart),
+      raw.subarray(sigEnd, end)
+    ]),
+    byteLength: end
+  };
+}
+var signerSignatureHash = (h) => sha512_256(h.signerSighashPreimage);
+var blockId = (h) => hashAll([signerSignatureHash(h), h.consensusHash]);
+// ../verify/src/marf.ts
+var MARF_VALUE_SIZE = 40;
+var NodeId = {
+  Empty: 0,
+  Leaf: 1,
+  Node4: 2,
+  Node16: 3,
+  Node48: 4,
+  Node256: 5
+};
+var NODE_PTR_COUNT = {
+  [NodeId.Node4]: 4,
+  [NodeId.Node16]: 16,
+  [NodeId.Node48]: 48,
+  [NodeId.Node256]: 256
+};
+var isBackptr = (id) => (id & 128) !== 0;
+var marfPath = (key) => sha512_256(new TextEncoder().encode(key));
+function marfValue(value) {
+  const v = new Uint8Array(MARF_VALUE_SIZE);
+  v.set(sha512_256(new TextEncoder().encode(value)));
+  return v;
+}
+function pathPreimage(path) {
+  if (path.length > 32)
+    throw new Error("trie path longer than 32 bytes");
+  return concat([Uint8Array.of(path.length), path]);
+}
+var leafHash = (path, value) => hashAll([Uint8Array.of(NodeId.Leaf), pathPreimage(path), value]);
+function nodeHash(node, children) {
+  const parts = [Uint8Array.of(node.id)];
+  for (const p of node.ptrs)
+    parts.push(Uint8Array.of(p.id, p.chr), p.backBlock);
+  parts.push(pathPreimage(node.path), ...children);
+  return hashAll(parts);
+}
+var PROOF_KIND = [
+  "Node4",
+  "Node16",
+  "Node48",
+  "Node256",
+  "Leaf",
+  "Shunt"
+];
+var KIND_PTRS = {
+  Node4: 4,
+  Node16: 16,
+  Node48: 48,
+  Node256: 256
+};
+function decodeProof(bytes) {
+  const r = new Reader(bytes);
+  const hash = () => r.bytes(32);
+  const steps = r.vec(() => {
+    const kind = PROOF_KIND[r.u8()];
+    if (!kind)
+      throw new Error("bad proof step type");
+    if (kind === "Shunt")
+      return { kind, idx: r.i64(), hashes: r.vec(hash, 1 << 20) };
+    const chr = r.u8();
+    if (kind === "Leaf")
+      return {
+        kind,
+        chr,
+        path: r.bytes(r.u32()),
+        value: r.bytes(MARF_VALUE_SIZE)
+      };
+    const node = {
+      id: r.u8(),
+      path: r.bytes(r.u32()),
+      ptrs: r.vec(() => ({ id: r.u8(), chr: r.u8(), backBlock: r.bytes(32) }), 256)
+    };
+    const hashes = Array.from({ length: KIND_PTRS[kind] - 1 }, hash);
+    return { kind, chr, node, hashes };
+  }, 1 << 20);
+  if (!r.done)
+    throw new Error("trailing bytes after proof");
+  return steps;
+}
+var isShunt = (s) => s?.kind === "Shunt";
+var segmentEnd = (p, i) => {
+  let j = i + 1;
+  while (j < p.length && !isShunt(p[j]))
+    j++;
+  return j;
+};
+function segmentProofHash(step, childHash) {
+  const count = KIND_PTRS[step.kind];
+  if (step.node.ptrs.length !== count)
+    return null;
+  const all = [];
+  let ih = 0;
+  for (const p of step.node.ptrs) {
+    if (p.id !== NodeId.Empty && p.chr === step.chr)
+      all.push(childHash);
+    else {
+      const h = step.hashes[ih++];
+      if (!h)
+        return null;
+      all.push(h);
+    }
+  }
+  return all.length === count ? nodeHash(step.node, all) : null;
+}
+function verifySegment(seg, start) {
+  let h = start;
+  for (const s of seg) {
+    if (s.kind === "Shunt" || !h)
+      return null;
+    h = s.kind === "Leaf" ? leafHash(s.path, s.value) : segmentProofHash(s, h);
+  }
+  return h;
+}
+function segmentPathPrefix(seg) {
+  const parts = [];
+  for (const s of seg) {
+    if (s.kind === "Shunt")
+      return null;
+    if (s.kind === "Leaf")
+      parts.push(s.path);
+    else
+      parts.push(Uint8Array.of(s.chr), s.node.path);
+  }
+  return concat(parts.reverse());
+}
+function isWellFormed(p, expectedPath) {
+  if (p[0]?.kind !== "Leaf")
+    return false;
+  let i = 0;
+  let path = new Uint8Array;
+  while (i < p.length) {
+    const j = segmentEnd(p, i);
+    const prefix = segmentPathPrefix(p.slice(i, j));
+    if (!prefix)
+      return false;
+    if (i === 0) {
+      if (!bytesEqual(prefix, expectedPath))
+        return false;
+      path = prefix;
+    } else if (prefix.length > path.length || !bytesEqual(path.subarray(0, prefix.length), prefix))
+      return false;
+    i = j;
+    if (i >= p.length)
+      return false;
+    let k = i + 1;
+    while (k < p.length && isShunt(p[k]))
+      k++;
+    i = k;
+  }
+  return true;
+}
+function shuntHash(lead, idx, inserted, hashes) {
+  if (idx === 0n)
+    return null;
+  const all = lead ? [lead] : [];
+  let hi = 0;
+  for (let i = 0;i < hashes.length + 1; i++) {
+    if (idx - 1n === BigInt(i))
+      all.push(inserted);
+    else {
+      const h = hashes[hi++];
+      if (!h)
+        return null;
+      all.push(h);
+    }
+  }
+  return hashAll(all);
+}
+function verifySteps(proof, path, value, root, rootToBlock) {
+  if (!isWellFormed(proof, path))
+    return false;
+  const first = proof[0];
+  if (first?.kind !== "Leaf" || !bytesEqual(first.value, value))
+    return false;
+  let i = 0;
+  let j = segmentEnd(proof, i);
+  const nodeRoot = verifySegment(proof.slice(i, j), leafHash(first.path, first.value));
+  if (!nodeRoot)
+    return false;
+  i = j;
+  const head = proof[i];
+  if (!isShunt(head) || head.idx !== 0n)
+    return false;
+  let trieHash = head.hashes.length === 0 ? nodeRoot : hashAll([nodeRoot, ...head.hashes]);
+  i += 1;
+  if (i >= proof.length)
+    return bytesEqual(root, trieHash);
+  let backBlock = rootToBlock.get(hex(trieHash));
+  if (!backBlock || isShunt(proof[i]))
+    return false;
+  while (i < proof.length) {
+    j = segmentEnd(proof, i);
+    const nextNodeRoot = verifySegment(proof.slice(i, j), backBlock);
+    if (!nextNodeRoot)
+      return false;
+    i = j;
+    if (i >= proof.length)
+      return false;
+    j = i;
+    while (j < proof.length) {
+      const s = proof[j];
+      if (!isShunt(s) || s.idx === 0n)
+        break;
+      j++;
+    }
+    j -= 1;
+    if (j < i)
+      return false;
+    let penultimate = trieHash;
+    for (const s of proof.slice(i, j)) {
+      if (!isShunt(s))
+        return false;
+      const h = shuntHash(null, s.idx, penultimate, s.hashes);
+      if (!h)
+        return false;
+      penultimate = h;
+    }
+    const junction = proof[j];
+    if (!isShunt(junction))
+      return false;
+    const next = shuntHash(nextNodeRoot, junction.idx, penultimate, junction.hashes);
+    if (!next)
+      return false;
+    trieHash = next;
+    backBlock = rootToBlock.get(hex(trieHash));
+    if (!backBlock)
+      return false;
+    i = j + 1;
+    if (bytesEqual(trieHash, root))
+      break;
+  }
+  return bytesEqual(root, trieHash);
+}
+function marfProofAncestors(proof) {
+  let steps;
+  try {
+    steps = decodeProof(proof);
+  } catch {
+    return [];
+  }
+  const ids = new Set;
+  for (const s of steps) {
+    if (s.kind === "Leaf" || s.kind === "Shunt")
+      continue;
+    const ptr = s.node.ptrs.find((p) => p.id !== NodeId.Empty && p.chr === s.chr);
+    if (ptr && isBackptr(ptr.id))
+      ids.add(hex(ptr.backBlock));
+  }
+  return [...ids];
+}
+function verifyMarfProof(input) {
+  const rootToBlock = new Map;
+  for (const h of input.headers)
+    rootToBlock.set(hex(h.stateIndexRoot), blockId(h));
+  try {
+    const steps = decodeProof(input.proof);
+    return verifySteps(steps, input.path, input.value, input.root, rootToBlock);
+  } catch {
+    return false;
+  }
+}
+// ../verify/src/witness.ts
+var WITNESS_VERSION = 3;
+var PATH_LEN = 32;
+var TRIE_HASH_EMPTY = unhex("c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a");
+var ZERO_BLOCK = new Uint8Array(32);
+function parseWitness(bytes) {
+  const r = new Reader(bytes);
+  const version = r.u8();
+  if (version !== WITNESS_VERSION)
+    throw new Error(`unsupported witness version ${version}`);
+  const ancestorRoots = Array.from({ length: r.u32() }, () => r.bytes(32));
+  const blockTable = Array.from({ length: r.u32() }, () => r.bytes(32));
+  const leaves = [];
+  const seen = new Set;
+  let nodes = 0;
+  const readNode = (prefix, expectedId) => {
+    nodes++;
+    const id = r.u8();
+    if (expectedId !== null && id !== expectedId)
+      throw new Error(`child id ${id} does not match its pointer id ${expectedId}`);
+    const path = r.bytes(r.u8());
+    const depth = prefix.length + path.length;
+    if (id === NodeId.Leaf) {
+      if (depth !== PATH_LEN)
+        throw new Error("leaf path does not complete 32 bytes");
+      const valueHash = r.bytes(32);
+      const full = Uint8Array.from([...prefix, ...path]);
+      const key = hex(full);
+      if (seen.has(key))
+        throw new Error(`duplicate leaf ${key}`);
+      seen.add(key);
+      leaves.push({ path: full, valueHash });
+      return leafHash(path, padValue(valueHash));
+    }
+    const count = NODE_PTR_COUNT[id];
+    if (count === undefined)
+      throw new Error(`bad node id ${id}`);
+    if (depth >= PATH_LEN)
+      throw new Error("interior node at full path depth");
+    const n = r.u16();
+    if (n !== count)
+      throw new Error(`node id ${id} has ${n} ptrs, expected ${count}`);
+    const ptrs = [];
+    for (let i = 0;i < n; i++) {
+      const pid = r.u8();
+      if (pid === NodeId.Empty) {
+        ptrs.push({ id: pid, chr: 0, backBlock: ZERO_BLOCK });
+        continue;
+      }
+      const chr = r.u8();
+      if (!isBackptr(pid)) {
+        ptrs.push({ id: pid, chr, backBlock: ZERO_BLOCK });
+        continue;
+      }
+      const block = blockTable[r.u32()];
+      if (!block)
+        throw new Error("backptr table index out of range");
+      ptrs.push({ id: pid, chr, backBlock: block });
+    }
+    const childPrefix = [...prefix, ...path];
+    const children = ptrs.map((p) => {
+      if (p.id === NodeId.Empty)
+        return TRIE_HASH_EMPTY;
+      if (isBackptr(p.id))
+        return p.backBlock;
+      return readNode([...childPrefix, p.chr], p.id);
+    });
+    return nodeHash({ id, path, ptrs }, children);
+  };
+  const nodeRoot = readNode([], null);
+  if (!r.done)
+    throw new Error("trailing bytes after witness");
+  const root = ancestorRoots.length === 0 ? nodeRoot : hashAll([nodeRoot, ...ancestorRoots]);
+  return { root, ancestorRoots, leaves, nodes };
+}
+var padValue = (valueHash) => {
+  const v = new Uint8Array(MARF_VALUE_SIZE);
+  v.set(valueHash);
+  return v;
+};
+var leafHolds = (leaf, value) => value.length === MARF_VALUE_SIZE && bytesEqual(padValue(leaf.valueHash), value);
+var INTERNAL_PREFIX = "__MARF_";
+function classifyBlockDiff(input) {
+  const writes = indexClaims(input.writes, (v) => marfValue(v));
+  const internal = indexClaims(input.internal, (v) => {
+    const value = unhex(v);
+    if (value.length !== MARF_VALUE_SIZE)
+      throw new Error(`internal value must be ${MARF_VALUE_SIZE} bytes`);
+    return value;
+  });
+  for (const { key } of internal.values())
+    if (!key.startsWith(INTERNAL_PREFIX))
+      throw new Error(`internal key must start with ${INTERNAL_PREFIX}: ${key}`);
+  const out = {
+    writes: [],
+    carried: [],
+    internal: [],
+    hidden: [],
+    missing: [],
+    complete: false
+  };
+  const matched = new Set;
+  for (const leaf of input.leaves) {
+    const pathHex = hex(leaf.path);
+    const write = writes.get(pathHex);
+    if (write && leafHolds(leaf, write.value)) {
+      out.writes.push({ ...leaf, key: write.key });
+      matched.add(pathHex);
+      continue;
+    }
+    const bookkeeping = internal.get(pathHex);
+    if (bookkeeping && leafHolds(leaf, bookkeeping.value)) {
+      out.internal.push({ ...leaf, key: bookkeeping.key });
+      continue;
+    }
+    const parent = write ? undefined : input.parentValue(pathHex);
+    if (parent !== undefined && leafHolds(leaf, unhex(parent)))
+      out.carried.push(leaf);
+    else
+      out.hidden.push(leaf);
+  }
+  for (const [pathHex, { key }] of writes)
+    if (!matched.has(pathHex))
+      out.missing.push(key);
+  out.complete = out.hidden.length === 0 && out.missing.length === 0;
+  return out;
+}
+function indexClaims(claims, toValue) {
+  const byPath = new Map;
+  for (const [key, value] of claims) {
+    const pathHex = hex(marfPath(key));
+    if (byPath.has(pathHex))
+      throw new Error(`duplicate claimed key ${key}`);
+    byPath.set(pathHex, { key, value: toValue(value) });
+  }
+  return byPath;
+}
+// ../../node_modules/@noble/curves/utils.js
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+var _0n = /* @__PURE__ */ BigInt(0);
+var _1n = /* @__PURE__ */ BigInt(1);
+function abool(value, title = "") {
+  if (typeof value !== "boolean") {
+    const prefix = title && `"${title}" `;
+    throw new Error(prefix + "expected boolean, got type=" + typeof value);
+  }
+  return value;
+}
+function abignumber(n) {
+  if (typeof n === "bigint") {
+    if (!isPosBig(n))
+      throw new Error("positive bigint expected, got " + n);
+  } else
+    anumber(n);
+  return n;
+}
+function numberToHexUnpadded(num) {
+  const hex = abignumber(num).toString(16);
+  return hex.length & 1 ? "0" + hex : hex;
+}
+function hexToNumber(hex) {
+  if (typeof hex !== "string")
+    throw new Error("hex string expected, got " + typeof hex);
+  return hex === "" ? _0n : BigInt("0x" + hex);
+}
+function bytesToNumberBE(bytes) {
+  return hexToNumber(bytesToHex(bytes));
+}
+function bytesToNumberLE(bytes) {
+  return hexToNumber(bytesToHex(copyBytes(abytes(bytes)).reverse()));
+}
+function numberToBytesBE(n, len) {
+  anumber(len);
+  n = abignumber(n);
+  const res = hexToBytes(n.toString(16).padStart(len * 2, "0"));
+  if (res.length !== len)
+    throw new Error("number too large");
+  return res;
+}
+function numberToBytesLE(n, len) {
+  return numberToBytesBE(n, len).reverse();
+}
+function copyBytes(bytes) {
+  return Uint8Array.from(bytes);
+}
+function asciiToBytes(ascii) {
+  return Uint8Array.from(ascii, (c, i) => {
+    const charCode = c.charCodeAt(0);
+    if (c.length !== 1 || charCode > 127) {
+      throw new Error(`string contains non-ASCII character "${ascii[i]}" with code ${charCode} at position ${i}`);
+    }
+    return charCode;
+  });
+}
+var isPosBig = (n) => typeof n === "bigint" && _0n <= n;
+function inRange(n, min, max) {
+  return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
+}
+function aInRange(title, n, min, max) {
+  if (!inRange(n, min, max))
+    throw new Error("expected valid " + title + ": " + min + " <= n < " + max + ", got " + n);
+}
+function bitLen(n) {
+  let len;
+  for (len = 0;n > _0n; n >>= _1n, len += 1)
+    ;
+  return len;
+}
+var bitMask = (n) => (_1n << BigInt(n)) - _1n;
+function createHmacDrbg(hashLen, qByteLen, hmacFn) {
+  anumber(hashLen, "hashLen");
+  anumber(qByteLen, "qByteLen");
+  if (typeof hmacFn !== "function")
+    throw new Error("hmacFn must be a function");
+  const u8n = (len) => new Uint8Array(len);
+  const NULL = Uint8Array.of();
+  const byte0 = Uint8Array.of(0);
+  const byte1 = Uint8Array.of(1);
+  const _maxDrbgIters = 1000;
+  let v = u8n(hashLen);
+  let k = u8n(hashLen);
+  let i = 0;
+  const reset = () => {
+    v.fill(1);
+    k.fill(0);
+    i = 0;
+  };
+  const h = (...msgs) => hmacFn(k, concatBytes(v, ...msgs));
+  const reseed = (seed = NULL) => {
+    k = h(byte0, seed);
+    v = h();
+    if (seed.length === 0)
+      return;
+    k = h(byte1, seed);
+    v = h();
+  };
+  const gen = () => {
+    if (i++ >= _maxDrbgIters)
+      throw new Error("drbg: tried max amount of iterations");
+    let len = 0;
+    const out = [];
+    while (len < qByteLen) {
+      v = h();
+      const sl = v.slice();
+      out.push(sl);
+      len += v.length;
+    }
+    return concatBytes(...out);
+  };
+  const genUntil = (seed, pred) => {
+    reset();
+    reseed(seed);
+    let res = undefined;
+    while (!(res = pred(gen())))
+      reseed();
+    reset();
+    return res;
+  };
+  return genUntil;
+}
+function validateObject(object, fields = {}, optFields = {}) {
+  if (!object || typeof object !== "object")
+    throw new Error("expected valid options object");
+  function checkField(fieldName, expectedType, isOpt) {
+    const val = object[fieldName];
+    if (isOpt && val === undefined)
+      return;
+    const current = typeof val;
+    if (current !== expectedType || val === null)
+      throw new Error(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`);
+  }
+  const iter = (f, isOpt) => Object.entries(f).forEach(([k, v]) => checkField(k, v, isOpt));
+  iter(fields, false);
+  iter(optFields, true);
+}
+function memoized(fn) {
+  const map = new WeakMap;
+  return (arg, ...args) => {
+    const val = map.get(arg);
+    if (val !== undefined)
+      return val;
+    const computed = fn(arg, ...args);
+    map.set(arg, computed);
+    return computed;
+  };
+}
+
+// ../../node_modules/@noble/curves/abstract/modular.js
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+var _0n2 = /* @__PURE__ */ BigInt(0);
+var _1n2 = /* @__PURE__ */ BigInt(1);
+var _2n = /* @__PURE__ */ BigInt(2);
+var _3n = /* @__PURE__ */ BigInt(3);
+var _4n = /* @__PURE__ */ BigInt(4);
+var _5n = /* @__PURE__ */ BigInt(5);
+var _7n = /* @__PURE__ */ BigInt(7);
+var _8n = /* @__PURE__ */ BigInt(8);
+var _9n = /* @__PURE__ */ BigInt(9);
+var _16n = /* @__PURE__ */ BigInt(16);
+function mod(a, b) {
+  const result = a % b;
+  return result >= _0n2 ? result : b + result;
+}
+function pow2(x, power, modulo) {
+  let res = x;
+  while (power-- > _0n2) {
+    res *= res;
+    res %= modulo;
+  }
+  return res;
+}
+function invert(number, modulo) {
+  if (number === _0n2)
+    throw new Error("invert: expected non-zero number");
+  if (modulo <= _0n2)
+    throw new Error("invert: expected positive modulus, got " + modulo);
+  let a = mod(number, modulo);
+  let b = modulo;
+  let x = _0n2, y = _1n2, u = _1n2, v = _0n2;
+  while (a !== _0n2) {
+    const q = b / a;
+    const r = b % a;
+    const m = x - u * q;
+    const n = y - v * q;
+    b = a, a = r, x = u, y = v, u = m, v = n;
+  }
+  const gcd = b;
+  if (gcd !== _1n2)
+    throw new Error("invert: does not exist");
+  return mod(x, modulo);
+}
+function assertIsSquare(Fp, root, n) {
+  if (!Fp.eql(Fp.sqr(root), n))
+    throw new Error("Cannot find square root");
+}
+function sqrt3mod4(Fp, n) {
+  const p1div4 = (Fp.ORDER + _1n2) / _4n;
+  const root = Fp.pow(n, p1div4);
+  assertIsSquare(Fp, root, n);
+  return root;
+}
+function sqrt5mod8(Fp, n) {
+  const p5div8 = (Fp.ORDER - _5n) / _8n;
+  const n2 = Fp.mul(n, _2n);
+  const v = Fp.pow(n2, p5div8);
+  const nv = Fp.mul(n, v);
+  const i = Fp.mul(Fp.mul(nv, _2n), v);
+  const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
+  assertIsSquare(Fp, root, n);
+  return root;
+}
+function sqrt9mod16(P) {
+  const Fp_ = Field(P);
+  const tn = tonelliShanks(P);
+  const c1 = tn(Fp_, Fp_.neg(Fp_.ONE));
+  const c2 = tn(Fp_, c1);
+  const c3 = tn(Fp_, Fp_.neg(c1));
+  const c4 = (P + _7n) / _16n;
+  return (Fp, n) => {
+    let tv1 = Fp.pow(n, c4);
+    let tv2 = Fp.mul(tv1, c1);
+    const tv3 = Fp.mul(tv1, c2);
+    const tv4 = Fp.mul(tv1, c3);
+    const e1 = Fp.eql(Fp.sqr(tv2), n);
+    const e2 = Fp.eql(Fp.sqr(tv3), n);
+    tv1 = Fp.cmov(tv1, tv2, e1);
+    tv2 = Fp.cmov(tv4, tv3, e2);
+    const e3 = Fp.eql(Fp.sqr(tv2), n);
+    const root = Fp.cmov(tv1, tv2, e3);
+    assertIsSquare(Fp, root, n);
+    return root;
+  };
+}
+function tonelliShanks(P) {
+  if (P < _3n)
+    throw new Error("sqrt is not defined for small field");
+  let Q = P - _1n2;
+  let S = 0;
+  while (Q % _2n === _0n2) {
+    Q /= _2n;
+    S++;
+  }
+  let Z = _2n;
+  const _Fp = Field(P);
+  while (FpLegendre(_Fp, Z) === 1) {
+    if (Z++ > 1000)
+      throw new Error("Cannot find square root: probably non-prime P");
+  }
+  if (S === 1)
+    return sqrt3mod4;
+  let cc = _Fp.pow(Z, Q);
+  const Q1div2 = (Q + _1n2) / _2n;
+  return function tonelliSlow(Fp, n) {
+    if (Fp.is0(n))
+      return n;
+    if (FpLegendre(Fp, n) !== 1)
+      throw new Error("Cannot find square root");
+    let M = S;
+    let c = Fp.mul(Fp.ONE, cc);
+    let t = Fp.pow(n, Q);
+    let R = Fp.pow(n, Q1div2);
+    while (!Fp.eql(t, Fp.ONE)) {
+      if (Fp.is0(t))
+        return Fp.ZERO;
+      let i = 1;
+      let t_tmp = Fp.sqr(t);
+      while (!Fp.eql(t_tmp, Fp.ONE)) {
+        i++;
+        t_tmp = Fp.sqr(t_tmp);
+        if (i === M)
+          throw new Error("Cannot find square root");
+      }
+      const exponent = _1n2 << BigInt(M - i - 1);
+      const b = Fp.pow(c, exponent);
+      M = i;
+      c = Fp.sqr(b);
+      t = Fp.mul(t, c);
+      R = Fp.mul(R, b);
+    }
+    return R;
+  };
+}
+function FpSqrt(P) {
+  if (P % _4n === _3n)
+    return sqrt3mod4;
+  if (P % _8n === _5n)
+    return sqrt5mod8;
+  if (P % _16n === _9n)
+    return sqrt9mod16(P);
+  return tonelliShanks(P);
+}
+var FIELD_FIELDS = [
+  "create",
+  "isValid",
+  "is0",
+  "neg",
+  "inv",
+  "sqrt",
+  "sqr",
+  "eql",
+  "add",
+  "sub",
+  "mul",
+  "pow",
+  "div",
+  "addN",
+  "subN",
+  "mulN",
+  "sqrN"
+];
+function validateField(field) {
+  const initial = {
+    ORDER: "bigint",
+    BYTES: "number",
+    BITS: "number"
+  };
+  const opts = FIELD_FIELDS.reduce((map, val) => {
+    map[val] = "function";
+    return map;
+  }, initial);
+  validateObject(field, opts);
+  return field;
+}
+function FpPow(Fp, num, power) {
+  if (power < _0n2)
+    throw new Error("invalid exponent, negatives unsupported");
+  if (power === _0n2)
+    return Fp.ONE;
+  if (power === _1n2)
+    return num;
+  let p = Fp.ONE;
+  let d = num;
+  while (power > _0n2) {
+    if (power & _1n2)
+      p = Fp.mul(p, d);
+    d = Fp.sqr(d);
+    power >>= _1n2;
+  }
+  return p;
+}
+function FpInvertBatch(Fp, nums, passZero = false) {
+  const inverted = new Array(nums.length).fill(passZero ? Fp.ZERO : undefined);
+  const multipliedAcc = nums.reduce((acc, num, i) => {
+    if (Fp.is0(num))
+      return acc;
+    inverted[i] = acc;
+    return Fp.mul(acc, num);
+  }, Fp.ONE);
+  const invertedAcc = Fp.inv(multipliedAcc);
+  nums.reduceRight((acc, num, i) => {
+    if (Fp.is0(num))
+      return acc;
+    inverted[i] = Fp.mul(acc, inverted[i]);
+    return Fp.mul(acc, num);
+  }, invertedAcc);
+  return inverted;
+}
+function FpLegendre(Fp, n) {
+  const p1mod2 = (Fp.ORDER - _1n2) / _2n;
+  const powered = Fp.pow(n, p1mod2);
+  const yes = Fp.eql(powered, Fp.ONE);
+  const zero = Fp.eql(powered, Fp.ZERO);
+  const no = Fp.eql(powered, Fp.neg(Fp.ONE));
+  if (!yes && !zero && !no)
+    throw new Error("invalid Legendre symbol result");
+  return yes ? 1 : zero ? 0 : -1;
+}
+function nLength(n, nBitLength) {
+  if (nBitLength !== undefined)
+    anumber(nBitLength);
+  const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;
+  const nByteLength = Math.ceil(_nBitLength / 8);
+  return { nBitLength: _nBitLength, nByteLength };
+}
+
+class _Field {
+  ORDER;
+  BITS;
+  BYTES;
+  isLE;
+  ZERO = _0n2;
+  ONE = _1n2;
+  _lengths;
+  _sqrt;
+  _mod;
+  constructor(ORDER, opts = {}) {
+    if (ORDER <= _0n2)
+      throw new Error("invalid field: expected ORDER > 0, got " + ORDER);
+    let _nbitLength = undefined;
+    this.isLE = false;
+    if (opts != null && typeof opts === "object") {
+      if (typeof opts.BITS === "number")
+        _nbitLength = opts.BITS;
+      if (typeof opts.sqrt === "function")
+        this.sqrt = opts.sqrt;
+      if (typeof opts.isLE === "boolean")
+        this.isLE = opts.isLE;
+      if (opts.allowedLengths)
+        this._lengths = opts.allowedLengths?.slice();
+      if (typeof opts.modFromBytes === "boolean")
+        this._mod = opts.modFromBytes;
+    }
+    const { nBitLength, nByteLength } = nLength(ORDER, _nbitLength);
+    if (nByteLength > 2048)
+      throw new Error("invalid field: expected ORDER of <= 2048 bytes");
+    this.ORDER = ORDER;
+    this.BITS = nBitLength;
+    this.BYTES = nByteLength;
+    this._sqrt = undefined;
+    Object.preventExtensions(this);
+  }
+  create(num) {
+    return mod(num, this.ORDER);
+  }
+  isValid(num) {
+    if (typeof num !== "bigint")
+      throw new Error("invalid field element: expected bigint, got " + typeof num);
+    return _0n2 <= num && num < this.ORDER;
+  }
+  is0(num) {
+    return num === _0n2;
+  }
+  isValidNot0(num) {
+    return !this.is0(num) && this.isValid(num);
+  }
+  isOdd(num) {
+    return (num & _1n2) === _1n2;
+  }
+  neg(num) {
+    return mod(-num, this.ORDER);
+  }
+  eql(lhs, rhs) {
+    return lhs === rhs;
+  }
+  sqr(num) {
+    return mod(num * num, this.ORDER);
+  }
+  add(lhs, rhs) {
+    return mod(lhs + rhs, this.ORDER);
+  }
+  sub(lhs, rhs) {
+    return mod(lhs - rhs, this.ORDER);
+  }
+  mul(lhs, rhs) {
+    return mod(lhs * rhs, this.ORDER);
+  }
+  pow(num, power) {
+    return FpPow(this, num, power);
+  }
+  div(lhs, rhs) {
+    return mod(lhs * invert(rhs, this.ORDER), this.ORDER);
+  }
+  sqrN(num) {
+    return num * num;
+  }
+  addN(lhs, rhs) {
+    return lhs + rhs;
+  }
+  subN(lhs, rhs) {
+    return lhs - rhs;
+  }
+  mulN(lhs, rhs) {
+    return lhs * rhs;
+  }
+  inv(num) {
+    return invert(num, this.ORDER);
+  }
+  sqrt(num) {
+    if (!this._sqrt)
+      this._sqrt = FpSqrt(this.ORDER);
+    return this._sqrt(this, num);
+  }
+  toBytes(num) {
+    return this.isLE ? numberToBytesLE(num, this.BYTES) : numberToBytesBE(num, this.BYTES);
+  }
+  fromBytes(bytes, skipValidation = false) {
+    abytes(bytes);
+    const { _lengths: allowedLengths, BYTES, isLE, ORDER, _mod: modFromBytes } = this;
+    if (allowedLengths) {
+      if (!allowedLengths.includes(bytes.length) || bytes.length > BYTES) {
+        throw new Error("Field.fromBytes: expected " + allowedLengths + " bytes, got " + bytes.length);
+      }
+      const padded = new Uint8Array(BYTES);
+      padded.set(bytes, isLE ? 0 : padded.length - bytes.length);
+      bytes = padded;
+    }
+    if (bytes.length !== BYTES)
+      throw new Error("Field.fromBytes: expected " + BYTES + " bytes, got " + bytes.length);
+    let scalar = isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);
+    if (modFromBytes)
+      scalar = mod(scalar, ORDER);
+    if (!skipValidation) {
+      if (!this.isValid(scalar))
+        throw new Error("invalid field element: outside of range 0..ORDER");
+    }
+    return scalar;
+  }
+  invertBatch(lst) {
+    return FpInvertBatch(this, lst);
+  }
+  cmov(a, b, condition) {
+    return condition ? b : a;
+  }
+}
+function Field(ORDER, opts = {}) {
+  return new _Field(ORDER, opts);
+}
+function getFieldBytesLength(fieldOrder) {
+  if (typeof fieldOrder !== "bigint")
+    throw new Error("field order must be bigint");
+  const bitLength = fieldOrder.toString(2).length;
+  return Math.ceil(bitLength / 8);
+}
+function getMinHashLength(fieldOrder) {
+  const length = getFieldBytesLength(fieldOrder);
+  return length + Math.ceil(length / 2);
+}
+function mapHashToField(key, fieldOrder, isLE = false) {
+  abytes(key);
+  const len = key.length;
+  const fieldLen = getFieldBytesLength(fieldOrder);
+  const minLen = getMinHashLength(fieldOrder);
+  if (len < 16 || len < minLen || len > 1024)
+    throw new Error("expected " + minLen + "-1024 bytes of input, got " + len);
+  const num = isLE ? bytesToNumberLE(key) : bytesToNumberBE(key);
+  const reduced = mod(num, fieldOrder - _1n2) + _1n2;
+  return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
+}
+
+// ../../node_modules/@noble/curves/abstract/curve.js
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+var _0n3 = /* @__PURE__ */ BigInt(0);
+var _1n3 = /* @__PURE__ */ BigInt(1);
+function negateCt(condition, item) {
+  const neg = item.negate();
+  return condition ? neg : item;
+}
+function normalizeZ(c, points) {
+  const invertedZs = FpInvertBatch(c.Fp, points.map((p) => p.Z));
+  return points.map((p, i) => c.fromAffine(p.toAffine(invertedZs[i])));
+}
+function validateW(W, bits) {
+  if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
+    throw new Error("invalid window size, expected [1.." + bits + "], got W=" + W);
+}
+function calcWOpts(W, scalarBits) {
+  validateW(W, scalarBits);
+  const windows = Math.ceil(scalarBits / W) + 1;
+  const windowSize = 2 ** (W - 1);
+  const maxNumber = 2 ** W;
+  const mask = bitMask(W);
+  const shiftBy = BigInt(W);
+  return { windows, windowSize, mask, maxNumber, shiftBy };
+}
+function calcOffsets(n, window2, wOpts) {
+  const { windowSize, mask, maxNumber, shiftBy } = wOpts;
+  let wbits = Number(n & mask);
+  let nextN = n >> shiftBy;
+  if (wbits > windowSize) {
+    wbits -= maxNumber;
+    nextN += _1n3;
+  }
+  const offsetStart = window2 * windowSize;
+  const offset = offsetStart + Math.abs(wbits) - 1;
+  const isZero = wbits === 0;
+  const isNeg = wbits < 0;
+  const isNegF = window2 % 2 !== 0;
+  const offsetF = offsetStart;
+  return { nextN, offset, isZero, isNeg, isNegF, offsetF };
+}
+var pointPrecomputes = new WeakMap;
+var pointWindowSizes = new WeakMap;
+function getW(P) {
+  return pointWindowSizes.get(P) || 1;
+}
+function assert0(n) {
+  if (n !== _0n3)
+    throw new Error("invalid wNAF");
+}
+
+class wNAF {
+  BASE;
+  ZERO;
+  Fn;
+  bits;
+  constructor(Point, bits) {
+    this.BASE = Point.BASE;
+    this.ZERO = Point.ZERO;
+    this.Fn = Point.Fn;
+    this.bits = bits;
+  }
+  _unsafeLadder(elm, n, p = this.ZERO) {
+    let d = elm;
+    while (n > _0n3) {
+      if (n & _1n3)
+        p = p.add(d);
+      d = d.double();
+      n >>= _1n3;
+    }
+    return p;
+  }
+  precomputeWindow(point, W) {
+    const { windows, windowSize } = calcWOpts(W, this.bits);
+    const points = [];
+    let p = point;
+    let base = p;
+    for (let window2 = 0;window2 < windows; window2++) {
+      base = p;
+      points.push(base);
+      for (let i = 1;i < windowSize; i++) {
+        base = base.add(p);
+        points.push(base);
+      }
+      p = base.double();
+    }
+    return points;
+  }
+  wNAF(W, precomputes, n) {
+    if (!this.Fn.isValid(n))
+      throw new Error("invalid scalar");
+    let p = this.ZERO;
+    let f = this.BASE;
+    const wo = calcWOpts(W, this.bits);
+    for (let window2 = 0;window2 < wo.windows; window2++) {
+      const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window2, wo);
+      n = nextN;
+      if (isZero) {
+        f = f.add(negateCt(isNegF, precomputes[offsetF]));
+      } else {
+        p = p.add(negateCt(isNeg, precomputes[offset]));
+      }
+    }
+    assert0(n);
+    return { p, f };
+  }
+  wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {
+    const wo = calcWOpts(W, this.bits);
+    for (let window2 = 0;window2 < wo.windows; window2++) {
+      if (n === _0n3)
+        break;
+      const { nextN, offset, isZero, isNeg } = calcOffsets(n, window2, wo);
+      n = nextN;
+      if (isZero) {
+        continue;
+      } else {
+        const item = precomputes[offset];
+        acc = acc.add(isNeg ? item.negate() : item);
+      }
+    }
+    assert0(n);
+    return acc;
+  }
+  getPrecomputes(W, point, transform) {
+    let comp = pointPrecomputes.get(point);
+    if (!comp) {
+      comp = this.precomputeWindow(point, W);
+      if (W !== 1) {
+        if (typeof transform === "function")
+          comp = transform(comp);
+        pointPrecomputes.set(point, comp);
+      }
+    }
+    return comp;
+  }
+  cached(point, scalar, transform) {
+    const W = getW(point);
+    return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar);
+  }
+  unsafe(point, scalar, transform, prev) {
+    const W = getW(point);
+    if (W === 1)
+      return this._unsafeLadder(point, scalar, prev);
+    return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, prev);
+  }
+  createCache(P, W) {
+    validateW(W, this.bits);
+    pointWindowSizes.set(P, W);
+    pointPrecomputes.delete(P);
+  }
+  hasCache(elm) {
+    return getW(elm) !== 1;
+  }
+}
+function mulEndoUnsafe(Point, point, k1, k2) {
+  let acc = point;
+  let p1 = Point.ZERO;
+  let p2 = Point.ZERO;
+  while (k1 > _0n3 || k2 > _0n3) {
+    if (k1 & _1n3)
+      p1 = p1.add(acc);
+    if (k2 & _1n3)
+      p2 = p2.add(acc);
+    acc = acc.double();
+    k1 >>= _1n3;
+    k2 >>= _1n3;
+  }
+  return { p1, p2 };
+}
+function createField(order, field, isLE) {
+  if (field) {
+    if (field.ORDER !== order)
+      throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+    validateField(field);
+    return field;
+  } else {
+    return Field(order, { isLE });
+  }
+}
+function createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {
+  if (FpFnLE === undefined)
+    FpFnLE = type === "edwards";
+  if (!CURVE || typeof CURVE !== "object")
+    throw new Error(`expected valid ${type} CURVE object`);
+  for (const p of ["p", "n", "h"]) {
+    const val = CURVE[p];
+    if (!(typeof val === "bigint" && val > _0n3))
+      throw new Error(`CURVE.${p} must be positive bigint`);
+  }
+  const Fp = createField(CURVE.p, curveOpts.Fp, FpFnLE);
+  const Fn = createField(CURVE.n, curveOpts.Fn, FpFnLE);
+  const _b = type === "weierstrass" ? "b" : "d";
+  const params = ["Gx", "Gy", "a", _b];
+  for (const p of params) {
+    if (!Fp.isValid(CURVE[p]))
+      throw new Error(`CURVE.${p} must be valid field element of CURVE.Fp`);
+  }
+  CURVE = Object.freeze(Object.assign({}, CURVE));
+  return { CURVE, Fp, Fn };
+}
+function createKeygen(randomSecretKey, getPublicKey) {
+  return function keygen(seed) {
+    const secretKey = randomSecretKey(seed);
+    return { secretKey, publicKey: getPublicKey(secretKey) };
+  };
+}
+
+// ../../node_modules/@noble/curves/abstract/hash-to-curve.js
+var _DST_scalar = asciiToBytes("HashToScalar-");
+
+// ../../node_modules/@noble/hashes/hmac.js
+class _HMAC {
+  oHash;
+  iHash;
+  blockLen;
+  outputLen;
+  finished = false;
+  destroyed = false;
+  constructor(hash, key) {
+    ahash(hash);
+    abytes(key, undefined, "key");
+    this.iHash = hash.create();
+    if (typeof this.iHash.update !== "function")
+      throw new Error("Expected instance of class which extends utils.Hash");
+    this.blockLen = this.iHash.blockLen;
+    this.outputLen = this.iHash.outputLen;
+    const blockLen = this.blockLen;
+    const pad = new Uint8Array(blockLen);
+    pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+    for (let i = 0;i < pad.length; i++)
+      pad[i] ^= 54;
+    this.iHash.update(pad);
+    this.oHash = hash.create();
+    for (let i = 0;i < pad.length; i++)
+      pad[i] ^= 54 ^ 92;
+    this.oHash.update(pad);
+    clean(pad);
+  }
+  update(buf) {
+    aexists(this);
+    this.iHash.update(buf);
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    abytes(out, this.outputLen, "output");
+    this.finished = true;
+    this.iHash.digestInto(out);
+    this.oHash.update(out);
+    this.oHash.digestInto(out);
+    this.destroy();
+  }
+  digest() {
+    const out = new Uint8Array(this.oHash.outputLen);
+    this.digestInto(out);
+    return out;
+  }
+  _cloneInto(to) {
+    to ||= Object.create(Object.getPrototypeOf(this), {});
+    const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+    to = to;
+    to.finished = finished;
+    to.destroyed = destroyed;
+    to.blockLen = blockLen;
+    to.outputLen = outputLen;
+    to.oHash = oHash._cloneInto(to.oHash);
+    to.iHash = iHash._cloneInto(to.iHash);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = true;
+    this.oHash.destroy();
+    this.iHash.destroy();
+  }
+}
+var hmac = (hash, key, message) => new _HMAC(hash, key).update(message).digest();
+hmac.create = (hash, key) => new _HMAC(hash, key);
+
+// ../../node_modules/@noble/curves/abstract/weierstrass.js
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+var divNearest = (num, den) => (num + (num >= 0 ? den : -den) / _2n2) / den;
+function _splitEndoScalar(k, basis, n) {
+  const [[a1, b1], [a2, b2]] = basis;
+  const c1 = divNearest(b2 * k, n);
+  const c2 = divNearest(-b1 * k, n);
+  let k1 = k - c1 * a1 - c2 * a2;
+  let k2 = -c1 * b1 - c2 * b2;
+  const k1neg = k1 < _0n4;
+  const k2neg = k2 < _0n4;
+  if (k1neg)
+    k1 = -k1;
+  if (k2neg)
+    k2 = -k2;
+  const MAX_NUM = bitMask(Math.ceil(bitLen(n) / 2)) + _1n4;
+  if (k1 < _0n4 || k1 >= MAX_NUM || k2 < _0n4 || k2 >= MAX_NUM) {
+    throw new Error("splitScalar (endomorphism): failed, k=" + k);
+  }
+  return { k1neg, k1, k2neg, k2 };
+}
+function validateSigFormat(format) {
+  if (!["compact", "recovered", "der"].includes(format))
+    throw new Error('Signature format must be "compact", "recovered", or "der"');
+  return format;
+}
+function validateSigOpts(opts, def) {
+  const optsn = {};
+  for (let optName of Object.keys(def)) {
+    optsn[optName] = opts[optName] === undefined ? def[optName] : opts[optName];
+  }
+  abool(optsn.lowS, "lowS");
+  abool(optsn.prehash, "prehash");
+  if (optsn.format !== undefined)
+    validateSigFormat(optsn.format);
+  return optsn;
+}
+
+class DERErr extends Error {
+  constructor(m = "") {
+    super(m);
+  }
+}
+var DER = {
+  Err: DERErr,
+  _tlv: {
+    encode: (tag, data) => {
+      const { Err: E } = DER;
+      if (tag < 0 || tag > 256)
+        throw new E("tlv.encode: wrong tag");
+      if (data.length & 1)
+        throw new E("tlv.encode: unpadded data");
+      const dataLen = data.length / 2;
+      const len = numberToHexUnpadded(dataLen);
+      if (len.length / 2 & 128)
+        throw new E("tlv.encode: long form length too big");
+      const lenLen = dataLen > 127 ? numberToHexUnpadded(len.length / 2 | 128) : "";
+      const t = numberToHexUnpadded(tag);
+      return t + lenLen + len + data;
+    },
+    decode(tag, data) {
+      const { Err: E } = DER;
+      let pos = 0;
+      if (tag < 0 || tag > 256)
+        throw new E("tlv.encode: wrong tag");
+      if (data.length < 2 || data[pos++] !== tag)
+        throw new E("tlv.decode: wrong tlv");
+      const first = data[pos++];
+      const isLong = !!(first & 128);
+      let length = 0;
+      if (!isLong)
+        length = first;
+      else {
+        const lenLen = first & 127;
+        if (!lenLen)
+          throw new E("tlv.decode(long): indefinite length not supported");
+        if (lenLen > 4)
+          throw new E("tlv.decode(long): byte length is too big");
+        const lengthBytes = data.subarray(pos, pos + lenLen);
+        if (lengthBytes.length !== lenLen)
+          throw new E("tlv.decode: length bytes not complete");
+        if (lengthBytes[0] === 0)
+          throw new E("tlv.decode(long): zero leftmost byte");
+        for (const b of lengthBytes)
+          length = length << 8 | b;
+        pos += lenLen;
+        if (length < 128)
+          throw new E("tlv.decode(long): not minimal encoding");
+      }
+      const v = data.subarray(pos, pos + length);
+      if (v.length !== length)
+        throw new E("tlv.decode: wrong value length");
+      return { v, l: data.subarray(pos + length) };
+    }
+  },
+  _int: {
+    encode(num) {
+      const { Err: E } = DER;
+      if (num < _0n4)
+        throw new E("integer: negative integers are not allowed");
+      let hex = numberToHexUnpadded(num);
+      if (Number.parseInt(hex[0], 16) & 8)
+        hex = "00" + hex;
+      if (hex.length & 1)
+        throw new E("unexpected DER parsing assertion: unpadded hex");
+      return hex;
+    },
+    decode(data) {
+      const { Err: E } = DER;
+      if (data[0] & 128)
+        throw new E("invalid signature integer: negative");
+      if (data[0] === 0 && !(data[1] & 128))
+        throw new E("invalid signature integer: unnecessary leading zero");
+      return bytesToNumberBE(data);
+    }
+  },
+  toSig(bytes) {
+    const { Err: E, _int: int, _tlv: tlv } = DER;
+    const data = abytes(bytes, undefined, "signature");
+    const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data);
+    if (seqLeftBytes.length)
+      throw new E("invalid signature: left bytes after parsing");
+    const { v: rBytes, l: rLeftBytes } = tlv.decode(2, seqBytes);
+    const { v: sBytes, l: sLeftBytes } = tlv.decode(2, rLeftBytes);
+    if (sLeftBytes.length)
+      throw new E("invalid signature: left bytes after parsing");
+    return { r: int.decode(rBytes), s: int.decode(sBytes) };
+  },
+  hexFromSig(sig) {
+    const { _tlv: tlv, _int: int } = DER;
+    const rs = tlv.encode(2, int.encode(sig.r));
+    const ss = tlv.encode(2, int.encode(sig.s));
+    const seq = rs + ss;
+    return tlv.encode(48, seq);
+  }
+};
+var _0n4 = BigInt(0);
+var _1n4 = BigInt(1);
+var _2n2 = BigInt(2);
+var _3n2 = BigInt(3);
+var _4n2 = BigInt(4);
+function weierstrass(params, extraOpts = {}) {
+  const validated = createCurveFields("weierstrass", params, extraOpts);
+  const { Fp, Fn } = validated;
+  let CURVE = validated.CURVE;
+  const { h: cofactor, n: CURVE_ORDER } = CURVE;
+  validateObject(extraOpts, {}, {
+    allowInfinityPoint: "boolean",
+    clearCofactor: "function",
+    isTorsionFree: "function",
+    fromBytes: "function",
+    toBytes: "function",
+    endo: "object"
+  });
+  const { endo } = extraOpts;
+  if (endo) {
+    if (!Fp.is0(CURVE.a) || typeof endo.beta !== "bigint" || !Array.isArray(endo.basises)) {
+      throw new Error('invalid endo: expected "beta": bigint and "basises": array');
+    }
+  }
+  const lengths = getWLengths(Fp, Fn);
+  function assertCompressionIsSupported() {
+    if (!Fp.isOdd)
+      throw new Error("compression is not supported: Field does not have .isOdd()");
+  }
+  function pointToBytes(_c, point, isCompressed) {
+    const { x, y } = point.toAffine();
+    const bx = Fp.toBytes(x);
+    abool(isCompressed, "isCompressed");
+    if (isCompressed) {
+      assertCompressionIsSupported();
+      const hasEvenY = !Fp.isOdd(y);
+      return concatBytes(pprefix(hasEvenY), bx);
+    } else {
+      return concatBytes(Uint8Array.of(4), bx, Fp.toBytes(y));
+    }
+  }
+  function pointFromBytes(bytes) {
+    abytes(bytes, undefined, "Point");
+    const { publicKey: comp, publicKeyUncompressed: uncomp } = lengths;
+    const length = bytes.length;
+    const head = bytes[0];
+    const tail = bytes.subarray(1);
+    if (length === comp && (head === 2 || head === 3)) {
+      const x = Fp.fromBytes(tail);
+      if (!Fp.isValid(x))
+        throw new Error("bad point: is not on curve, wrong x");
+      const y2 = weierstrassEquation(x);
+      let y;
+      try {
+        y = Fp.sqrt(y2);
+      } catch (sqrtError) {
+        const err = sqrtError instanceof Error ? ": " + sqrtError.message : "";
+        throw new Error("bad point: is not on curve, sqrt error" + err);
+      }
+      assertCompressionIsSupported();
+      const evenY = Fp.isOdd(y);
+      const evenH = (head & 1) === 1;
+      if (evenH !== evenY)
+        y = Fp.neg(y);
+      return { x, y };
+    } else if (length === uncomp && head === 4) {
+      const L = Fp.BYTES;
+      const x = Fp.fromBytes(tail.subarray(0, L));
+      const y = Fp.fromBytes(tail.subarray(L, L * 2));
+      if (!isValidXY(x, y))
+        throw new Error("bad point: is not on curve");
+      return { x, y };
+    } else {
+      throw new Error(`bad point: got length ${length}, expected compressed=${comp} or uncompressed=${uncomp}`);
+    }
+  }
+  const encodePoint = extraOpts.toBytes || pointToBytes;
+  const decodePoint = extraOpts.fromBytes || pointFromBytes;
+  function weierstrassEquation(x) {
+    const x2 = Fp.sqr(x);
+    const x3 = Fp.mul(x2, x);
+    return Fp.add(Fp.add(x3, Fp.mul(x, CURVE.a)), CURVE.b);
+  }
+  function isValidXY(x, y) {
+    const left = Fp.sqr(y);
+    const right = weierstrassEquation(x);
+    return Fp.eql(left, right);
+  }
+  if (!isValidXY(CURVE.Gx, CURVE.Gy))
+    throw new Error("bad curve params: generator point");
+  const _4a3 = Fp.mul(Fp.pow(CURVE.a, _3n2), _4n2);
+  const _27b2 = Fp.mul(Fp.sqr(CURVE.b), BigInt(27));
+  if (Fp.is0(Fp.add(_4a3, _27b2)))
+    throw new Error("bad curve params: a or b");
+  function acoord(title, n, banZero = false) {
+    if (!Fp.isValid(n) || banZero && Fp.is0(n))
+      throw new Error(`bad point coordinate ${title}`);
+    return n;
+  }
+  function aprjpoint(other) {
+    if (!(other instanceof Point))
+      throw new Error("Weierstrass Point expected");
+  }
+  function splitEndoScalarN(k) {
+    if (!endo || !endo.basises)
+      throw new Error("no endo");
+    return _splitEndoScalar(k, endo.basises, Fn.ORDER);
+  }
+  const toAffineMemo = memoized((p, iz) => {
+    const { X, Y, Z } = p;
+    if (Fp.eql(Z, Fp.ONE))
+      return { x: X, y: Y };
+    const is0 = p.is0();
+    if (iz == null)
+      iz = is0 ? Fp.ONE : Fp.inv(Z);
+    const x = Fp.mul(X, iz);
+    const y = Fp.mul(Y, iz);
+    const zz = Fp.mul(Z, iz);
+    if (is0)
+      return { x: Fp.ZERO, y: Fp.ZERO };
+    if (!Fp.eql(zz, Fp.ONE))
+      throw new Error("invZ was invalid");
+    return { x, y };
+  });
+  const assertValidMemo = memoized((p) => {
+    if (p.is0()) {
+      if (extraOpts.allowInfinityPoint && !Fp.is0(p.Y))
+        return;
+      throw new Error("bad point: ZERO");
+    }
+    const { x, y } = p.toAffine();
+    if (!Fp.isValid(x) || !Fp.isValid(y))
+      throw new Error("bad point: x or y not field elements");
+    if (!isValidXY(x, y))
+      throw new Error("bad point: equation left != right");
+    if (!p.isTorsionFree())
+      throw new Error("bad point: not in prime-order subgroup");
+    return true;
+  });
+  function finishEndo(endoBeta, k1p, k2p, k1neg, k2neg) {
+    k2p = new Point(Fp.mul(k2p.X, endoBeta), k2p.Y, k2p.Z);
+    k1p = negateCt(k1neg, k1p);
+    k2p = negateCt(k2neg, k2p);
+    return k1p.add(k2p);
+  }
+
+  class Point {
+    static BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);
+    static ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
+    static Fp = Fp;
+    static Fn = Fn;
+    X;
+    Y;
+    Z;
+    constructor(X, Y, Z) {
+      this.X = acoord("x", X);
+      this.Y = acoord("y", Y, true);
+      this.Z = acoord("z", Z);
+      Object.freeze(this);
+    }
+    static CURVE() {
+      return CURVE;
+    }
+    static fromAffine(p) {
+      const { x, y } = p || {};
+      if (!p || !Fp.isValid(x) || !Fp.isValid(y))
+        throw new Error("invalid affine point");
+      if (p instanceof Point)
+        throw new Error("projective point not allowed");
+      if (Fp.is0(x) && Fp.is0(y))
+        return Point.ZERO;
+      return new Point(x, y, Fp.ONE);
+    }
+    static fromBytes(bytes) {
+      const P = Point.fromAffine(decodePoint(abytes(bytes, undefined, "point")));
+      P.assertValidity();
+      return P;
+    }
+    static fromHex(hex) {
+      return Point.fromBytes(hexToBytes(hex));
+    }
+    get x() {
+      return this.toAffine().x;
+    }
+    get y() {
+      return this.toAffine().y;
+    }
+    precompute(windowSize = 8, isLazy = true) {
+      wnaf.createCache(this, windowSize);
+      if (!isLazy)
+        this.multiply(_3n2);
+      return this;
+    }
+    assertValidity() {
+      assertValidMemo(this);
+    }
+    hasEvenY() {
+      const { y } = this.toAffine();
+      if (!Fp.isOdd)
+        throw new Error("Field doesn't support isOdd");
+      return !Fp.isOdd(y);
+    }
+    equals(other) {
+      aprjpoint(other);
+      const { X: X1, Y: Y1, Z: Z1 } = this;
+      const { X: X2, Y: Y2, Z: Z2 } = other;
+      const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));
+      const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));
+      return U1 && U2;
+    }
+    negate() {
+      return new Point(this.X, Fp.neg(this.Y), this.Z);
+    }
+    double() {
+      const { a, b } = CURVE;
+      const b3 = Fp.mul(b, _3n2);
+      const { X: X1, Y: Y1, Z: Z1 } = this;
+      let { ZERO: X3, ZERO: Y3, ZERO: Z3 } = Fp;
+      let t0 = Fp.mul(X1, X1);
+      let t1 = Fp.mul(Y1, Y1);
+      let t2 = Fp.mul(Z1, Z1);
+      let t3 = Fp.mul(X1, Y1);
+      t3 = Fp.add(t3, t3);
+      Z3 = Fp.mul(X1, Z1);
+      Z3 = Fp.add(Z3, Z3);
+      X3 = Fp.mul(a, Z3);
+      Y3 = Fp.mul(b3, t2);
+      Y3 = Fp.add(X3, Y3);
+      X3 = Fp.sub(t1, Y3);
+      Y3 = Fp.add(t1, Y3);
+      Y3 = Fp.mul(X3, Y3);
+      X3 = Fp.mul(t3, X3);
+      Z3 = Fp.mul(b3, Z3);
+      t2 = Fp.mul(a, t2);
+      t3 = Fp.sub(t0, t2);
+      t3 = Fp.mul(a, t3);
+      t3 = Fp.add(t3, Z3);
+      Z3 = Fp.add(t0, t0);
+      t0 = Fp.add(Z3, t0);
+      t0 = Fp.add(t0, t2);
+      t0 = Fp.mul(t0, t3);
+      Y3 = Fp.add(Y3, t0);
+      t2 = Fp.mul(Y1, Z1);
+      t2 = Fp.add(t2, t2);
+      t0 = Fp.mul(t2, t3);
+      X3 = Fp.sub(X3, t0);
+      Z3 = Fp.mul(t2, t1);
+      Z3 = Fp.add(Z3, Z3);
+      Z3 = Fp.add(Z3, Z3);
+      return new Point(X3, Y3, Z3);
+    }
+    add(other) {
+      aprjpoint(other);
+      const { X: X1, Y: Y1, Z: Z1 } = this;
+      const { X: X2, Y: Y2, Z: Z2 } = other;
+      let { ZERO: X3, ZERO: Y3, ZERO: Z3 } = Fp;
+      const a = CURVE.a;
+      const b3 = Fp.mul(CURVE.b, _3n2);
+      let t0 = Fp.mul(X1, X2);
+      let t1 = Fp.mul(Y1, Y2);
+      let t2 = Fp.mul(Z1, Z2);
+      let t3 = Fp.add(X1, Y1);
+      let t4 = Fp.add(X2, Y2);
+      t3 = Fp.mul(t3, t4);
+      t4 = Fp.add(t0, t1);
+      t3 = Fp.sub(t3, t4);
+      t4 = Fp.add(X1, Z1);
+      let t5 = Fp.add(X2, Z2);
+      t4 = Fp.mul(t4, t5);
+      t5 = Fp.add(t0, t2);
+      t4 = Fp.sub(t4, t5);
+      t5 = Fp.add(Y1, Z1);
+      X3 = Fp.add(Y2, Z2);
+      t5 = Fp.mul(t5, X3);
+      X3 = Fp.add(t1, t2);
+      t5 = Fp.sub(t5, X3);
+      Z3 = Fp.mul(a, t4);
+      X3 = Fp.mul(b3, t2);
+      Z3 = Fp.add(X3, Z3);
+      X3 = Fp.sub(t1, Z3);
+      Z3 = Fp.add(t1, Z3);
+      Y3 = Fp.mul(X3, Z3);
+      t1 = Fp.add(t0, t0);
+      t1 = Fp.add(t1, t0);
+      t2 = Fp.mul(a, t2);
+      t4 = Fp.mul(b3, t4);
+      t1 = Fp.add(t1, t2);
+      t2 = Fp.sub(t0, t2);
+      t2 = Fp.mul(a, t2);
+      t4 = Fp.add(t4, t2);
+      t0 = Fp.mul(t1, t4);
+      Y3 = Fp.add(Y3, t0);
+      t0 = Fp.mul(t5, t4);
+      X3 = Fp.mul(t3, X3);
+      X3 = Fp.sub(X3, t0);
+      t0 = Fp.mul(t3, t1);
+      Z3 = Fp.mul(t5, Z3);
+      Z3 = Fp.add(Z3, t0);
+      return new Point(X3, Y3, Z3);
+    }
+    subtract(other) {
+      return this.add(other.negate());
+    }
+    is0() {
+      return this.equals(Point.ZERO);
+    }
+    multiply(scalar) {
+      const { endo } = extraOpts;
+      if (!Fn.isValidNot0(scalar))
+        throw new Error("invalid scalar: out of range");
+      let point, fake;
+      const mul = (n) => wnaf.cached(this, n, (p) => normalizeZ(Point, p));
+      if (endo) {
+        const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(scalar);
+        const { p: k1p, f: k1f } = mul(k1);
+        const { p: k2p, f: k2f } = mul(k2);
+        fake = k1f.add(k2f);
+        point = finishEndo(endo.beta, k1p, k2p, k1neg, k2neg);
+      } else {
+        const { p, f } = mul(scalar);
+        point = p;
+        fake = f;
+      }
+      return normalizeZ(Point, [point, fake])[0];
+    }
+    multiplyUnsafe(sc) {
+      const { endo } = extraOpts;
+      const p = this;
+      if (!Fn.isValid(sc))
+        throw new Error("invalid scalar: out of range");
+      if (sc === _0n4 || p.is0())
+        return Point.ZERO;
+      if (sc === _1n4)
+        return p;
+      if (wnaf.hasCache(this))
+        return this.multiply(sc);
+      if (endo) {
+        const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(sc);
+        const { p1, p2 } = mulEndoUnsafe(Point, p, k1, k2);
+        return finishEndo(endo.beta, p1, p2, k1neg, k2neg);
+      } else {
+        return wnaf.unsafe(p, sc);
+      }
+    }
+    toAffine(invertedZ) {
+      return toAffineMemo(this, invertedZ);
+    }
+    isTorsionFree() {
+      const { isTorsionFree } = extraOpts;
+      if (cofactor === _1n4)
+        return true;
+      if (isTorsionFree)
+        return isTorsionFree(Point, this);
+      return wnaf.unsafe(this, CURVE_ORDER).is0();
+    }
+    clearCofactor() {
+      const { clearCofactor } = extraOpts;
+      if (cofactor === _1n4)
+        return this;
+      if (clearCofactor)
+        return clearCofactor(Point, this);
+      return this.multiplyUnsafe(cofactor);
+    }
+    isSmallOrder() {
+      return this.multiplyUnsafe(cofactor).is0();
+    }
+    toBytes(isCompressed = true) {
+      abool(isCompressed, "isCompressed");
+      this.assertValidity();
+      return encodePoint(Point, this, isCompressed);
+    }
+    toHex(isCompressed = true) {
+      return bytesToHex(this.toBytes(isCompressed));
+    }
+    toString() {
+      return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+    }
+  }
+  const bits = Fn.BITS;
+  const wnaf = new wNAF(Point, extraOpts.endo ? Math.ceil(bits / 2) : bits);
+  Point.BASE.precompute(8);
+  return Point;
+}
+function pprefix(hasEvenY) {
+  return Uint8Array.of(hasEvenY ? 2 : 3);
+}
+function getWLengths(Fp, Fn) {
+  return {
+    secretKey: Fn.BYTES,
+    publicKey: 1 + Fp.BYTES,
+    publicKeyUncompressed: 1 + 2 * Fp.BYTES,
+    publicKeyHasPrefix: true,
+    signature: 2 * Fn.BYTES
+  };
+}
+function ecdh(Point, ecdhOpts = {}) {
+  const { Fn } = Point;
+  const randomBytes_ = ecdhOpts.randomBytes || randomBytes;
+  const lengths = Object.assign(getWLengths(Point.Fp, Fn), { seed: getMinHashLength(Fn.ORDER) });
+  function isValidSecretKey(secretKey) {
+    try {
+      const num = Fn.fromBytes(secretKey);
+      return Fn.isValidNot0(num);
+    } catch (error) {
+      return false;
+    }
+  }
+  function isValidPublicKey(publicKey, isCompressed) {
+    const { publicKey: comp, publicKeyUncompressed } = lengths;
+    try {
+      const l = publicKey.length;
+      if (isCompressed === true && l !== comp)
+        return false;
+      if (isCompressed === false && l !== publicKeyUncompressed)
+        return false;
+      return !!Point.fromBytes(publicKey);
+    } catch (error) {
+      return false;
+    }
+  }
+  function randomSecretKey(seed = randomBytes_(lengths.seed)) {
+    return mapHashToField(abytes(seed, lengths.seed, "seed"), Fn.ORDER);
+  }
+  function getPublicKey(secretKey, isCompressed = true) {
+    return Point.BASE.multiply(Fn.fromBytes(secretKey)).toBytes(isCompressed);
+  }
+  function isProbPub(item) {
+    const { secretKey, publicKey, publicKeyUncompressed } = lengths;
+    if (!isBytes(item))
+      return;
+    if ("_lengths" in Fn && Fn._lengths || secretKey === publicKey)
+      return;
+    const l = abytes(item, undefined, "key").length;
+    return l === publicKey || l === publicKeyUncompressed;
+  }
+  function getSharedSecret(secretKeyA, publicKeyB, isCompressed = true) {
+    if (isProbPub(secretKeyA) === true)
+      throw new Error("first arg must be private key");
+    if (isProbPub(publicKeyB) === false)
+      throw new Error("second arg must be public key");
+    const s = Fn.fromBytes(secretKeyA);
+    const b = Point.fromBytes(publicKeyB);
+    return b.multiply(s).toBytes(isCompressed);
+  }
+  const utils = {
+    isValidSecretKey,
+    isValidPublicKey,
+    randomSecretKey
+  };
+  const keygen = createKeygen(randomSecretKey, getPublicKey);
+  return Object.freeze({ getPublicKey, getSharedSecret, keygen, Point, utils, lengths });
+}
+function ecdsa(Point, hash, ecdsaOpts = {}) {
+  ahash(hash);
+  validateObject(ecdsaOpts, {}, {
+    hmac: "function",
+    lowS: "boolean",
+    randomBytes: "function",
+    bits2int: "function",
+    bits2int_modN: "function"
+  });
+  ecdsaOpts = Object.assign({}, ecdsaOpts);
+  const randomBytes2 = ecdsaOpts.randomBytes || randomBytes;
+  const hmac2 = ecdsaOpts.hmac || ((key, msg) => hmac(hash, key, msg));
+  const { Fp, Fn } = Point;
+  const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;
+  const { keygen, getPublicKey, getSharedSecret, utils, lengths } = ecdh(Point, ecdsaOpts);
+  const defaultSigOpts = {
+    prehash: true,
+    lowS: typeof ecdsaOpts.lowS === "boolean" ? ecdsaOpts.lowS : true,
+    format: "compact",
+    extraEntropy: false
+  };
+  const hasLargeCofactor = CURVE_ORDER * _2n2 < Fp.ORDER;
+  function isBiggerThanHalfOrder(number) {
+    const HALF = CURVE_ORDER >> _1n4;
+    return number > HALF;
+  }
+  function validateRS(title, num) {
+    if (!Fn.isValidNot0(num))
+      throw new Error(`invalid signature ${title}: out of range 1..Point.Fn.ORDER`);
+    return num;
+  }
+  function assertSmallCofactor() {
+    if (hasLargeCofactor)
+      throw new Error('"recovered" sig type is not supported for cofactor >2 curves');
+  }
+  function validateSigLength(bytes, format) {
+    validateSigFormat(format);
+    const size = lengths.signature;
+    const sizer = format === "compact" ? size : format === "recovered" ? size + 1 : undefined;
+    return abytes(bytes, sizer);
+  }
+
+  class Signature {
+    r;
+    s;
+    recovery;
+    constructor(r, s, recovery) {
+      this.r = validateRS("r", r);
+      this.s = validateRS("s", s);
+      if (recovery != null) {
+        assertSmallCofactor();
+        if (![0, 1, 2, 3].includes(recovery))
+          throw new Error("invalid recovery id");
+        this.recovery = recovery;
+      }
+      Object.freeze(this);
+    }
+    static fromBytes(bytes, format = defaultSigOpts.format) {
+      validateSigLength(bytes, format);
+      let recid;
+      if (format === "der") {
+        const { r, s } = DER.toSig(abytes(bytes));
+        return new Signature(r, s);
+      }
+      if (format === "recovered") {
+        recid = bytes[0];
+        format = "compact";
+        bytes = bytes.subarray(1);
+      }
+      const L = lengths.signature / 2;
+      const r = bytes.subarray(0, L);
+      const s = bytes.subarray(L, L * 2);
+      return new Signature(Fn.fromBytes(r), Fn.fromBytes(s), recid);
+    }
+    static fromHex(hex, format) {
+      return this.fromBytes(hexToBytes(hex), format);
+    }
+    assertRecovery() {
+      const { recovery } = this;
+      if (recovery == null)
+        throw new Error("invalid recovery id: must be present");
+      return recovery;
+    }
+    addRecoveryBit(recovery) {
+      return new Signature(this.r, this.s, recovery);
+    }
+    recoverPublicKey(messageHash) {
+      const { r, s } = this;
+      const recovery = this.assertRecovery();
+      const radj = recovery === 2 || recovery === 3 ? r + CURVE_ORDER : r;
+      if (!Fp.isValid(radj))
+        throw new Error("invalid recovery id: sig.r+curve.n != R.x");
+      const x = Fp.toBytes(radj);
+      const R = Point.fromBytes(concatBytes(pprefix((recovery & 1) === 0), x));
+      const ir = Fn.inv(radj);
+      const h = bits2int_modN(abytes(messageHash, undefined, "msgHash"));
+      const u1 = Fn.create(-h * ir);
+      const u2 = Fn.create(s * ir);
+      const Q = Point.BASE.multiplyUnsafe(u1).add(R.multiplyUnsafe(u2));
+      if (Q.is0())
+        throw new Error("invalid recovery: point at infinify");
+      Q.assertValidity();
+      return Q;
+    }
+    hasHighS() {
+      return isBiggerThanHalfOrder(this.s);
+    }
+    toBytes(format = defaultSigOpts.format) {
+      validateSigFormat(format);
+      if (format === "der")
+        return hexToBytes(DER.hexFromSig(this));
+      const { r, s } = this;
+      const rb = Fn.toBytes(r);
+      const sb = Fn.toBytes(s);
+      if (format === "recovered") {
+        assertSmallCofactor();
+        return concatBytes(Uint8Array.of(this.assertRecovery()), rb, sb);
+      }
+      return concatBytes(rb, sb);
+    }
+    toHex(format) {
+      return bytesToHex(this.toBytes(format));
+    }
+  }
+  const bits2int = ecdsaOpts.bits2int || function bits2int_def(bytes) {
+    if (bytes.length > 8192)
+      throw new Error("input is too large");
+    const num = bytesToNumberBE(bytes);
+    const delta = bytes.length * 8 - fnBits;
+    return delta > 0 ? num >> BigInt(delta) : num;
+  };
+  const bits2int_modN = ecdsaOpts.bits2int_modN || function bits2int_modN_def(bytes) {
+    return Fn.create(bits2int(bytes));
+  };
+  const ORDER_MASK = bitMask(fnBits);
+  function int2octets(num) {
+    aInRange("num < 2^" + fnBits, num, _0n4, ORDER_MASK);
+    return Fn.toBytes(num);
+  }
+  function validateMsgAndHash(message, prehash) {
+    abytes(message, undefined, "message");
+    return prehash ? abytes(hash(message), undefined, "prehashed message") : message;
+  }
+  function prepSig(message, secretKey, opts) {
+    const { lowS, prehash, extraEntropy } = validateSigOpts(opts, defaultSigOpts);
+    message = validateMsgAndHash(message, prehash);
+    const h1int = bits2int_modN(message);
+    const d = Fn.fromBytes(secretKey);
+    if (!Fn.isValidNot0(d))
+      throw new Error("invalid private key");
+    const seedArgs = [int2octets(d), int2octets(h1int)];
+    if (extraEntropy != null && extraEntropy !== false) {
+      const e = extraEntropy === true ? randomBytes2(lengths.secretKey) : extraEntropy;
+      seedArgs.push(abytes(e, undefined, "extraEntropy"));
+    }
+    const seed = concatBytes(...seedArgs);
+    const m = h1int;
+    function k2sig(kBytes) {
+      const k = bits2int(kBytes);
+      if (!Fn.isValidNot0(k))
+        return;
+      const ik = Fn.inv(k);
+      const q = Point.BASE.multiply(k).toAffine();
+      const r = Fn.create(q.x);
+      if (r === _0n4)
+        return;
+      const s = Fn.create(ik * Fn.create(m + r * d));
+      if (s === _0n4)
+        return;
+      let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n4);
+      let normS = s;
+      if (lowS && isBiggerThanHalfOrder(s)) {
+        normS = Fn.neg(s);
+        recovery ^= 1;
+      }
+      return new Signature(r, normS, hasLargeCofactor ? undefined : recovery);
+    }
+    return { seed, k2sig };
+  }
+  function sign(message, secretKey, opts = {}) {
+    const { seed, k2sig } = prepSig(message, secretKey, opts);
+    const drbg = createHmacDrbg(hash.outputLen, Fn.BYTES, hmac2);
+    const sig = drbg(seed, k2sig);
+    return sig.toBytes(opts.format);
+  }
+  function verify(signature, message, publicKey, opts = {}) {
+    const { lowS, prehash, format } = validateSigOpts(opts, defaultSigOpts);
+    publicKey = abytes(publicKey, undefined, "publicKey");
+    message = validateMsgAndHash(message, prehash);
+    if (!isBytes(signature)) {
+      const end = signature instanceof Signature ? ", use sig.toBytes()" : "";
+      throw new Error("verify expects Uint8Array signature" + end);
+    }
+    validateSigLength(signature, format);
+    try {
+      const sig = Signature.fromBytes(signature, format);
+      const P = Point.fromBytes(publicKey);
+      if (lowS && sig.hasHighS())
+        return false;
+      const { r, s } = sig;
+      const h = bits2int_modN(message);
+      const is = Fn.inv(s);
+      const u1 = Fn.create(h * is);
+      const u2 = Fn.create(r * is);
+      const R = Point.BASE.multiplyUnsafe(u1).add(P.multiplyUnsafe(u2));
+      if (R.is0())
+        return false;
+      const v = Fn.create(R.x);
+      return v === r;
+    } catch (e) {
+      return false;
+    }
+  }
+  function recoverPublicKey(signature, message, opts = {}) {
+    const { prehash } = validateSigOpts(opts, defaultSigOpts);
+    message = validateMsgAndHash(message, prehash);
+    return Signature.fromBytes(signature, "recovered").recoverPublicKey(message).toBytes();
+  }
+  return Object.freeze({
+    keygen,
+    getPublicKey,
+    getSharedSecret,
+    utils,
+    lengths,
+    Point,
+    sign,
+    verify,
+    recoverPublicKey,
+    Signature,
+    hash
+  });
+}
+
+// ../../node_modules/@noble/curves/secp256k1.js
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+var secp256k1_CURVE = {
+  p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),
+  n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),
+  h: BigInt(1),
+  a: BigInt(0),
+  b: BigInt(7),
+  Gx: BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
+  Gy: BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")
+};
+var secp256k1_ENDO = {
+  beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
+  basises: [
+    [BigInt("0x3086d221a7d46bcde86c90e49284eb15"), -BigInt("0xe4437ed6010e88286f547fa90abfe4c3")],
+    [BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), BigInt("0x3086d221a7d46bcde86c90e49284eb15")]
+  ]
+};
+var _2n3 = /* @__PURE__ */ BigInt(2);
+function sqrtMod(y) {
+  const P = secp256k1_CURVE.p;
+  const _3n = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
+  const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
+  const b2 = y * y * y % P;
+  const b3 = b2 * b2 * y % P;
+  const b6 = pow2(b3, _3n, P) * b3 % P;
+  const b9 = pow2(b6, _3n, P) * b3 % P;
+  const b11 = pow2(b9, _2n3, P) * b2 % P;
+  const b22 = pow2(b11, _11n, P) * b11 % P;
+  const b44 = pow2(b22, _22n, P) * b22 % P;
+  const b88 = pow2(b44, _44n, P) * b44 % P;
+  const b176 = pow2(b88, _88n, P) * b88 % P;
+  const b220 = pow2(b176, _44n, P) * b44 % P;
+  const b223 = pow2(b220, _3n, P) * b3 % P;
+  const t1 = pow2(b223, _23n, P) * b22 % P;
+  const t2 = pow2(t1, _6n, P) * b2 % P;
+  const root = pow2(t2, _2n3, P);
+  if (!Fpk1.eql(Fpk1.sqr(root), y))
+    throw new Error("Cannot find square root");
+  return root;
+}
+var Fpk1 = Field(secp256k1_CURVE.p, { sqrt: sqrtMod });
+var Pointk1 = /* @__PURE__ */ weierstrass(secp256k1_CURVE, {
+  Fp: Fpk1,
+  endo: secp256k1_ENDO
+});
+var secp256k1 = /* @__PURE__ */ ecdsa(Pointk1, sha256);
+
+// ../verify/src/signers.ts
+import { deserializeCV } from "@secondlayer/stacks/clarity";
+import { c32address, hash160 } from "@secondlayer/stacks/utils";
+var MAINNET_P2PKH = 22;
+var SIGNERS_CONTRACT = "SP000000000000000000002Q6VF78.signers";
+function decodeSignerSet(value) {
+  const cv = deserializeCV(typeof value === "string" ? value : hex(value));
+  if (cv.type !== "some" || cv.value.type !== "list")
+    throw new Error("signer set must be (some (list ...))");
+  const set = new Map;
+  for (const entry of cv.value.value) {
+    if (entry.type !== "tuple")
+      throw new Error("signer entry must be a tuple");
+    const { signer, weight } = entry.value;
+    if (signer?.type !== "address" || weight?.type !== "uint")
+      throw new Error("signer entry needs (signer principal) (weight uint)");
+    if (set.has(signer.value))
+      throw new Error(`duplicate signer ${signer.value}`);
+    set.set(signer.value, BigInt(weight.value));
+  }
+  return set;
+}
+function verifySignerSignatures(header, set) {
+  const msg = signerSignatureHash(header);
+  let totalWeight = 0n;
+  for (const w of set.values())
+    totalWeight += w;
+  const threshold = (totalWeight * 7n + 9n) / 10n;
+  const out = {
+    valid: false,
+    signedWeight: 0n,
+    totalWeight,
+    threshold,
+    signers: [],
+    unknown: [],
+    duplicates: [],
+    invalid: 0
+  };
+  const seen = new Set;
+  for (const sig of header.signerSignatures) {
+    const who = recoverSigner(msg, sig);
+    if (!who)
+      out.invalid++;
+    else if (seen.has(who))
+      out.duplicates.push(who);
+    else {
+      seen.add(who);
+      const weight = set.get(who);
+      if (weight === undefined)
+        out.unknown.push(who);
+      else {
+        out.signers.push(who);
+        out.signedWeight += weight;
+      }
+    }
+  }
+  out.valid = totalWeight > 0n && out.signedWeight >= threshold && out.unknown.length === 0 && out.duplicates.length === 0 && out.invalid === 0;
+  return out;
+}
+function recoverSigner(msg, sig) {
+  try {
+    const s = secp256k1.Signature.fromBytes(sig, "recovered");
+    if (s.hasHighS())
+      return null;
+    const pubkey = s.recoverPublicKey(msg).toBytes(true);
+    return c32address(MAINNET_P2PKH, hex(hash160(pubkey)));
+  } catch {
+    return null;
+  }
+}
+// ../../node_modules/@noble/hashes/legacy.js
+var Rho160 = /* @__PURE__ */ Uint8Array.from([
+  7,
+  4,
+  13,
+  1,
+  10,
+  6,
+  15,
+  3,
+  12,
+  0,
+  9,
+  5,
+  2,
+  14,
+  11,
+  8
+]);
+var Id160 = /* @__PURE__ */ (() => Uint8Array.from(new Array(16).fill(0).map((_, i) => i)))();
+var Pi160 = /* @__PURE__ */ (() => Id160.map((i) => (9 * i + 5) % 16))();
+var idxLR = /* @__PURE__ */ (() => {
+  const L = [Id160];
+  const R = [Pi160];
+  const res = [L, R];
+  for (let i = 0;i < 4; i++)
+    for (let j of res)
+      j.push(j[i].map((k) => Rho160[k]));
+  return res;
+})();
+var idxL = /* @__PURE__ */ (() => idxLR[0])();
+var idxR = /* @__PURE__ */ (() => idxLR[1])();
+var shifts160 = /* @__PURE__ */ [
+  [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
+  [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
+  [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
+  [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
+  [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
+].map((i) => Uint8Array.from(i));
+var shiftsL160 = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts160[i][j]));
+var shiftsR160 = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts160[i][j]));
+var Kl160 = /* @__PURE__ */ Uint32Array.from([
+  0,
+  1518500249,
+  1859775393,
+  2400959708,
+  2840853838
+]);
+var Kr160 = /* @__PURE__ */ Uint32Array.from([
+  1352829926,
+  1548603684,
+  1836072691,
+  2053994217,
+  0
+]);
+function ripemd_f(group, x, y, z) {
+  if (group === 0)
+    return x ^ y ^ z;
+  if (group === 1)
+    return x & y | ~x & z;
+  if (group === 2)
+    return (x | ~y) ^ z;
+  if (group === 3)
+    return x & z | y & ~z;
+  return x ^ (y | ~z);
+}
+var BUF_160 = /* @__PURE__ */ new Uint32Array(16);
+
+class _RIPEMD160 extends HashMD {
+  h0 = 1732584193 | 0;
+  h1 = 4023233417 | 0;
+  h2 = 2562383102 | 0;
+  h3 = 271733878 | 0;
+  h4 = 3285377520 | 0;
+  constructor() {
+    super(64, 20, 8, true);
+  }
+  get() {
+    const { h0, h1, h2, h3, h4 } = this;
+    return [h0, h1, h2, h3, h4];
+  }
+  set(h0, h1, h2, h3, h4) {
+    this.h0 = h0 | 0;
+    this.h1 = h1 | 0;
+    this.h2 = h2 | 0;
+    this.h3 = h3 | 0;
+    this.h4 = h4 | 0;
+  }
+  process(view, offset) {
+    for (let i = 0;i < 16; i++, offset += 4)
+      BUF_160[i] = view.getUint32(offset, true);
+    let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
+    for (let group = 0;group < 5; group++) {
+      const rGroup = 4 - group;
+      const hbl = Kl160[group], hbr = Kr160[group];
+      const rl = idxL[group], rr = idxR[group];
+      const sl = shiftsL160[group], sr = shiftsR160[group];
+      for (let i = 0;i < 16; i++) {
+        const tl = rotl(al + ripemd_f(group, bl, cl, dl) + BUF_160[rl[i]] + hbl, sl[i]) + el | 0;
+        al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl;
+      }
+      for (let i = 0;i < 16; i++) {
+        const tr = rotl(ar + ripemd_f(rGroup, br, cr, dr) + BUF_160[rr[i]] + hbr, sr[i]) + er | 0;
+        ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr;
+      }
+    }
+    this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
+  }
+  roundClean() {
+    clean(BUF_160);
+  }
+  destroy() {
+    this.destroyed = true;
+    clean(this.buffer);
+    this.set(0, 0, 0, 0, 0);
+  }
+}
+var ripemd160 = /* @__PURE__ */ createHasher(() => new _RIPEMD160);
+
+// ../verify/src/burn.ts
+var PREIMAGE_PREFIX = Uint8Array.of(23, 0, 0, 0);
+var BHH_START = 4;
+var BHH_END = 36;
+function verifyConsensusPreimage(consensusHash, preimage) {
+  if (consensusHash.length !== 20 || preimage.length < BHH_END)
+    return null;
+  if (!bytesEqual(preimage.subarray(0, BHH_START), PREIMAGE_PREFIX))
+    return null;
+  if (!bytesEqual(ripemd160(sha256(preimage)), consensusHash))
+    return null;
+  return hex(preimage.subarray(BHH_START, BHH_END));
+}
+var MAINNET_FIRST_BURN_HEIGHT = 666050;
+var MAINNET_REWARD_CYCLE_LENGTH = 2100;
+var MAINNET_PREPARE_LENGTH = 100;
+var cycleStart = (cycle, firstBurnHeight = MAINNET_FIRST_BURN_HEIGHT, cycleLength = MAINNET_REWARD_CYCLE_LENGTH) => firstBurnHeight + cycle * cycleLength;
+function rewardCycle(burnHeight, firstBurnHeight = MAINNET_FIRST_BURN_HEIGHT, cycleLength = MAINNET_REWARD_CYCLE_LENGTH) {
+  if (burnHeight < firstBurnHeight)
+    throw new Error(`burn height ${burnHeight} precedes the first burn block`);
+  return Math.floor((burnHeight - firstBurnHeight) / cycleLength);
+}
+// ../verify/src/keys.ts
+import { serializeCV } from "@secondlayer/stacks/clarity";
+import { c32addressDecode } from "@secondlayer/stacks/utils";
+var StoreType = { DataMap: 0, Variable: 1, FungibleToken: 2 };
+function mapEntryKey(contractId, mapName, key) {
+  return `vm::${contractId}::${StoreType.DataMap}::${mapName}::${serializeCV(key)}`;
+}
+function dataVarKey(contractId, varName) {
+  return `vm::${contractId}::${StoreType.Variable}::${varName}`;
+}
+// ../verify/src/bitcoin/header.ts
+var HEADER_SIZE = 80;
+function toBytes(raw) {
+  return typeof raw === "string" ? hexToBytes(raw) : raw;
+}
+function reverseBytes(bytes) {
+  return Uint8Array.from(bytes).reverse();
+}
+function parseHeader(raw) {
+  const bytes = toBytes(raw);
+  if (bytes.length !== HEADER_SIZE) {
+    throw new RangeError(`block header must be ${HEADER_SIZE} bytes, got ${bytes.length}`);
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, HEADER_SIZE);
+  return {
+    version: view.getInt32(0, true),
+    prevHash: bytesToHex(reverseBytes(bytes.subarray(4, 36))),
+    merkleRoot: bytesToHex(reverseBytes(bytes.subarray(36, 68))),
+    time: view.getUint32(68, true),
+    bits: view.getUint32(72, true),
+    nonce: view.getUint32(76, true)
+  };
+}
+function headerHash(raw) {
+  const bytes = toBytes(raw);
+  if (bytes.length !== HEADER_SIZE) {
+    throw new RangeError(`block header must be ${HEADER_SIZE} bytes, got ${bytes.length}`);
+  }
+  return sha256(sha256(bytes));
+}
+
+// ../verify/src/bitcoin/pow.ts
+var POW_LIMIT = 0xffffn << 208n;
+var RETARGET_INTERVAL = 2016;
+var TARGET_TIMESPAN = 14 * 24 * 60 * 60;
+var TWO_256 = 1n << 256n;
+function decodeCompact(bits) {
+  const size = bits >>> 24;
+  let word = bits & 8388607;
+  let target;
+  if (size <= 3) {
+    word >>>= 8 * (3 - size);
+    target = BigInt(word);
+  } else {
+    target = BigInt(word) << BigInt(8 * (size - 3));
+  }
+  const negative = word !== 0 && (bits & 8388608) !== 0;
+  const overflow = word !== 0 && (size > 34 || word > 255 && size > 33 || word > 65535 && size > 32);
+  return { target: target & TWO_256 - 1n, negative, overflow };
+}
+function bitsToTarget(bits) {
+  const { target, negative, overflow } = decodeCompact(bits);
+  if (negative || overflow || target === 0n) {
+    throw new RangeError(`bits 0x${bits.toString(16).padStart(8, "0")} do not encode a valid target`);
+  }
+  return target;
+}
+function targetToBits(target) {
+  if (target < 0n)
+    throw new RangeError("target must be non-negative");
+  let size = target === 0n ? 0 : Math.ceil(target.toString(2).length / 8);
+  let compact = size <= 3 ? Number(target << BigInt(8 * (3 - size))) : Number(target >> BigInt(8 * (size - 3)));
+  if (compact & 8388608) {
+    compact >>>= 8;
+    size += 1;
+  }
+  return (size << 24 | compact) >>> 0;
+}
+function hashToBigInt(hash) {
+  let n = 0n;
+  for (let i = hash.length - 1;i >= 0; i--) {
+    n = n << 8n | BigInt(hash[i]);
+  }
+  return n;
+}
+function checkProofOfWork(hash, bits) {
+  const { target, negative, overflow } = decodeCompact(bits);
+  if (negative || overflow || target === 0n || target > POW_LIMIT) {
+    return false;
+  }
+  return hashToBigInt(hash) <= target;
+}
+function headerWork(bits) {
+  const target = bitsToTarget(bits);
+  return (TWO_256 - 1n - target) / (target + 1n) + 1n;
+}
+function nextRetargetBits(lastBits, firstTime, lastTime) {
+  let actual = lastTime - firstTime;
+  if (actual < TARGET_TIMESPAN / 4)
+    actual = TARGET_TIMESPAN / 4;
+  if (actual > TARGET_TIMESPAN * 4)
+    actual = TARGET_TIMESPAN * 4;
+  let target = bitsToTarget(lastBits) * BigInt(actual) / BigInt(TARGET_TIMESPAN);
+  if (target > POW_LIMIT)
+    target = POW_LIMIT;
+  return targetToBits(target);
+}
+
+// ../verify/src/bitcoin/chain.ts
+var MEDIAN_TIME_SPAN = 11;
+var BIP65_HEIGHT = 388381;
+
+class HeaderValidationError extends Error {
+  height;
+  rule;
+  name = "HeaderValidationError";
+  constructor(height, rule, detail) {
+    super(`header at height ${height} failed ${rule}: ${detail}`);
+    this.height = height;
+    this.rule = rule;
+  }
+}
+var hex8 = (n) => `0x${n.toString(16).padStart(8, "0")}`;
+
+class HeaderChain {
+  base;
+  periodStartTime;
+  entries = [];
+  heights = new Map;
+  work = 0n;
+  constructor(base, periodStartTime) {
+    this.base = base;
+    this.periodStartTime = periodStartTime;
+  }
+  static fromCheckpoint(checkpoint) {
+    const { height } = checkpoint;
+    if (!Number.isSafeInteger(height) || height < 0) {
+      throw new HeaderValidationError(height, "checkpoint", "height must be a non-negative integer");
+    }
+    const raw = toRaw(checkpoint.header, height);
+    const header = parseHeader(raw);
+    try {
+      bitsToTarget(header.bits);
+    } catch (err) {
+      throw new HeaderValidationError(height, "checkpoint", err.message);
+    }
+    const atPeriodStart = height % RETARGET_INTERVAL === 0;
+    let periodStartTime = checkpoint.periodStartTime;
+    if (atPeriodStart) {
+      if (periodStartTime !== undefined && periodStartTime !== header.time) {
+        throw new HeaderValidationError(height, "checkpoint", `periodStartTime ${periodStartTime} disagrees with the period-start checkpoint's own time ${header.time}`);
+      }
+      periodStartTime = header.time;
+    } else if (periodStartTime === undefined) {
+      throw new HeaderValidationError(height, "checkpoint", `periodStartTime is required for a checkpoint inside a difficulty period (period starts at ${height - height % RETARGET_INTERVAL})`);
+    }
+    const chain = new HeaderChain(height, periodStartTime);
+    chain.push(raw, header);
+    return chain;
+  }
+  get tip() {
+    return this.entries[this.entries.length - 1];
+  }
+  get totalWork() {
+    return this.work;
+  }
+  get checkpointHeight() {
+    return this.base;
+  }
+  heightOf(hashHex) {
+    return this.heights.get(hashHex.toLowerCase());
+  }
+  headerAt(height) {
+    return this.entries[height - this.base];
+  }
+  append(headers) {
+    const before = this.entries.length;
+    const workBefore = this.work;
+    try {
+      for (const item of headers) {
+        const height = this.tip.height + 1;
+        const raw = toRaw(item, height);
+        this.validate(height, raw, parseHeader(raw));
+      }
+    } catch (err) {
+      for (const removed of this.entries.splice(before)) {
+        this.heights.delete(removed.hash);
+      }
+      this.work = workBefore;
+      throw err;
+    }
+  }
+  validate(height, raw, header) {
+    const prev = this.tip;
+    if (header.prevHash !== prev.hash) {
+      const known = this.heights.get(header.prevHash);
+      throw new HeaderValidationError(height, "prev-link", known === undefined ? `prevHash ${header.prevHash} does not match tip ${prev.hash} at ${prev.height}` : `prevHash points at height ${known}, not the tip at ${prev.height} (forks/reorgs are not supported)`);
+    }
+    const expectedBits = this.expectedBits(height, prev);
+    if (header.bits !== expectedBits) {
+      const atRetarget = height % RETARGET_INTERVAL === 0;
+      throw new HeaderValidationError(height, atRetarget ? "retarget" : "bits", atRetarget ? `bits ${hex8(header.bits)} != retargeted ${hex8(expectedBits)}` : `bits ${hex8(header.bits)} != previous ${hex8(expectedBits)} (only height % ${RETARGET_INTERVAL} == 0 may change difficulty)`);
+    }
+    const mtp = this.medianTimePast();
+    if (header.time <= mtp) {
+      throw new HeaderValidationError(height, "median-time-past", `time ${header.time} <= median of previous ${Math.min(MEDIAN_TIME_SPAN, this.entries.length)} blocks (${mtp})`);
+    }
+    if (height >= BIP65_HEIGHT && header.version < 4) {
+      throw new HeaderValidationError(height, "version", `version ${header.version} < 4 (required from height ${BIP65_HEIGHT})`);
+    }
+    const hash = headerHash(raw);
+    if (!checkProofOfWork(hash, header.bits)) {
+      throw new HeaderValidationError(height, "proof-of-work", `hash ${bytesToHex(reverseBytes(hash))} exceeds target for bits ${hex8(header.bits)}`);
+    }
+    this.push(raw, header, hash);
+  }
+  expectedBits(height, prev) {
+    if (height % RETARGET_INTERVAL !== 0)
+      return prev.header.bits;
+    const firstHeight = height - RETARGET_INTERVAL;
+    const firstTime = firstHeight < this.base ? this.periodStartTime : this.headerAt(firstHeight).header.time;
+    return nextRetargetBits(prev.header.bits, firstTime, prev.header.time);
+  }
+  medianTimePast() {
+    const times = this.entries.slice(-MEDIAN_TIME_SPAN).map((e) => e.header.time).sort((a, b) => a - b);
+    return times[Math.floor(times.length / 2)];
+  }
+  push(raw, header, hash = headerHash(raw)) {
+    const height = this.base + this.entries.length;
+    const hashHex = bytesToHex(reverseBytes(hash));
+    this.entries.push({ height, hash: hashHex, header, raw });
+    this.heights.set(hashHex, height);
+    this.work += headerWork(header.bits);
+  }
+}
+function toRaw(item, height) {
+  let raw;
+  try {
+    raw = typeof item === "string" ? hexToBytes(item) : Uint8Array.from(item);
+  } catch {
+    throw new HeaderValidationError(height, "format", "header is not valid hex");
+  }
+  if (raw.length !== HEADER_SIZE) {
+    throw new HeaderValidationError(height, "format", `header must be ${HEADER_SIZE} bytes, got ${raw.length}`);
+  }
+  return raw;
+}
+// ../verify/src/checkpoint.ts
+var MAINNET_CHECKPOINT = {
+  stacks: {
+    header: [
+      "01000000000088a9900000006629951a50e3616a1c1e0b8c05ba66615c7065053804c56e2a68dc605cf905df5a754c57",
+      "144e9ddde1191353b05f1a5e6d3c99244aeb006ba4f4db761cb1efecfb92693a8c08fefc766a4cd5ccfcb8f13789a809",
+      "e7ee0c2e6b7dfb64868cf1e4e6acc50513202acfab84553454b433248c0ef06cebda3c734c000000006aa28bfd013be3",
+      "826a60039f518d7021a4799f2e083dafaaaac7a2d56fda601d674d596d3046b9bbcd52e79fba491e54d92fdab0ca3ab9",
+      "9ccf346c6e6726fbd4c8579a02b80000000d0004f2d135dd684fcdf24973ad0e9d4f11ef10890a8159614b1df97d8f31",
+      "76532d1ce4ebdcbbf45afcd01d5bb298ef9556b232f877f3586d65303642dabc210059012d5f341c979fd10a1ce9b48f",
+      "4a38f68da5ccbb8749c02e164a99668328890ed706accfbec155202f63ff487a26aba793169341c2ff91a43ffed38f0e",
+      "941c3dc1012a12bb2148d6cf23dd05e228d29286e3bb87ff717712ecc2c9f0c4297c241ac41f879baeee87a570243a31",
+      "cf43e775862e71a7f51cb150bbc31f3a2f62a1772d00f8bdd615ab5b58841c7918d69cf98a030f52ca410c9b91a188ba",
+      "038138563ea35f8453075907fc3cdac7e3eff8fa9f61fcb53a1e14a102309fa297e420826bfe015628863a16f1bdc077",
+      "90c6eead0cfd7a0aa7222df6d8d41415427b0b4057eb972dc31bd413f1e425ef1bc738cc5c3b8507890bad0940bafdf2",
+      "220a6ecadb33ed002f9a476eb20c5e532bafa7b559b285932e1dab1159c93038d8cb0da8d55d25294cc8e6b0972efc08",
+      "fdf825407e3215d8d01531f5cddfe993db10be07b38c18fa006999eb6418eac4696bb42ca149f79832442754ea08b0e1",
+      "c6237feb522df034a3388c0de90b1a4652218b319f839ff16a132baa90dbbca2876f52b1a5750dc07001cffca3ed6e92",
+      "2483e6567f183a78a1c09d16846743f08c5cce93e7e06294c4a722283d31195722b6ce97087c6dd00eedecd1db77be10",
+      "9c298c322c53e83ea43201dd0684e8171ad29f6895ed9892d3932daeb0986f32992d6758db194ae9ba8eb256fdff3b61",
+      "af0cd448aafe5e4e62e7e75409dfcd3cef3913c792e412849a02550109083fa52598f5fa2907e840050c41db32163838",
+      "32aa7cb5e23de14ced47961e356b23e442f2a657ea89fed2845a6b380624dc12347e4d591c80e15016ae35fc005ae002",
+      "f1fc5837c21185b88b06cc8611cfb482c021df5329d878e2b4f221341a47e6fe02182c9250d25fe162f42a0bbe9b8ce2",
+      "f9a70aa2dcca9e955a61a0fe24016398a0fdf5e2541d3d0838d9f7e24b4093d27660a48cd71bf0728fe5d02e6d374a3e",
+      "aa67c91aee87635d7458bb1fe89755021fbe8d34e271fba1d765b065e266008a862c839aeec0d6a9940cfe44e0bc1586",
+      "2bd2ac23b3ab6fc59734a8171b44401b395984f0f906b2d15b4a3a24d2136a8ca925485f197197b3aa1bb2c46d02e000",
+      "01000000010100000000"
+    ].join(""),
+    cycle: 143,
+    signerSet: [
+      "0a0b0000001d0c00000002067369676e65720516f5061b1c62f399ecc0db8cbb21f8d481af079a380677656967687401",
+      "000000000000000000000000000002860c00000002067369676e65720516a3bbf2a4133fbd5bd1880982957b7a760347",
+      "b2dc0677656967687401000000000000000000000000000000090c00000002067369676e657205164f72f6b5a9f5d863",
+      "34b2f0fe701db51a7a246f3d0677656967687401000000000000000000000000000000990c00000002067369676e6572",
+      "051653ec8b4f51c8286dad6f4ff81ca2a3409d2f382d0677656967687401000000000000000000000000000000050c00",
+      "000002067369676e65720516dba631825ff0f15c7c5946b560070f8f5f5747cb06776569676874010000000000000000",
+      "00000000000000240c00000002067369676e6572051600d058b39f4495b412ff7eada763eaa6386eb90a067765696768",
+      "7401000000000000000000000000000002860c00000002067369676e65720516321ac33715d684d5e8d0cf427cd98557",
+      "6f64c6df06776569676874010000000000000000000000000000000b0c00000002067369676e6572051677a52718ba90",
+      "fca67984166b2a084edb9b3bd8f10677656967687401000000000000000000000000000000030c00000002067369676e",
+      "65720516a54a20479b3b65a461a427b9161b78e64db58ba70677656967687401000000000000000000000000000001a9",
+      "0c00000002067369676e65720516bc1a58c2a058a9e4150db25562e8331ef8a4267c0677656967687401000000000000",
+      "000000000000000000060c00000002067369676e657205161091d2da4c9ee17a340171c0d23c4304b54ef43f06776569",
+      "67687401000000000000000000000000000000680c00000002067369676e6572051654d01a0973ed139736a1a43032a6",
+      "a18d9295ec7206776569676874010000000000000000000000000000008d0c00000002067369676e657205160c49f5b6",
+      "c62f1163ddbb21f92aba86f17f7be4880677656967687401000000000000000000000000000000680c00000002067369",
+      "676e65720516ad16c79ac56b58f0797f78c5343853674606268006776569676874010000000000000000000000000000",
+      "00680c00000002067369676e657205169689e56df00385b6bd81fb6b7769d5b04088acb8067765696768740100000000",
+      "0000000000000000000000ad0c00000002067369676e65720516a4f7f81412f4413771a48825cfbe2062a774d4e90677",
+      "656967687401000000000000000000000000000003090c00000002067369676e65720516ed73a7398f1c3eb566f3bd7f",
+      "4bd43f52adf33d8f0677656967687401000000000000000000000000000000680c00000002067369676e65720516937b",
+      "3b43e0d94c9ef8f171892bce949709e1d41f0677656967687401000000000000000000000000000000250c0000000206",
+      "7369676e6572051631542aacfd6e04858181c3067b5eb07399ba89df0677656967687401000000000000000000000000",
+      "0000005b0c00000002067369676e6572051649f034cd1662a222dbc38a6acd64008ba7e5576606776569676874010000",
+      "00000000000000000000000000060c00000002067369676e65720516a20f660dea498c169897a39cb89ce0d98856e572",
+      "0677656967687401000000000000000000000000000000090c00000002067369676e6572051652d58897b3678f3a758f",
+      "a4b9270744fec0605b210677656967687401000000000000000000000000000000680c00000002067369676e65720516",
+      "31733264626dc5fef36eb683a5069d89f63b64cc0677656967687401000000000000000000000000000000090c000000",
+      "02067369676e65720516d80db618c2def577604cd8e40a3940b5b639b1ac067765696768740100000000000000000000",
+      "00000000000a0c00000002067369676e657205162042a380d946a82866465af8521a273efe6d2a600677656967687401",
+      "000000000000000000000000000000490c00000002067369676e6572051635e1b36efc22bc607db92f9100cb08e3473d",
+      "602506776569676874010000000000000000000000000000006b0c00000002067369676e657205164843b97054e43dd1",
+      "a8571fc1e72949c5bedfb7e906776569676874010000000000000000000000000000004d0c00000002067369676e6572",
+      "05164883355670025c19ecae644ffa20e75ce1d730ad0677656967687401000000000000000000000000000000090c00",
+      "000002067369676e65720516089ffd0e0ecd61d9e3c8ee42ef94148acf88aa8806776569676874010000000000000000",
+      "0000000000000015"
+    ].join("")
+  },
+  bitcoin: {
+    height: 967680,
+    header: "00000030410ccb1cba623e26f2e02f3fcb0e7f06f66998b68cb5010000000000000000003d16ae2558e8ec7b8dd369ee29bb2733fbd39bcc1058c681970a36a7f1a2bdea1135ae6ac51e0217480c3581"
+  }
+};
+// ../verify/src/source.ts
+class SourceError extends Error {
+  url;
+  status;
+  name = "SourceError";
+  constructor(url, status, detail) {
+    super(`${url}: ${detail}`);
+    this.url = url;
+    this.status = status;
+  }
+}
+var MAX_ATTEMPTS = 3;
+var MAX_RETRY_SECONDS = 10;
+async function get(url, opts, attempt = 1) {
+  const doFetch = opts.fetch ?? fetch;
+  let res;
+  try {
+    res = await doFetch(url, { headers: opts.headers });
+  } catch (err) {
+    throw new SourceError(url, null, err.message);
+  }
+  if (res.status === 404)
+    return null;
+  if (res.status === 503 && attempt < MAX_ATTEMPTS) {
+    const header = res.headers.get("retry-after");
+    const seconds = header === null ? 1 : Number(header);
+    const wait = Number.isFinite(seconds) ? Math.min(Math.max(seconds, 0), MAX_RETRY_SECONDS) : 1;
+    await new Promise((r) => setTimeout(r, wait * 1000));
+    return get(url, opts, attempt + 1);
+  }
+  if (!res.ok)
+    throw new SourceError(url, res.status, `HTTP ${res.status}`);
+  return res;
+}
+async function getJson(url, opts) {
+  const res = await get(url, opts);
+  return res ? await res.json() : null;
+}
+async function getBytes(url, opts) {
+  const res = await get(url, opts);
+  return res ? new Uint8Array(await res.arrayBuffer()) : null;
+}
+var required = (url, v) => {
+  if (v === null)
+    throw new SourceError(url, 404, "not found");
+  return v;
+};
+var trimSlash = (s) => s.replace(/\/+$/, "");
+var toMarf = (url, j) => {
+  if (j === null)
+    return null;
+  const proof = j.proof ?? j.marf_proof;
+  if (typeof proof !== "string" || typeof j.data !== "string")
+    throw new SourceError(url, 200, "MARF answer needs data and proof");
+  return { data: j.data, proof: unhex(proof) };
+};
+var VM_WRITE_TYPES = [
+  "var_set",
+  "map_set",
+  "map_insert",
+  "map_delete"
+];
+var PAGE = 1000;
+
+class SecondlayerProofSource {
+  #base;
+  #http;
+  constructor(opts) {
+    this.#base = trimSlash(opts.baseUrl);
+    this.#http = {
+      headers: { authorization: `Bearer ${opts.apiKey}` },
+      fetch: opts.fetch
+    };
+  }
+  getBlock = async (ref) => {
+    const url = typeof ref === "number" ? `${this.#base}/v1/proofs/block/height/${ref}` : `${this.#base}/v1/proofs/block/${ref}`;
+    return required(url, await getBytes(url, this.#http));
+  };
+  getMarfProof = async (pathHex, tipId) => {
+    const url = `${this.#base}/v1/proofs/marf/${pathHex}?tip=${tipId}`;
+    return toMarf(url, await getJson(url, this.#http));
+  };
+  getWitness = async (blockId) => {
+    const url = `${this.#base}/v1/proofs/witness/${blockId}`;
+    return required(url, await getBytes(url, this.#http));
+  };
+  getBurnPreimage = async (consensusHash) => {
+    const url = `${this.#base}/v1/proofs/burn/${consensusHash}`;
+    const j = required(url, await getJson(url, this.#http));
+    return { preimage: unhex(j.preimage), burnHeight: j.burn_height };
+  };
+  getBitcoinHeaders = async (from, count) => {
+    const url = `${this.#base}/v1/proofs/bitcoin-headers?from=${from}&count=${count}`;
+    const j = required(url, await getJson(url, this.#http));
+    if (j.from !== from)
+      throw new SourceError(url, 200, `headers start at ${j.from}`);
+    return j.headers;
+  };
+  getStateWrites = (height) => this.#pages("state_writes", `${this.#base}/v1/index/state-writes?block_height=${height}&limit=${PAGE}`);
+  getVmEvents = async (height) => {
+    const out = [];
+    for (const type of VM_WRITE_TYPES) {
+      const url = `${this.#base}/v1/index/events?event_type=${type}&from_height=${height}&to_height=${height}&limit=${PAGE}`;
+      out.push(...await this.#pages("events", url) ?? []);
+    }
+    return out.sort((a, b) => a.event_index - b.event_index);
+  };
+  async#pages(field, url) {
+    const out = [];
+    let cursor = null;
+    for (;; ) {
+      const page = cursor ? `${url}&cursor=${encodeURIComponent(cursor)}` : url;
+      const j = await getJson(page, this.#http);
+      if (j === null)
+        return cursor === null ? null : out;
+      const rows = j[field];
+      if (!Array.isArray(rows))
+        throw new SourceError(page, 200, `answer has no ${field} array`);
+      out.push(...rows);
+      const next = j.next_cursor;
+      if (rows.length < PAGE || typeof next !== "string" || next === cursor)
+        return out;
+      cursor = next;
+    }
+  }
+}
+
+class NodeRpcProofSource {
+  #base;
+  #http;
+  constructor(opts) {
+    this.#base = trimSlash(opts.nodeUrl);
+    this.#http = { fetch: opts.fetch };
+  }
+  getBlock = async (ref) => {
+    const url = typeof ref === "number" ? `${this.#base}/v3/blocks/height/${ref}` : `${this.#base}/v3/blocks/${ref}`;
+    return required(url, await getBytes(url, this.#http));
+  };
+  getMarfProof = async (pathHex, tipId) => {
+    const url = `${this.#base}/v2/clarity/marf/${pathHex}?tip=${tipId}&proof=1`;
+    return toMarf(url, await getJson(url, this.#http));
+  };
+}
+// ../verify/src/state.ts
+var INTERNAL = {
+  self: "__MARF_BLOCK_HEIGHT_SELF",
+  heightToHash: "__MARF_BLOCK_HEIGHT_TO_HASH",
+  hashToHeight: "__MARF_BLOCK_HASH_TO_HEIGHT"
+};
+var heightValue = (h) => {
+  const v = new Uint8Array(MARF_VALUE_SIZE);
+  new DataView(v.buffer).setUint32(0, h, true);
+  return hex(v);
+};
+var padded = (b32) => `${hex(b32)}${"00".repeat(8)}`;
+function internalEntries(height, parentBlockId, leaves) {
+  const out = [[INTERNAL.self, heightValue(height)]];
+  const ownKey = `${INTERNAL.heightToHash}::${height}`;
+  const ownPath = marfPath(ownKey);
+  const own = leaves.find((l) => bytesEqual(l.path, ownPath));
+  if (own) {
+    out.push([ownKey, padded(own.valueHash)]);
+    out.push([
+      `${INTERNAL.hashToHeight}::${hex(own.valueHash)}`,
+      heightValue(height)
+    ]);
+  }
+  if (height > 0) {
+    out.push([
+      `${INTERNAL.heightToHash}::${height - 1}`,
+      padded(parentBlockId)
+    ]);
+    out.push([
+      `${INTERNAL.hashToHeight}::${hex(parentBlockId)}`,
+      heightValue(height - 1)
+    ]);
+  }
+  return out;
+}
+var utf8 = new TextDecoder("utf-8", { fatal: true });
+var strip0x = (s) => s.startsWith("0x") ? s.slice(2) : s;
+var leafHex = (l) => ({
+  path: hex(l.path),
+  valueHash: hex(l.valueHash)
+});
+function lastWrites(writes, failures) {
+  const out = new Map;
+  for (const w of [...writes].sort((a, b) => a.ordinal - b.ordinal)) {
+    try {
+      out.set(w.key, {
+        value: utf8.decode(unhex(strip0x(w.value_hex))),
+        txIndex: w.tx_index
+      });
+    } catch {
+      failures.push({
+        step: "names",
+        code: "bad-write",
+        message: `state write ${w.ordinal} value is not UTF-8 hex`,
+        key: w.key,
+        ordinal: w.ordinal
+      });
+    }
+  }
+  return out;
+}
+function rowWrite(row) {
+  const need = (v, name) => {
+    if (!v)
+      throw new Error(`${row.event_type} row has no ${name}`);
+    return v;
+  };
+  if (row.event_type === "var_set")
+    return [
+      dataVarKey(row.contract_id, need(row.var_name, "var_name")),
+      strip0x(need(row.raw_value, "raw_value")).toLowerCase()
+    ];
+  const key = `vm::${row.contract_id}::0::${need(row.map, "map")}::${strip0x(need(row.raw_key, "raw_key")).toLowerCase()}`;
+  if (row.event_type === "map_delete")
+    return [key, "09"];
+  return [key, `0a${strip0x(need(row.raw_value, "raw_value")).toLowerCase()}`];
+}
+function checkRows(rows, leaves, failures) {
+  const byPath = new Map(leaves.map((l) => [hex(l.path), l]));
+  const named = [];
+  for (const row of [...rows].sort((a, b) => a.event_index - b.event_index)) {
+    try {
+      const [key, value] = rowWrite(row);
+      named.push({ row, key, path: hex(marfPath(key)), value });
+    } catch (err) {
+      failures.push({
+        step: "rows",
+        code: "bad-row",
+        message: err.message,
+        ordinal: row.event_index
+      });
+    }
+  }
+  const last = new Map(named.map((n, i) => [n.path, i]));
+  named.forEach((n, i) => {
+    const leaf = byPath.get(n.path);
+    const at = { key: n.key, path: n.path, ordinal: n.row.event_index };
+    if (!leaf)
+      failures.push({
+        step: "rows",
+        code: "key-not-written",
+        message: `${n.row.event_type} row ${n.row.event_index} names a key the block did not write`,
+        ...at
+      });
+    else if (last.get(n.path) === i && padded(leaf.valueHash) !== hex(marfValue(n.value)))
+      failures.push({
+        step: "rows",
+        code: "value-mismatch",
+        message: `${n.row.event_type} row ${n.row.event_index} value differs from the block's leaf`,
+        ...at
+      });
+  });
+  return named.length;
+}
+async function verifyBlockState(input) {
+  const out = { rowsChecked: 0, notes: [], failures: [] };
+  let witness;
+  try {
+    witness = parseWitness(input.witness);
+  } catch (err) {
+    out.failures.push({
+      step: "witness",
+      code: "malformed",
+      message: err.message
+    });
+    return out;
+  }
+  if (!bytesEqual(witness.root, input.stateRoot)) {
+    out.failures.push({
+      step: "witness",
+      code: "root-mismatch",
+      message: `witness root ${hex(witness.root)} != header state_index_root ${hex(input.stateRoot)}`
+    });
+    return out;
+  }
+  const { leaves } = witness;
+  const internal = internalEntries(input.height, input.parentBlockId, leaves);
+  const named = input.writes !== null;
+  const last = lastWrites(input.writes ?? [], out.failures);
+  const writes = [...last].map(([k, w]) => [k, w.value]);
+  const first = classifyBlockDiff({
+    leaves,
+    writes,
+    internal,
+    parentValue: () => {
+      return;
+    }
+  });
+  const inParent = new Map((input.parentLeaves ?? []).map((l) => [hex(l.path), hex(l.valueHash)]));
+  const carried = new Map;
+  for (const leaf of first.hidden) {
+    const pathHex = hex(leaf.path);
+    if (inParent.get(pathHex) === hex(leaf.valueHash) || named && await input.parentHolds?.(leaf))
+      carried.set(pathHex, padded(leaf.valueHash));
+  }
+  const d = classifyBlockDiff({
+    leaves,
+    writes,
+    internal,
+    parentValue: (p) => carried.get(p)
+  });
+  out.diff = {
+    named,
+    writes: named ? d.writes.map((l) => ({
+      ...leafHex(l),
+      key: l.key,
+      txIndex: last.get(l.key)?.txIndex ?? null,
+      named: true
+    })) : d.hidden.map((l) => ({ ...leafHex(l), named: false })),
+    carried: d.carried.map(leafHex),
+    internal: d.internal.map((l) => ({ ...leafHex(l), key: l.key }))
+  };
+  if (!named)
+    out.notes.push(`source has no state_writes for block ${input.height}: ${d.hidden.length} written leaves are proven in the block but unnamed`);
+  else {
+    for (const l of d.hidden)
+      out.failures.push({
+        step: "names",
+        code: "hidden-write",
+        message: `leaf ${hex(l.path)} is not a named write, a carried parent value or MARF bookkeeping`,
+        path: hex(l.path)
+      });
+    for (const key of d.missing)
+      out.failures.push({
+        step: "names",
+        code: "missing-write",
+        message: `state write ${key} has no leaf holding its value`,
+        key,
+        path: hex(marfPath(key))
+      });
+  }
+  if (input.rows)
+    out.rowsChecked = checkRows(input.rows, leaves, out.failures);
+  return out;
+}
+// ../verify/src/verify-block.ts
+import { uintCV } from "@secondlayer/stacks/clarity";
+class Broken extends Error {
+  failure;
+  constructor(failure) {
+    super(failure.message);
+    this.failure = failure;
+  }
+}
+var fail = (f) => {
+  throw new Broken(f);
+};
+async function fetchFor(step, what, call, extra = {}) {
+  try {
+    return await call();
+  } catch (err) {
+    if (err instanceof Broken)
+      throw err;
+    return fail({
+      step,
+      code: "unavailable",
+      message: `${what}: ${err.message}`,
+      ...extra
+    });
+  }
+}
+var BITCOIN_BATCH = 2016;
+async function findAnchor(low, high, window2, probe, maxProbes = 32) {
+  let [lo, hi] = [low, high];
+  const target = (window2[0] + window2[1]) / 2;
+  let bisect = false;
+  for (let i = 0;i < maxProbes; i++) {
+    const span = hi.height - lo.height;
+    if (span <= 1)
+      return null;
+    let h = Math.floor((lo.height + hi.height) / 2);
+    if (!bisect && lo.burn !== undefined && hi.burn !== undefined && hi.burn > lo.burn)
+      h = lo.height + Math.round((target - lo.burn) * span / (hi.burn - lo.burn));
+    h = Math.min(Math.max(h, lo.height + 1), hi.height - 1);
+    const p = await probe(h);
+    if (p.height <= lo.height || p.height >= hi.height)
+      return null;
+    if (p.burn >= window2[0] && p.burn < window2[1])
+      return p;
+    if (p.burn < window2[0])
+      lo = p;
+    else
+      hi = p;
+    bisect = hi.height - lo.height > span / 2;
+  }
+  return null;
+}
+
+class BlockVerifier {
+  #source;
+  #checkpoint;
+  #chain;
+  #sets = new Map;
+  #anchors = new Map;
+  #headers = new Map;
+  #burns = new Map;
+  #preimages = new Map;
+  #start;
+  constructor(opts) {
+    this.#source = opts.source;
+    this.#checkpoint = opts.checkpoint ?? MAINNET_CHECKPOINT;
+    const { stacks } = this.#checkpoint;
+    const header = parseNakamotoHeader(unhex(stacks.header));
+    this.#start = { header, id: hex(blockId(header)) };
+    this.#headers.set(this.#start.id, header);
+    this.#sets.set(stacks.cycle, decodeSignerSet(stacks.signerSet));
+    this.#chain = HeaderChain.fromCheckpoint(this.#checkpoint.bitcoin);
+  }
+  async verify(ref) {
+    const out = { ok: false, notes: [], failures: [] };
+    try {
+      await this.#verify(ref, out);
+    } catch (err) {
+      if (!(err instanceof Broken))
+        throw err;
+      out.failures.unshift(err.failure);
+    }
+    out.ok = out.failures.length === 0;
+    return out;
+  }
+  async#verify(ref, out) {
+    const src = this.#source;
+    const raw = await fetchFor("block", `block ${ref}`, () => src.getBlock(ref));
+    const header = parseHeader2(raw, "block");
+    const id = hex(blockId(header));
+    const height = Number(header.chainLength);
+    if (typeof ref === "string" && id !== ref.replace(/^0x/, "").toLowerCase())
+      fail({
+        step: "block",
+        code: "id-mismatch",
+        message: `source returned block ${id} for ${ref}`
+      });
+    if (typeof ref === "number" && height !== ref)
+      fail({
+        step: "block",
+        code: "height-mismatch",
+        message: `source returned height ${height} for ${ref}`
+      });
+    out.height = height;
+    out.blockId = id;
+    out.stateRoot = hex(header.stateIndexRoot);
+    const burn = await this.#bindBurn(header, "burn");
+    const cycle = rewardCycle(burn.burnHeight);
+    out.burnHeight = burn.burnHeight;
+    out.bitcoinBlockHash = burn.hash;
+    out.cycle = cycle;
+    const set = await this.#signerSet(cycle, {
+      height,
+      burn: burn.burnHeight
+    });
+    const sig = verifySignerSignatures(header, set);
+    out.signerWeight = sig.signedWeight;
+    out.totalWeight = sig.totalWeight;
+    out.threshold = sig.threshold;
+    if (!sig.valid)
+      fail(signatureFailure(sig, "signatures", cycle));
+    const witness = await fetchFor("witness", `witness ${id}`, () => src.getWitness(id));
+    const { getStateWrites, getVmEvents } = src;
+    const writes = getStateWrites ? await fetchFor("names", `state_writes ${height}`, () => getStateWrites.call(src, height)) : null;
+    const rows = getVmEvents ? await fetchFor("rows", `vm_events ${height}`, () => getVmEvents.call(src, height)) : undefined;
+    const parentId = hex(header.parentBlockId);
+    const state = await verifyBlockState({
+      height,
+      parentBlockId: header.parentBlockId,
+      stateRoot: header.stateIndexRoot,
+      witness,
+      writes,
+      rows,
+      parentLeaves: await this.#parentLeaves(parentId, out.notes),
+      parentHolds: (leaf) => this.#parentHolds(parentId, leaf)
+    });
+    out.diff = state.diff;
+    if (rows)
+      out.rowsChecked = state.rowsChecked;
+    out.notes.push(...state.notes);
+    out.failures.push(...state.failures);
+  }
+  async#header(id, step, extra = {}) {
+    const known = this.#headers.get(id);
+    if (known)
+      return known;
+    const raw = await fetchFor(step, `block ${id}`, () => this.#source.getBlock(id), extra);
+    const header = parseHeader2(raw, step);
+    if (hex(blockId(header)) !== id)
+      fail({
+        step,
+        code: "id-mismatch",
+        message: `source returned another block for ${id}`,
+        blockId: id,
+        ...extra
+      });
+    this.#headers.set(id, header);
+    return header;
+  }
+  async#proveAt(tip, path, value, proof, step, extra = {}) {
+    const headers = [tip];
+    for (const id of marfProofAncestors(proof))
+      headers.push(await this.#header(id, step, extra));
+    return verifyMarfProof({
+      proof,
+      path,
+      value,
+      root: tip.stateIndexRoot,
+      headers
+    });
+  }
+  async#parentLeaves(parentId, notes) {
+    try {
+      const parent = await this.#header(parentId, "names");
+      const w = parseWitness(await this.#source.getWitness(parentId));
+      if (bytesEqual(w.root, parent.stateIndexRoot))
+        return w.leaves;
+      notes.push(`parent witness ${parentId} root does not match its header`);
+    } catch (err) {
+      notes.push(`parent witness ${parentId} unavailable: ${err.message}`);
+    }
+    return;
+  }
+  async#parentHolds(parentId, leaf) {
+    const parent = await this.#header(parentId, "names");
+    const pathHex = hex(leaf.path);
+    const answer = await fetchFor("names", `MARF ${pathHex} at parent`, () => this.#source.getMarfProof(pathHex, parentId));
+    if (!answer)
+      return false;
+    const value = new Uint8Array(MARF_VALUE_SIZE);
+    value.set(leaf.valueHash);
+    return this.#proveAt(parent, leaf.path, value, answer.proof, "names");
+  }
+  async#bindBurn(header, step, extra = {}) {
+    const ch = hex(header.consensusHash);
+    const known = this.#burns.get(ch);
+    if (known)
+      return known;
+    const bp = await fetchFor(step, `burn preimage ${ch}`, () => this.#preimage(ch), extra);
+    const hash = verifyConsensusPreimage(header.consensusHash, bp.preimage);
+    if (!hash)
+      return fail({
+        step,
+        code: "preimage-mismatch",
+        message: `preimage does not hash to consensus hash ${ch}`,
+        ...extra
+      });
+    if (bp.burnHeight < this.#chain.checkpointHeight)
+      fail({
+        step,
+        code: "before-checkpoint",
+        message: `burn height ${bp.burnHeight} is below the Bitcoin checkpoint ${this.#chain.checkpointHeight}`,
+        ...extra
+      });
+    await this.#syncBitcoin(bp.burnHeight);
+    const burnHeight = this.#chain.heightOf(hash);
+    if (burnHeight === undefined)
+      return fail({
+        step,
+        code: "burn-not-in-chain",
+        message: `burn block ${hash} is not in the verified Bitcoin chain (synced ${this.#chain.checkpointHeight}..${this.#chain.tip.height})`,
+        ...extra
+      });
+    const bound = { burnHeight, hash };
+    this.#burns.set(ch, bound);
+    return bound;
+  }
+  async#syncBitcoin(height) {
+    while (this.#chain.tip.height < height) {
+      const from = this.#chain.tip.height + 1;
+      const count = Math.min(BITCOIN_BATCH, height - from + 1);
+      const headers = await fetchFor("bitcoin", `bitcoin headers ${from}`, () => this.#source.getBitcoinHeaders(from, count));
+      if (headers.length === 0)
+        fail({
+          step: "bitcoin",
+          code: "unavailable",
+          message: `source has no Bitcoin headers from ${from}`
+        });
+      try {
+        this.#chain.append(headers);
+      } catch (err) {
+        if (!(err instanceof HeaderValidationError))
+          throw err;
+        fail({ step: "bitcoin", code: "invalid-header", message: err.message });
+      }
+    }
+  }
+  async#signerSet(cycle, target) {
+    const known = this.#sets.get(cycle);
+    if (known)
+      return known;
+    const first = this.#checkpoint.stacks.cycle;
+    if (cycle < first)
+      fail({
+        step: "signer-set",
+        code: "before-checkpoint",
+        message: `cycle ${cycle} precedes the checkpoint's cycle ${first}`,
+        cycle
+      });
+    let lo = await this.#startPoint();
+    for (let c = first;c < cycle; c++) {
+      const next = this.#sets.get(c + 1);
+      if (next) {
+        lo = this.#anchors.get(c + 1) ?? lo;
+        continue;
+      }
+      const anchor = await this.#findAnchor(c + 1, lo, target);
+      this.#sets.set(c + 1, await this.#proveNextSet(c + 1, anchor));
+      this.#anchors.set(c + 1, anchor);
+      lo = anchor;
+    }
+    return this.#sets.get(cycle);
+  }
+  async#startPoint() {
+    const { header } = this.#start;
+    const height = Number(header.chainLength);
+    try {
+      return { height, burn: await this.#burnHint(header) };
+    } catch {
+      return { height };
+    }
+  }
+  async#burnHint(header) {
+    const ch = hex(header.consensusHash);
+    return this.#burns.get(ch)?.burnHeight ?? (await this.#preimage(ch)).burnHeight;
+  }
+  async#preimage(ch) {
+    let bp = this.#preimages.get(ch);
+    if (!bp) {
+      bp = await this.#source.getBurnPreimage(ch);
+      this.#preimages.set(ch, bp);
+    }
+    return bp;
+  }
+  async#findAnchor(cycle, lo, hi) {
+    const start = cycleStart(cycle);
+    const window2 = [start - MAINNET_PREPARE_LENGTH, start];
+    const probe = async (h) => {
+      const raw = await fetchFor("signer-set", `block at height ${h}`, () => this.#source.getBlock(h), { cycle });
+      const header = parseHeader2(raw, "signer-set");
+      const id = hex(blockId(header));
+      this.#headers.set(id, header);
+      const burn = await fetchFor("signer-set", `burn hint for block ${id}`, () => this.#burnHint(header), { cycle, blockId: id });
+      return { height: Number(header.chainLength), burn, header, id };
+    };
+    const anchor = await findAnchor(lo, hi, window2, probe);
+    if (!anchor)
+      return fail({
+        step: "signer-set",
+        code: "anchor-not-found",
+        message: `no block with a burn height in ${window2[0]}..${window2[1] - 1} (cycle ${cycle} prepare phase) between heights ${lo.height} and ${hi.height}`,
+        cycle
+      });
+    return anchor;
+  }
+  async#proveNextSet(cycle, anchor) {
+    const at = { cycle, blockId: anchor.id };
+    const { burnHeight } = await this.#bindBurn(anchor.header, "signer-set", at);
+    const start = cycleStart(cycle);
+    if (burnHeight < start - MAINNET_PREPARE_LENGTH || burnHeight >= start)
+      fail({
+        step: "signer-set",
+        code: "anchor-outside-window",
+        message: `anchor burn height ${burnHeight} is outside cycle ${cycle}'s prepare phase ${start - MAINNET_PREPARE_LENGTH}..${start - 1}`,
+        ...at
+      });
+    const signing = rewardCycle(burnHeight);
+    const sig = verifySignerSignatures(anchor.header, this.#sets.get(signing));
+    if (!sig.valid)
+      fail({
+        ...signatureFailure(sig, "signer-set", signing),
+        ...at,
+        code: "anchor-unsigned"
+      });
+    const path = marfPath(mapEntryKey(SIGNERS_CONTRACT, "cycle-signer-set", uintCV(cycle)));
+    const answer = await fetchFor("signer-set", `signer set ${cycle} at ${anchor.id}`, () => this.#source.getMarfProof(hex(path), anchor.id), at);
+    const value = answer?.data.replace(/^0x/, "") ?? "";
+    const proven = answer !== null && await this.#proveAt(anchor.header, path, marfValue(value), answer.proof, "signer-set", at);
+    if (!proven)
+      fail({
+        step: "signer-set",
+        code: "set-proof-invalid",
+        message: `signer set ${cycle} is not proven in anchor ${anchor.id}'s state`,
+        ...at
+      });
+    let set;
+    try {
+      set = decodeSignerSet(value);
+    } catch (err) {
+      return fail({
+        step: "signer-set",
+        code: "set-proof-invalid",
+        message: `signer set ${cycle}: ${err.message}`,
+        ...at
+      });
+    }
+    return set;
+  }
+}
+function parseHeader2(raw, step) {
+  try {
+    return parseNakamotoHeader(raw);
+  } catch (err) {
+    return fail({
+      step,
+      code: "invalid-header",
+      message: `block bytes do not parse: ${err.message}`
+    });
+  }
+}
+function signatureFailure(sig, step, cycle) {
+  const weight = `${sig.signedWeight}/${sig.totalWeight} signed, threshold ${sig.threshold}`;
+  if (sig.unknown.length)
+    return {
+      step,
+      code: "unknown-signer",
+      message: `${sig.unknown.length} signer(s) not in cycle ${cycle}'s set (${weight})`,
+      cycle
+    };
+  if (sig.duplicates.length)
+    return {
+      step,
+      code: "duplicate-signer",
+      message: `${sig.duplicates.length} duplicate signature(s) (${weight})`,
+      cycle
+    };
+  if (sig.invalid)
+    return {
+      step,
+      code: "bad-signature",
+      message: `${sig.invalid} signature(s) do not recover (${weight})`,
+      cycle
+    };
+  return {
+    step,
+    code: "below-threshold",
+    message: `cycle ${cycle} signers: ${weight}`,
+    cycle
+  };
+}
+// src/commands/verify-block.ts
+init_output();
+init_resolve_auth();
+var LINKS = [
+  { step: "block", label: "block" },
+  { step: "bitcoin", label: "bitcoin" },
+  { step: "burn", label: "burn" },
+  { step: "signer-set", label: "cycle" },
+  { step: "signatures", label: "signatures" },
+  { step: "witness", label: "state root" },
+  { step: "names", label: "diff" },
+  { step: "rows", label: "rows" }
+];
+var LABEL_WIDTH = Math.max(...LINKS.map((l) => l.label.length));
+var n = (v) => v.toLocaleString("en-US");
+function parseBlockRef(raw) {
+  if (/^\d+$/.test(raw)) {
+    const height = Number(raw);
+    if (Number.isSafeInteger(height))
+      return height;
+  }
+  const hash = raw.replace(/^0x/i, "").toLowerCase();
+  if (/^[0-9a-f]{64}$/.test(hash))
+    return hash;
+  throw new Error(`expected a block height or a 64-hex index block hash, got "${raw}"`);
+}
+async function readCheckpoint(path) {
+  const cp = JSON.parse(await readFile3(path, "utf8"));
+  const ok = typeof cp?.stacks?.header === "string" && Number.isSafeInteger(cp.stacks.cycle) && typeof cp.stacks.signerSet === "string" && Number.isSafeInteger(cp.bitcoin?.height) && typeof cp.bitcoin?.header === "string";
+  if (!ok)
+    throw new Error(`${path}: a checkpoint needs stacks.{header, cycle, signerSet} and bitcoin.{height, header}`);
+  return cp;
+}
+function defaultSource(node) {
+  const api = new SecondlayerProofSource({
+    baseUrl: resolveApiUrl(),
+    apiKey: resolveDataPlaneKey() ?? ""
+  });
+  return node ? { ...api, ...new NodeRpcProofSource({ nodeUrl: node }) } : api;
+}
+function prepareSource(src, rows) {
+  const out = {
+    getBlock: (ref) => src.getBlock(ref),
+    getMarfProof: (path, tip) => src.getMarfProof(path, tip),
+    getBurnPreimage: (ch) => src.getBurnPreimage(ch),
+    getWitness: (id) => {
+      note(`  fetching state witness ${id}`);
+      return src.getWitness(id);
+    },
+    getBitcoinHeaders: (from, count) => {
+      note(`  syncing Bitcoin headers ${n(from)}..${n(from + count - 1)}`);
+      return src.getBitcoinHeaders(from, count);
+    }
+  };
+  const { getStateWrites, getVmEvents } = src;
+  if (rows && getStateWrites)
+    out.getStateWrites = (height) => getStateWrites.call(src, height);
+  if (rows && getVmEvents)
+    out.getVmEvents = (height) => {
+      note(`  fetching indexed rows for ${n(height)}`);
+      return getVmEvents.call(src, height);
+    };
+  return out;
+}
+function linkDetail(step, r, cp, rows) {
+  switch (step) {
+    case "block":
+      return `${n(r.height ?? 0)}  ${r.blockId}`;
+    case "bitcoin":
+      return `headers ${n(cp.bitcoin.height)}..${n(r.burnHeight ?? 0)}, proof-of-work and retargets checked`;
+    case "burn":
+      return `height ${n(r.burnHeight ?? 0)}  ${r.bitcoinBlockHash}`;
+    case "signer-set":
+      return r.cycle === cp.stacks.cycle ? `${r.cycle}, the checkpoint's own signer set` : `${r.cycle}, signer set proven forward from checkpoint cycle ${cp.stacks.cycle}`;
+    case "signatures":
+      return `${n(r.signerWeight ?? 0n)} / ${n(r.totalWeight ?? 0n)} weight signed, threshold ${n(r.threshold ?? 0n)}`;
+    case "witness":
+      return `${r.stateRoot} matches the witness`;
+    case "names": {
+      const d = r.diff;
+      if (!d)
+        return "";
+      const named = d.writes.filter((w) => w.named).length;
+      const written = named ? `${d.writes.length} written (${named} named, ${d.writes.length - named} unnamed)` : `${d.writes.length} written (unnamed${rows ? "" : "; --rows names them"})`;
+      return `${written}, ${d.carried.length} carried, ${d.internal.length} internal`;
+    }
+    case "rows":
+      return `${n(r.rowsChecked ?? 0)} vm_events rows match the diff`;
+  }
+}
+function report(r, cp, rows) {
+  const first = r.failures[0];
+  const broken = first ? LINKS.findIndex((l) => l.step === first.step) : LINKS.length;
+  for (const [i, link] of LINKS.entries()) {
+    const label = link.label.padEnd(LABEL_WIDTH);
+    const failure = r.failures.find((f) => f.step === link.step);
+    if (failure)
+      writeData(`${red("✗")} ${label}  ${failure.message}`);
+    else if (link.step === "rows" && !rows)
+      writeData(dim(`· ${label}  not checked (pass --rows)`));
+    else if (i > broken)
+      writeData(dim(`· ${label}  not checked: an earlier link is broken`));
+    else if (link.step === "rows" && r.rowsChecked === undefined)
+      writeData(dim(`· ${label}  not checked: the source serves no indexed rows`));
+    else
+      writeData(`${green("✓")} ${label}  ${linkDetail(link.step, r, cp, rows)}`);
+  }
+  for (const line of r.notes)
+    if (rows || !line.includes("state_writes"))
+      note(`  note: ${line}`);
+  if (!first) {
+    const from = n(parseNakamotoHeader(unhex(cp.stacks.header)).chainLength);
+    writeData(green(`✓ Block ${n(r.height ?? 0)} is proven. Trusted: only the checkpoint (Stacks ${from}, Bitcoin ${n(cp.bitcoin.height)}).`));
+    return;
+  }
+  const label = LINKS[broken]?.label ?? first.step;
+  writeData(red(first.code === "unavailable" ? `✗ Could not check the ${label} link: the source could not serve it.` : `✗ Not proven: the ${label} link is broken.`));
+}
+function verificationJson(r) {
+  return JSON.stringify(r, (_k, v) => typeof v === "bigint" ? v.toString() : v, 2);
+}
+function exitCodeOf(r) {
+  if (r.ok)
+    return VERIFY_EXIT.CLEAN;
+  return r.failures[0]?.code === "unavailable" ? VERIFY_EXIT.UNANCHORED : VERIFY_EXIT.DIVERGED;
+}
+async function runVerifyBlock(ref, opts, deps = {}) {
+  let checkpoint;
+  let verifier;
+  let target;
+  try {
+    target = parseBlockRef(ref);
+    checkpoint = opts.checkpoint ? await readCheckpoint(opts.checkpoint) : MAINNET_CHECKPOINT;
+    const source = prepareSource(deps.source ?? defaultSource(opts.node), !!opts.rows);
+    verifier = new BlockVerifier({ source, checkpoint });
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    return VERIFY_EXIT.UNANCHORED;
+  }
+  note(`Verifying block ${typeof target === "number" ? n(target) : target}`);
+  const result = await verifier.verify(target);
+  if (opts.json)
+    writeData(verificationJson(result));
+  else
+    report(result, checkpoint, !!opts.rows);
+  return exitCodeOf(result);
+}
+function attachVerifyBlockCommand(verify) {
+  return verify.command("block").description("Prove one Stacks block from the checkpoint built into this release, trusting nothing else").argument("<ref>", "block height or index block hash").option("--node <url>", "read blocks and MARF proofs from this Stacks node RPC instead of the API").option("--checkpoint <file>", "trust this checkpoint JSON instead of the one built into this release").option("--rows", "also prove the indexer's rows for the block (state_writes, vm_events) against its state diff").addHelpText("after", `
+What is proven, link by link:
+  bitcoin     headers from the checkpoint to the block's burn block: proof-of-work and retargets
+  burn        the block's consensus hash commits to that Bitcoin block
+  cycle       the reward cycle's signer set, proven forward from the checkpoint's set
+  signatures  signers holding at least 70% of the weight signed the block header
+  state root  the state witness hashes to the root in the signed header
+  diff        every leaf the block wrote, carried, or kept as bookkeeping
+  rows        with --rows: the Index API's rows match that diff
+
+Nothing is trusted except the checkpoint. Proofs come from the API
+(SECONDLAYER_API_URL, or --api-url) with your account key, or from a node
+with --node; a source that lies can fail a link but never pass one.
+
+Examples:
+  $ secondlayer verify block 9137005
+  $ secondlayer verify block 0x2e5962b00b8f243e1a4b5a1b7ff3076618ce5e737e30c019bc61e461c92f57ff
+  $ secondlayer verify block 9137005 --node http://127.0.0.1:20443 --rows
+  $ secondlayer verify block 9137005 --json
+
+Output: one line per link on stdout, progress on stderr. --json prints the
+full verification result instead (signer weights as decimal strings).
+
+Exit codes:
+  0  every link holds
+  1  a link is broken (the first is named)
+  2  could not check: the source could not serve a link, or bad input`).action(async (ref, opts, cmd) => {
+    const json = cmd.optsWithGlobals().json === true;
+    process.exit(await runVerifyBlock(ref, { ...opts, json }));
+  });
+}
+
+// src/commands/verify.ts
 var VERIFY_EXIT = {
   CLEAN: 0,
   DIVERGED: 1,
@@ -204012,7 +208305,7 @@ function statusLabel(status) {
   return yellow("missing");
 }
 function attachVerifyCommand(cmd) {
-  return cmd.argument("[target]", "all | raw | decode:<name> | subgraph:<name>", "raw").option("--quick", "coverage/identity only (default)").option("--deep", "include semantic / scratch replay where available").option("--anchor", "require a verified archive signature").requiredOption("--against <manifest>", "archive manifest: an https URL or a local file path").option("--from-block <n>", "first height to check").option("--to-block <n>", "last height to check").option("--counts", "also compare transaction/event row counts (slower)").option("--semantic", "also recompute per-partition semantic digests locally and compare (slow: full re-stream)").option("--public-key <pem>", "pin a signing key; default is the archive key built into this release").option("--insecure", "skip the manifest signature check (not recommended)").option("--json", "Output as JSON").addHelpText("after", `
+  return cmd.argument("[target]", "all | raw | decode:<name> | subgraph:<name>", "raw").option("--quick", "coverage/identity only (default)").option("--deep", "include semantic / scratch replay where available").option("--anchor", "require a verified archive signature").option("--against <manifest>", "archive manifest: an https URL or a local file path (required)").option("--from-block <n>", "first height to check").option("--to-block <n>", "last height to check").option("--counts", "also compare transaction/event row counts (slower)").option("--semantic", "also recompute per-partition semantic digests locally and compare (slow: full re-stream)").option("--public-key <pem>", "pin a signing key; default is the archive key built into this release").option("--insecure", "skip the manifest signature check (not recommended)").option("--json", "Output as JSON").addHelpText("after", `
 Examples:
   $ secondlayer verify --against https://archive.secondlayer.tools/.../snapshots/<digest>.json
   $ secondlayer verify raw --against ./snapshot.json --from-block 8000000 --to-block 8499999
@@ -204023,7 +208316,11 @@ Examples:
 Exit codes:
   0  local data matches the archive
   1  divergence found (divergent ranges are listed)
-  2  unanchored — reference unavailable or unverifiable`).action(async (targetArg, opts) => {
+  2  unanchored — reference unavailable or unverifiable`).action(async (targetArg, opts, command) => {
+    if (opts.against === undefined)
+      command.error("error: required option '--against <manifest>' not specified", {
+        code: "commander.missingMandatoryOptionValue"
+      });
     try {
       const target = parseVerifyTarget(targetArg);
       const mode = opts.deep ? "deep" : opts.anchor ? "anchor" : "quick";
@@ -204202,7 +208499,8 @@ Exit codes:
   });
 }
 function registerVerifyCommand(program) {
-  attachVerifyCommand(program.command("verify").description("Compare local chain data against a signed archive (read-only; nothing is uploaded)"));
+  const verify = attachVerifyCommand(program.command("verify").description("Compare local chain data against a signed archive, or prove one block with `verify block` (read-only)"));
+  attachVerifyBlockCommand(verify);
 }
 
 // src/commands/archive.ts
@@ -206251,8 +210549,8 @@ init_output();
 init_resolve_auth();
 
 // src/commands/faucet.ts
-import { randomBytes as randomBytes2 } from "node:crypto";
-import { readFile as readFile4 } from "node:fs/promises";
+import { randomBytes as randomBytes3 } from "node:crypto";
+import { readFile as readFile5 } from "node:fs/promises";
 import { join as join11 } from "node:path";
 import { http as http3, createWalletClient } from "@secondlayer/stacks";
 import { mnemonicToAccount } from "@secondlayer/stacks/accounts";
@@ -206266,7 +210564,7 @@ async function readDeployerMnemonic(projectDir) {
   const path = join11(projectDir, "settings", "Devnet.toml");
   let raw;
   try {
-    raw = await readFile4(path, "utf8");
+    raw = await readFile5(path, "utf8");
   } catch {
     throw new Error(`could not read ${path}`);
   }
@@ -206337,8 +210635,8 @@ is what makes minting possible without Bitcoin.`).action(async (opts) => {
         chain: devnet,
         transport: http3(rpcUrl)
       });
-      const depositTxid = randomBytes2(32).toString("hex");
-      const sweepTxid = randomBytes2(32).toString("hex");
+      const depositTxid = randomBytes3(32).toString("hex");
+      const sweepTxid = randomBytes3(32).toString("hex");
       note(`  minting ${amount} sats to ${opts.to}`);
       note(`  via ${contract} as signer ${account.address}`);
       const txid = await client.callContract({
@@ -207356,7 +211654,7 @@ import { resolveApiKey as resolveApiKey4 } from "@secondlayer/sdk";
 
 // src/lib/project-file.ts
 import { existsSync as existsSync8 } from "node:fs";
-import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
 import { dirname as dirname10, join as join14, parse as parsePath2, resolve as resolve9 } from "node:path";
 import { z as z4 } from "zod";
@@ -207373,7 +211671,7 @@ async function readActiveProject(cwd, globalDefault) {
     const candidate = join14(dir, DIRNAME, FILENAME);
     if (existsSync8(candidate)) {
       try {
-        const raw = await readFile5(candidate, "utf8");
+        const raw = await readFile6(candidate, "utf8");
         const parsed = ProjectFileSchema.parse(JSON.parse(raw));
         return { slug: parsed.slug, resolvedFrom: candidate };
       } catch {}
@@ -207611,7 +211909,7 @@ import { planUninstall, uninstallCommand } from "@secondlayer/shared/runtime";
 
 // src/lib/instance-init.ts
 init_output();
-import { randomBytes as randomBytes3 } from "node:crypto";
+import { randomBytes as randomBytes4 } from "node:crypto";
 import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "node:fs";
 import { resolve as resolve10 } from "node:path";
 import { ARCHIVE_ROOT_PUBLIC_KEY_PEM } from "@secondlayer/shared/archive/root-key";
@@ -207640,10 +211938,10 @@ function instanceNetworkFromEnv(fallback = "mainnet") {
   }
 }
 function generateInstanceToken() {
-  return randomBytes3(32).toString("hex");
+  return randomBytes4(32).toString("hex");
 }
 function generateSecretsKey() {
-  return randomBytes3(32).toString("hex");
+  return randomBytes4(32).toString("hex");
 }
 function generateSigningPrivateKey() {
   return generateEd25519KeyPair().privateKeyPem;
@@ -208462,7 +212760,7 @@ dbcache=4096
 
 // src/lib/setup-wizard.ts
 import { spawn as spawn3, spawnSync as spawnSync5 } from "node:child_process";
-import { randomBytes as randomBytes4 } from "node:crypto";
+import { randomBytes as randomBytes5 } from "node:crypto";
 import { existsSync as existsSync12 } from "node:fs";
 import { writeFile as writeFile6 } from "node:fs/promises";
 import { createServer } from "node:net";
@@ -208563,7 +212861,7 @@ async function resolveAvailablePublishSpec(spec, claimedByDocker = new Set, maxA
   return { spec, remapped: false };
 }
 function randomHex(bytes) {
-  return randomBytes4(bytes).toString("hex");
+  return randomBytes5(bytes).toString("hex");
 }
 function resolveSecrets(config) {
   const envPath = join17(config.dir, ".env");
@@ -209298,5 +213596,5 @@ registerCreditsCommand(program);
 registerArchiveCommand(program);
 program.parse();
 
-//# debugId=09267A0D0DFF448064756E2164756E21
+//# debugId=2C1F9BFC90AE711664756E2164756E21
 //# sourceMappingURL=cli.js.map