@neuraiproject/neurai-depin-msg 1.0.0

package/dist/neurai-depin-msg.js

@@ -0,0 +1,4709 @@
+var neuraiDepinMsg = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // node_modules/@noble/hashes/crypto.js
+  var require_crypto = __commonJS({
+    "node_modules/@noble/hashes/crypto.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.crypto = void 0;
+      exports.crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+    }
+  });
+
+  // node_modules/@noble/hashes/utils.js
+  var require_utils = __commonJS({
+    "node_modules/@noble/hashes/utils.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.wrapXOFConstructorWithOpts = exports.wrapConstructorWithOpts = exports.wrapConstructor = exports.Hash = exports.nextTick = exports.swap32IfBE = exports.byteSwapIfBE = exports.swap8IfBE = exports.isLE = void 0;
+      exports.isBytes = isBytes;
+      exports.anumber = anumber;
+      exports.abytes = abytes;
+      exports.ahash = ahash;
+      exports.aexists = aexists;
+      exports.aoutput = aoutput;
+      exports.u8 = u8;
+      exports.u32 = u32;
+      exports.clean = clean;
+      exports.createView = createView;
+      exports.rotr = rotr;
+      exports.rotl = rotl;
+      exports.byteSwap = byteSwap;
+      exports.byteSwap32 = byteSwap32;
+      exports.bytesToHex = bytesToHex2;
+      exports.hexToBytes = hexToBytes2;
+      exports.asyncLoop = asyncLoop;
+      exports.utf8ToBytes = utf8ToBytes;
+      exports.bytesToUtf8 = bytesToUtf8;
+      exports.toBytes = toBytes;
+      exports.kdfInputToBytes = kdfInputToBytes;
+      exports.concatBytes = concatBytes2;
+      exports.checkOpts = checkOpts;
+      exports.createHasher = createHasher;
+      exports.createOptHasher = createOptHasher;
+      exports.createXOFer = createXOFer;
+      exports.randomBytes = randomBytes2;
+      var crypto_1 = require_crypto();
+      function isBytes(a) {
+        return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+      }
+      function anumber(n) {
+        if (!Number.isSafeInteger(n) || n < 0)
+          throw new Error("positive integer expected, got " + n);
+      }
+      function abytes(b, ...lengths) {
+        if (!isBytes(b))
+          throw new Error("Uint8Array expected");
+        if (lengths.length > 0 && !lengths.includes(b.length))
+          throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+      }
+      function ahash(h) {
+        if (typeof h !== "function" || typeof h.create !== "function")
+          throw new Error("Hash should be 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);
+        const min = instance.outputLen;
+        if (out.length < min) {
+          throw new Error("digestInto() expects output buffer of length at least " + min);
+        }
+      }
+      function u8(arr) {
+        return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+      }
+      function u32(arr) {
+        return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+      }
+      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;
+      }
+      exports.isLE = (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+      function byteSwap(word) {
+        return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+      }
+      exports.swap8IfBE = exports.isLE ? (n) => n : (n) => byteSwap(n);
+      exports.byteSwapIfBE = exports.swap8IfBE;
+      function byteSwap32(arr) {
+        for (let i = 0; i < arr.length; i++) {
+          arr[i] = byteSwap(arr[i]);
+        }
+        return arr;
+      }
+      exports.swap32IfBE = exports.isLE ? (u) => u : byteSwap32;
+      var hasHexBuiltin = /* @__PURE__ */ (() => (
+        // @ts-ignore
+        typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function"
+      ))();
+      var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+      function bytesToHex2(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 hexToBytes2(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 === void 0 || n2 === void 0) {
+            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;
+      }
+      var nextTick = async () => {
+      };
+      exports.nextTick = nextTick;
+      async function asyncLoop(iters, tick, cb) {
+        let ts = Date.now();
+        for (let i = 0; i < iters; i++) {
+          cb(i);
+          const diff = Date.now() - ts;
+          if (diff >= 0 && diff < tick)
+            continue;
+          await (0, exports.nextTick)();
+          ts += diff;
+        }
+      }
+      function utf8ToBytes(str) {
+        if (typeof str !== "string")
+          throw new Error("string expected");
+        return new Uint8Array(new TextEncoder().encode(str));
+      }
+      function bytesToUtf8(bytes) {
+        return new TextDecoder().decode(bytes);
+      }
+      function toBytes(data) {
+        if (typeof data === "string")
+          data = utf8ToBytes(data);
+        abytes(data);
+        return data;
+      }
+      function kdfInputToBytes(data) {
+        if (typeof data === "string")
+          data = utf8ToBytes(data);
+        abytes(data);
+        return data;
+      }
+      function concatBytes2(...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 checkOpts(defaults, opts) {
+        if (opts !== void 0 && {}.toString.call(opts) !== "[object Object]")
+          throw new Error("options should be object or undefined");
+        const merged = Object.assign(defaults, opts);
+        return merged;
+      }
+      var Hash = class {
+      };
+      exports.Hash = Hash;
+      function createHasher(hashCons) {
+        const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+        const tmp = hashCons();
+        hashC.outputLen = tmp.outputLen;
+        hashC.blockLen = tmp.blockLen;
+        hashC.create = () => hashCons();
+        return hashC;
+      }
+      function createOptHasher(hashCons) {
+        const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+        const tmp = hashCons({});
+        hashC.outputLen = tmp.outputLen;
+        hashC.blockLen = tmp.blockLen;
+        hashC.create = (opts) => hashCons(opts);
+        return hashC;
+      }
+      function createXOFer(hashCons) {
+        const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+        const tmp = hashCons({});
+        hashC.outputLen = tmp.outputLen;
+        hashC.blockLen = tmp.blockLen;
+        hashC.create = (opts) => hashCons(opts);
+        return hashC;
+      }
+      exports.wrapConstructor = createHasher;
+      exports.wrapConstructorWithOpts = createOptHasher;
+      exports.wrapXOFConstructorWithOpts = createXOFer;
+      function randomBytes2(bytesLength = 32) {
+        if (crypto_1.crypto && typeof crypto_1.crypto.getRandomValues === "function") {
+          return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength));
+        }
+        if (crypto_1.crypto && typeof crypto_1.crypto.randomBytes === "function") {
+          return Uint8Array.from(crypto_1.crypto.randomBytes(bytesLength));
+        }
+        throw new Error("crypto.getRandomValues must be defined");
+      }
+    }
+  });
+
+  // node_modules/@noble/hashes/_md.js
+  var require_md = __commonJS({
+    "node_modules/@noble/hashes/_md.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.SHA512_IV = exports.SHA384_IV = exports.SHA224_IV = exports.SHA256_IV = exports.HashMD = void 0;
+      exports.setBigUint64 = setBigUint64;
+      exports.Chi = Chi;
+      exports.Maj = Maj;
+      var utils_ts_1 = require_utils();
+      function setBigUint64(view, byteOffset, value, isLE) {
+        if (typeof view.setBigUint64 === "function")
+          return view.setBigUint64(byteOffset, value, isLE);
+        const _32n = BigInt(32);
+        const _u32_max = BigInt(4294967295);
+        const wh = Number(value >> _32n & _u32_max);
+        const wl = Number(value & _u32_max);
+        const h = isLE ? 4 : 0;
+        const l = isLE ? 0 : 4;
+        view.setUint32(byteOffset + h, wh, isLE);
+        view.setUint32(byteOffset + l, wl, isLE);
+      }
+      function Chi(a, b, c) {
+        return a & b ^ ~a & c;
+      }
+      function Maj(a, b, c) {
+        return a & b ^ a & c ^ b & c;
+      }
+      var HashMD = class extends utils_ts_1.Hash {
+        constructor(blockLen, outputLen, padOffset, isLE) {
+          super();
+          this.finished = false;
+          this.length = 0;
+          this.pos = 0;
+          this.destroyed = false;
+          this.blockLen = blockLen;
+          this.outputLen = outputLen;
+          this.padOffset = padOffset;
+          this.isLE = isLE;
+          this.buffer = new Uint8Array(blockLen);
+          this.view = (0, utils_ts_1.createView)(this.buffer);
+        }
+        update(data) {
+          (0, utils_ts_1.aexists)(this);
+          data = (0, utils_ts_1.toBytes)(data);
+          (0, utils_ts_1.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 = (0, utils_ts_1.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) {
+          (0, utils_ts_1.aexists)(this);
+          (0, utils_ts_1.aoutput)(out, this);
+          this.finished = true;
+          const { buffer, view, blockLen, isLE } = this;
+          let { pos } = this;
+          buffer[pos++] = 128;
+          (0, utils_ts_1.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;
+          setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+          this.process(view, 0);
+          const oview = (0, utils_ts_1.createView)(out);
+          const len = this.outputLen;
+          if (len % 4)
+            throw new Error("_sha2: outputLen should 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 || (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();
+        }
+      };
+      exports.HashMD = HashMD;
+      exports.SHA256_IV = Uint32Array.from([
+        1779033703,
+        3144134277,
+        1013904242,
+        2773480762,
+        1359893119,
+        2600822924,
+        528734635,
+        1541459225
+      ]);
+      exports.SHA224_IV = Uint32Array.from([
+        3238371032,
+        914150663,
+        812702999,
+        4144912697,
+        4290775857,
+        1750603025,
+        1694076839,
+        3204075428
+      ]);
+      exports.SHA384_IV = Uint32Array.from([
+        3418070365,
+        3238371032,
+        1654270250,
+        914150663,
+        2438529370,
+        812702999,
+        355462360,
+        4144912697,
+        1731405415,
+        4290775857,
+        2394180231,
+        1750603025,
+        3675008525,
+        1694076839,
+        1203062813,
+        3204075428
+      ]);
+      exports.SHA512_IV = Uint32Array.from([
+        1779033703,
+        4089235720,
+        3144134277,
+        2227873595,
+        1013904242,
+        4271175723,
+        2773480762,
+        1595750129,
+        1359893119,
+        2917565137,
+        2600822924,
+        725511199,
+        528734635,
+        4215389547,
+        1541459225,
+        327033209
+      ]);
+    }
+  });
+
+  // node_modules/@noble/hashes/_u64.js
+  var require_u64 = __commonJS({
+    "node_modules/@noble/hashes/_u64.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.toBig = exports.shrSL = exports.shrSH = exports.rotrSL = exports.rotrSH = exports.rotrBL = exports.rotrBH = exports.rotr32L = exports.rotr32H = exports.rotlSL = exports.rotlSH = exports.rotlBL = exports.rotlBH = exports.add5L = exports.add5H = exports.add4L = exports.add4H = exports.add3L = exports.add3H = void 0;
+      exports.add = add;
+      exports.fromBig = fromBig;
+      exports.split = split;
+      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 toBig = (h, l) => BigInt(h >>> 0) << _32n | BigInt(l >>> 0);
+      exports.toBig = toBig;
+      var shrSH = (h, _l, s) => h >>> s;
+      exports.shrSH = shrSH;
+      var shrSL = (h, l, s) => h << 32 - s | l >>> s;
+      exports.shrSL = shrSL;
+      var rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+      exports.rotrSH = rotrSH;
+      var rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+      exports.rotrSL = rotrSL;
+      var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+      exports.rotrBH = rotrBH;
+      var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+      exports.rotrBL = rotrBL;
+      var rotr32H = (_h, l) => l;
+      exports.rotr32H = rotr32H;
+      var rotr32L = (h, _l) => h;
+      exports.rotr32L = rotr32L;
+      var rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+      exports.rotlSH = rotlSH;
+      var rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+      exports.rotlSL = rotlSL;
+      var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+      exports.rotlBH = rotlBH;
+      var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+      exports.rotlBL = rotlBL;
+      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);
+      exports.add3L = add3L;
+      var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+      exports.add3H = add3H;
+      var add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+      exports.add4L = add4L;
+      var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+      exports.add4H = add4H;
+      var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+      exports.add5L = add5L;
+      var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+      exports.add5H = add5H;
+      var u64 = {
+        fromBig,
+        split,
+        toBig,
+        shrSH,
+        shrSL,
+        rotrSH,
+        rotrSL,
+        rotrBH,
+        rotrBL,
+        rotr32H,
+        rotr32L,
+        rotlSH,
+        rotlSL,
+        rotlBH,
+        rotlBL,
+        add,
+        add3L,
+        add3H,
+        add4L,
+        add4H,
+        add5H,
+        add5L
+      };
+      exports.default = u64;
+    }
+  });
+
+  // node_modules/@noble/hashes/sha2.js
+  var require_sha2 = __commonJS({
+    "node_modules/@noble/hashes/sha2.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.sha512_224 = exports.sha512_256 = exports.sha384 = exports.sha512 = exports.sha224 = exports.sha256 = exports.SHA512_256 = exports.SHA512_224 = exports.SHA384 = exports.SHA512 = exports.SHA224 = exports.SHA256 = void 0;
+      var _md_ts_1 = require_md();
+      var u64 = require_u64();
+      var utils_ts_1 = require_utils();
+      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);
+      var SHA256 = class extends _md_ts_1.HashMD {
+        constructor(outputLen = 32) {
+          super(64, outputLen, 8, false);
+          this.A = _md_ts_1.SHA256_IV[0] | 0;
+          this.B = _md_ts_1.SHA256_IV[1] | 0;
+          this.C = _md_ts_1.SHA256_IV[2] | 0;
+          this.D = _md_ts_1.SHA256_IV[3] | 0;
+          this.E = _md_ts_1.SHA256_IV[4] | 0;
+          this.F = _md_ts_1.SHA256_IV[5] | 0;
+          this.G = _md_ts_1.SHA256_IV[6] | 0;
+          this.H = _md_ts_1.SHA256_IV[7] | 0;
+        }
+        get() {
+          const { A, B, C, D, E, F, G, H } = this;
+          return [A, B, C, D, E, F, G, H];
+        }
+        // prettier-ignore
+        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 = (0, utils_ts_1.rotr)(W15, 7) ^ (0, utils_ts_1.rotr)(W15, 18) ^ W15 >>> 3;
+            const s1 = (0, utils_ts_1.rotr)(W2, 17) ^ (0, utils_ts_1.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 = (0, utils_ts_1.rotr)(E, 6) ^ (0, utils_ts_1.rotr)(E, 11) ^ (0, utils_ts_1.rotr)(E, 25);
+            const T1 = H + sigma1 + (0, _md_ts_1.Chi)(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+            const sigma0 = (0, utils_ts_1.rotr)(A, 2) ^ (0, utils_ts_1.rotr)(A, 13) ^ (0, utils_ts_1.rotr)(A, 22);
+            const T2 = sigma0 + (0, _md_ts_1.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() {
+          (0, utils_ts_1.clean)(SHA256_W);
+        }
+        destroy() {
+          this.set(0, 0, 0, 0, 0, 0, 0, 0);
+          (0, utils_ts_1.clean)(this.buffer);
+        }
+      };
+      exports.SHA256 = SHA256;
+      var SHA224 = class extends SHA256 {
+        constructor() {
+          super(28);
+          this.A = _md_ts_1.SHA224_IV[0] | 0;
+          this.B = _md_ts_1.SHA224_IV[1] | 0;
+          this.C = _md_ts_1.SHA224_IV[2] | 0;
+          this.D = _md_ts_1.SHA224_IV[3] | 0;
+          this.E = _md_ts_1.SHA224_IV[4] | 0;
+          this.F = _md_ts_1.SHA224_IV[5] | 0;
+          this.G = _md_ts_1.SHA224_IV[6] | 0;
+          this.H = _md_ts_1.SHA224_IV[7] | 0;
+        }
+      };
+      exports.SHA224 = SHA224;
+      var K512 = /* @__PURE__ */ (() => u64.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);
+      var SHA512 = class extends _md_ts_1.HashMD {
+        constructor(outputLen = 64) {
+          super(128, outputLen, 16, false);
+          this.Ah = _md_ts_1.SHA512_IV[0] | 0;
+          this.Al = _md_ts_1.SHA512_IV[1] | 0;
+          this.Bh = _md_ts_1.SHA512_IV[2] | 0;
+          this.Bl = _md_ts_1.SHA512_IV[3] | 0;
+          this.Ch = _md_ts_1.SHA512_IV[4] | 0;
+          this.Cl = _md_ts_1.SHA512_IV[5] | 0;
+          this.Dh = _md_ts_1.SHA512_IV[6] | 0;
+          this.Dl = _md_ts_1.SHA512_IV[7] | 0;
+          this.Eh = _md_ts_1.SHA512_IV[8] | 0;
+          this.El = _md_ts_1.SHA512_IV[9] | 0;
+          this.Fh = _md_ts_1.SHA512_IV[10] | 0;
+          this.Fl = _md_ts_1.SHA512_IV[11] | 0;
+          this.Gh = _md_ts_1.SHA512_IV[12] | 0;
+          this.Gl = _md_ts_1.SHA512_IV[13] | 0;
+          this.Hh = _md_ts_1.SHA512_IV[14] | 0;
+          this.Hl = _md_ts_1.SHA512_IV[15] | 0;
+        }
+        // prettier-ignore
+        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];
+        }
+        // prettier-ignore
+        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 = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);
+            const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);
+            const W2h = SHA512_W_H[i - 2] | 0;
+            const W2l = SHA512_W_L[i - 2] | 0;
+            const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);
+            const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);
+            const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+            const SUMh = u64.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 = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);
+            const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);
+            const CHIh = Eh & Fh ^ ~Eh & Gh;
+            const CHIl = El & Fl ^ ~El & Gl;
+            const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+            const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+            const T1l = T1ll | 0;
+            const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);
+            const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.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 } = u64.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 = u64.add3L(T1l, sigma0l, MAJl);
+            Ah = u64.add3H(All, T1h, sigma0h, MAJh);
+            Al = All | 0;
+          }
+          ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+          ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+          ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+          ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+          ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+          ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+          ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+          ({ h: Hh, l: Hl } = u64.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() {
+          (0, utils_ts_1.clean)(SHA512_W_H, SHA512_W_L);
+        }
+        destroy() {
+          (0, utils_ts_1.clean)(this.buffer);
+          this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+        }
+      };
+      exports.SHA512 = SHA512;
+      var SHA384 = class extends SHA512 {
+        constructor() {
+          super(48);
+          this.Ah = _md_ts_1.SHA384_IV[0] | 0;
+          this.Al = _md_ts_1.SHA384_IV[1] | 0;
+          this.Bh = _md_ts_1.SHA384_IV[2] | 0;
+          this.Bl = _md_ts_1.SHA384_IV[3] | 0;
+          this.Ch = _md_ts_1.SHA384_IV[4] | 0;
+          this.Cl = _md_ts_1.SHA384_IV[5] | 0;
+          this.Dh = _md_ts_1.SHA384_IV[6] | 0;
+          this.Dl = _md_ts_1.SHA384_IV[7] | 0;
+          this.Eh = _md_ts_1.SHA384_IV[8] | 0;
+          this.El = _md_ts_1.SHA384_IV[9] | 0;
+          this.Fh = _md_ts_1.SHA384_IV[10] | 0;
+          this.Fl = _md_ts_1.SHA384_IV[11] | 0;
+          this.Gh = _md_ts_1.SHA384_IV[12] | 0;
+          this.Gl = _md_ts_1.SHA384_IV[13] | 0;
+          this.Hh = _md_ts_1.SHA384_IV[14] | 0;
+          this.Hl = _md_ts_1.SHA384_IV[15] | 0;
+        }
+      };
+      exports.SHA384 = SHA384;
+      var T224_IV = /* @__PURE__ */ Uint32Array.from([
+        2352822216,
+        424955298,
+        1944164710,
+        2312950998,
+        502970286,
+        855612546,
+        1738396948,
+        1479516111,
+        258812777,
+        2077511080,
+        2011393907,
+        79989058,
+        1067287976,
+        1780299464,
+        286451373,
+        2446758561
+      ]);
+      var T256_IV = /* @__PURE__ */ Uint32Array.from([
+        573645204,
+        4230739756,
+        2673172387,
+        3360449730,
+        596883563,
+        1867755857,
+        2520282905,
+        1497426621,
+        2519219938,
+        2827943907,
+        3193839141,
+        1401305490,
+        721525244,
+        746961066,
+        246885852,
+        2177182882
+      ]);
+      var SHA512_224 = class extends SHA512 {
+        constructor() {
+          super(28);
+          this.Ah = T224_IV[0] | 0;
+          this.Al = T224_IV[1] | 0;
+          this.Bh = T224_IV[2] | 0;
+          this.Bl = T224_IV[3] | 0;
+          this.Ch = T224_IV[4] | 0;
+          this.Cl = T224_IV[5] | 0;
+          this.Dh = T224_IV[6] | 0;
+          this.Dl = T224_IV[7] | 0;
+          this.Eh = T224_IV[8] | 0;
+          this.El = T224_IV[9] | 0;
+          this.Fh = T224_IV[10] | 0;
+          this.Fl = T224_IV[11] | 0;
+          this.Gh = T224_IV[12] | 0;
+          this.Gl = T224_IV[13] | 0;
+          this.Hh = T224_IV[14] | 0;
+          this.Hl = T224_IV[15] | 0;
+        }
+      };
+      exports.SHA512_224 = SHA512_224;
+      var SHA512_256 = class extends SHA512 {
+        constructor() {
+          super(32);
+          this.Ah = T256_IV[0] | 0;
+          this.Al = T256_IV[1] | 0;
+          this.Bh = T256_IV[2] | 0;
+          this.Bl = T256_IV[3] | 0;
+          this.Ch = T256_IV[4] | 0;
+          this.Cl = T256_IV[5] | 0;
+          this.Dh = T256_IV[6] | 0;
+          this.Dl = T256_IV[7] | 0;
+          this.Eh = T256_IV[8] | 0;
+          this.El = T256_IV[9] | 0;
+          this.Fh = T256_IV[10] | 0;
+          this.Fl = T256_IV[11] | 0;
+          this.Gh = T256_IV[12] | 0;
+          this.Gl = T256_IV[13] | 0;
+          this.Hh = T256_IV[14] | 0;
+          this.Hl = T256_IV[15] | 0;
+        }
+      };
+      exports.SHA512_256 = SHA512_256;
+      exports.sha256 = (0, utils_ts_1.createHasher)(() => new SHA256());
+      exports.sha224 = (0, utils_ts_1.createHasher)(() => new SHA224());
+      exports.sha512 = (0, utils_ts_1.createHasher)(() => new SHA512());
+      exports.sha384 = (0, utils_ts_1.createHasher)(() => new SHA384());
+      exports.sha512_256 = (0, utils_ts_1.createHasher)(() => new SHA512_256());
+      exports.sha512_224 = (0, utils_ts_1.createHasher)(() => new SHA512_224());
+    }
+  });
+
+  // node_modules/@noble/hashes/hmac.js
+  var require_hmac = __commonJS({
+    "node_modules/@noble/hashes/hmac.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.hmac = exports.HMAC = void 0;
+      var utils_ts_1 = require_utils();
+      var HMAC = class extends utils_ts_1.Hash {
+        constructor(hash, _key) {
+          super();
+          this.finished = false;
+          this.destroyed = false;
+          (0, utils_ts_1.ahash)(hash);
+          const key = (0, utils_ts_1.toBytes)(_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);
+          (0, utils_ts_1.clean)(pad);
+        }
+        update(buf) {
+          (0, utils_ts_1.aexists)(this);
+          this.iHash.update(buf);
+          return this;
+        }
+        digestInto(out) {
+          (0, utils_ts_1.aexists)(this);
+          (0, utils_ts_1.abytes)(out, this.outputLen);
+          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 || (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();
+        }
+      };
+      exports.HMAC = HMAC;
+      var hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
+      exports.hmac = hmac;
+      exports.hmac.create = (hash, key) => new HMAC(hash, key);
+    }
+  });
+
+  // node_modules/@noble/curves/utils.js
+  var require_utils2 = __commonJS({
+    "node_modules/@noble/curves/utils.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.notImplemented = exports.bitMask = exports.utf8ToBytes = exports.randomBytes = exports.isBytes = exports.hexToBytes = exports.concatBytes = exports.bytesToUtf8 = exports.bytesToHex = exports.anumber = exports.abytes = void 0;
+      exports.abool = abool;
+      exports._abool2 = _abool2;
+      exports._abytes2 = _abytes2;
+      exports.numberToHexUnpadded = numberToHexUnpadded;
+      exports.hexToNumber = hexToNumber;
+      exports.bytesToNumberBE = bytesToNumberBE;
+      exports.bytesToNumberLE = bytesToNumberLE;
+      exports.numberToBytesBE = numberToBytesBE;
+      exports.numberToBytesLE = numberToBytesLE;
+      exports.numberToVarBytesBE = numberToVarBytesBE;
+      exports.ensureBytes = ensureBytes;
+      exports.equalBytes = equalBytes;
+      exports.copyBytes = copyBytes;
+      exports.asciiToBytes = asciiToBytes;
+      exports.inRange = inRange;
+      exports.aInRange = aInRange;
+      exports.bitLen = bitLen;
+      exports.bitGet = bitGet;
+      exports.bitSet = bitSet;
+      exports.createHmacDrbg = createHmacDrbg;
+      exports.validateObject = validateObject;
+      exports.isHash = isHash;
+      exports._validateObject = _validateObject;
+      exports.memoized = memoized;
+      var utils_js_1 = require_utils();
+      var utils_js_2 = require_utils();
+      Object.defineProperty(exports, "abytes", { enumerable: true, get: function() {
+        return utils_js_2.abytes;
+      } });
+      Object.defineProperty(exports, "anumber", { enumerable: true, get: function() {
+        return utils_js_2.anumber;
+      } });
+      Object.defineProperty(exports, "bytesToHex", { enumerable: true, get: function() {
+        return utils_js_2.bytesToHex;
+      } });
+      Object.defineProperty(exports, "bytesToUtf8", { enumerable: true, get: function() {
+        return utils_js_2.bytesToUtf8;
+      } });
+      Object.defineProperty(exports, "concatBytes", { enumerable: true, get: function() {
+        return utils_js_2.concatBytes;
+      } });
+      Object.defineProperty(exports, "hexToBytes", { enumerable: true, get: function() {
+        return utils_js_2.hexToBytes;
+      } });
+      Object.defineProperty(exports, "isBytes", { enumerable: true, get: function() {
+        return utils_js_2.isBytes;
+      } });
+      Object.defineProperty(exports, "randomBytes", { enumerable: true, get: function() {
+        return utils_js_2.randomBytes;
+      } });
+      Object.defineProperty(exports, "utf8ToBytes", { enumerable: true, get: function() {
+        return utils_js_2.utf8ToBytes;
+      } });
+      var _0n = /* @__PURE__ */ BigInt(0);
+      var _1n = /* @__PURE__ */ BigInt(1);
+      function abool(title, value) {
+        if (typeof value !== "boolean")
+          throw new Error(title + " boolean expected, got " + value);
+      }
+      function _abool2(value, title = "") {
+        if (typeof value !== "boolean") {
+          const prefix = title && `"${title}"`;
+          throw new Error(prefix + "expected boolean, got type=" + typeof value);
+        }
+        return value;
+      }
+      function _abytes2(value, length, title = "") {
+        const bytes = (0, utils_js_1.isBytes)(value);
+        const len = value?.length;
+        const needsLen = length !== void 0;
+        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 numberToHexUnpadded(num) {
+        const hex = 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((0, utils_js_1.bytesToHex)(bytes));
+      }
+      function bytesToNumberLE(bytes) {
+        (0, utils_js_1.abytes)(bytes);
+        return hexToNumber((0, utils_js_1.bytesToHex)(Uint8Array.from(bytes).reverse()));
+      }
+      function numberToBytesBE(n, len) {
+        return (0, utils_js_1.hexToBytes)(n.toString(16).padStart(len * 2, "0"));
+      }
+      function numberToBytesLE(n, len) {
+        return numberToBytesBE(n, len).reverse();
+      }
+      function numberToVarBytesBE(n) {
+        return (0, utils_js_1.hexToBytes)(numberToHexUnpadded(n));
+      }
+      function ensureBytes(title, hex, expectedLength) {
+        let res;
+        if (typeof hex === "string") {
+          try {
+            res = (0, utils_js_1.hexToBytes)(hex);
+          } catch (e) {
+            throw new Error(title + " must be hex string or Uint8Array, cause: " + e);
+          }
+        } else if ((0, utils_js_1.isBytes)(hex)) {
+          res = Uint8Array.from(hex);
+        } else {
+          throw new Error(title + " must be hex string or Uint8Array");
+        }
+        const len = res.length;
+        if (typeof expectedLength === "number" && len !== expectedLength)
+          throw new Error(title + " of length " + expectedLength + " expected, got " + len);
+        return res;
+      }
+      function equalBytes(a, b) {
+        if (a.length !== b.length)
+          return false;
+        let diff = 0;
+        for (let i = 0; i < a.length; i++)
+          diff |= a[i] ^ b[i];
+        return diff === 0;
+      }
+      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;
+      }
+      function bitGet(n, pos) {
+        return n >> BigInt(pos) & _1n;
+      }
+      function bitSet(n, pos, value) {
+        return n | (value ? _1n : _0n) << BigInt(pos);
+      }
+      var bitMask = (n) => (_1n << BigInt(n)) - _1n;
+      exports.bitMask = bitMask;
+      function createHmacDrbg(hashLen, qByteLen, hmacFn) {
+        if (typeof hashLen !== "number" || hashLen < 2)
+          throw new Error("hashLen must be a number");
+        if (typeof qByteLen !== "number" || qByteLen < 2)
+          throw new Error("qByteLen must be a number");
+        if (typeof hmacFn !== "function")
+          throw new Error("hmacFn must be a function");
+        const u8n = (len) => new Uint8Array(len);
+        const u8of = (byte) => Uint8Array.of(byte);
+        let v = u8n(hashLen);
+        let k = u8n(hashLen);
+        let i = 0;
+        const reset = () => {
+          v.fill(1);
+          k.fill(0);
+          i = 0;
+        };
+        const h = (...b) => hmacFn(k, v, ...b);
+        const reseed = (seed = u8n(0)) => {
+          k = h(u8of(0), seed);
+          v = h();
+          if (seed.length === 0)
+            return;
+          k = h(u8of(1), seed);
+          v = h();
+        };
+        const gen = () => {
+          if (i++ >= 1e3)
+            throw new Error("drbg: tried 1000 values");
+          let len = 0;
+          const out = [];
+          while (len < qByteLen) {
+            v = h();
+            const sl = v.slice();
+            out.push(sl);
+            len += v.length;
+          }
+          return (0, utils_js_1.concatBytes)(...out);
+        };
+        const genUntil = (seed, pred) => {
+          reset();
+          reseed(seed);
+          let res = void 0;
+          while (!(res = pred(gen())))
+            reseed();
+          reset();
+          return res;
+        };
+        return genUntil;
+      }
+      var validatorFns = {
+        bigint: (val) => typeof val === "bigint",
+        function: (val) => typeof val === "function",
+        boolean: (val) => typeof val === "boolean",
+        string: (val) => typeof val === "string",
+        stringOrUint8Array: (val) => typeof val === "string" || (0, utils_js_1.isBytes)(val),
+        isSafeInteger: (val) => Number.isSafeInteger(val),
+        array: (val) => Array.isArray(val),
+        field: (val, object) => object.Fp.isValid(val),
+        hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
+      };
+      function validateObject(object, validators, optValidators = {}) {
+        const checkField = (fieldName, type, isOptional) => {
+          const checkVal = validatorFns[type];
+          if (typeof checkVal !== "function")
+            throw new Error("invalid validator function");
+          const val = object[fieldName];
+          if (isOptional && val === void 0)
+            return;
+          if (!checkVal(val, object)) {
+            throw new Error("param " + String(fieldName) + " is invalid. Expected " + type + ", got " + val);
+          }
+        };
+        for (const [fieldName, type] of Object.entries(validators))
+          checkField(fieldName, type, false);
+        for (const [fieldName, type] of Object.entries(optValidators))
+          checkField(fieldName, type, true);
+        return object;
+      }
+      function isHash(val) {
+        return typeof val === "function" && Number.isSafeInteger(val.outputLen);
+      }
+      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 === void 0)
+            return;
+          const current = typeof val;
+          if (current !== expectedType || val === null)
+            throw new Error(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`);
+        }
+        Object.entries(fields).forEach(([k, v]) => checkField(k, v, false));
+        Object.entries(optFields).forEach(([k, v]) => checkField(k, v, true));
+      }
+      var notImplemented = () => {
+        throw new Error("not implemented");
+      };
+      exports.notImplemented = notImplemented;
+      function memoized(fn) {
+        const map = /* @__PURE__ */ new WeakMap();
+        return (arg, ...args) => {
+          const val = map.get(arg);
+          if (val !== void 0)
+            return val;
+          const computed = fn(arg, ...args);
+          map.set(arg, computed);
+          return computed;
+        };
+      }
+    }
+  });
+
+  // node_modules/@noble/curves/abstract/modular.js
+  var require_modular = __commonJS({
+    "node_modules/@noble/curves/abstract/modular.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.isNegativeLE = void 0;
+      exports.mod = mod;
+      exports.pow = pow;
+      exports.pow2 = pow2;
+      exports.invert = invert;
+      exports.tonelliShanks = tonelliShanks;
+      exports.FpSqrt = FpSqrt;
+      exports.validateField = validateField;
+      exports.FpPow = FpPow;
+      exports.FpInvertBatch = FpInvertBatch;
+      exports.FpDiv = FpDiv;
+      exports.FpLegendre = FpLegendre;
+      exports.FpIsSquare = FpIsSquare;
+      exports.nLength = nLength;
+      exports.Field = Field;
+      exports.FpSqrtOdd = FpSqrtOdd;
+      exports.FpSqrtEven = FpSqrtEven;
+      exports.hashToPrivateScalar = hashToPrivateScalar;
+      exports.getFieldBytesLength = getFieldBytesLength;
+      exports.getMinHashLength = getMinHashLength;
+      exports.mapHashToField = mapHashToField;
+      var utils_ts_1 = require_utils2();
+      var _0n = BigInt(0);
+      var _1n = 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 >= _0n ? result : b + result;
+      }
+      function pow(num, power, modulo) {
+        return FpPow(Field(modulo), num, power);
+      }
+      function pow2(x, power, modulo) {
+        let res = x;
+        while (power-- > _0n) {
+          res *= res;
+          res %= modulo;
+        }
+        return res;
+      }
+      function invert(number, modulo) {
+        if (number === _0n)
+          throw new Error("invert: expected non-zero number");
+        if (modulo <= _0n)
+          throw new Error("invert: expected positive modulus, got " + modulo);
+        let a = mod(number, modulo);
+        let b = modulo;
+        let x = _0n, y = _1n, u = _1n, v = _0n;
+        while (a !== _0n) {
+          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 !== _1n)
+          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 + _1n) / _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 - _1n;
+        let S = 0;
+        while (Q % _2n === _0n) {
+          Q /= _2n;
+          S++;
+        }
+        let Z = _2n;
+        const _Fp = Field(P);
+        while (FpLegendre(_Fp, Z) === 1) {
+          if (Z++ > 1e3)
+            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 + _1n) / _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 = _1n << 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 isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n) === _1n;
+      exports.isNegativeLE = isNegativeLE;
+      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",
+          MASK: "bigint",
+          BYTES: "number",
+          BITS: "number"
+        };
+        const opts = FIELD_FIELDS.reduce((map, val) => {
+          map[val] = "function";
+          return map;
+        }, initial);
+        (0, utils_ts_1._validateObject)(field, opts);
+        return field;
+      }
+      function FpPow(Fp, num, power) {
+        if (power < _0n)
+          throw new Error("invalid exponent, negatives unsupported");
+        if (power === _0n)
+          return Fp.ONE;
+        if (power === _1n)
+          return num;
+        let p = Fp.ONE;
+        let d = num;
+        while (power > _0n) {
+          if (power & _1n)
+            p = Fp.mul(p, d);
+          d = Fp.sqr(d);
+          power >>= _1n;
+        }
+        return p;
+      }
+      function FpInvertBatch(Fp, nums, passZero = false) {
+        const inverted = new Array(nums.length).fill(passZero ? Fp.ZERO : void 0);
+        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 FpDiv(Fp, lhs, rhs) {
+        return Fp.mul(lhs, typeof rhs === "bigint" ? invert(rhs, Fp.ORDER) : Fp.inv(rhs));
+      }
+      function FpLegendre(Fp, n) {
+        const p1mod2 = (Fp.ORDER - _1n) / _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 FpIsSquare(Fp, n) {
+        const l = FpLegendre(Fp, n);
+        return l === 1;
+      }
+      function nLength(n, nBitLength) {
+        if (nBitLength !== void 0)
+          (0, utils_ts_1.anumber)(nBitLength);
+        const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
+        const nByteLength = Math.ceil(_nBitLength / 8);
+        return { nBitLength: _nBitLength, nByteLength };
+      }
+      function Field(ORDER, bitLenOrOpts, isLE = false, opts = {}) {
+        if (ORDER <= _0n)
+          throw new Error("invalid field: expected ORDER > 0, got " + ORDER);
+        let _nbitLength = void 0;
+        let _sqrt = void 0;
+        let modFromBytes = false;
+        let allowedLengths = void 0;
+        if (typeof bitLenOrOpts === "object" && bitLenOrOpts != null) {
+          if (opts.sqrt || isLE)
+            throw new Error("cannot specify opts in two arguments");
+          const _opts = bitLenOrOpts;
+          if (_opts.BITS)
+            _nbitLength = _opts.BITS;
+          if (_opts.sqrt)
+            _sqrt = _opts.sqrt;
+          if (typeof _opts.isLE === "boolean")
+            isLE = _opts.isLE;
+          if (typeof _opts.modFromBytes === "boolean")
+            modFromBytes = _opts.modFromBytes;
+          allowedLengths = _opts.allowedLengths;
+        } else {
+          if (typeof bitLenOrOpts === "number")
+            _nbitLength = bitLenOrOpts;
+          if (opts.sqrt)
+            _sqrt = opts.sqrt;
+        }
+        const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, _nbitLength);
+        if (BYTES > 2048)
+          throw new Error("invalid field: expected ORDER of <= 2048 bytes");
+        let sqrtP;
+        const f = Object.freeze({
+          ORDER,
+          isLE,
+          BITS,
+          BYTES,
+          MASK: (0, utils_ts_1.bitMask)(BITS),
+          ZERO: _0n,
+          ONE: _1n,
+          allowedLengths,
+          create: (num) => mod(num, ORDER),
+          isValid: (num) => {
+            if (typeof num !== "bigint")
+              throw new Error("invalid field element: expected bigint, got " + typeof num);
+            return _0n <= num && num < ORDER;
+          },
+          is0: (num) => num === _0n,
+          // is valid and invertible
+          isValidNot0: (num) => !f.is0(num) && f.isValid(num),
+          isOdd: (num) => (num & _1n) === _1n,
+          neg: (num) => mod(-num, ORDER),
+          eql: (lhs, rhs) => lhs === rhs,
+          sqr: (num) => mod(num * num, ORDER),
+          add: (lhs, rhs) => mod(lhs + rhs, ORDER),
+          sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
+          mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
+          pow: (num, power) => FpPow(f, num, power),
+          div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
+          // Same as above, but doesn't normalize
+          sqrN: (num) => num * num,
+          addN: (lhs, rhs) => lhs + rhs,
+          subN: (lhs, rhs) => lhs - rhs,
+          mulN: (lhs, rhs) => lhs * rhs,
+          inv: (num) => invert(num, ORDER),
+          sqrt: _sqrt || ((n) => {
+            if (!sqrtP)
+              sqrtP = FpSqrt(ORDER);
+            return sqrtP(f, n);
+          }),
+          toBytes: (num) => isLE ? (0, utils_ts_1.numberToBytesLE)(num, BYTES) : (0, utils_ts_1.numberToBytesBE)(num, BYTES),
+          fromBytes: (bytes, skipValidation = true) => {
+            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 ? (0, utils_ts_1.bytesToNumberLE)(bytes) : (0, utils_ts_1.bytesToNumberBE)(bytes);
+            if (modFromBytes)
+              scalar = mod(scalar, ORDER);
+            if (!skipValidation) {
+              if (!f.isValid(scalar))
+                throw new Error("invalid field element: outside of range 0..ORDER");
+            }
+            return scalar;
+          },
+          // TODO: we don't need it here, move out to separate fn
+          invertBatch: (lst) => FpInvertBatch(f, lst),
+          // We can't move this out because Fp6, Fp12 implement it
+          // and it's unclear what to return in there.
+          cmov: (a, b, c) => c ? b : a
+        });
+        return Object.freeze(f);
+      }
+      function FpSqrtOdd(Fp, elm) {
+        if (!Fp.isOdd)
+          throw new Error("Field doesn't have isOdd");
+        const root = Fp.sqrt(elm);
+        return Fp.isOdd(root) ? root : Fp.neg(root);
+      }
+      function FpSqrtEven(Fp, elm) {
+        if (!Fp.isOdd)
+          throw new Error("Field doesn't have isOdd");
+        const root = Fp.sqrt(elm);
+        return Fp.isOdd(root) ? Fp.neg(root) : root;
+      }
+      function hashToPrivateScalar(hash, groupOrder, isLE = false) {
+        hash = (0, utils_ts_1.ensureBytes)("privateHash", hash);
+        const hashLen = hash.length;
+        const minLen = nLength(groupOrder).nByteLength + 8;
+        if (minLen < 24 || hashLen < minLen || hashLen > 1024)
+          throw new Error("hashToPrivateScalar: expected " + minLen + "-1024 bytes of input, got " + hashLen);
+        const num = isLE ? (0, utils_ts_1.bytesToNumberLE)(hash) : (0, utils_ts_1.bytesToNumberBE)(hash);
+        return mod(num, groupOrder - _1n) + _1n;
+      }
+      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) {
+        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 ? (0, utils_ts_1.bytesToNumberLE)(key) : (0, utils_ts_1.bytesToNumberBE)(key);
+        const reduced = mod(num, fieldOrder - _1n) + _1n;
+        return isLE ? (0, utils_ts_1.numberToBytesLE)(reduced, fieldLen) : (0, utils_ts_1.numberToBytesBE)(reduced, fieldLen);
+      }
+    }
+  });
+
+  // node_modules/@noble/curves/abstract/curve.js
+  var require_curve = __commonJS({
+    "node_modules/@noble/curves/abstract/curve.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.wNAF = void 0;
+      exports.negateCt = negateCt;
+      exports.normalizeZ = normalizeZ;
+      exports.mulEndoUnsafe = mulEndoUnsafe;
+      exports.pippenger = pippenger;
+      exports.precomputeMSMUnsafe = precomputeMSMUnsafe;
+      exports.validateBasic = validateBasic;
+      exports._createCurveFields = _createCurveFields;
+      var utils_ts_1 = require_utils2();
+      var modular_ts_1 = require_modular();
+      var _0n = BigInt(0);
+      var _1n = BigInt(1);
+      function negateCt(condition, item) {
+        const neg = item.negate();
+        return condition ? neg : item;
+      }
+      function normalizeZ(c, points) {
+        const invertedZs = (0, modular_ts_1.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 = (0, utils_ts_1.bitMask)(W);
+        const shiftBy = BigInt(W);
+        return { windows, windowSize, mask, maxNumber, shiftBy };
+      }
+      function calcOffsets(n, window, wOpts) {
+        const { windowSize, mask, maxNumber, shiftBy } = wOpts;
+        let wbits = Number(n & mask);
+        let nextN = n >> shiftBy;
+        if (wbits > windowSize) {
+          wbits -= maxNumber;
+          nextN += _1n;
+        }
+        const offsetStart = window * windowSize;
+        const offset = offsetStart + Math.abs(wbits) - 1;
+        const isZero = wbits === 0;
+        const isNeg = wbits < 0;
+        const isNegF = window % 2 !== 0;
+        const offsetF = offsetStart;
+        return { nextN, offset, isZero, isNeg, isNegF, offsetF };
+      }
+      function validateMSMPoints(points, c) {
+        if (!Array.isArray(points))
+          throw new Error("array expected");
+        points.forEach((p, i) => {
+          if (!(p instanceof c))
+            throw new Error("invalid point at index " + i);
+        });
+      }
+      function validateMSMScalars(scalars, field) {
+        if (!Array.isArray(scalars))
+          throw new Error("array of scalars expected");
+        scalars.forEach((s, i) => {
+          if (!field.isValid(s))
+            throw new Error("invalid scalar at index " + i);
+        });
+      }
+      var pointPrecomputes = /* @__PURE__ */ new WeakMap();
+      var pointWindowSizes = /* @__PURE__ */ new WeakMap();
+      function getW(P) {
+        return pointWindowSizes.get(P) || 1;
+      }
+      function assert0(n) {
+        if (n !== _0n)
+          throw new Error("invalid wNAF");
+      }
+      var wNAF = class {
+        // Parametrized with a given Point class (not individual point)
+        constructor(Point, bits) {
+          this.BASE = Point.BASE;
+          this.ZERO = Point.ZERO;
+          this.Fn = Point.Fn;
+          this.bits = bits;
+        }
+        // non-const time multiplication ladder
+        _unsafeLadder(elm, n, p = this.ZERO) {
+          let d = elm;
+          while (n > _0n) {
+            if (n & _1n)
+              p = p.add(d);
+            d = d.double();
+            n >>= _1n;
+          }
+          return p;
+        }
+        /**
+         * Creates a wNAF precomputation window. Used for caching.
+         * Default window size is set by `utils.precompute()` and is equal to 8.
+         * Number of precomputed points depends on the curve size:
+         * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
+         * - 𝑊 is the window size
+         * - 𝑛 is the bitlength of the curve order.
+         * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
+         * @param point Point instance
+         * @param W window size
+         * @returns precomputed point tables flattened to a single array
+         */
+        precomputeWindow(point, W) {
+          const { windows, windowSize } = calcWOpts(W, this.bits);
+          const points = [];
+          let p = point;
+          let base = p;
+          for (let window = 0; window < windows; window++) {
+            base = p;
+            points.push(base);
+            for (let i = 1; i < windowSize; i++) {
+              base = base.add(p);
+              points.push(base);
+            }
+            p = base.double();
+          }
+          return points;
+        }
+        /**
+         * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+         * More compact implementation:
+         * https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541
+         * @returns real and fake (for const-time) 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 window = 0; window < wo.windows; window++) {
+            const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, 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 };
+        }
+        /**
+         * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.
+         * @param acc accumulator point to add result of multiplication
+         * @returns point
+         */
+        wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {
+          const wo = calcWOpts(W, this.bits);
+          for (let window = 0; window < wo.windows; window++) {
+            if (n === _0n)
+              break;
+            const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, 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);
+        }
+        // We calculate precomputes for elliptic curve point multiplication
+        // using windowed method. This specifies window size and
+        // stores precomputed values. Usually only base point would be precomputed.
+        createCache(P, W) {
+          validateW(W, this.bits);
+          pointWindowSizes.set(P, W);
+          pointPrecomputes.delete(P);
+        }
+        hasCache(elm) {
+          return getW(elm) !== 1;
+        }
+      };
+      exports.wNAF = wNAF;
+      function mulEndoUnsafe(Point, point, k1, k2) {
+        let acc = point;
+        let p1 = Point.ZERO;
+        let p2 = Point.ZERO;
+        while (k1 > _0n || k2 > _0n) {
+          if (k1 & _1n)
+            p1 = p1.add(acc);
+          if (k2 & _1n)
+            p2 = p2.add(acc);
+          acc = acc.double();
+          k1 >>= _1n;
+          k2 >>= _1n;
+        }
+        return { p1, p2 };
+      }
+      function pippenger(c, fieldN, points, scalars) {
+        validateMSMPoints(points, c);
+        validateMSMScalars(scalars, fieldN);
+        const plength = points.length;
+        const slength = scalars.length;
+        if (plength !== slength)
+          throw new Error("arrays of points and scalars must have equal length");
+        const zero = c.ZERO;
+        const wbits = (0, utils_ts_1.bitLen)(BigInt(plength));
+        let windowSize = 1;
+        if (wbits > 12)
+          windowSize = wbits - 3;
+        else if (wbits > 4)
+          windowSize = wbits - 2;
+        else if (wbits > 0)
+          windowSize = 2;
+        const MASK = (0, utils_ts_1.bitMask)(windowSize);
+        const buckets = new Array(Number(MASK) + 1).fill(zero);
+        const lastBits = Math.floor((fieldN.BITS - 1) / windowSize) * windowSize;
+        let sum = zero;
+        for (let i = lastBits; i >= 0; i -= windowSize) {
+          buckets.fill(zero);
+          for (let j = 0; j < slength; j++) {
+            const scalar = scalars[j];
+            const wbits2 = Number(scalar >> BigInt(i) & MASK);
+            buckets[wbits2] = buckets[wbits2].add(points[j]);
+          }
+          let resI = zero;
+          for (let j = buckets.length - 1, sumI = zero; j > 0; j--) {
+            sumI = sumI.add(buckets[j]);
+            resI = resI.add(sumI);
+          }
+          sum = sum.add(resI);
+          if (i !== 0)
+            for (let j = 0; j < windowSize; j++)
+              sum = sum.double();
+        }
+        return sum;
+      }
+      function precomputeMSMUnsafe(c, fieldN, points, windowSize) {
+        validateW(windowSize, fieldN.BITS);
+        validateMSMPoints(points, c);
+        const zero = c.ZERO;
+        const tableSize = 2 ** windowSize - 1;
+        const chunks = Math.ceil(fieldN.BITS / windowSize);
+        const MASK = (0, utils_ts_1.bitMask)(windowSize);
+        const tables = points.map((p) => {
+          const res = [];
+          for (let i = 0, acc = p; i < tableSize; i++) {
+            res.push(acc);
+            acc = acc.add(p);
+          }
+          return res;
+        });
+        return (scalars) => {
+          validateMSMScalars(scalars, fieldN);
+          if (scalars.length > points.length)
+            throw new Error("array of scalars must be smaller than array of points");
+          let res = zero;
+          for (let i = 0; i < chunks; i++) {
+            if (res !== zero)
+              for (let j = 0; j < windowSize; j++)
+                res = res.double();
+            const shiftBy = BigInt(chunks * windowSize - (i + 1) * windowSize);
+            for (let j = 0; j < scalars.length; j++) {
+              const n = scalars[j];
+              const curr = Number(n >> shiftBy & MASK);
+              if (!curr)
+                continue;
+              res = res.add(tables[j][curr - 1]);
+            }
+          }
+          return res;
+        };
+      }
+      function validateBasic(curve) {
+        (0, modular_ts_1.validateField)(curve.Fp);
+        (0, utils_ts_1.validateObject)(curve, {
+          n: "bigint",
+          h: "bigint",
+          Gx: "field",
+          Gy: "field"
+        }, {
+          nBitLength: "isSafeInteger",
+          nByteLength: "isSafeInteger"
+        });
+        return Object.freeze({
+          ...(0, modular_ts_1.nLength)(curve.n, curve.nBitLength),
+          ...curve,
+          ...{ p: curve.Fp.ORDER }
+        });
+      }
+      function createField(order, field, isLE) {
+        if (field) {
+          if (field.ORDER !== order)
+            throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+          (0, modular_ts_1.validateField)(field);
+          return field;
+        } else {
+          return (0, modular_ts_1.Field)(order, { isLE });
+        }
+      }
+      function _createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {
+        if (FpFnLE === void 0)
+          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 > _0n))
+            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 };
+      }
+    }
+  });
+
+  // node_modules/@noble/curves/abstract/weierstrass.js
+  var require_weierstrass = __commonJS({
+    "node_modules/@noble/curves/abstract/weierstrass.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.DER = exports.DERErr = void 0;
+      exports._splitEndoScalar = _splitEndoScalar;
+      exports._normFnElement = _normFnElement;
+      exports.weierstrassN = weierstrassN;
+      exports.SWUFpSqrtRatio = SWUFpSqrtRatio;
+      exports.mapToCurveSimpleSWU = mapToCurveSimpleSWU;
+      exports.ecdh = ecdh;
+      exports.ecdsa = ecdsa;
+      exports.weierstrassPoints = weierstrassPoints;
+      exports._legacyHelperEquat = _legacyHelperEquat;
+      exports.weierstrass = weierstrass;
+      var hmac_js_1 = require_hmac();
+      var utils_1 = require_utils();
+      var utils_ts_1 = require_utils2();
+      var curve_ts_1 = require_curve();
+      var modular_ts_1 = require_modular();
+      var divNearest = (num, den) => (num + (num >= 0 ? den : -den) / _2n) / 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 < _0n;
+        const k2neg = k2 < _0n;
+        if (k1neg)
+          k1 = -k1;
+        if (k2neg)
+          k2 = -k2;
+        const MAX_NUM = (0, utils_ts_1.bitMask)(Math.ceil((0, utils_ts_1.bitLen)(n) / 2)) + _1n;
+        if (k1 < _0n || k1 >= MAX_NUM || k2 < _0n || 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] === void 0 ? def[optName] : opts[optName];
+        }
+        (0, utils_ts_1._abool2)(optsn.lowS, "lowS");
+        (0, utils_ts_1._abool2)(optsn.prehash, "prehash");
+        if (optsn.format !== void 0)
+          validateSigFormat(optsn.format);
+        return optsn;
+      }
+      var DERErr = class extends Error {
+        constructor(m = "") {
+          super(m);
+        }
+      };
+      exports.DERErr = DERErr;
+      exports.DER = {
+        // asn.1 DER encoding utils
+        Err: DERErr,
+        // Basic building block is TLV (Tag-Length-Value)
+        _tlv: {
+          encode: (tag, data) => {
+            const { Err: E } = exports.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 = (0, utils_ts_1.numberToHexUnpadded)(dataLen);
+            if (len.length / 2 & 128)
+              throw new E("tlv.encode: long form length too big");
+            const lenLen = dataLen > 127 ? (0, utils_ts_1.numberToHexUnpadded)(len.length / 2 | 128) : "";
+            const t = (0, utils_ts_1.numberToHexUnpadded)(tag);
+            return t + lenLen + len + data;
+          },
+          // v - value, l - left bytes (unparsed)
+          decode(tag, data) {
+            const { Err: E } = exports.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) };
+          }
+        },
+        // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
+        // since we always use positive integers here. It must always be empty:
+        // - add zero byte if exists
+        // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
+        _int: {
+          encode(num) {
+            const { Err: E } = exports.DER;
+            if (num < _0n)
+              throw new E("integer: negative integers are not allowed");
+            let hex = (0, utils_ts_1.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 } = exports.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 (0, utils_ts_1.bytesToNumberBE)(data);
+          }
+        },
+        toSig(hex) {
+          const { Err: E, _int: int, _tlv: tlv } = exports.DER;
+          const data = (0, utils_ts_1.ensureBytes)("signature", hex);
+          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 } = exports.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 _0n = BigInt(0);
+      var _1n = BigInt(1);
+      var _2n = BigInt(2);
+      var _3n = BigInt(3);
+      var _4n = BigInt(4);
+      function _normFnElement(Fn, key) {
+        const { BYTES: expected } = Fn;
+        let num;
+        if (typeof key === "bigint") {
+          num = key;
+        } else {
+          let bytes = (0, utils_ts_1.ensureBytes)("private key", key);
+          try {
+            num = Fn.fromBytes(bytes);
+          } catch (error) {
+            throw new Error(`invalid private key: expected ui8a of size ${expected}, got ${typeof key}`);
+          }
+        }
+        if (!Fn.isValidNot0(num))
+          throw new Error("invalid private key: out of range [1..N-1]");
+        return num;
+      }
+      function weierstrassN(params, extraOpts = {}) {
+        const validated = (0, curve_ts_1._createCurveFields)("weierstrass", params, extraOpts);
+        const { Fp, Fn } = validated;
+        let CURVE = validated.CURVE;
+        const { h: cofactor, n: CURVE_ORDER } = CURVE;
+        (0, utils_ts_1._validateObject)(extraOpts, {}, {
+          allowInfinityPoint: "boolean",
+          clearCofactor: "function",
+          isTorsionFree: "function",
+          fromBytes: "function",
+          toBytes: "function",
+          endo: "object",
+          wrapPrivateKey: "boolean"
+        });
+        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);
+          (0, utils_ts_1._abool2)(isCompressed, "isCompressed");
+          if (isCompressed) {
+            assertCompressionIsSupported();
+            const hasEvenY = !Fp.isOdd(y);
+            return (0, utils_ts_1.concatBytes)(pprefix(hasEvenY), bx);
+          } else {
+            return (0, utils_ts_1.concatBytes)(Uint8Array.of(4), bx, Fp.toBytes(y));
+          }
+        }
+        function pointFromBytes(bytes) {
+          (0, utils_ts_1._abytes2)(bytes, void 0, "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 isYOdd = Fp.isOdd(y);
+            const isHeadOdd = (head & 1) === 1;
+            if (isHeadOdd !== isYOdd)
+              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, _3n), _4n);
+        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("ProjectivePoint expected");
+        }
+        function splitEndoScalarN(k) {
+          if (!endo || !endo.basises)
+            throw new Error("no endo");
+          return _splitEndoScalar(k, endo.basises, Fn.ORDER);
+        }
+        const toAffineMemo = (0, utils_ts_1.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 = (0, utils_ts_1.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 = (0, curve_ts_1.negateCt)(k1neg, k1p);
+          k2p = (0, curve_ts_1.negateCt)(k2neg, k2p);
+          return k1p.add(k2p);
+        }
+        class Point {
+          /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+          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;
+          }
+          /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+          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((0, utils_ts_1._abytes2)(bytes, void 0, "point")));
+            P.assertValidity();
+            return P;
+          }
+          static fromHex(hex) {
+            return Point.fromBytes((0, utils_ts_1.ensureBytes)("pointHex", hex));
+          }
+          get x() {
+            return this.toAffine().x;
+          }
+          get y() {
+            return this.toAffine().y;
+          }
+          /**
+           *
+           * @param windowSize
+           * @param isLazy true will defer table computation until the first multiplication
+           * @returns
+           */
+          precompute(windowSize = 8, isLazy = true) {
+            wnaf.createCache(this, windowSize);
+            if (!isLazy)
+              this.multiply(_3n);
+            return this;
+          }
+          // TODO: return `this`
+          /** A point on curve is valid if it conforms to equation. */
+          assertValidity() {
+            assertValidMemo(this);
+          }
+          hasEvenY() {
+            const { y } = this.toAffine();
+            if (!Fp.isOdd)
+              throw new Error("Field doesn't support isOdd");
+            return !Fp.isOdd(y);
+          }
+          /** Compare one point to another. */
+          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;
+          }
+          /** Flips point to one corresponding to (x, -y) in Affine coordinates. */
+          negate() {
+            return new Point(this.X, Fp.neg(this.Y), this.Z);
+          }
+          // Renes-Costello-Batina exception-free doubling formula.
+          // There is 30% faster Jacobian formula, but it is not complete.
+          // https://eprint.iacr.org/2015/1060, algorithm 3
+          // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
+          double() {
+            const { a, b } = CURVE;
+            const b3 = Fp.mul(b, _3n);
+            const { X: X1, Y: Y1, Z: Z1 } = this;
+            let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
+            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);
+          }
+          // Renes-Costello-Batina exception-free addition formula.
+          // There is 30% faster Jacobian formula, but it is not complete.
+          // https://eprint.iacr.org/2015/1060, algorithm 1
+          // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
+          add(other) {
+            aprjpoint(other);
+            const { X: X1, Y: Y1, Z: Z1 } = this;
+            const { X: X2, Y: Y2, Z: Z2 } = other;
+            let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
+            const a = CURVE.a;
+            const b3 = Fp.mul(CURVE.b, _3n);
+            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);
+          }
+          /**
+           * Constant time multiplication.
+           * Uses wNAF method. Windowed method may be 10% faster,
+           * but takes 2x longer to generate and consumes 2x memory.
+           * Uses precomputes when available.
+           * Uses endomorphism for Koblitz curves.
+           * @param scalar by which the point would be multiplied
+           * @returns New point
+           */
+          multiply(scalar) {
+            const { endo: endo2 } = extraOpts;
+            if (!Fn.isValidNot0(scalar))
+              throw new Error("invalid scalar: out of range");
+            let point, fake;
+            const mul = (n) => wnaf.cached(this, n, (p) => (0, curve_ts_1.normalizeZ)(Point, p));
+            if (endo2) {
+              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(endo2.beta, k1p, k2p, k1neg, k2neg);
+            } else {
+              const { p, f } = mul(scalar);
+              point = p;
+              fake = f;
+            }
+            return (0, curve_ts_1.normalizeZ)(Point, [point, fake])[0];
+          }
+          /**
+           * Non-constant-time multiplication. Uses double-and-add algorithm.
+           * It's faster, but should only be used when you don't care about
+           * an exposed secret key e.g. sig verification, which works over *public* keys.
+           */
+          multiplyUnsafe(sc) {
+            const { endo: endo2 } = extraOpts;
+            const p = this;
+            if (!Fn.isValid(sc))
+              throw new Error("invalid scalar: out of range");
+            if (sc === _0n || p.is0())
+              return Point.ZERO;
+            if (sc === _1n)
+              return p;
+            if (wnaf.hasCache(this))
+              return this.multiply(sc);
+            if (endo2) {
+              const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(sc);
+              const { p1, p2 } = (0, curve_ts_1.mulEndoUnsafe)(Point, p, k1, k2);
+              return finishEndo(endo2.beta, p1, p2, k1neg, k2neg);
+            } else {
+              return wnaf.unsafe(p, sc);
+            }
+          }
+          multiplyAndAddUnsafe(Q, a, b) {
+            const sum = this.multiplyUnsafe(a).add(Q.multiplyUnsafe(b));
+            return sum.is0() ? void 0 : sum;
+          }
+          /**
+           * Converts Projective point to affine (x, y) coordinates.
+           * @param invertedZ Z^-1 (inverted zero) - optional, precomputation is useful for invertBatch
+           */
+          toAffine(invertedZ) {
+            return toAffineMemo(this, invertedZ);
+          }
+          /**
+           * Checks whether Point is free of torsion elements (is in prime subgroup).
+           * Always torsion-free for cofactor=1 curves.
+           */
+          isTorsionFree() {
+            const { isTorsionFree } = extraOpts;
+            if (cofactor === _1n)
+              return true;
+            if (isTorsionFree)
+              return isTorsionFree(Point, this);
+            return wnaf.unsafe(this, CURVE_ORDER).is0();
+          }
+          clearCofactor() {
+            const { clearCofactor } = extraOpts;
+            if (cofactor === _1n)
+              return this;
+            if (clearCofactor)
+              return clearCofactor(Point, this);
+            return this.multiplyUnsafe(cofactor);
+          }
+          isSmallOrder() {
+            return this.multiplyUnsafe(cofactor).is0();
+          }
+          toBytes(isCompressed = true) {
+            (0, utils_ts_1._abool2)(isCompressed, "isCompressed");
+            this.assertValidity();
+            return encodePoint(Point, this, isCompressed);
+          }
+          toHex(isCompressed = true) {
+            return (0, utils_ts_1.bytesToHex)(this.toBytes(isCompressed));
+          }
+          toString() {
+            return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+          }
+          // TODO: remove
+          get px() {
+            return this.X;
+          }
+          get py() {
+            return this.X;
+          }
+          get pz() {
+            return this.Z;
+          }
+          toRawBytes(isCompressed = true) {
+            return this.toBytes(isCompressed);
+          }
+          _setWindowSize(windowSize) {
+            this.precompute(windowSize);
+          }
+          static normalizeZ(points) {
+            return (0, curve_ts_1.normalizeZ)(Point, points);
+          }
+          static msm(points, scalars) {
+            return (0, curve_ts_1.pippenger)(Point, Fn, points, scalars);
+          }
+          static fromPrivateKey(privateKey) {
+            return Point.BASE.multiply(_normFnElement(Fn, privateKey));
+          }
+        }
+        Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);
+        Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
+        Point.Fp = Fp;
+        Point.Fn = Fn;
+        const bits = Fn.BITS;
+        const wnaf = new curve_ts_1.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 SWUFpSqrtRatio(Fp, Z) {
+        const q = Fp.ORDER;
+        let l = _0n;
+        for (let o = q - _1n; o % _2n === _0n; o /= _2n)
+          l += _1n;
+        const c1 = l;
+        const _2n_pow_c1_1 = _2n << c1 - _1n - _1n;
+        const _2n_pow_c1 = _2n_pow_c1_1 * _2n;
+        const c2 = (q - _1n) / _2n_pow_c1;
+        const c3 = (c2 - _1n) / _2n;
+        const c4 = _2n_pow_c1 - _1n;
+        const c5 = _2n_pow_c1_1;
+        const c6 = Fp.pow(Z, c2);
+        const c7 = Fp.pow(Z, (c2 + _1n) / _2n);
+        let sqrtRatio = (u, v) => {
+          let tv1 = c6;
+          let tv2 = Fp.pow(v, c4);
+          let tv3 = Fp.sqr(tv2);
+          tv3 = Fp.mul(tv3, v);
+          let tv5 = Fp.mul(u, tv3);
+          tv5 = Fp.pow(tv5, c3);
+          tv5 = Fp.mul(tv5, tv2);
+          tv2 = Fp.mul(tv5, v);
+          tv3 = Fp.mul(tv5, u);
+          let tv4 = Fp.mul(tv3, tv2);
+          tv5 = Fp.pow(tv4, c5);
+          let isQR = Fp.eql(tv5, Fp.ONE);
+          tv2 = Fp.mul(tv3, c7);
+          tv5 = Fp.mul(tv4, tv1);
+          tv3 = Fp.cmov(tv2, tv3, isQR);
+          tv4 = Fp.cmov(tv5, tv4, isQR);
+          for (let i = c1; i > _1n; i--) {
+            let tv52 = i - _2n;
+            tv52 = _2n << tv52 - _1n;
+            let tvv5 = Fp.pow(tv4, tv52);
+            const e1 = Fp.eql(tvv5, Fp.ONE);
+            tv2 = Fp.mul(tv3, tv1);
+            tv1 = Fp.mul(tv1, tv1);
+            tvv5 = Fp.mul(tv4, tv1);
+            tv3 = Fp.cmov(tv2, tv3, e1);
+            tv4 = Fp.cmov(tvv5, tv4, e1);
+          }
+          return { isValid: isQR, value: tv3 };
+        };
+        if (Fp.ORDER % _4n === _3n) {
+          const c12 = (Fp.ORDER - _3n) / _4n;
+          const c22 = Fp.sqrt(Fp.neg(Z));
+          sqrtRatio = (u, v) => {
+            let tv1 = Fp.sqr(v);
+            const tv2 = Fp.mul(u, v);
+            tv1 = Fp.mul(tv1, tv2);
+            let y1 = Fp.pow(tv1, c12);
+            y1 = Fp.mul(y1, tv2);
+            const y2 = Fp.mul(y1, c22);
+            const tv3 = Fp.mul(Fp.sqr(y1), v);
+            const isQR = Fp.eql(tv3, u);
+            let y = Fp.cmov(y2, y1, isQR);
+            return { isValid: isQR, value: y };
+          };
+        }
+        return sqrtRatio;
+      }
+      function mapToCurveSimpleSWU(Fp, opts) {
+        (0, modular_ts_1.validateField)(Fp);
+        const { A, B, Z } = opts;
+        if (!Fp.isValid(A) || !Fp.isValid(B) || !Fp.isValid(Z))
+          throw new Error("mapToCurveSimpleSWU: invalid opts");
+        const sqrtRatio = SWUFpSqrtRatio(Fp, Z);
+        if (!Fp.isOdd)
+          throw new Error("Field does not have .isOdd()");
+        return (u) => {
+          let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
+          tv1 = Fp.sqr(u);
+          tv1 = Fp.mul(tv1, Z);
+          tv2 = Fp.sqr(tv1);
+          tv2 = Fp.add(tv2, tv1);
+          tv3 = Fp.add(tv2, Fp.ONE);
+          tv3 = Fp.mul(tv3, B);
+          tv4 = Fp.cmov(Z, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO));
+          tv4 = Fp.mul(tv4, A);
+          tv2 = Fp.sqr(tv3);
+          tv6 = Fp.sqr(tv4);
+          tv5 = Fp.mul(tv6, A);
+          tv2 = Fp.add(tv2, tv5);
+          tv2 = Fp.mul(tv2, tv3);
+          tv6 = Fp.mul(tv6, tv4);
+          tv5 = Fp.mul(tv6, B);
+          tv2 = Fp.add(tv2, tv5);
+          x = Fp.mul(tv1, tv3);
+          const { isValid, value } = sqrtRatio(tv2, tv6);
+          y = Fp.mul(tv1, u);
+          y = Fp.mul(y, value);
+          x = Fp.cmov(x, tv3, isValid);
+          y = Fp.cmov(y, value, isValid);
+          const e1 = Fp.isOdd(u) === Fp.isOdd(y);
+          y = Fp.cmov(Fp.neg(y), y, e1);
+          const tv4_inv = (0, modular_ts_1.FpInvertBatch)(Fp, [tv4], true)[0];
+          x = Fp.mul(x, tv4_inv);
+          return { x, y };
+        };
+      }
+      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 || utils_ts_1.randomBytes;
+        const lengths = Object.assign(getWLengths(Point.Fp, Fn), { seed: (0, modular_ts_1.getMinHashLength)(Fn.ORDER) });
+        function isValidSecretKey(secretKey) {
+          try {
+            return !!_normFnElement(Fn, secretKey);
+          } 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 (0, modular_ts_1.mapHashToField)((0, utils_ts_1._abytes2)(seed, lengths.seed, "seed"), Fn.ORDER);
+        }
+        function getPublicKey(secretKey, isCompressed = true) {
+          return Point.BASE.multiply(_normFnElement(Fn, secretKey)).toBytes(isCompressed);
+        }
+        function keygen(seed) {
+          const secretKey = randomSecretKey(seed);
+          return { secretKey, publicKey: getPublicKey(secretKey) };
+        }
+        function isProbPub(item) {
+          if (typeof item === "bigint")
+            return false;
+          if (item instanceof Point)
+            return true;
+          const { secretKey, publicKey, publicKeyUncompressed } = lengths;
+          if (Fn.allowedLengths || secretKey === publicKey)
+            return void 0;
+          const l = (0, utils_ts_1.ensureBytes)("key", item).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 = _normFnElement(Fn, secretKeyA);
+          const b = Point.fromHex(publicKeyB);
+          return b.multiply(s).toBytes(isCompressed);
+        }
+        const utils = {
+          isValidSecretKey,
+          isValidPublicKey,
+          randomSecretKey,
+          // TODO: remove
+          isValidPrivateKey: isValidSecretKey,
+          randomPrivateKey: randomSecretKey,
+          normPrivateKeyToScalar: (key) => _normFnElement(Fn, key),
+          precompute(windowSize = 8, point = Point.BASE) {
+            return point.precompute(windowSize, false);
+          }
+        };
+        return Object.freeze({ getPublicKey, getSharedSecret, keygen, Point, utils, lengths });
+      }
+      function ecdsa(Point, hash, ecdsaOpts = {}) {
+        (0, utils_1.ahash)(hash);
+        (0, utils_ts_1._validateObject)(ecdsaOpts, {}, {
+          hmac: "function",
+          lowS: "boolean",
+          randomBytes: "function",
+          bits2int: "function",
+          bits2int_modN: "function"
+        });
+        const randomBytes2 = ecdsaOpts.randomBytes || utils_ts_1.randomBytes;
+        const hmac = ecdsaOpts.hmac || ((key, ...msgs) => (0, hmac_js_1.hmac)(hash, key, (0, utils_ts_1.concatBytes)(...msgs)));
+        const { Fp, Fn } = Point;
+        const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;
+        const { keygen, getPublicKey, getSharedSecret, utils, lengths } = ecdh(Point, ecdsaOpts);
+        const defaultSigOpts = {
+          prehash: false,
+          lowS: typeof ecdsaOpts.lowS === "boolean" ? ecdsaOpts.lowS : false,
+          format: void 0,
+          //'compact' as ECDSASigFormat,
+          extraEntropy: false
+        };
+        const defaultSigOpts_format = "compact";
+        function isBiggerThanHalfOrder(number) {
+          const HALF = CURVE_ORDER >> _1n;
+          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 validateSigLength(bytes, format) {
+          validateSigFormat(format);
+          const size = lengths.signature;
+          const sizer = format === "compact" ? size : format === "recovered" ? size + 1 : void 0;
+          return (0, utils_ts_1._abytes2)(bytes, sizer, `${format} signature`);
+        }
+        class Signature {
+          constructor(r, s, recovery) {
+            this.r = validateRS("r", r);
+            this.s = validateRS("s", s);
+            if (recovery != null)
+              this.recovery = recovery;
+            Object.freeze(this);
+          }
+          static fromBytes(bytes, format = defaultSigOpts_format) {
+            validateSigLength(bytes, format);
+            let recid;
+            if (format === "der") {
+              const { r: r2, s: s2 } = exports.DER.toSig((0, utils_ts_1._abytes2)(bytes));
+              return new Signature(r2, s2);
+            }
+            if (format === "recovered") {
+              recid = bytes[0];
+              format = "compact";
+              bytes = bytes.subarray(1);
+            }
+            const L = Fn.BYTES;
+            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((0, utils_ts_1.hexToBytes)(hex), format);
+          }
+          addRecoveryBit(recovery) {
+            return new Signature(this.r, this.s, recovery);
+          }
+          recoverPublicKey(messageHash) {
+            const FIELD_ORDER = Fp.ORDER;
+            const { r, s, recovery: rec } = this;
+            if (rec == null || ![0, 1, 2, 3].includes(rec))
+              throw new Error("recovery id invalid");
+            const hasCofactor = CURVE_ORDER * _2n < FIELD_ORDER;
+            if (hasCofactor && rec > 1)
+              throw new Error("recovery id is ambiguous for h>1 curve");
+            const radj = rec === 2 || rec === 3 ? r + CURVE_ORDER : r;
+            if (!Fp.isValid(radj))
+              throw new Error("recovery id 2 or 3 invalid");
+            const x = Fp.toBytes(radj);
+            const R = Point.fromBytes((0, utils_ts_1.concatBytes)(pprefix((rec & 1) === 0), x));
+            const ir = Fn.inv(radj);
+            const h = bits2int_modN((0, utils_ts_1.ensureBytes)("msgHash", messageHash));
+            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("point at infinify");
+            Q.assertValidity();
+            return Q;
+          }
+          // Signatures should be low-s, to prevent malleability.
+          hasHighS() {
+            return isBiggerThanHalfOrder(this.s);
+          }
+          toBytes(format = defaultSigOpts_format) {
+            validateSigFormat(format);
+            if (format === "der")
+              return (0, utils_ts_1.hexToBytes)(exports.DER.hexFromSig(this));
+            const r = Fn.toBytes(this.r);
+            const s = Fn.toBytes(this.s);
+            if (format === "recovered") {
+              if (this.recovery == null)
+                throw new Error("recovery bit must be present");
+              return (0, utils_ts_1.concatBytes)(Uint8Array.of(this.recovery), r, s);
+            }
+            return (0, utils_ts_1.concatBytes)(r, s);
+          }
+          toHex(format) {
+            return (0, utils_ts_1.bytesToHex)(this.toBytes(format));
+          }
+          // TODO: remove
+          assertValidity() {
+          }
+          static fromCompact(hex) {
+            return Signature.fromBytes((0, utils_ts_1.ensureBytes)("sig", hex), "compact");
+          }
+          static fromDER(hex) {
+            return Signature.fromBytes((0, utils_ts_1.ensureBytes)("sig", hex), "der");
+          }
+          normalizeS() {
+            return this.hasHighS() ? new Signature(this.r, Fn.neg(this.s), this.recovery) : this;
+          }
+          toDERRawBytes() {
+            return this.toBytes("der");
+          }
+          toDERHex() {
+            return (0, utils_ts_1.bytesToHex)(this.toBytes("der"));
+          }
+          toCompactRawBytes() {
+            return this.toBytes("compact");
+          }
+          toCompactHex() {
+            return (0, utils_ts_1.bytesToHex)(this.toBytes("compact"));
+          }
+        }
+        const bits2int = ecdsaOpts.bits2int || function bits2int_def(bytes) {
+          if (bytes.length > 8192)
+            throw new Error("input is too large");
+          const num = (0, utils_ts_1.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 = (0, utils_ts_1.bitMask)(fnBits);
+        function int2octets(num) {
+          (0, utils_ts_1.aInRange)("num < 2^" + fnBits, num, _0n, ORDER_MASK);
+          return Fn.toBytes(num);
+        }
+        function validateMsgAndHash(message, prehash) {
+          (0, utils_ts_1._abytes2)(message, void 0, "message");
+          return prehash ? (0, utils_ts_1._abytes2)(hash(message), void 0, "prehashed message") : message;
+        }
+        function prepSig(message, privateKey, opts) {
+          if (["recovered", "canonical"].some((k) => k in opts))
+            throw new Error("sign() legacy options not supported");
+          const { lowS, prehash, extraEntropy } = validateSigOpts(opts, defaultSigOpts);
+          message = validateMsgAndHash(message, prehash);
+          const h1int = bits2int_modN(message);
+          const d = _normFnElement(Fn, privateKey);
+          const seedArgs = [int2octets(d), int2octets(h1int)];
+          if (extraEntropy != null && extraEntropy !== false) {
+            const e = extraEntropy === true ? randomBytes2(lengths.secretKey) : extraEntropy;
+            seedArgs.push((0, utils_ts_1.ensureBytes)("extraEntropy", e));
+          }
+          const seed = (0, utils_ts_1.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 === _0n)
+              return;
+            const s = Fn.create(ik * Fn.create(m + r * d));
+            if (s === _0n)
+              return;
+            let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n);
+            let normS = s;
+            if (lowS && isBiggerThanHalfOrder(s)) {
+              normS = Fn.neg(s);
+              recovery ^= 1;
+            }
+            return new Signature(r, normS, recovery);
+          }
+          return { seed, k2sig };
+        }
+        function sign2(message, secretKey, opts = {}) {
+          message = (0, utils_ts_1.ensureBytes)("message", message);
+          const { seed, k2sig } = prepSig(message, secretKey, opts);
+          const drbg = (0, utils_ts_1.createHmacDrbg)(hash.outputLen, Fn.BYTES, hmac);
+          const sig = drbg(seed, k2sig);
+          return sig;
+        }
+        function tryParsingSig(sg) {
+          let sig = void 0;
+          const isHex = typeof sg === "string" || (0, utils_ts_1.isBytes)(sg);
+          const isObj = !isHex && sg !== null && typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint";
+          if (!isHex && !isObj)
+            throw new Error("invalid signature, expected Uint8Array, hex string or Signature instance");
+          if (isObj) {
+            sig = new Signature(sg.r, sg.s);
+          } else if (isHex) {
+            try {
+              sig = Signature.fromBytes((0, utils_ts_1.ensureBytes)("sig", sg), "der");
+            } catch (derError) {
+              if (!(derError instanceof exports.DER.Err))
+                throw derError;
+            }
+            if (!sig) {
+              try {
+                sig = Signature.fromBytes((0, utils_ts_1.ensureBytes)("sig", sg), "compact");
+              } catch (error) {
+                return false;
+              }
+            }
+          }
+          if (!sig)
+            return false;
+          return sig;
+        }
+        function verify(signature, message, publicKey, opts = {}) {
+          const { lowS, prehash, format } = validateSigOpts(opts, defaultSigOpts);
+          publicKey = (0, utils_ts_1.ensureBytes)("publicKey", publicKey);
+          message = validateMsgAndHash((0, utils_ts_1.ensureBytes)("message", message), prehash);
+          if ("strict" in opts)
+            throw new Error("options.strict was renamed to lowS");
+          const sig = format === void 0 ? tryParsingSig(signature) : Signature.fromBytes((0, utils_ts_1.ensureBytes)("sig", signature), format);
+          if (sig === false)
+            return false;
+          try {
+            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: sign2,
+          verify,
+          recoverPublicKey,
+          Signature,
+          hash
+        });
+      }
+      function weierstrassPoints(c) {
+        const { CURVE, curveOpts } = _weierstrass_legacy_opts_to_new(c);
+        const Point = weierstrassN(CURVE, curveOpts);
+        return _weierstrass_new_output_to_legacy(c, Point);
+      }
+      function _weierstrass_legacy_opts_to_new(c) {
+        const CURVE = {
+          a: c.a,
+          b: c.b,
+          p: c.Fp.ORDER,
+          n: c.n,
+          h: c.h,
+          Gx: c.Gx,
+          Gy: c.Gy
+        };
+        const Fp = c.Fp;
+        let allowedLengths = c.allowedPrivateKeyLengths ? Array.from(new Set(c.allowedPrivateKeyLengths.map((l) => Math.ceil(l / 2)))) : void 0;
+        const Fn = (0, modular_ts_1.Field)(CURVE.n, {
+          BITS: c.nBitLength,
+          allowedLengths,
+          modFromBytes: c.wrapPrivateKey
+        });
+        const curveOpts = {
+          Fp,
+          Fn,
+          allowInfinityPoint: c.allowInfinityPoint,
+          endo: c.endo,
+          isTorsionFree: c.isTorsionFree,
+          clearCofactor: c.clearCofactor,
+          fromBytes: c.fromBytes,
+          toBytes: c.toBytes
+        };
+        return { CURVE, curveOpts };
+      }
+      function _ecdsa_legacy_opts_to_new(c) {
+        const { CURVE, curveOpts } = _weierstrass_legacy_opts_to_new(c);
+        const ecdsaOpts = {
+          hmac: c.hmac,
+          randomBytes: c.randomBytes,
+          lowS: c.lowS,
+          bits2int: c.bits2int,
+          bits2int_modN: c.bits2int_modN
+        };
+        return { CURVE, curveOpts, hash: c.hash, ecdsaOpts };
+      }
+      function _legacyHelperEquat(Fp, a, b) {
+        function weierstrassEquation(x) {
+          const x2 = Fp.sqr(x);
+          const x3 = Fp.mul(x2, x);
+          return Fp.add(Fp.add(x3, Fp.mul(x, a)), b);
+        }
+        return weierstrassEquation;
+      }
+      function _weierstrass_new_output_to_legacy(c, Point) {
+        const { Fp, Fn } = Point;
+        function isWithinCurveOrder(num) {
+          return (0, utils_ts_1.inRange)(num, _1n, Fn.ORDER);
+        }
+        const weierstrassEquation = _legacyHelperEquat(Fp, c.a, c.b);
+        return Object.assign({}, {
+          CURVE: c,
+          Point,
+          ProjectivePoint: Point,
+          normPrivateKeyToScalar: (key) => _normFnElement(Fn, key),
+          weierstrassEquation,
+          isWithinCurveOrder
+        });
+      }
+      function _ecdsa_new_output_to_legacy(c, _ecdsa) {
+        const Point = _ecdsa.Point;
+        return Object.assign({}, _ecdsa, {
+          ProjectivePoint: Point,
+          CURVE: Object.assign({}, c, (0, modular_ts_1.nLength)(Point.Fn.ORDER, Point.Fn.BITS))
+        });
+      }
+      function weierstrass(c) {
+        const { CURVE, curveOpts, hash, ecdsaOpts } = _ecdsa_legacy_opts_to_new(c);
+        const Point = weierstrassN(CURVE, curveOpts);
+        const signs = ecdsa(Point, hash, ecdsaOpts);
+        return _ecdsa_new_output_to_legacy(c, signs);
+      }
+    }
+  });
+
+  // node_modules/@noble/curves/_shortw_utils.js
+  var require_shortw_utils = __commonJS({
+    "node_modules/@noble/curves/_shortw_utils.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.getHash = getHash;
+      exports.createCurve = createCurve;
+      var weierstrass_ts_1 = require_weierstrass();
+      function getHash(hash) {
+        return { hash };
+      }
+      function createCurve(curveDef, defHash) {
+        const create = (hash) => (0, weierstrass_ts_1.weierstrass)({ ...curveDef, hash });
+        return { ...create(defHash), create };
+      }
+    }
+  });
+
+  // node_modules/@noble/curves/abstract/hash-to-curve.js
+  var require_hash_to_curve = __commonJS({
+    "node_modules/@noble/curves/abstract/hash-to-curve.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports._DST_scalar = void 0;
+      exports.expand_message_xmd = expand_message_xmd;
+      exports.expand_message_xof = expand_message_xof;
+      exports.hash_to_field = hash_to_field;
+      exports.isogenyMap = isogenyMap;
+      exports.createHasher = createHasher;
+      var utils_ts_1 = require_utils2();
+      var modular_ts_1 = require_modular();
+      var os2ip = utils_ts_1.bytesToNumberBE;
+      function i2osp(value, length) {
+        anum(value);
+        anum(length);
+        if (value < 0 || value >= 1 << 8 * length)
+          throw new Error("invalid I2OSP input: " + value);
+        const res = Array.from({ length }).fill(0);
+        for (let i = length - 1; i >= 0; i--) {
+          res[i] = value & 255;
+          value >>>= 8;
+        }
+        return new Uint8Array(res);
+      }
+      function strxor(a, b) {
+        const arr = new Uint8Array(a.length);
+        for (let i = 0; i < a.length; i++) {
+          arr[i] = a[i] ^ b[i];
+        }
+        return arr;
+      }
+      function anum(item) {
+        if (!Number.isSafeInteger(item))
+          throw new Error("number expected");
+      }
+      function normDST(DST) {
+        if (!(0, utils_ts_1.isBytes)(DST) && typeof DST !== "string")
+          throw new Error("DST must be Uint8Array or string");
+        return typeof DST === "string" ? (0, utils_ts_1.utf8ToBytes)(DST) : DST;
+      }
+      function expand_message_xmd(msg, DST, lenInBytes, H) {
+        (0, utils_ts_1.abytes)(msg);
+        anum(lenInBytes);
+        DST = normDST(DST);
+        if (DST.length > 255)
+          DST = H((0, utils_ts_1.concatBytes)((0, utils_ts_1.utf8ToBytes)("H2C-OVERSIZE-DST-"), DST));
+        const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;
+        const ell = Math.ceil(lenInBytes / b_in_bytes);
+        if (lenInBytes > 65535 || ell > 255)
+          throw new Error("expand_message_xmd: invalid lenInBytes");
+        const DST_prime = (0, utils_ts_1.concatBytes)(DST, i2osp(DST.length, 1));
+        const Z_pad = i2osp(0, r_in_bytes);
+        const l_i_b_str = i2osp(lenInBytes, 2);
+        const b = new Array(ell);
+        const b_0 = H((0, utils_ts_1.concatBytes)(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
+        b[0] = H((0, utils_ts_1.concatBytes)(b_0, i2osp(1, 1), DST_prime));
+        for (let i = 1; i <= ell; i++) {
+          const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];
+          b[i] = H((0, utils_ts_1.concatBytes)(...args));
+        }
+        const pseudo_random_bytes = (0, utils_ts_1.concatBytes)(...b);
+        return pseudo_random_bytes.slice(0, lenInBytes);
+      }
+      function expand_message_xof(msg, DST, lenInBytes, k, H) {
+        (0, utils_ts_1.abytes)(msg);
+        anum(lenInBytes);
+        DST = normDST(DST);
+        if (DST.length > 255) {
+          const dkLen = Math.ceil(2 * k / 8);
+          DST = H.create({ dkLen }).update((0, utils_ts_1.utf8ToBytes)("H2C-OVERSIZE-DST-")).update(DST).digest();
+        }
+        if (lenInBytes > 65535 || DST.length > 255)
+          throw new Error("expand_message_xof: invalid lenInBytes");
+        return H.create({ dkLen: lenInBytes }).update(msg).update(i2osp(lenInBytes, 2)).update(DST).update(i2osp(DST.length, 1)).digest();
+      }
+      function hash_to_field(msg, count, options) {
+        (0, utils_ts_1._validateObject)(options, {
+          p: "bigint",
+          m: "number",
+          k: "number",
+          hash: "function"
+        });
+        const { p, k, m, hash, expand, DST } = options;
+        if (!(0, utils_ts_1.isHash)(options.hash))
+          throw new Error("expected valid hash");
+        (0, utils_ts_1.abytes)(msg);
+        anum(count);
+        const log2p = p.toString(2).length;
+        const L = Math.ceil((log2p + k) / 8);
+        const len_in_bytes = count * m * L;
+        let prb;
+        if (expand === "xmd") {
+          prb = expand_message_xmd(msg, DST, len_in_bytes, hash);
+        } else if (expand === "xof") {
+          prb = expand_message_xof(msg, DST, len_in_bytes, k, hash);
+        } else if (expand === "_internal_pass") {
+          prb = msg;
+        } else {
+          throw new Error('expand must be "xmd" or "xof"');
+        }
+        const u = new Array(count);
+        for (let i = 0; i < count; i++) {
+          const e = new Array(m);
+          for (let j = 0; j < m; j++) {
+            const elm_offset = L * (j + i * m);
+            const tv = prb.subarray(elm_offset, elm_offset + L);
+            e[j] = (0, modular_ts_1.mod)(os2ip(tv), p);
+          }
+          u[i] = e;
+        }
+        return u;
+      }
+      function isogenyMap(field, map) {
+        const coeff = map.map((i) => Array.from(i).reverse());
+        return (x, y) => {
+          const [xn, xd, yn, yd] = coeff.map((val) => val.reduce((acc, i) => field.add(field.mul(acc, x), i)));
+          const [xd_inv, yd_inv] = (0, modular_ts_1.FpInvertBatch)(field, [xd, yd], true);
+          x = field.mul(xn, xd_inv);
+          y = field.mul(y, field.mul(yn, yd_inv));
+          return { x, y };
+        };
+      }
+      exports._DST_scalar = (0, utils_ts_1.utf8ToBytes)("HashToScalar-");
+      function createHasher(Point, mapToCurve, defaults) {
+        if (typeof mapToCurve !== "function")
+          throw new Error("mapToCurve() must be defined");
+        function map(num) {
+          return Point.fromAffine(mapToCurve(num));
+        }
+        function clear(initial) {
+          const P = initial.clearCofactor();
+          if (P.equals(Point.ZERO))
+            return Point.ZERO;
+          P.assertValidity();
+          return P;
+        }
+        return {
+          defaults,
+          hashToCurve(msg, options) {
+            const opts = Object.assign({}, defaults, options);
+            const u = hash_to_field(msg, 2, opts);
+            const u0 = map(u[0]);
+            const u1 = map(u[1]);
+            return clear(u0.add(u1));
+          },
+          encodeToCurve(msg, options) {
+            const optsDst = defaults.encodeDST ? { DST: defaults.encodeDST } : {};
+            const opts = Object.assign({}, defaults, optsDst, options);
+            const u = hash_to_field(msg, 1, opts);
+            const u0 = map(u[0]);
+            return clear(u0);
+          },
+          /** See {@link H2CHasher} */
+          mapToCurve(scalars) {
+            if (!Array.isArray(scalars))
+              throw new Error("expected array of bigints");
+            for (const i of scalars)
+              if (typeof i !== "bigint")
+                throw new Error("expected array of bigints");
+            return clear(map(scalars));
+          },
+          // hash_to_scalar can produce 0: https://www.rfc-editor.org/errata/eid8393
+          // RFC 9380, draft-irtf-cfrg-bbs-signatures-08
+          hashToScalar(msg, options) {
+            const N = Point.Fn.ORDER;
+            const opts = Object.assign({}, defaults, { p: N, m: 1, DST: exports._DST_scalar }, options);
+            return hash_to_field(msg, 1, opts)[0][0];
+          }
+        };
+      }
+    }
+  });
+
+  // node_modules/@noble/curves/secp256k1.js
+  var require_secp256k1 = __commonJS({
+    "node_modules/@noble/curves/secp256k1.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.encodeToCurve = exports.hashToCurve = exports.secp256k1_hasher = exports.schnorr = exports.secp256k1 = void 0;
+      var sha2_js_1 = require_sha2();
+      var utils_js_1 = require_utils();
+      var _shortw_utils_ts_1 = require_shortw_utils();
+      var hash_to_curve_ts_1 = require_hash_to_curve();
+      var modular_ts_1 = require_modular();
+      var weierstrass_ts_1 = require_weierstrass();
+      var utils_ts_1 = require_utils2();
+      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 _0n = /* @__PURE__ */ BigInt(0);
+      var _1n = /* @__PURE__ */ BigInt(1);
+      var _2n = /* @__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 = (0, modular_ts_1.pow2)(b3, _3n, P) * b3 % P;
+        const b9 = (0, modular_ts_1.pow2)(b6, _3n, P) * b3 % P;
+        const b11 = (0, modular_ts_1.pow2)(b9, _2n, P) * b2 % P;
+        const b22 = (0, modular_ts_1.pow2)(b11, _11n, P) * b11 % P;
+        const b44 = (0, modular_ts_1.pow2)(b22, _22n, P) * b22 % P;
+        const b88 = (0, modular_ts_1.pow2)(b44, _44n, P) * b44 % P;
+        const b176 = (0, modular_ts_1.pow2)(b88, _88n, P) * b88 % P;
+        const b220 = (0, modular_ts_1.pow2)(b176, _44n, P) * b44 % P;
+        const b223 = (0, modular_ts_1.pow2)(b220, _3n, P) * b3 % P;
+        const t1 = (0, modular_ts_1.pow2)(b223, _23n, P) * b22 % P;
+        const t2 = (0, modular_ts_1.pow2)(t1, _6n, P) * b2 % P;
+        const root = (0, modular_ts_1.pow2)(t2, _2n, P);
+        if (!Fpk1.eql(Fpk1.sqr(root), y))
+          throw new Error("Cannot find square root");
+        return root;
+      }
+      var Fpk1 = (0, modular_ts_1.Field)(secp256k1_CURVE.p, { sqrt: sqrtMod });
+      exports.secp256k1 = (0, _shortw_utils_ts_1.createCurve)({ ...secp256k1_CURVE, Fp: Fpk1, lowS: true, endo: secp256k1_ENDO }, sha2_js_1.sha256);
+      var TAGGED_HASH_PREFIXES = {};
+      function taggedHash(tag, ...messages) {
+        let tagP = TAGGED_HASH_PREFIXES[tag];
+        if (tagP === void 0) {
+          const tagH = (0, sha2_js_1.sha256)((0, utils_ts_1.utf8ToBytes)(tag));
+          tagP = (0, utils_ts_1.concatBytes)(tagH, tagH);
+          TAGGED_HASH_PREFIXES[tag] = tagP;
+        }
+        return (0, sha2_js_1.sha256)((0, utils_ts_1.concatBytes)(tagP, ...messages));
+      }
+      var pointToBytes = (point) => point.toBytes(true).slice(1);
+      var Pointk1 = /* @__PURE__ */ (() => exports.secp256k1.Point)();
+      var hasEven = (y) => y % _2n === _0n;
+      function schnorrGetExtPubKey(priv) {
+        const { Fn, BASE } = Pointk1;
+        const d_ = (0, weierstrass_ts_1._normFnElement)(Fn, priv);
+        const p = BASE.multiply(d_);
+        const scalar = hasEven(p.y) ? d_ : Fn.neg(d_);
+        return { scalar, bytes: pointToBytes(p) };
+      }
+      function lift_x(x) {
+        const Fp = Fpk1;
+        if (!Fp.isValidNot0(x))
+          throw new Error("invalid x: Fail if x \u2265 p");
+        const xx = Fp.create(x * x);
+        const c = Fp.create(xx * x + BigInt(7));
+        let y = Fp.sqrt(c);
+        if (!hasEven(y))
+          y = Fp.neg(y);
+        const p = Pointk1.fromAffine({ x, y });
+        p.assertValidity();
+        return p;
+      }
+      var num = utils_ts_1.bytesToNumberBE;
+      function challenge(...args) {
+        return Pointk1.Fn.create(num(taggedHash("BIP0340/challenge", ...args)));
+      }
+      function schnorrGetPublicKey(secretKey) {
+        return schnorrGetExtPubKey(secretKey).bytes;
+      }
+      function schnorrSign(message, secretKey, auxRand = (0, utils_js_1.randomBytes)(32)) {
+        const { Fn } = Pointk1;
+        const m = (0, utils_ts_1.ensureBytes)("message", message);
+        const { bytes: px, scalar: d } = schnorrGetExtPubKey(secretKey);
+        const a = (0, utils_ts_1.ensureBytes)("auxRand", auxRand, 32);
+        const t = Fn.toBytes(d ^ num(taggedHash("BIP0340/aux", a)));
+        const rand = taggedHash("BIP0340/nonce", t, px, m);
+        const { bytes: rx, scalar: k } = schnorrGetExtPubKey(rand);
+        const e = challenge(rx, px, m);
+        const sig = new Uint8Array(64);
+        sig.set(rx, 0);
+        sig.set(Fn.toBytes(Fn.create(k + e * d)), 32);
+        if (!schnorrVerify(sig, m, px))
+          throw new Error("sign: Invalid signature produced");
+        return sig;
+      }
+      function schnorrVerify(signature, message, publicKey) {
+        const { Fn, BASE } = Pointk1;
+        const sig = (0, utils_ts_1.ensureBytes)("signature", signature, 64);
+        const m = (0, utils_ts_1.ensureBytes)("message", message);
+        const pub = (0, utils_ts_1.ensureBytes)("publicKey", publicKey, 32);
+        try {
+          const P = lift_x(num(pub));
+          const r = num(sig.subarray(0, 32));
+          if (!(0, utils_ts_1.inRange)(r, _1n, secp256k1_CURVE.p))
+            return false;
+          const s = num(sig.subarray(32, 64));
+          if (!(0, utils_ts_1.inRange)(s, _1n, secp256k1_CURVE.n))
+            return false;
+          const e = challenge(Fn.toBytes(r), pointToBytes(P), m);
+          const R = BASE.multiplyUnsafe(s).add(P.multiplyUnsafe(Fn.neg(e)));
+          const { x, y } = R.toAffine();
+          if (R.is0() || !hasEven(y) || x !== r)
+            return false;
+          return true;
+        } catch (error) {
+          return false;
+        }
+      }
+      exports.schnorr = (() => {
+        const size = 32;
+        const seedLength = 48;
+        const randomSecretKey = (seed = (0, utils_js_1.randomBytes)(seedLength)) => {
+          return (0, modular_ts_1.mapHashToField)(seed, secp256k1_CURVE.n);
+        };
+        exports.secp256k1.utils.randomSecretKey;
+        function keygen(seed) {
+          const secretKey = randomSecretKey(seed);
+          return { secretKey, publicKey: schnorrGetPublicKey(secretKey) };
+        }
+        return {
+          keygen,
+          getPublicKey: schnorrGetPublicKey,
+          sign: schnorrSign,
+          verify: schnorrVerify,
+          Point: Pointk1,
+          utils: {
+            randomSecretKey,
+            randomPrivateKey: randomSecretKey,
+            taggedHash,
+            // TODO: remove
+            lift_x,
+            pointToBytes,
+            numberToBytesBE: utils_ts_1.numberToBytesBE,
+            bytesToNumberBE: utils_ts_1.bytesToNumberBE,
+            mod: modular_ts_1.mod
+          },
+          lengths: {
+            secretKey: size,
+            publicKey: size,
+            publicKeyHasPrefix: false,
+            signature: size * 2,
+            seed: seedLength
+          }
+        };
+      })();
+      var isoMap = /* @__PURE__ */ (() => (0, hash_to_curve_ts_1.isogenyMap)(Fpk1, [
+        // xNum
+        [
+          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
+          "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
+          "0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262",
+          "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c"
+        ],
+        // xDen
+        [
+          "0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b",
+          "0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14",
+          "0x0000000000000000000000000000000000000000000000000000000000000001"
+          // LAST 1
+        ],
+        // yNum
+        [
+          "0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c",
+          "0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3",
+          "0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931",
+          "0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84"
+        ],
+        // yDen
+        [
+          "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b",
+          "0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573",
+          "0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f",
+          "0x0000000000000000000000000000000000000000000000000000000000000001"
+          // LAST 1
+        ]
+      ].map((i) => i.map((j) => BigInt(j)))))();
+      var mapSWU = /* @__PURE__ */ (() => (0, weierstrass_ts_1.mapToCurveSimpleSWU)(Fpk1, {
+        A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"),
+        B: BigInt("1771"),
+        Z: Fpk1.create(BigInt("-11"))
+      }))();
+      exports.secp256k1_hasher = (() => (0, hash_to_curve_ts_1.createHasher)(exports.secp256k1.Point, (scalars) => {
+        const { x, y } = mapSWU(Fpk1.create(scalars[0]));
+        return isoMap(x, y);
+      }, {
+        DST: "secp256k1_XMD:SHA-256_SSWU_RO_",
+        encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_",
+        p: Fpk1.ORDER,
+        m: 1,
+        k: 128,
+        expand: "xmd",
+        hash: sha2_js_1.sha256
+      }))();
+      exports.hashToCurve = (() => exports.secp256k1_hasher.hashToCurve)();
+      exports.encodeToCurve = (() => exports.secp256k1_hasher.encodeToCurve)();
+    }
+  });
+
+  // node_modules/@noble/curves/abstract/utils.js
+  var require_utils3 = __commonJS({
+    "node_modules/@noble/curves/abstract/utils.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.isHash = exports.validateObject = exports.memoized = exports.notImplemented = exports.createHmacDrbg = exports.bitMask = exports.bitSet = exports.bitGet = exports.bitLen = exports.aInRange = exports.inRange = exports.asciiToBytes = exports.copyBytes = exports.equalBytes = exports.ensureBytes = exports.numberToVarBytesBE = exports.numberToBytesLE = exports.numberToBytesBE = exports.bytesToNumberLE = exports.bytesToNumberBE = exports.hexToNumber = exports.numberToHexUnpadded = exports.abool = exports.utf8ToBytes = exports.randomBytes = exports.isBytes = exports.hexToBytes = exports.concatBytes = exports.bytesToUtf8 = exports.bytesToHex = exports.anumber = exports.abytes = void 0;
+      var u = require_utils2();
+      exports.abytes = u.abytes;
+      exports.anumber = u.anumber;
+      exports.bytesToHex = u.bytesToHex;
+      exports.bytesToUtf8 = u.bytesToUtf8;
+      exports.concatBytes = u.concatBytes;
+      exports.hexToBytes = u.hexToBytes;
+      exports.isBytes = u.isBytes;
+      exports.randomBytes = u.randomBytes;
+      exports.utf8ToBytes = u.utf8ToBytes;
+      exports.abool = u.abool;
+      exports.numberToHexUnpadded = u.numberToHexUnpadded;
+      exports.hexToNumber = u.hexToNumber;
+      exports.bytesToNumberBE = u.bytesToNumberBE;
+      exports.bytesToNumberLE = u.bytesToNumberLE;
+      exports.numberToBytesBE = u.numberToBytesBE;
+      exports.numberToBytesLE = u.numberToBytesLE;
+      exports.numberToVarBytesBE = u.numberToVarBytesBE;
+      exports.ensureBytes = u.ensureBytes;
+      exports.equalBytes = u.equalBytes;
+      exports.copyBytes = u.copyBytes;
+      exports.asciiToBytes = u.asciiToBytes;
+      exports.inRange = u.inRange;
+      exports.aInRange = u.aInRange;
+      exports.bitLen = u.bitLen;
+      exports.bitGet = u.bitGet;
+      exports.bitSet = u.bitSet;
+      exports.bitMask = u.bitMask;
+      exports.createHmacDrbg = u.createHmacDrbg;
+      exports.notImplemented = u.notImplemented;
+      exports.memoized = u.memoized;
+      exports.validateObject = u.validateObject;
+      exports.isHash = u.isHash;
+    }
+  });
+
+  // node_modules/@bitcoinerlab/secp256k1/dist/index.js
+  var require_dist = __commonJS({
+    "node_modules/@bitcoinerlab/secp256k1/dist/index.js"(exports) {
+      "use strict";
+      var secp256k12 = require_secp256k1();
+      var mod = require_modular();
+      var utils = require_utils3();
+      function _interopNamespaceDefault(e) {
+        var n = /* @__PURE__ */ Object.create(null);
+        if (e) {
+          Object.keys(e).forEach(function(k) {
+            if (k !== "default") {
+              var d = Object.getOwnPropertyDescriptor(e, k);
+              Object.defineProperty(n, k, d.get ? d : {
+                enumerable: true,
+                get: function() {
+                  return e[k];
+                }
+              });
+            }
+          });
+        }
+        n.default = e;
+        return Object.freeze(n);
+      }
+      var mod__namespace = /* @__PURE__ */ _interopNamespaceDefault(mod);
+      var utils__namespace = /* @__PURE__ */ _interopNamespaceDefault(utils);
+      var Point = secp256k12.secp256k1.ProjectivePoint;
+      var THROW_BAD_PRIVATE = "Expected Private";
+      var THROW_BAD_POINT = "Expected Point";
+      var THROW_BAD_TWEAK = "Expected Tweak";
+      var THROW_BAD_HASH = "Expected Hash";
+      var THROW_BAD_SIGNATURE = "Expected Signature";
+      var THROW_BAD_EXTRA_DATA = "Expected Extra Data (32 bytes)";
+      var THROW_BAD_SCALAR = "Expected Scalar";
+      var THROW_BAD_RECOVERY_ID = "Bad Recovery Id";
+      var HASH_SIZE = 32;
+      var TWEAK_SIZE = 32;
+      var BN32_N = new Uint8Array([
+        255,
+        255,
+        255,
+        255,
+        255,
+        255,
+        255,
+        255,
+        255,
+        255,
+        255,
+        255,
+        255,
+        255,
+        255,
+        254,
+        186,
+        174,
+        220,
+        230,
+        175,
+        72,
+        160,
+        59,
+        191,
+        210,
+        94,
+        140,
+        208,
+        54,
+        65,
+        65
+      ]);
+      var EXTRA_DATA_SIZE = 32;
+      var BN32_ZERO = new Uint8Array(32);
+      var BN32_P_MINUS_N = new Uint8Array([
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        69,
+        81,
+        35,
+        25,
+        80,
+        183,
+        95,
+        196,
+        64,
+        45,
+        161,
+        114,
+        47,
+        201,
+        186,
+        238
+      ]);
+      var _1n = BigInt(1);
+      function isUint8Array(value) {
+        return value instanceof Uint8Array;
+      }
+      function cmpBN32(data1, data2) {
+        for (let i = 0; i < 32; ++i) {
+          if (data1[i] !== data2[i]) {
+            return data1[i] < data2[i] ? -1 : 1;
+          }
+        }
+        return 0;
+      }
+      function isZero(x) {
+        return cmpBN32(x, BN32_ZERO) === 0;
+      }
+      function isTweak(tweak) {
+        if (!(tweak instanceof Uint8Array) || tweak.length !== TWEAK_SIZE || cmpBN32(tweak, BN32_N) >= 0) {
+          return false;
+        }
+        return true;
+      }
+      function isSignature(signature) {
+        return signature instanceof Uint8Array && signature.length === 64 && cmpBN32(signature.subarray(0, 32), BN32_N) < 0 && cmpBN32(signature.subarray(32, 64), BN32_N) < 0;
+      }
+      function isSigrLessThanPMinusN(signature) {
+        return isUint8Array(signature) && signature.length === 64 && cmpBN32(signature.subarray(0, 32), BN32_P_MINUS_N) < 0;
+      }
+      function isSignatureNonzeroRS(signature) {
+        return !(isZero(signature.subarray(0, 32)) || isZero(signature.subarray(32, 64)));
+      }
+      function isHash(h) {
+        return h instanceof Uint8Array && h.length === HASH_SIZE;
+      }
+      function isExtraData(e) {
+        return e === void 0 || e instanceof Uint8Array && e.length === EXTRA_DATA_SIZE;
+      }
+      function normalizeScalar(scalar) {
+        let num;
+        if (typeof scalar === "bigint") {
+          num = scalar;
+        } else if (typeof scalar === "number" && Number.isSafeInteger(scalar) && scalar >= 0) {
+          num = BigInt(scalar);
+        } else if (typeof scalar === "string") {
+          if (scalar.length !== 64)
+            throw new Error("Expected 32 bytes of private scalar");
+          num = utils__namespace.hexToNumber(scalar);
+        } else if (scalar instanceof Uint8Array) {
+          if (scalar.length !== 32)
+            throw new Error("Expected 32 bytes of private scalar");
+          num = utils__namespace.bytesToNumberBE(scalar);
+        } else {
+          throw new TypeError("Expected valid private scalar");
+        }
+        if (num < 0)
+          throw new Error("Expected private scalar >= 0");
+        return num;
+      }
+      function normalizePrivateKey(privateKey) {
+        return secp256k12.secp256k1.utils.normPrivateKeyToScalar(privateKey);
+      }
+      function _privateAdd(privateKey, tweak) {
+        const p = normalizePrivateKey(privateKey);
+        const t = normalizeScalar(tweak);
+        const add = utils__namespace.numberToBytesBE(mod__namespace.mod(p + t, secp256k12.secp256k1.CURVE.n), 32);
+        return secp256k12.secp256k1.utils.isValidPrivateKey(add) ? add : null;
+      }
+      function _privateSub(privateKey, tweak) {
+        const p = normalizePrivateKey(privateKey);
+        const t = normalizeScalar(tweak);
+        const sub = utils__namespace.numberToBytesBE(mod__namespace.mod(p - t, secp256k12.secp256k1.CURVE.n), 32);
+        return secp256k12.secp256k1.utils.isValidPrivateKey(sub) ? sub : null;
+      }
+      function _privateNegate(privateKey) {
+        const p = normalizePrivateKey(privateKey);
+        const not = utils__namespace.numberToBytesBE(secp256k12.secp256k1.CURVE.n - p, 32);
+        return secp256k12.secp256k1.utils.isValidPrivateKey(not) ? not : null;
+      }
+      function _pointAddScalar(p, tweak, isCompressed) {
+        const P = fromHex(p);
+        const t = normalizeScalar(tweak);
+        const Q = Point.BASE.multiplyAndAddUnsafe(P, t, _1n);
+        if (!Q)
+          throw new Error("Tweaked point at infinity");
+        return Q.toRawBytes(isCompressed);
+      }
+      function _pointMultiply(p, tweak, isCompressed) {
+        const P = fromHex(p);
+        const h = typeof tweak === "string" ? tweak : utils__namespace.bytesToHex(tweak);
+        const t = utils__namespace.hexToNumber(h);
+        return P.multiply(t).toRawBytes(isCompressed);
+      }
+      function assumeCompression(compressed, p) {
+        if (compressed === void 0) {
+          return p !== void 0 ? isPointCompressed(p) : true;
+        }
+        return !!compressed;
+      }
+      function throwToNull(fn) {
+        try {
+          return fn();
+        } catch (e) {
+          return null;
+        }
+      }
+      function fromXOnly(bytes) {
+        return secp256k12.schnorr.utils.lift_x(utils__namespace.bytesToNumberBE(bytes));
+      }
+      function fromHex(bytes) {
+        return bytes.length === 32 ? fromXOnly(bytes) : Point.fromHex(bytes);
+      }
+      function _isPoint(p, xOnly) {
+        if (p.length === 32 !== xOnly)
+          return false;
+        try {
+          if (xOnly)
+            return !!fromXOnly(p);
+          else
+            return !!Point.fromHex(p);
+        } catch (e) {
+          return false;
+        }
+      }
+      function isPoint(p) {
+        return _isPoint(p, false);
+      }
+      function isPointCompressed(p) {
+        const PUBLIC_KEY_COMPRESSED_SIZE = 33;
+        return _isPoint(p, false) && p.length === PUBLIC_KEY_COMPRESSED_SIZE;
+      }
+      function isPrivate(d) {
+        return secp256k12.secp256k1.utils.isValidPrivateKey(d);
+      }
+      function isXOnlyPoint(p) {
+        return _isPoint(p, true);
+      }
+      function xOnlyPointAddTweak(p, tweak) {
+        if (!isXOnlyPoint(p)) {
+          throw new Error(THROW_BAD_POINT);
+        }
+        if (!isTweak(tweak)) {
+          throw new Error(THROW_BAD_TWEAK);
+        }
+        return throwToNull(() => {
+          const P = _pointAddScalar(p, tweak, true);
+          const parity = P[0] % 2 === 1 ? 1 : 0;
+          return { parity, xOnlyPubkey: P.slice(1) };
+        });
+      }
+      function xOnlyPointFromPoint(p) {
+        if (!isPoint(p)) {
+          throw new Error(THROW_BAD_POINT);
+        }
+        return p.slice(1, 33);
+      }
+      function pointFromScalar2(sk, compressed) {
+        if (!isPrivate(sk)) {
+          throw new Error(THROW_BAD_PRIVATE);
+        }
+        return throwToNull(
+          () => secp256k12.secp256k1.getPublicKey(sk, assumeCompression(compressed))
+        );
+      }
+      function xOnlyPointFromScalar(d) {
+        if (!isPrivate(d)) {
+          throw new Error(THROW_BAD_PRIVATE);
+        }
+        return xOnlyPointFromPoint(pointFromScalar2(d));
+      }
+      function pointCompress(p, compressed) {
+        if (!isPoint(p)) {
+          throw new Error(THROW_BAD_POINT);
+        }
+        return fromHex(p).toRawBytes(assumeCompression(compressed, p));
+      }
+      function pointMultiply2(a, tweak, compressed) {
+        if (!isPoint(a)) {
+          throw new Error(THROW_BAD_POINT);
+        }
+        if (!isTweak(tweak)) {
+          throw new Error(THROW_BAD_TWEAK);
+        }
+        return throwToNull(
+          () => _pointMultiply(a, tweak, assumeCompression(compressed, a))
+        );
+      }
+      function pointAdd(a, b, compressed) {
+        if (!isPoint(a) || !isPoint(b)) {
+          throw new Error(THROW_BAD_POINT);
+        }
+        return throwToNull(() => {
+          const A = fromHex(a);
+          const B = fromHex(b);
+          if (A.equals(B.negate())) {
+            return null;
+          } else {
+            return A.add(B).toRawBytes(assumeCompression(compressed, a));
+          }
+        });
+      }
+      function pointAddScalar(p, tweak, compressed) {
+        if (!isPoint(p)) {
+          throw new Error(THROW_BAD_POINT);
+        }
+        if (!isTweak(tweak)) {
+          throw new Error(THROW_BAD_TWEAK);
+        }
+        return throwToNull(
+          () => _pointAddScalar(p, tweak, assumeCompression(compressed, p))
+        );
+      }
+      function privateAdd(d, tweak) {
+        if (!isPrivate(d)) {
+          throw new Error(THROW_BAD_PRIVATE);
+        }
+        if (!isTweak(tweak)) {
+          throw new Error(THROW_BAD_TWEAK);
+        }
+        return throwToNull(() => _privateAdd(d, tweak));
+      }
+      function privateSub(d, tweak) {
+        if (!isPrivate(d)) {
+          throw new Error(THROW_BAD_PRIVATE);
+        }
+        if (!isTweak(tweak)) {
+          throw new Error(THROW_BAD_TWEAK);
+        }
+        return throwToNull(() => _privateSub(d, tweak));
+      }
+      function privateNegate(d) {
+        if (!isPrivate(d)) {
+          throw new Error(THROW_BAD_PRIVATE);
+        }
+        return _privateNegate(d);
+      }
+      function sign2(h, d, e) {
+        if (!isPrivate(d)) {
+          throw new Error(THROW_BAD_PRIVATE);
+        }
+        if (!isHash(h)) {
+          throw new Error(THROW_BAD_SCALAR);
+        }
+        if (!isExtraData(e)) {
+          throw new Error(THROW_BAD_EXTRA_DATA);
+        }
+        return secp256k12.secp256k1.sign(h, d, { extraEntropy: e }).toCompactRawBytes();
+      }
+      function signRecoverable(h, d, e) {
+        if (!isPrivate(d)) {
+          throw new Error(THROW_BAD_PRIVATE);
+        }
+        if (!isHash(h)) {
+          throw new Error(THROW_BAD_SCALAR);
+        }
+        if (!isExtraData(e)) {
+          throw new Error(THROW_BAD_EXTRA_DATA);
+        }
+        const sig = secp256k12.secp256k1.sign(h, d, { extraEntropy: e });
+        return {
+          signature: sig.toCompactRawBytes(),
+          recoveryId: sig.recovery
+        };
+      }
+      function signSchnorr(h, d, e) {
+        if (!isPrivate(d)) {
+          throw new Error(THROW_BAD_PRIVATE);
+        }
+        if (!isHash(h)) {
+          throw new Error(THROW_BAD_SCALAR);
+        }
+        if (!isExtraData(e)) {
+          throw new Error(THROW_BAD_EXTRA_DATA);
+        }
+        return secp256k12.schnorr.sign(h, d, e);
+      }
+      function recover(h, signature, recoveryId, compressed) {
+        if (!isHash(h)) {
+          throw new Error(THROW_BAD_HASH);
+        }
+        if (!isSignature(signature) || !isSignatureNonzeroRS(signature)) {
+          throw new Error(THROW_BAD_SIGNATURE);
+        }
+        if (recoveryId & 2) {
+          if (!isSigrLessThanPMinusN(signature))
+            throw new Error(THROW_BAD_RECOVERY_ID);
+        }
+        if (!isXOnlyPoint(signature.subarray(0, 32))) {
+          throw new Error(THROW_BAD_SIGNATURE);
+        }
+        const s = secp256k12.secp256k1.Signature.fromCompact(signature).addRecoveryBit(recoveryId);
+        const Q = s.recoverPublicKey(h);
+        if (!Q)
+          throw new Error(THROW_BAD_SIGNATURE);
+        return Q.toRawBytes(assumeCompression(compressed));
+      }
+      function verify(h, Q, signature, strict) {
+        if (!isPoint(Q)) {
+          throw new Error(THROW_BAD_POINT);
+        }
+        if (!isSignature(signature)) {
+          throw new Error(THROW_BAD_SIGNATURE);
+        }
+        if (!isHash(h)) {
+          throw new Error(THROW_BAD_SCALAR);
+        }
+        return secp256k12.secp256k1.verify(signature, h, Q, { lowS: strict });
+      }
+      function verifySchnorr(h, Q, signature) {
+        if (!isXOnlyPoint(Q)) {
+          throw new Error(THROW_BAD_POINT);
+        }
+        if (!isSignature(signature)) {
+          throw new Error(THROW_BAD_SIGNATURE);
+        }
+        if (!isHash(h)) {
+          throw new Error(THROW_BAD_SCALAR);
+        }
+        return secp256k12.schnorr.verify(signature, h, Q);
+      }
+      exports.isPoint = isPoint;
+      exports.isPointCompressed = isPointCompressed;
+      exports.isPrivate = isPrivate;
+      exports.isXOnlyPoint = isXOnlyPoint;
+      exports.pointAdd = pointAdd;
+      exports.pointAddScalar = pointAddScalar;
+      exports.pointCompress = pointCompress;
+      exports.pointFromScalar = pointFromScalar2;
+      exports.pointMultiply = pointMultiply2;
+      exports.privateAdd = privateAdd;
+      exports.privateNegate = privateNegate;
+      exports.privateSub = privateSub;
+      exports.recover = recover;
+      exports.sign = sign2;
+      exports.signRecoverable = signRecoverable;
+      exports.signSchnorr = signSchnorr;
+      exports.verify = verify;
+      exports.verifySchnorr = verifySchnorr;
+      exports.xOnlyPointAddTweak = xOnlyPointAddTweak;
+      exports.xOnlyPointFromPoint = xOnlyPointFromPoint;
+      exports.xOnlyPointFromScalar = xOnlyPointFromScalar;
+    }
+  });
+
+  // src/index.js
+  var src_exports = {};
+  __export(src_exports, {
+    base58Decode: () => base58Decode,
+    buildDepinMessage: () => buildDepinMessage,
+    bytesToHex: () => bytesToHex,
+    doubleSha256: () => doubleSha256,
+    hash160: () => hash160,
+    hexToBytes: () => hexToBytes,
+    isWIF: () => isWIF,
+    sha256: () => sha256,
+    wifToHex: () => wifToHex
+  });
+  var secp256k1 = __toESM(require_dist());
+  function writeCompactSize(value) {
+    if (value < 0)
+      throw new Error("CompactSize cannot be negative");
+    if (value < 253) {
+      return new Uint8Array([value]);
+    } else if (value <= 65535) {
+      const buf = new Uint8Array(3);
+      buf[0] = 253;
+      buf[1] = value & 255;
+      buf[2] = value >> 8 & 255;
+      return buf;
+    } else if (value <= 4294967295) {
+      const buf = new Uint8Array(5);
+      buf[0] = 254;
+      buf[1] = value & 255;
+      buf[2] = value >> 8 & 255;
+      buf[3] = value >> 16 & 255;
+      buf[4] = value >> 24 & 255;
+      return buf;
+    } else {
+      const buf = new Uint8Array(9);
+      buf[0] = 255;
+      const low = value >>> 0;
+      const high = Math.floor(value / 4294967296) >>> 0;
+      buf[1] = low & 255;
+      buf[2] = low >> 8 & 255;
+      buf[3] = low >> 16 & 255;
+      buf[4] = low >> 24 & 255;
+      buf[5] = high & 255;
+      buf[6] = high >> 8 & 255;
+      buf[7] = high >> 16 & 255;
+      buf[8] = high >> 24 & 255;
+      return buf;
+    }
+  }
+  function serializeString(str) {
+    const encoder = new TextEncoder();
+    const strBytes = encoder.encode(str);
+    return concatBytes(writeCompactSize(strBytes.length), strBytes);
+  }
+  function serializeVector(data) {
+    return concatBytes(writeCompactSize(data.length), data);
+  }
+  function serializeInt64(value) {
+    const buf = new Uint8Array(8);
+    const low = value >>> 0;
+    const high = Math.floor(value / 4294967296) >>> 0;
+    buf[0] = low & 255;
+    buf[1] = low >> 8 & 255;
+    buf[2] = low >> 16 & 255;
+    buf[3] = low >> 24 & 255;
+    buf[4] = high & 255;
+    buf[5] = high >> 8 & 255;
+    buf[6] = high >> 16 & 255;
+    buf[7] = high >> 24 & 255;
+    return buf;
+  }
+  function concatBytes(...arrays) {
+    const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const arr of arrays) {
+      result.set(arr, offset);
+      offset += arr.length;
+    }
+    return result;
+  }
+  function hexToBytes(hex) {
+    if (hex.length % 2 !== 0)
+      throw new Error("Hex must have even length");
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+      bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
+    }
+    return bytes;
+  }
+  function bytesToHex(bytes) {
+    return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  function encodeDER(signature) {
+    if (signature.length !== 64) {
+      throw new Error("Raw signature must be 64 bytes");
+    }
+    const r = signature.slice(0, 32);
+    const s = signature.slice(32, 64);
+    function encodeInteger(value) {
+      let i = 0;
+      while (i < value.length - 1 && value[i] === 0 && (value[i + 1] & 128) === 0) {
+        i++;
+      }
+      const trimmed = value.slice(i);
+      const needsPadding = (trimmed[0] & 128) !== 0;
+      const paddedValue = needsPadding ? concatBytes(new Uint8Array([0]), trimmed) : trimmed;
+      return concatBytes(
+        new Uint8Array([2, paddedValue.length]),
+        paddedValue
+      );
+    }
+    const rDER = encodeInteger(r);
+    const sDER = encodeInteger(s);
+    const sequenceLength = rDER.length + sDER.length;
+    return concatBytes(
+      new Uint8Array([48, sequenceLength]),
+      rDER,
+      sDER
+    );
+  }
+  var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+  function base58Decode(str) {
+    const bytes = [];
+    for (let i = 0; i < str.length; i++) {
+      const charIndex = BASE58_ALPHABET.indexOf(str[i]);
+      if (charIndex === -1)
+        throw new Error("Invalid Base58 character: " + str[i]);
+      let carry = charIndex;
+      for (let j = 0; j < bytes.length; j++) {
+        carry += bytes[j] * 58;
+        bytes[j] = carry & 255;
+        carry >>= 8;
+      }
+      while (carry > 0) {
+        bytes.push(carry & 255);
+        carry >>= 8;
+      }
+    }
+    for (let i = 0; i < str.length && str[i] === "1"; i++) {
+      bytes.push(0);
+    }
+    return new Uint8Array(bytes.reverse());
+  }
+  async function wifToHex(wif) {
+    const decoded = base58Decode(wif);
+    if (decoded.length < 37) {
+      throw new Error("Invalid WIF: too short");
+    }
+    const payload = decoded.slice(0, -4);
+    const checksum = decoded.slice(-4);
+    const hash = await doubleSha256(payload);
+    for (let i = 0; i < 4; i++) {
+      if (checksum[i] !== hash[i]) {
+        throw new Error("Invalid WIF: checksum mismatch");
+      }
+    }
+    let privateKeyBytes;
+    if (payload.length === 34) {
+      privateKeyBytes = payload.slice(1, 33);
+    } else if (payload.length === 33) {
+      privateKeyBytes = payload.slice(1, 33);
+    } else {
+      throw new Error("Invalid WIF: unexpected length " + payload.length);
+    }
+    return bytesToHex(privateKeyBytes);
+  }
+  function isWIF(str) {
+    return /^[5KLcT][1-9A-HJ-NP-Za-km-z]{50,51}$/.test(str);
+  }
+  async function sha256(data) {
+    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+    return new Uint8Array(hashBuffer);
+  }
+  async function doubleSha256(data) {
+    const first = await sha256(data);
+    return sha256(first);
+  }
+  function ripemd160(data) {
+    let h0 = 1732584193, h1 = 4023233417, h2 = 2562383102, h3 = 271733878, h4 = 3285377520;
+    const K1 = [0, 1518500249, 1859775393, 2400959708, 2840853838];
+    const K2 = [1352829926, 1548603684, 1836072691, 2053994217, 0];
+    const R1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13];
+    const R2 = [5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11];
+    const S1 = [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6];
+    const S2 = [8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11];
+    function rotl(x, n) {
+      return (x << n | x >>> 32 - n) >>> 0;
+    }
+    const bitLen = data.length * 8;
+    const padLen = (64 - (data.length + 9) % 64) % 64;
+    const padded = new Uint8Array(data.length + 1 + padLen + 8);
+    padded.set(data);
+    padded[data.length] = 128;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.length - 8, bitLen, true);
+    const blocks = padded.length / 64;
+    for (let i = 0; i < blocks; i++) {
+      const X = new Uint32Array(16);
+      for (let j = 0; j < 16; j++) {
+        const offset = i * 64 + j * 4;
+        X[j] = padded[offset] | padded[offset + 1] << 8 | padded[offset + 2] << 16 | padded[offset + 3] << 24;
+      }
+      let a1 = h0, b1 = h1, c1 = h2, d1 = h3, e1 = h4;
+      let a2 = h0, b2 = h1, c2 = h2, d2 = h3, e2 = h4;
+      for (let j = 0; j < 80; j++) {
+        const round = Math.floor(j / 16);
+        let f1, f2;
+        if (round === 0) {
+          f1 = b1 ^ c1 ^ d1;
+          f2 = b2 ^ (c2 | ~d2);
+        } else if (round === 1) {
+          f1 = b1 & c1 | ~b1 & d1;
+          f2 = b2 & d2 | c2 & ~d2;
+        } else if (round === 2) {
+          f1 = (b1 | ~c1) ^ d1;
+          f2 = (b2 | ~c2) ^ d2;
+        } else if (round === 3) {
+          f1 = b1 & d1 | c1 & ~d1;
+          f2 = b2 & c2 | ~b2 & d2;
+        } else {
+          f1 = b1 ^ (c1 | ~d1);
+          f2 = b2 ^ c2 ^ d2;
+        }
+        const t1 = rotl(a1 + f1 + X[R1[j]] + K1[round] >>> 0, S1[j]) + e1 >>> 0;
+        a1 = e1;
+        e1 = d1;
+        d1 = rotl(c1, 10);
+        c1 = b1;
+        b1 = t1;
+        const t2 = rotl(a2 + f2 + X[R2[j]] + K2[round] >>> 0, S2[j]) + e2 >>> 0;
+        a2 = e2;
+        e2 = d2;
+        d2 = rotl(c2, 10);
+        c2 = b2;
+        b2 = t2;
+      }
+      const t = h1 + c1 + d2 >>> 0;
+      h1 = h2 + d1 + e2 >>> 0;
+      h2 = h3 + e1 + a2 >>> 0;
+      h3 = h4 + a1 + b2 >>> 0;
+      h4 = h0 + b1 + c2 >>> 0;
+      h0 = t;
+    }
+    const result = new Uint8Array(20);
+    const rv = new DataView(result.buffer);
+    rv.setUint32(0, h0, true);
+    rv.setUint32(4, h1, true);
+    rv.setUint32(8, h2, true);
+    rv.setUint32(12, h3, true);
+    rv.setUint32(16, h4, true);
+    return result;
+  }
+  async function hash160(data) {
+    const sha = await sha256(data);
+    return ripemd160(sha);
+  }
+  async function kdfSha256(sharedSecret, outputLen) {
+    const output = new Uint8Array(outputLen);
+    let offset = 0;
+    let counter = 1;
+    while (offset < outputLen) {
+      const counterBytes = new Uint8Array(4);
+      counterBytes[0] = counter >> 24 & 255;
+      counterBytes[1] = counter >> 16 & 255;
+      counterBytes[2] = counter >> 8 & 255;
+      counterBytes[3] = counter & 255;
+      const data = concatBytes(sharedSecret, counterBytes);
+      const hash = await sha256(data);
+      const remaining = outputLen - offset;
+      const toCopy = Math.min(remaining, 32);
+      output.set(hash.slice(0, toCopy), offset);
+      offset += toCopy;
+      counter++;
+    }
+    return output;
+  }
+  function randomBytes(length) {
+    const bytes = new Uint8Array(length);
+    crypto.getRandomValues(bytes);
+    return bytes;
+  }
+  async function aes256CbcEncrypt(plaintext, key, iv) {
+    const cryptoKey = await crypto.subtle.importKey(
+      "raw",
+      key,
+      { name: "AES-CBC" },
+      false,
+      ["encrypt"]
+    );
+    const ciphertext = await crypto.subtle.encrypt(
+      { name: "AES-CBC", iv },
+      cryptoKey,
+      plaintext
+    );
+    return new Uint8Array(ciphertext);
+  }
+  async function hmacSha256(key, data) {
+    const cryptoKey = await crypto.subtle.importKey(
+      "raw",
+      key,
+      { name: "HMAC", hash: { name: "SHA-256" } },
+      false,
+      ["sign"]
+    );
+    const mac = await crypto.subtle.sign("HMAC", cryptoKey, data);
+    return new Uint8Array(mac);
+  }
+  async function eciesEncrypt(plaintext, recipientPubKeys) {
+    const ephemeralPrivKey = randomBytes(32);
+    const ephemeralPubKey = secp256k1.pointFromScalar(ephemeralPrivKey, true);
+    if (!(ephemeralPubKey instanceof Uint8Array) || ephemeralPubKey.length !== 33) {
+      throw new Error("Failed to generate ephemeral public key");
+    }
+    const aesKey = await kdfSha256(ephemeralPrivKey, 32);
+    const iv = randomBytes(16);
+    const ciphertext = await aes256CbcEncrypt(plaintext, aesKey, iv);
+    const payloadHmac = await hmacSha256(aesKey, ciphertext);
+    const payload = concatBytes(iv, ciphertext, payloadHmac);
+    const recipientKeys = /* @__PURE__ */ new Map();
+    for (const recipientPubKey of recipientPubKeys) {
+      if (!(recipientPubKey instanceof Uint8Array) || recipientPubKey.length !== 33) {
+        throw new Error("Recipient pubkey must be 33 bytes compressed");
+      }
+      const sharedPointCompressed = secp256k1.pointMultiply(recipientPubKey, ephemeralPrivKey, true);
+      const sharedSecret = await sha256(sharedPointCompressed);
+      const encKey = await kdfSha256(sharedSecret, 32);
+      const recipientIV = randomBytes(16);
+      const encryptedAESKey = await aes256CbcEncrypt(aesKey, encKey, recipientIV);
+      const recipientHmac = await hmacSha256(encKey, encryptedAESKey);
+      const recipientPackage = concatBytes(recipientIV, encryptedAESKey, recipientHmac);
+      const keyHash = await hash160(recipientPubKey);
+      const keyHashHex = bytesToHex(keyHash);
+      recipientKeys.set(keyHashHex, recipientPackage);
+    }
+    return {
+      ephemeralPubKey,
+      encryptedPayload: payload,
+      recipientKeys
+    };
+  }
+  function serializeEciesMessage(msg) {
+    const parts = [];
+    parts.push(serializeVector(msg.ephemeralPubKey));
+    parts.push(serializeVector(msg.encryptedPayload));
+    const entries = Array.from(msg.recipientKeys.entries()).map(([hash160Hex, recipientPackage]) => {
+      const keyBytes = hexToBytes(hash160Hex);
+      if (keyBytes.length !== 20)
+        throw new Error("recipient key hash160 must be 20 bytes");
+      return { keyBytes, recipientPackage };
+    });
+    entries.sort((a, b) => {
+      for (let i = 0; i < 20; i++) {
+        if (a.keyBytes[i] !== b.keyBytes[i])
+          return a.keyBytes[i] - b.keyBytes[i];
+      }
+      return 0;
+    });
+    parts.push(writeCompactSize(entries.length));
+    for (const { keyBytes, recipientPackage } of entries) {
+      parts.push(keyBytes);
+      parts.push(serializeVector(recipientPackage));
+    }
+    return concatBytes(...parts);
+  }
+  async function buildDepinMessage(params) {
+    if (!params.token)
+      throw new Error("Token is required");
+    if (!params.senderAddress)
+      throw new Error("Sender address is required");
+    if (!params.senderPubKey || params.senderPubKey.length !== 66) {
+      throw new Error("Sender public key must be 66 hex characters");
+    }
+    let privateKeyHex = params.privateKey;
+    if (!privateKeyHex) {
+      throw new Error("Private key is required");
+    }
+    if (isWIF(privateKeyHex)) {
+      console.log("Detected WIF format, converting to hex...");
+      privateKeyHex = await wifToHex(privateKeyHex);
+      console.log("Private key converted successfully");
+    }
+    if (privateKeyHex.length !== 64) {
+      throw new Error("Private key must be 64 hex characters (or WIF format)");
+    }
+    if (!params.message)
+      throw new Error("Message is required");
+    if (!params.recipientPubKeys || params.recipientPubKeys.length === 0) {
+      throw new Error("At least one recipient is required");
+    }
+    if (!params.timestamp || params.timestamp <= 0) {
+      throw new Error("Timestamp must be positive");
+    }
+    const privateKey = hexToBytes(privateKeyHex);
+    const senderPubKey = hexToBytes(params.senderPubKey);
+    const recipientPubKeys = params.recipientPubKeys.map((pk) => {
+      if (pk.length !== 66)
+        throw new Error("Recipient pubkey must be 66 hex chars");
+      return hexToBytes(pk);
+    });
+    const senderHex = params.senderPubKey.toLowerCase();
+    if (!params.recipientPubKeys.some((pk) => pk.toLowerCase() === senderHex)) {
+      recipientPubKeys.push(senderPubKey);
+    }
+    const encoder = new TextEncoder();
+    const messageBytes = encoder.encode(params.message);
+    const eciesMsg = await eciesEncrypt(messageBytes, recipientPubKeys);
+    const encryptedPayload = serializeEciesMessage(eciesMsg);
+    const hashData = concatBytes(
+      serializeString(params.token),
+      serializeString(params.senderAddress),
+      serializeInt64(params.timestamp),
+      serializeVector(encryptedPayload)
+    );
+    const messageHashBytes = await doubleSha256(hashData);
+    const messageHash = bytesToHex(messageHashBytes.slice().reverse());
+    const sigResult = secp256k1.sign(messageHashBytes, privateKey);
+    let signature;
+    if (sigResult instanceof Uint8Array) {
+      if (sigResult.length === 64) {
+        signature = encodeDER(sigResult);
+      } else {
+        signature = sigResult;
+      }
+    } else if (typeof sigResult === "object" && sigResult.toDER) {
+      signature = sigResult.toDER();
+    } else if (typeof sigResult === "object" && sigResult.signature) {
+      if (sigResult.signature.length === 64) {
+        signature = encodeDER(sigResult.signature);
+      } else {
+        signature = sigResult.signature;
+      }
+    } else {
+      throw new Error("Unknown signature format from secp256k1.sign()");
+    }
+    const serialized = concatBytes(
+      serializeString(params.token),
+      serializeString(params.senderAddress),
+      serializeInt64(params.timestamp),
+      serializeVector(signature),
+      serializeVector(encryptedPayload)
+    );
+    return {
+      hex: bytesToHex(serialized),
+      messageHash,
+      messageHashBytes: bytesToHex(messageHashBytes),
+      encryptedSize: encryptedPayload.length,
+      recipientCount: recipientPubKeys.length
+    };
+  }
+  if (typeof globalThis !== "undefined") {
+    globalThis.neuraiDepinMsg = {
+      buildDepinMessage,
+      wifToHex,
+      isWIF,
+      utils: {
+        hexToBytes,
+        bytesToHex,
+        sha256,
+        doubleSha256,
+        hash160,
+        base58Decode
+      }
+    };
+  }
+  return __toCommonJS(src_exports);
+})();
+/*! Bundled license information:
+
+@noble/hashes/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/utils.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/abstract/modular.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/abstract/curve.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/abstract/weierstrass.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/_shortw_utils.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/secp256k1.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/