@secondlayer/cli 19.2.0 → 19.2.2

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 as randomBytes2 } from "node:crypto";
+import { randomBytes } 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-${randomBytes2(4).toString("hex")}.mjs`);
+    const tempPath = path.join(tmpdir3(), `secondlayer-config-${randomBytes(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, 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 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 init_ansis = __esm(() => {
   import__2 = __toESM(require_ansis(), 1);
-  ({ 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);
+  ({ 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);
 });
 
 // ../../node_modules/@antfu/ni/node_modules/package-manager-detector/dist/constants.mjs
@@ -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/.claude/worktrees/release/node_modules/typescript/lib", __filename = "/Users/ryan/projects/secondlayer/.claude/worktrees/release/node_modules/typescript/lib/typescript.js";
+  var __dirname = "/Users/ryan/projects/secondlayer/.claude/worktrees/agent-a6ba56a9f98cf6ff7/node_modules/typescript/lib", __filename = "/Users/ryan/projects/secondlayer/.claude/worktrees/agent-a6ba56a9f98cf6ff7/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
@@ -200248,7 +200248,7 @@ function client() {
     apiKey: resolveDataPlaneKey()
   });
 }
-function fail2(action, err) {
+function fail(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)) {
@@ -200301,7 +200301,7 @@ function registerIndexCommand(program) {
         recipient: o.recipient
       }), o.json);
     } catch (err) {
-      fail2("list ft transfers", err);
+      fail("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) => {
@@ -200313,7 +200313,7 @@ function registerIndexCommand(program) {
         assetIdentifier: o.assetIdentifier
       }), o.json);
     } catch (err) {
-      fail2("list nft transfers", err);
+      fail("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) => {
@@ -200326,7 +200326,7 @@ function registerIndexCommand(program) {
         assetIdentifier: o.assetIdentifier
       }), o.json);
     } catch (err) {
-      fail2("list events", err);
+      fail("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) => {
@@ -200337,21 +200337,21 @@ function registerIndexCommand(program) {
         sender: o.sender
       }), o.json);
     } catch (err) {
-      fail2("list contract calls", err);
+      fail("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) {
-      fail2("list canonical blocks", err);
+      fail("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) {
-      fail2("list blocks", err);
+      fail("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) => {
@@ -200359,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) {
-      fail2("get block", err);
+      fail("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) => {
@@ -200370,14 +200370,14 @@ function registerIndexCommand(program) {
         sender: o.sender
       }), o.json);
     } catch (err) {
-      fail2("list transactions", err);
+      fail("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) {
-      fail2("get transaction", err);
+      fail("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) => {
@@ -200389,7 +200389,7 @@ function registerIndexCommand(program) {
         caller: o.caller
       }), o.json);
     } catch (err) {
-      fail2("list stacking actions", err);
+      fail("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) => {
@@ -200403,14 +200403,14 @@ function registerIndexCommand(program) {
         limit: o.limit ? Number.parseInt(o.limit, 10) : undefined
       }), o.json);
     } catch (err) {
-      fail2("list mempool", err);
+      fail("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) {
-      fail2("get mempool tx", err);
+      fail("get mempool tx", err);
     }
   });
 }
@@ -201469,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 hmac2(saltedPassword, "Client Key");
+    const clientKey = await hmac(saltedPassword, "Client Key");
     const auth = "n=*,r=" + nonce + "," + "r=" + res.r + ",s=" + res.s + ",i=" + res.i + ",c=biws,r=" + res.r;
-    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");
+    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");
     write(bytes_default().p().str(payload).end());
   }
   function SASLFinal(x) {
@@ -201691,10 +201691,10 @@ function parseError(x) {
 function md5(x) {
   return crypto2.createHash("md5").update(x).digest("hex");
 }
-function hmac2(key, x) {
+function hmac(key, x) {
   return crypto2.createHmac("sha256", key).update(x).digest();
 }
-function sha2562(x) {
+function sha256(x) {
   return crypto2.createHash("sha256").update(x).digest();
 }
 function xor(a, b) {
@@ -202526,7 +202526,7 @@ var {
 // package.json
 var package_default = {
   name: "@secondlayer/cli",
-  version: "19.2.0",
+  version: "19.2.2",
   description: "Run a Stacks index on your own hardware — set it up, restore verified history, and keep it current.",
   repository: {
     type: "git",
@@ -202569,6 +202569,7 @@ var package_default = {
     "@secondlayer/shared": "^11.20.0",
     "@secondlayer/stacks": "^6.1.1",
     "@secondlayer/subgraphs": "^6.3.6",
+    "@secondlayer/verify": "^0.2.0",
     esbuild: "^0.28.2",
     "smol-toml": "^1.8.0",
     zod: "^4.3.6"
@@ -202583,7 +202584,6 @@ 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",
@@ -204002,4110 +204002,20 @@ 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();
+import { readFile as readFile3 } from "node:fs/promises";
+import {
+  BlockVerifier,
+  MAINNET_CHECKPOINT,
+  NodeRpcProofSource,
+  SecondlayerProofSource,
+  parseNakamotoHeader,
+  unhex
+} from "@secondlayer/verify";
 var LINKS = [
+  { step: "ancestry", label: "ancestry" },
   { step: "block", label: "block" },
   { step: "bitcoin", label: "bitcoin" },
   { step: "burn", label: "burn" },
@@ -208142,7 +204052,7 @@ function defaultSource(node) {
   });
   return node ? { ...api, ...new NodeRpcProofSource({ nodeUrl: node }) } : api;
 }
-function prepareSource(src, rows) {
+function prepareSource(src) {
   const out = {
     getBlock: (ref) => src.getBlock(ref),
     getMarfProof: (path, tip) => src.getMarfProof(path, tip),
@@ -208156,10 +204066,12 @@ function prepareSource(src, rows) {
       return src.getBitcoinHeaders(from, count);
     }
   };
-  const { getStateWrites, getVmEvents } = src;
-  if (rows && getStateWrites)
+  const { getEpoch2Header, getStateWrites, getVmEvents } = src;
+  if (getEpoch2Header)
+    out.getEpoch2Header = (id) => getEpoch2Header.call(src, id);
+  if (getStateWrites)
     out.getStateWrites = (height) => getStateWrites.call(src, height);
-  if (rows && getVmEvents)
+  if (getVmEvents)
     out.getVmEvents = (height) => {
       note(`  fetching indexed rows for ${n(height)}`);
       return getVmEvents.call(src, height);
@@ -208168,6 +204080,14 @@ function prepareSource(src, rows) {
 }
 function linkDetail(step, r, cp, rows) {
   switch (step) {
+    case "ancestry": {
+      const a = r.ancestry;
+      if (!a)
+        return "";
+      const checkpoint = parseNakamotoHeader(unhex(cp.stacks.header));
+      const start = a.fromHeight === Number(checkpoint.chainLength) ? `the checkpoint ${n(a.fromHeight)}` : `block ${n(a.fromHeight)}`;
+      return a.via === "marf" ? `${n(r.height ?? 0)} proven in the state of ${start} (one MARF proof)` : `${n(r.height ?? 0)} reached from ${start} by parent links`;
+    }
     case "block":
       return `${n(r.height ?? 0)}  ${r.blockId}`;
     case "bitcoin":
@@ -208192,18 +204112,29 @@ function linkDetail(step, r, cp, rows) {
       return `${n(r.rowsChecked ?? 0)} vm_events rows match the diff`;
   }
 }
+function notNeeded(step, r) {
+  if (!r.ancestry)
+    return false;
+  if (step === "bitcoin" || step === "burn")
+    return r.burnHeight === undefined;
+  return step === "signer-set" || step === "signatures";
+}
 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 (link.step === "ancestry" && !failure && !r.ancestry)
+      continue;
     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 (notNeeded(link.step, r))
+      writeData(dim(`· ${label}  not needed: the block is hash-chained to the checkpoint`));
     else if (link.step === "rows" && r.rowsChecked === undefined)
       writeData(dim(`· ${label}  not checked: the source serves no indexed rows`));
     else
@@ -208235,8 +204166,8 @@ async function runVerifyBlock(ref, opts, deps = {}) {
   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 });
+    const source = prepareSource(deps.source ?? defaultSource(opts.node));
+    verifier = new BlockVerifier({ source, checkpoint, rows: !!opts.rows });
   } catch (err) {
     printError(err instanceof Error ? err.message : String(err));
     return VERIFY_EXIT.UNANCHORED;
@@ -208252,6 +204183,8 @@ async function runVerifyBlock(ref, opts, deps = {}) {
 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:
+  ancestry    below the checkpoint only: the block's id, from the checkpoint by
+              parent links or one MARF proof (signer links are then not needed)
   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
@@ -210549,7 +206482,7 @@ init_output();
 init_resolve_auth();
 
 // src/commands/faucet.ts
-import { randomBytes as randomBytes3 } from "node:crypto";
+import { randomBytes as randomBytes2 } 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";
@@ -210635,8 +206568,8 @@ is what makes minting possible without Bitcoin.`).action(async (opts) => {
         chain: devnet,
         transport: http3(rpcUrl)
       });
-      const depositTxid = randomBytes3(32).toString("hex");
-      const sweepTxid = randomBytes3(32).toString("hex");
+      const depositTxid = randomBytes2(32).toString("hex");
+      const sweepTxid = randomBytes2(32).toString("hex");
       note(`  minting ${amount} sats to ${opts.to}`);
       note(`  via ${contract} as signer ${account.address}`);
       const txid = await client.callContract({
@@ -211909,7 +207842,7 @@ import { planUninstall, uninstallCommand } from "@secondlayer/shared/runtime";
 
 // src/lib/instance-init.ts
 init_output();
-import { randomBytes as randomBytes4 } from "node:crypto";
+import { randomBytes as randomBytes3 } 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";
@@ -211938,10 +207871,10 @@ function instanceNetworkFromEnv(fallback = "mainnet") {
   }
 }
 function generateInstanceToken() {
-  return randomBytes4(32).toString("hex");
+  return randomBytes3(32).toString("hex");
 }
 function generateSecretsKey() {
-  return randomBytes4(32).toString("hex");
+  return randomBytes3(32).toString("hex");
 }
 function generateSigningPrivateKey() {
   return generateEd25519KeyPair().privateKeyPem;
@@ -212760,7 +208693,7 @@ dbcache=4096
 
 // src/lib/setup-wizard.ts
 import { spawn as spawn3, spawnSync as spawnSync5 } from "node:child_process";
-import { randomBytes as randomBytes5 } from "node:crypto";
+import { randomBytes as randomBytes4 } from "node:crypto";
 import { existsSync as existsSync12 } from "node:fs";
 import { writeFile as writeFile6 } from "node:fs/promises";
 import { createServer } from "node:net";
@@ -212861,7 +208794,7 @@ async function resolveAvailablePublishSpec(spec, claimedByDocker = new Set, maxA
   return { spec, remapped: false };
 }
 function randomHex(bytes) {
-  return randomBytes5(bytes).toString("hex");
+  return randomBytes4(bytes).toString("hex");
 }
 function resolveSecrets(config) {
   const envPath = join17(config.dir, ".env");
@@ -213596,5 +209529,5 @@ registerCreditsCommand(program);
 registerArchiveCommand(program);
 program.parse();
 
-//# debugId=2C1F9BFC90AE711664756E2164756E21
+//# debugId=92924A7AE61FB1AF64756E2164756E21
 //# sourceMappingURL=cli.js.map