@settlemint/sdk-cli 2.1.1-prc71cad32 → 2.1.1-prcb1d9c8d

package/dist/cli.js

@@ -837,7 +837,7 @@ var require_dist2 = __commonJS((exports) => {
 // ../../node_modules/@dotenvx/dotenvx/package.json
 var require_package = __commonJS((exports, module) => {
   module.exports = {
-    version: "1.39.1",
+    version: "1.40.1",
     name: "@dotenvx/dotenvx",
     description: "a better dotenv–from the creator of `dotenv`",
     author: "@motdotla",
@@ -4232,7 +4232,7 @@ var require_utils4 = __commonJS((exports) => {
   exports.wrapXOFConstructorWithOpts = wrapXOFConstructorWithOpts;
   exports.randomBytes = randomBytes;
   var crypto_1 = require_cryptoNode2();
-  var _assert_js_1 = require__assert2();
+  var _assert_ts_1 = require__assert2();
   function isBytes(a) {
     return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
   }
@@ -4261,9 +4261,12 @@ var require_utils4 = __commonJS((exports) => {
       arr[i] = byteSwap(arr[i]);
     }
   }
+  var hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
   var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
   function bytesToHex(bytes) {
-    (0, _assert_js_1.abytes)(bytes);
+    (0, _assert_ts_1.abytes)(bytes);
+    if (hasHexBuiltin)
+      return bytes.toHex();
     let hex = "";
     for (let i = 0;i < bytes.length; i++) {
       hex += hexes[bytes[i]];
@@ -4283,6 +4286,8 @@ var require_utils4 = __commonJS((exports) => {
   function hexToBytes(hex) {
     if (typeof hex !== "string")
       throw new Error("hex string expected, got " + typeof hex);
+    if (hasHexBuiltin)
+      return Uint8Array.fromHex(hex);
     const hl = hex.length;
     const al = hl / 2;
     if (hl % 2)
@@ -4320,14 +4325,14 @@ var require_utils4 = __commonJS((exports) => {
   function toBytes(data) {
     if (typeof data === "string")
       data = utf8ToBytes(data);
-    (0, _assert_js_1.abytes)(data);
+    (0, _assert_ts_1.abytes)(data);
     return data;
   }
   function concatBytes(...arrays) {
     let sum = 0;
     for (let i = 0;i < arrays.length; i++) {
       const a = arrays[i];
-      (0, _assert_js_1.abytes)(a);
+      (0, _assert_ts_1.abytes)(a);
       sum += a.length;
     }
     const res = new Uint8Array(sum);
@@ -4380,7 +4385,7 @@ var require_utils4 = __commonJS((exports) => {
       return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength));
     }
     if (crypto_1.crypto && typeof crypto_1.crypto.randomBytes === "function") {
-      return crypto_1.crypto.randomBytes(bytesLength);
+      return Uint8Array.from(crypto_1.crypto.randomBytes(bytesLength));
     }
     throw new Error("crypto.getRandomValues must be defined");
   }
@@ -4393,8 +4398,8 @@ var require__md = __commonJS((exports) => {
   exports.setBigUint64 = setBigUint64;
   exports.Chi = Chi;
   exports.Maj = Maj;
-  var _assert_js_1 = require__assert2();
-  var utils_js_1 = require_utils4();
+  var _assert_ts_1 = require__assert2();
+  var utils_ts_1 = require_utils4();
   function setBigUint64(view, byteOffset, value, isLE) {
     if (typeof view.setBigUint64 === "function")
       return view.setBigUint64(byteOffset, value, isLE);
@@ -4414,29 +4419,29 @@ var require__md = __commonJS((exports) => {
     return a & b ^ a & c ^ b & c;
   }
 
-  class HashMD extends utils_js_1.Hash {
+  class HashMD extends utils_ts_1.Hash {
     constructor(blockLen, outputLen, padOffset, isLE) {
       super();
-      this.blockLen = blockLen;
-      this.outputLen = outputLen;
-      this.padOffset = padOffset;
-      this.isLE = isLE;
       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_js_1.createView)(this.buffer);
+      this.view = (0, utils_ts_1.createView)(this.buffer);
     }
     update(data) {
-      (0, _assert_js_1.aexists)(this);
+      (0, _assert_ts_1.aexists)(this);
       const { view, buffer, blockLen } = this;
-      data = (0, utils_js_1.toBytes)(data);
+      data = (0, utils_ts_1.toBytes)(data);
       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_js_1.createView)(data);
+          const dataView = (0, utils_ts_1.createView)(data);
           for (;blockLen <= len - pos; pos += blockLen)
             this.process(dataView, pos);
           continue;
@@ -4454,8 +4459,8 @@ var require__md = __commonJS((exports) => {
       return this;
     }
     digestInto(out) {
-      (0, _assert_js_1.aexists)(this);
-      (0, _assert_js_1.aoutput)(out, this);
+      (0, _assert_ts_1.aexists)(this);
+      (0, _assert_ts_1.aoutput)(out, this);
       this.finished = true;
       const { buffer, view, blockLen, isLE } = this;
       let { pos } = this;
@@ -4469,7 +4474,7 @@ var require__md = __commonJS((exports) => {
         buffer[i] = 0;
       setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
       this.process(view, 0);
-      const oview = (0, utils_js_1.createView)(out);
+      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");
@@ -4503,6 +4508,178 @@ var require__md = __commonJS((exports) => {
   exports.HashMD = HashMD;
 });
 
+// ../../node_modules/@noble/hashes/sha256.js
+var require_sha256 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.sha224 = exports.sha256 = exports.SHA256 = undefined;
+  var _md_ts_1 = require__md();
+  var utils_ts_1 = require_utils4();
+  var SHA256_K = /* @__PURE__ */ new Uint32Array([
+    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_IV = /* @__PURE__ */ new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+
+  class SHA256 extends _md_ts_1.HashMD {
+    constructor(outputLen = 32) {
+      super(64, outputLen, 8, false);
+      this.A = SHA256_IV[0] | 0;
+      this.B = SHA256_IV[1] | 0;
+      this.C = SHA256_IV[2] | 0;
+      this.D = SHA256_IV[3] | 0;
+      this.E = SHA256_IV[4] | 0;
+      this.F = SHA256_IV[5] | 0;
+      this.G = SHA256_IV[6] | 0;
+      this.H = SHA256_IV[7] | 0;
+    }
+    get() {
+      const { A, B, C, D, E, F, G, H } = this;
+      return [A, B, C, D, E, F, G, H];
+    }
+    set(A, B, C, D, E, F, G, H) {
+      this.A = A | 0;
+      this.B = B | 0;
+      this.C = C | 0;
+      this.D = D | 0;
+      this.E = E | 0;
+      this.F = F | 0;
+      this.G = G | 0;
+      this.H = H | 0;
+    }
+    process(view, offset) {
+      for (let i = 0;i < 16; i++, offset += 4)
+        SHA256_W[i] = view.getUint32(offset, false);
+      for (let i = 16;i < 64; i++) {
+        const W15 = SHA256_W[i - 15];
+        const W2 = SHA256_W[i - 2];
+        const s0 = (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() {
+      SHA256_W.fill(0);
+    }
+    destroy() {
+      this.set(0, 0, 0, 0, 0, 0, 0, 0);
+      this.buffer.fill(0);
+    }
+  }
+  exports.SHA256 = SHA256;
+
+  class SHA224 extends SHA256 {
+    constructor() {
+      super(28);
+      this.A = 3238371032 | 0;
+      this.B = 914150663 | 0;
+      this.C = 812702999 | 0;
+      this.D = 4144912697 | 0;
+      this.E = 4290775857 | 0;
+      this.F = 1750603025 | 0;
+      this.G = 1694076839 | 0;
+      this.H = 3204075428 | 0;
+    }
+  }
+  exports.sha256 = (0, utils_ts_1.wrapConstructor)(() => new SHA256);
+  exports.sha224 = (0, utils_ts_1.wrapConstructor)(() => new SHA224);
+});
+
 // ../../node_modules/@noble/hashes/_u64.js
 var require__u64 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -4599,10 +4776,10 @@ var require__u64 = __commonJS((exports) => {
 var require_sha512 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.sha384 = exports.sha512_256 = exports.sha512_224 = exports.sha512 = exports.SHA384 = exports.SHA512_256 = exports.SHA512_224 = exports.SHA512 = undefined;
-  var _md_js_1 = require__md();
-  var _u64_js_1 = require__u64();
-  var utils_js_1 = require_utils4();
-  var [SHA512_Kh, SHA512_Kl] = /* @__PURE__ */ (() => _u64_js_1.default.split([
+  var _md_ts_1 = require__md();
+  var _u64_ts_1 = require__u64();
+  var utils_ts_1 = require_utils4();
+  var [SHA512_Kh, SHA512_Kl] = /* @__PURE__ */ (() => _u64_ts_1.default.split([
     "0x428a2f98d728ae22",
     "0x7137449123ef65cd",
     "0xb5c0fbcfec4d3b2f",
@@ -4687,9 +4864,9 @@ var require_sha512 = __commonJS((exports) => {
   var SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
   var SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
 
-  class SHA512 extends _md_js_1.HashMD {
-    constructor() {
-      super(128, 64, 16, false);
+  class SHA512 extends _md_ts_1.HashMD {
+    constructor(outputLen = 64) {
+      super(128, outputLen, 16, false);
       this.Ah = 1779033703 | 0;
       this.Al = 4089235720 | 0;
       this.Bh = 3144134277 | 0;
@@ -4737,28 +4914,28 @@ var require_sha512 = __commonJS((exports) => {
       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_js_1.default.rotrSH(W15h, W15l, 1) ^ _u64_js_1.default.rotrSH(W15h, W15l, 8) ^ _u64_js_1.default.shrSH(W15h, W15l, 7);
-        const s0l = _u64_js_1.default.rotrSL(W15h, W15l, 1) ^ _u64_js_1.default.rotrSL(W15h, W15l, 8) ^ _u64_js_1.default.shrSL(W15h, W15l, 7);
+        const s0h = _u64_ts_1.default.rotrSH(W15h, W15l, 1) ^ _u64_ts_1.default.rotrSH(W15h, W15l, 8) ^ _u64_ts_1.default.shrSH(W15h, W15l, 7);
+        const s0l = _u64_ts_1.default.rotrSL(W15h, W15l, 1) ^ _u64_ts_1.default.rotrSL(W15h, W15l, 8) ^ _u64_ts_1.default.shrSL(W15h, W15l, 7);
         const W2h = SHA512_W_H[i - 2] | 0;
         const W2l = SHA512_W_L[i - 2] | 0;
-        const s1h = _u64_js_1.default.rotrSH(W2h, W2l, 19) ^ _u64_js_1.default.rotrBH(W2h, W2l, 61) ^ _u64_js_1.default.shrSH(W2h, W2l, 6);
-        const s1l = _u64_js_1.default.rotrSL(W2h, W2l, 19) ^ _u64_js_1.default.rotrBL(W2h, W2l, 61) ^ _u64_js_1.default.shrSL(W2h, W2l, 6);
-        const SUMl = _u64_js_1.default.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
-        const SUMh = _u64_js_1.default.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
+        const s1h = _u64_ts_1.default.rotrSH(W2h, W2l, 19) ^ _u64_ts_1.default.rotrBH(W2h, W2l, 61) ^ _u64_ts_1.default.shrSH(W2h, W2l, 6);
+        const s1l = _u64_ts_1.default.rotrSL(W2h, W2l, 19) ^ _u64_ts_1.default.rotrBL(W2h, W2l, 61) ^ _u64_ts_1.default.shrSL(W2h, W2l, 6);
+        const SUMl = _u64_ts_1.default.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+        const SUMh = _u64_ts_1.default.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_js_1.default.rotrSH(Eh, El, 14) ^ _u64_js_1.default.rotrSH(Eh, El, 18) ^ _u64_js_1.default.rotrBH(Eh, El, 41);
-        const sigma1l = _u64_js_1.default.rotrSL(Eh, El, 14) ^ _u64_js_1.default.rotrSL(Eh, El, 18) ^ _u64_js_1.default.rotrBL(Eh, El, 41);
+        const sigma1h = _u64_ts_1.default.rotrSH(Eh, El, 14) ^ _u64_ts_1.default.rotrSH(Eh, El, 18) ^ _u64_ts_1.default.rotrBH(Eh, El, 41);
+        const sigma1l = _u64_ts_1.default.rotrSL(Eh, El, 14) ^ _u64_ts_1.default.rotrSL(Eh, El, 18) ^ _u64_ts_1.default.rotrBL(Eh, El, 41);
         const CHIh = Eh & Fh ^ ~Eh & Gh;
         const CHIl = El & Fl ^ ~El & Gl;
-        const T1ll = _u64_js_1.default.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
-        const T1h = _u64_js_1.default.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+        const T1ll = _u64_ts_1.default.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+        const T1h = _u64_ts_1.default.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
         const T1l = T1ll | 0;
-        const sigma0h = _u64_js_1.default.rotrSH(Ah, Al, 28) ^ _u64_js_1.default.rotrBH(Ah, Al, 34) ^ _u64_js_1.default.rotrBH(Ah, Al, 39);
-        const sigma0l = _u64_js_1.default.rotrSL(Ah, Al, 28) ^ _u64_js_1.default.rotrBL(Ah, Al, 34) ^ _u64_js_1.default.rotrBL(Ah, Al, 39);
+        const sigma0h = _u64_ts_1.default.rotrSH(Ah, Al, 28) ^ _u64_ts_1.default.rotrBH(Ah, Al, 34) ^ _u64_ts_1.default.rotrBH(Ah, Al, 39);
+        const sigma0l = _u64_ts_1.default.rotrSL(Ah, Al, 28) ^ _u64_ts_1.default.rotrBL(Ah, Al, 34) ^ _u64_ts_1.default.rotrBL(Ah, Al, 39);
         const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
         const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
         Hh = Gh | 0;
@@ -4767,25 +4944,25 @@ var require_sha512 = __commonJS((exports) => {
         Gl = Fl | 0;
         Fh = Eh | 0;
         Fl = El | 0;
-        ({ h: Eh, l: El } = _u64_js_1.default.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+        ({ h: Eh, l: El } = _u64_ts_1.default.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_js_1.default.add3L(T1l, sigma0l, MAJl);
-        Ah = _u64_js_1.default.add3H(All, T1h, sigma0h, MAJh);
+        const All = _u64_ts_1.default.add3L(T1l, sigma0l, MAJl);
+        Ah = _u64_ts_1.default.add3H(All, T1h, sigma0h, MAJh);
         Al = All | 0;
       }
-      ({ h: Ah, l: Al } = _u64_js_1.default.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
-      ({ h: Bh, l: Bl } = _u64_js_1.default.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
-      ({ h: Ch, l: Cl } = _u64_js_1.default.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
-      ({ h: Dh, l: Dl } = _u64_js_1.default.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
-      ({ h: Eh, l: El } = _u64_js_1.default.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
-      ({ h: Fh, l: Fl } = _u64_js_1.default.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
-      ({ h: Gh, l: Gl } = _u64_js_1.default.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
-      ({ h: Hh, l: Hl } = _u64_js_1.default.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+      ({ h: Ah, l: Al } = _u64_ts_1.default.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+      ({ h: Bh, l: Bl } = _u64_ts_1.default.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+      ({ h: Ch, l: Cl } = _u64_ts_1.default.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+      ({ h: Dh, l: Dl } = _u64_ts_1.default.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+      ({ h: Eh, l: El } = _u64_ts_1.default.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+      ({ h: Fh, l: Fl } = _u64_ts_1.default.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+      ({ h: Gh, l: Gl } = _u64_ts_1.default.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+      ({ h: Hh, l: Hl } = _u64_ts_1.default.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() {
@@ -4801,7 +4978,7 @@ var require_sha512 = __commonJS((exports) => {
 
   class SHA512_224 extends SHA512 {
     constructor() {
-      super();
+      super(28);
       this.Ah = 2352822216 | 0;
       this.Al = 424955298 | 0;
       this.Bh = 1944164710 | 0;
@@ -4818,14 +4995,13 @@ var require_sha512 = __commonJS((exports) => {
       this.Gl = 1780299464 | 0;
       this.Hh = 286451373 | 0;
       this.Hl = 2446758561 | 0;
-      this.outputLen = 28;
     }
   }
   exports.SHA512_224 = SHA512_224;
 
   class SHA512_256 extends SHA512 {
     constructor() {
-      super();
+      super(32);
       this.Ah = 573645204 | 0;
       this.Al = 4230739756 | 0;
       this.Bh = 2673172387 | 0;
@@ -4842,14 +5018,13 @@ var require_sha512 = __commonJS((exports) => {
       this.Gl = 746961066 | 0;
       this.Hh = 246885852 | 0;
       this.Hl = 2177182882 | 0;
-      this.outputLen = 32;
     }
   }
   exports.SHA512_256 = SHA512_256;
 
   class SHA384 extends SHA512 {
     constructor() {
-      super();
+      super(48);
       this.Ah = 3418070365 | 0;
       this.Al = 3238371032 | 0;
       this.Bh = 1654270250 | 0;
@@ -4866,14 +5041,39 @@ var require_sha512 = __commonJS((exports) => {
       this.Gl = 1694076839 | 0;
       this.Hh = 1203062813 | 0;
       this.Hl = 3204075428 | 0;
-      this.outputLen = 48;
     }
   }
   exports.SHA384 = SHA384;
-  exports.sha512 = (0, utils_js_1.wrapConstructor)(() => new SHA512);
-  exports.sha512_224 = (0, utils_js_1.wrapConstructor)(() => new SHA512_224);
-  exports.sha512_256 = (0, utils_js_1.wrapConstructor)(() => new SHA512_256);
-  exports.sha384 = (0, utils_js_1.wrapConstructor)(() => new SHA384);
+  exports.sha512 = (0, utils_ts_1.wrapConstructor)(() => new SHA512);
+  exports.sha512_224 = (0, utils_ts_1.wrapConstructor)(() => new SHA512_224);
+  exports.sha512_256 = (0, utils_ts_1.wrapConstructor)(() => new SHA512_256);
+  exports.sha384 = (0, utils_ts_1.wrapConstructor)(() => new SHA384);
+});
+
+// ../../node_modules/@noble/hashes/sha2.js
+var require_sha2 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.sha512_256 = exports.sha512_224 = exports.sha512 = exports.sha384 = exports.sha256 = exports.sha224 = undefined;
+  var sha256_ts_1 = require_sha256();
+  Object.defineProperty(exports, "sha224", { enumerable: true, get: function() {
+    return sha256_ts_1.sha224;
+  } });
+  Object.defineProperty(exports, "sha256", { enumerable: true, get: function() {
+    return sha256_ts_1.sha256;
+  } });
+  var sha512_ts_1 = require_sha512();
+  Object.defineProperty(exports, "sha384", { enumerable: true, get: function() {
+    return sha512_ts_1.sha384;
+  } });
+  Object.defineProperty(exports, "sha512", { enumerable: true, get: function() {
+    return sha512_ts_1.sha512;
+  } });
+  Object.defineProperty(exports, "sha512_224", { enumerable: true, get: function() {
+    return sha512_ts_1.sha512_224;
+  } });
+  Object.defineProperty(exports, "sha512_256", { enumerable: true, get: function() {
+    return sha512_ts_1.sha512_256;
+  } });
 });
 
 // ../../node_modules/@noble/curves/abstract/utils.js
@@ -4884,9 +5084,9 @@ var require_utils5 = __commonJS((exports) => {
   exports.isBytes = isBytes;
   exports.abytes = abytes;
   exports.abool = abool;
-  exports.bytesToHex = bytesToHex;
   exports.numberToHexUnpadded = numberToHexUnpadded;
   exports.hexToNumber = hexToNumber;
+  exports.bytesToHex = bytesToHex;
   exports.hexToBytes = hexToBytes;
   exports.bytesToNumberBE = bytesToNumberBE;
   exports.bytesToNumberLE = bytesToNumberLE;
@@ -4907,7 +5107,6 @@ var require_utils5 = __commonJS((exports) => {
   exports.memoized = memoized;
   var _0n = /* @__PURE__ */ BigInt(0);
   var _1n = /* @__PURE__ */ BigInt(1);
-  var _2n = /* @__PURE__ */ BigInt(2);
   function isBytes(a) {
     return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
   }
@@ -4919,15 +5118,6 @@ var require_utils5 = __commonJS((exports) => {
     if (typeof value !== "boolean")
       throw new Error(title + " boolean expected, got " + value);
   }
-  var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-  function bytesToHex(bytes) {
-    abytes(bytes);
-    let hex = "";
-    for (let i = 0;i < bytes.length; i++) {
-      hex += hexes[bytes[i]];
-    }
-    return hex;
-  }
   function numberToHexUnpadded(num) {
     const hex = num.toString(16);
     return hex.length & 1 ? "0" + hex : hex;
@@ -4937,6 +5127,18 @@ var require_utils5 = __commonJS((exports) => {
       throw new Error("hex string expected, got " + typeof hex);
     return hex === "" ? _0n : BigInt("0x" + hex);
   }
+  var hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
+  var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+  function bytesToHex(bytes) {
+    abytes(bytes);
+    if (hasHexBuiltin)
+      return bytes.toHex();
+    let hex = "";
+    for (let i = 0;i < bytes.length; i++) {
+      hex += hexes[bytes[i]];
+    }
+    return hex;
+  }
   var asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
   function asciiToBase16(ch) {
     if (ch >= asciis._0 && ch <= asciis._9)
@@ -4950,6 +5152,8 @@ var require_utils5 = __commonJS((exports) => {
   function hexToBytes(hex) {
     if (typeof hex !== "string")
       throw new Error("hex string expected, got " + typeof hex);
+    if (hasHexBuiltin)
+      return Uint8Array.fromHex(hex);
     const hl = hex.length;
     const al = hl / 2;
     if (hl % 2)
@@ -5048,9 +5252,9 @@ var require_utils5 = __commonJS((exports) => {
   function bitSet(n, pos, value) {
     return n | (value ? _1n : _0n) << BigInt(pos);
   }
-  var bitMask = (n) => (_2n << BigInt(n - 1)) - _1n;
+  var bitMask = (n) => (_1n << BigInt(n)) - _1n;
   exports.bitMask = bitMask;
-  var u8n = (data) => new Uint8Array(data);
+  var u8n = (len) => new Uint8Array(len);
   var u8fr = (arr) => Uint8Array.from(arr);
   function createHmacDrbg(hashLen, qByteLen, hmacFn) {
     if (typeof hashLen !== "number" || hashLen < 2)
@@ -5068,7 +5272,7 @@ var require_utils5 = __commonJS((exports) => {
       i = 0;
     };
     const h = (...b) => hmacFn(k, v, ...b);
-    const reseed = (seed = u8n()) => {
+    const reseed = (seed = u8n(0)) => {
       k = h(u8fr([0]), seed);
       v = h();
       if (seed.length === 0)
@@ -5171,7 +5375,7 @@ var require_modular = __commonJS((exports) => {
   exports.getMinHashLength = getMinHashLength;
   exports.mapHashToField = mapHashToField;
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-  var utils_js_1 = require_utils5();
+  var utils_ts_1 = require_utils5();
   var _0n = BigInt(0);
   var _1n = BigInt(1);
   var _2n = /* @__PURE__ */ BigInt(2);
@@ -5331,7 +5535,7 @@ var require_modular = __commonJS((exports) => {
       map[val] = "function";
       return map;
     }, initial);
-    return (0, utils_js_1.validateObject)(field, opts);
+    return (0, utils_ts_1.validateObject)(field, opts);
   }
   function FpPow(f, num, power) {
     if (power < _0n)
@@ -5398,7 +5602,7 @@ var require_modular = __commonJS((exports) => {
       isLE,
       BITS,
       BYTES,
-      MASK: (0, utils_js_1.bitMask)(BITS),
+      MASK: (0, utils_ts_1.bitMask)(BITS),
       ZERO: _0n,
       ONE: _1n,
       create: (num) => mod(num, ORDER),
@@ -5429,11 +5633,11 @@ var require_modular = __commonJS((exports) => {
       }),
       invertBatch: (lst) => FpInvertBatch(f, lst),
       cmov: (a, b, c) => c ? b : a,
-      toBytes: (num) => isLE ? (0, utils_js_1.numberToBytesLE)(num, BYTES) : (0, utils_js_1.numberToBytesBE)(num, BYTES),
+      toBytes: (num) => isLE ? (0, utils_ts_1.numberToBytesLE)(num, BYTES) : (0, utils_ts_1.numberToBytesBE)(num, BYTES),
       fromBytes: (bytes) => {
         if (bytes.length !== BYTES)
           throw new Error("Field.fromBytes: expected " + BYTES + " bytes, got " + bytes.length);
-        return isLE ? (0, utils_js_1.bytesToNumberLE)(bytes) : (0, utils_js_1.bytesToNumberBE)(bytes);
+        return isLE ? (0, utils_ts_1.bytesToNumberLE)(bytes) : (0, utils_ts_1.bytesToNumberBE)(bytes);
       }
     });
     return Object.freeze(f);
@@ -5451,12 +5655,12 @@ var require_modular = __commonJS((exports) => {
     return Fp.isOdd(root) ? Fp.neg(root) : root;
   }
   function hashToPrivateScalar(hash, groupOrder, isLE = false) {
-    hash = (0, utils_js_1.ensureBytes)("privateHash", hash);
+    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_js_1.bytesToNumberLE)(hash) : (0, utils_js_1.bytesToNumberBE)(hash);
+    const num = isLE ? (0, utils_ts_1.bytesToNumberLE)(hash) : (0, utils_ts_1.bytesToNumberBE)(hash);
     return mod(num, groupOrder - _1n) + _1n;
   }
   function getFieldBytesLength(fieldOrder) {
@@ -5475,9 +5679,9 @@ var require_modular = __commonJS((exports) => {
     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_js_1.bytesToNumberLE)(key) : (0, utils_js_1.bytesToNumberBE)(key);
+    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_js_1.numberToBytesLE)(reduced, fieldLen) : (0, utils_js_1.numberToBytesBE)(reduced, fieldLen);
+    return isLE ? (0, utils_ts_1.numberToBytesLE)(reduced, fieldLen) : (0, utils_ts_1.numberToBytesBE)(reduced, fieldLen);
   }
 });
 
@@ -5489,8 +5693,8 @@ var require_curve = __commonJS((exports) => {
   exports.precomputeMSMUnsafe = precomputeMSMUnsafe;
   exports.validateBasic = validateBasic;
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-  var modular_js_1 = require_modular();
-  var utils_js_1 = require_utils5();
+  var modular_ts_1 = require_modular();
+  var utils_ts_1 = require_utils5();
   var _0n = BigInt(0);
   var _1n = BigInt(1);
   function constTimeNegate(condition, item) {
@@ -5501,11 +5705,30 @@ var require_curve = __commonJS((exports) => {
     if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
       throw new Error("invalid window size, expected [1.." + bits + "], got W=" + W);
   }
-  function calcWOpts(W, bits) {
-    validateW(W, bits);
-    const windows = Math.ceil(bits / W) + 1;
+  function calcWOpts(W, scalarBits) {
+    validateW(W, scalarBits);
+    const windows = Math.ceil(scalarBits / W) + 1;
     const windowSize = 2 ** (W - 1);
-    return { windows, windowSize };
+    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, window2, 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 = window2 * windowSize;
+    const offset = offsetStart + Math.abs(wbits) - 1;
+    const isZero = wbits === 0;
+    const isNeg = wbits < 0;
+    const isNegF = window2 % 2 !== 0;
+    const offsetF = offsetStart;
+    return { nextN, offset, isZero, isNeg, isNegF, offsetF };
   }
   function validateMSMPoints(points, c) {
     if (!Array.isArray(points))
@@ -5561,53 +5784,33 @@ var require_curve = __commonJS((exports) => {
         return points;
       },
       wNAF(W, precomputes, n) {
-        const { windows, windowSize } = calcWOpts(W, bits);
         let p = c.ZERO;
         let f = c.BASE;
-        const mask = BigInt(2 ** W - 1);
-        const maxNumber = 2 ** W;
-        const shiftBy = BigInt(W);
-        for (let window2 = 0;window2 < windows; window2++) {
-          const offset = window2 * windowSize;
-          let wbits = Number(n & mask);
-          n >>= shiftBy;
-          if (wbits > windowSize) {
-            wbits -= maxNumber;
-            n += _1n;
-          }
-          const offset1 = offset;
-          const offset2 = offset + Math.abs(wbits) - 1;
-          const cond1 = window2 % 2 !== 0;
-          const cond2 = wbits < 0;
-          if (wbits === 0) {
-            f = f.add(constTimeNegate(cond1, precomputes[offset1]));
+        const wo = calcWOpts(W, bits);
+        for (let window2 = 0;window2 < wo.windows; window2++) {
+          const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window2, wo);
+          n = nextN;
+          if (isZero) {
+            f = f.add(constTimeNegate(isNegF, precomputes[offsetF]));
           } else {
-            p = p.add(constTimeNegate(cond2, precomputes[offset2]));
+            p = p.add(constTimeNegate(isNeg, precomputes[offset]));
           }
         }
         return { p, f };
       },
       wNAFUnsafe(W, precomputes, n, acc = c.ZERO) {
-        const { windows, windowSize } = calcWOpts(W, bits);
-        const mask = BigInt(2 ** W - 1);
-        const maxNumber = 2 ** W;
-        const shiftBy = BigInt(W);
-        for (let window2 = 0;window2 < windows; window2++) {
-          const offset = window2 * windowSize;
+        const wo = calcWOpts(W, bits);
+        for (let window2 = 0;window2 < wo.windows; window2++) {
           if (n === _0n)
             break;
-          let wbits = Number(n & mask);
-          n >>= shiftBy;
-          if (wbits > windowSize) {
-            wbits -= maxNumber;
-            n += _1n;
-          }
-          if (wbits === 0)
+          const { nextN, offset, isZero, isNeg } = calcOffsets(n, window2, wo);
+          n = nextN;
+          if (isZero) {
             continue;
-          let curr = precomputes[offset + Math.abs(wbits) - 1];
-          if (wbits < 0)
-            curr = curr.negate();
-          acc = acc.add(curr);
+          } else {
+            const item = precomputes[offset];
+            acc = acc.add(isNeg ? item.negate() : item);
+          }
         }
         return acc;
       },
@@ -5643,17 +5846,17 @@ var require_curve = __commonJS((exports) => {
     if (points.length !== scalars.length)
       throw new Error("arrays of points and scalars must have equal length");
     const zero = c.ZERO;
-    const wbits = (0, utils_js_1.bitLen)(BigInt(points.length));
+    const wbits = (0, utils_ts_1.bitLen)(BigInt(points.length));
     const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1;
-    const MASK = (1 << windowSize) - 1;
-    const buckets = new Array(MASK + 1).fill(zero);
+    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 < scalars.length; j++) {
         const scalar = scalars[j];
-        const wbits2 = Number(scalar >> BigInt(i) & BigInt(MASK));
+        const wbits2 = Number(scalar >> BigInt(i) & MASK);
         buckets[wbits2] = buckets[wbits2].add(points[j]);
       }
       let resI = zero;
@@ -5674,7 +5877,7 @@ var require_curve = __commonJS((exports) => {
     const zero = c.ZERO;
     const tableSize = 2 ** windowSize - 1;
     const chunks = Math.ceil(fieldN.BITS / windowSize);
-    const MASK = BigInt((1 << windowSize) - 1);
+    const MASK = (0, utils_ts_1.bitMask)(windowSize);
     const tables = points.map((p) => {
       const res = [];
       for (let i = 0, acc = p;i < tableSize; i++) {
@@ -5705,8 +5908,8 @@ var require_curve = __commonJS((exports) => {
     };
   }
   function validateBasic(curve) {
-    (0, modular_js_1.validateField)(curve.Fp);
-    (0, utils_js_1.validateObject)(curve, {
+    (0, modular_ts_1.validateField)(curve.Fp);
+    (0, utils_ts_1.validateObject)(curve, {
       n: "bigint",
       h: "bigint",
       Gx: "field",
@@ -5716,7 +5919,7 @@ var require_curve = __commonJS((exports) => {
       nByteLength: "isSafeInteger"
     });
     return Object.freeze({
-      ...(0, modular_js_1.nLength)(curve.n, curve.nBitLength),
+      ...(0, modular_ts_1.nLength)(curve.n, curve.nBitLength),
       ...curve,
       ...{ p: curve.Fp.ORDER }
     });
@@ -5728,18 +5931,17 @@ var require_edwards = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.twistedEdwards = twistedEdwards;
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-  var curve_js_1 = require_curve();
-  var modular_js_1 = require_modular();
-  var ut = require_utils5();
-  var utils_js_1 = require_utils5();
+  var curve_ts_1 = require_curve();
+  var modular_ts_1 = require_modular();
+  var utils_ts_1 = require_utils5();
   var _0n = BigInt(0);
   var _1n = BigInt(1);
   var _2n = BigInt(2);
   var _8n = BigInt(8);
   var VERIFY_DEFAULT = { zip215: true };
   function validateOpts(curve) {
-    const opts = (0, curve_js_1.validateBasic)(curve);
-    ut.validateObject(curve, {
+    const opts = (0, curve_ts_1.validateBasic)(curve);
+    (0, utils_ts_1.validateObject)(curve, {
       hash: "function",
       a: "bigint",
       d: "bigint",
@@ -5757,7 +5959,7 @@ var require_edwards = __commonJS((exports) => {
     const { Fp, n: CURVE_ORDER, prehash, hash: cHash, randomBytes, nByteLength, h: cofactor } = CURVE;
     const MASK = _2n << BigInt(nByteLength * 8) - _1n;
     const modP = Fp.create;
-    const Fn = (0, modular_js_1.Field)(CURVE.n, CURVE.nBitLength);
+    const Fn = (0, modular_ts_1.Field)(CURVE.n, CURVE.nBitLength);
     const uvRatio = CURVE.uvRatio || ((u, v) => {
       try {
         return { isValid: true, value: Fp.sqrt(u * Fp.inv(v)) };
@@ -5767,19 +5969,20 @@ var require_edwards = __commonJS((exports) => {
     });
     const adjustScalarBytes = CURVE.adjustScalarBytes || ((bytes) => bytes);
     const domain = CURVE.domain || ((data, ctx, phflag) => {
-      (0, utils_js_1.abool)("phflag", phflag);
+      (0, utils_ts_1.abool)("phflag", phflag);
       if (ctx.length || phflag)
         throw new Error("Contexts/pre-hash are not supported");
       return data;
     });
-    function aCoordinate(title, n) {
-      ut.aInRange("coordinate " + title, n, _0n, MASK);
+    function aCoordinate(title, n, banZero = false) {
+      const min = banZero ? _1n : _0n;
+      (0, utils_ts_1.aInRange)("coordinate " + title, n, min, MASK);
     }
-    function assertPoint(other) {
+    function aextpoint(other) {
       if (!(other instanceof Point))
         throw new Error("ExtendedPoint expected");
     }
-    const toAffineMemo = (0, utils_js_1.memoized)((p, iz) => {
+    const toAffineMemo = (0, utils_ts_1.memoized)((p, iz) => {
       const { ex: x, ey: y, ez: z2 } = p;
       const is0 = p.is0();
       if (iz == null)
@@ -5793,7 +5996,7 @@ var require_edwards = __commonJS((exports) => {
         throw new Error("invZ was invalid");
       return { x: ax, y: ay };
     });
-    const assertValidMemo = (0, utils_js_1.memoized)((p) => {
+    const assertValidMemo = (0, utils_ts_1.memoized)((p) => {
       const { a, d } = CURVE;
       if (p.is0())
         throw new Error("bad point: ZERO");
@@ -5816,14 +6019,14 @@ var require_edwards = __commonJS((exports) => {
 
     class Point {
       constructor(ex, ey, ez, et) {
+        aCoordinate("x", ex);
+        aCoordinate("y", ey);
+        aCoordinate("z", ez, true);
+        aCoordinate("t", et);
         this.ex = ex;
         this.ey = ey;
         this.ez = ez;
         this.et = et;
-        aCoordinate("x", ex);
-        aCoordinate("y", ey);
-        aCoordinate("z", ez);
-        aCoordinate("t", et);
         Object.freeze(this);
       }
       get x() {
@@ -5845,7 +6048,7 @@ var require_edwards = __commonJS((exports) => {
         return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
       }
       static msm(points, scalars) {
-        return (0, curve_js_1.pippenger)(Point, Fn, points, scalars);
+        return (0, curve_ts_1.pippenger)(Point, Fn, points, scalars);
       }
       _setWindowSize(windowSize) {
         wnaf.setWindowSize(this, windowSize);
@@ -5854,7 +6057,7 @@ var require_edwards = __commonJS((exports) => {
         assertValidMemo(this);
       }
       equals(other) {
-        assertPoint(other);
+        aextpoint(other);
         const { ex: X1, ey: Y1, ez: Z1 } = this;
         const { ex: X2, ey: Y2, ez: Z2 } = other;
         const X1Z2 = modP(X1 * Z2);
@@ -5888,27 +6091,10 @@ var require_edwards = __commonJS((exports) => {
         return new Point(X3, Y3, Z3, T3);
       }
       add(other) {
-        assertPoint(other);
+        aextpoint(other);
         const { a, d } = CURVE;
         const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this;
         const { ex: X2, ey: Y2, ez: Z2, et: T2 } = other;
-        if (a === BigInt(-1)) {
-          const A2 = modP((Y1 - X1) * (Y2 + X2));
-          const B2 = modP((Y1 + X1) * (Y2 - X2));
-          const F2 = modP(B2 - A2);
-          if (F2 === _0n)
-            return this.double();
-          const C2 = modP(Z1 * _2n * T2);
-          const D2 = modP(T1 * _2n * Z2);
-          const E2 = D2 + C2;
-          const G3 = B2 + A2;
-          const H2 = D2 - C2;
-          const X32 = modP(E2 * F2);
-          const Y32 = modP(G3 * H2);
-          const T32 = modP(E2 * H2);
-          const Z32 = modP(F2 * G3);
-          return new Point(X32, Y32, Z32, T32);
-        }
         const A = modP(X1 * X2);
         const B = modP(Y1 * Y2);
         const C = modP(T1 * d * T2);
@@ -5931,13 +6117,13 @@ var require_edwards = __commonJS((exports) => {
       }
       multiply(scalar) {
         const n = scalar;
-        ut.aInRange("scalar", n, _1n, CURVE_ORDER);
+        (0, utils_ts_1.aInRange)("scalar", n, _1n, CURVE_ORDER);
         const { p, f } = this.wNAF(n);
         return Point.normalizeZ([p, f])[0];
       }
       multiplyUnsafe(scalar, acc = Point.ZERO) {
         const n = scalar;
-        ut.aInRange("scalar", n, _0n, CURVE_ORDER);
+        (0, utils_ts_1.aInRange)("scalar", n, _0n, CURVE_ORDER);
         if (n === _0n)
           return I;
         if (this.is0() || n === _1n)
@@ -5962,14 +6148,14 @@ var require_edwards = __commonJS((exports) => {
       static fromHex(hex, zip215 = false) {
         const { d, a } = CURVE;
         const len = Fp.BYTES;
-        hex = (0, utils_js_1.ensureBytes)("pointHex", hex, len);
-        (0, utils_js_1.abool)("zip215", zip215);
+        hex = (0, utils_ts_1.ensureBytes)("pointHex", hex, len);
+        (0, utils_ts_1.abool)("zip215", zip215);
         const normed = hex.slice();
         const lastByte = hex[len - 1];
         normed[len - 1] = lastByte & ~128;
-        const y = ut.bytesToNumberLE(normed);
+        const y = (0, utils_ts_1.bytesToNumberLE)(normed);
         const max = zip215 ? MASK : Fp.ORDER;
-        ut.aInRange("pointHex.y", y, _0n, max);
+        (0, utils_ts_1.aInRange)("pointHex.y", y, _0n, max);
         const y2 = modP(y * y);
         const u = modP(y2 - _1n);
         const v = modP(d * y2 - a);
@@ -5985,35 +6171,40 @@ var require_edwards = __commonJS((exports) => {
         return Point.fromAffine({ x, y });
       }
       static fromPrivateKey(privKey) {
-        return getExtendedPublicKey(privKey).point;
+        const { scalar } = getPrivateScalar(privKey);
+        return G.multiply(scalar);
       }
       toRawBytes() {
         const { x, y } = this.toAffine();
-        const bytes = ut.numberToBytesLE(y, Fp.BYTES);
+        const bytes = (0, utils_ts_1.numberToBytesLE)(y, Fp.BYTES);
         bytes[bytes.length - 1] |= x & _1n ? 128 : 0;
         return bytes;
       }
       toHex() {
-        return ut.bytesToHex(this.toRawBytes());
+        return (0, utils_ts_1.bytesToHex)(this.toRawBytes());
       }
     }
     Point.BASE = new Point(CURVE.Gx, CURVE.Gy, _1n, modP(CURVE.Gx * CURVE.Gy));
     Point.ZERO = new Point(_0n, _1n, _1n, _0n);
     const { BASE: G, ZERO: I } = Point;
-    const wnaf = (0, curve_js_1.wNAF)(Point, nByteLength * 8);
+    const wnaf = (0, curve_ts_1.wNAF)(Point, nByteLength * 8);
     function modN(a) {
-      return (0, modular_js_1.mod)(a, CURVE_ORDER);
+      return (0, modular_ts_1.mod)(a, CURVE_ORDER);
     }
     function modN_LE(hash) {
-      return modN(ut.bytesToNumberLE(hash));
+      return modN((0, utils_ts_1.bytesToNumberLE)(hash));
     }
-    function getExtendedPublicKey(key) {
+    function getPrivateScalar(key) {
       const len = Fp.BYTES;
-      key = (0, utils_js_1.ensureBytes)("private key", key, len);
-      const hashed = (0, utils_js_1.ensureBytes)("hashed private key", cHash(key), 2 * len);
+      key = (0, utils_ts_1.ensureBytes)("private key", key, len);
+      const hashed = (0, utils_ts_1.ensureBytes)("hashed private key", cHash(key), 2 * len);
       const head = adjustScalarBytes(hashed.slice(0, len));
       const prefix = hashed.slice(len, 2 * len);
       const scalar = modN_LE(head);
+      return { head, prefix, scalar };
+    }
+    function getExtendedPublicKey(key) {
+      const { head, prefix, scalar } = getPrivateScalar(key);
       const point = G.multiply(scalar);
       const pointBytes = point.toRawBytes();
       return { head, prefix, scalar, point, pointBytes };
@@ -6022,11 +6213,11 @@ var require_edwards = __commonJS((exports) => {
       return getExtendedPublicKey(privKey).pointBytes;
     }
     function hashDomainToScalar(context = new Uint8Array, ...msgs) {
-      const msg = ut.concatBytes(...msgs);
-      return modN_LE(cHash(domain(msg, (0, utils_js_1.ensureBytes)("context", context), !!prehash)));
+      const msg = (0, utils_ts_1.concatBytes)(...msgs);
+      return modN_LE(cHash(domain(msg, (0, utils_ts_1.ensureBytes)("context", context), !!prehash)));
     }
     function sign(msg, privKey, options = {}) {
-      msg = (0, utils_js_1.ensureBytes)("message", msg);
+      msg = (0, utils_ts_1.ensureBytes)("message", msg);
       if (prehash)
         msg = prehash(msg);
       const { prefix, scalar, pointBytes } = getExtendedPublicKey(privKey);
@@ -6034,22 +6225,22 @@ var require_edwards = __commonJS((exports) => {
       const R = G.multiply(r).toRawBytes();
       const k = hashDomainToScalar(options.context, R, pointBytes, msg);
       const s = modN(r + k * scalar);
-      ut.aInRange("signature.s", s, _0n, CURVE_ORDER);
-      const res = ut.concatBytes(R, ut.numberToBytesLE(s, Fp.BYTES));
-      return (0, utils_js_1.ensureBytes)("result", res, Fp.BYTES * 2);
+      (0, utils_ts_1.aInRange)("signature.s", s, _0n, CURVE_ORDER);
+      const res = (0, utils_ts_1.concatBytes)(R, (0, utils_ts_1.numberToBytesLE)(s, Fp.BYTES));
+      return (0, utils_ts_1.ensureBytes)("result", res, Fp.BYTES * 2);
     }
     const verifyOpts = VERIFY_DEFAULT;
     function verify(sig, msg, publicKey, options = verifyOpts) {
       const { context, zip215 } = options;
       const len = Fp.BYTES;
-      sig = (0, utils_js_1.ensureBytes)("signature", sig, 2 * len);
-      msg = (0, utils_js_1.ensureBytes)("message", msg);
-      publicKey = (0, utils_js_1.ensureBytes)("publicKey", publicKey, len);
+      sig = (0, utils_ts_1.ensureBytes)("signature", sig, 2 * len);
+      msg = (0, utils_ts_1.ensureBytes)("message", msg);
+      publicKey = (0, utils_ts_1.ensureBytes)("publicKey", publicKey, len);
       if (zip215 !== undefined)
-        (0, utils_js_1.abool)("zip215", zip215);
+        (0, utils_ts_1.abool)("zip215", zip215);
       if (prehash)
         msg = prehash(msg);
-      const s = ut.bytesToNumberLE(sig.slice(len, 2 * len));
+      const s = (0, utils_ts_1.bytesToNumberLE)(sig.slice(len, 2 * len));
       let A, R, SB;
       try {
         A = Point.fromHex(publicKey, zip215);
@@ -6093,9 +6284,9 @@ var require_hash_to_curve = __commonJS((exports) => {
   exports.hash_to_field = hash_to_field;
   exports.isogenyMap = isogenyMap;
   exports.createHasher = createHasher;
-  var modular_js_1 = require_modular();
-  var utils_js_1 = require_utils5();
-  var os2ip = utils_js_1.bytesToNumberBE;
+  var modular_ts_1 = require_modular();
+  var utils_ts_1 = require_utils5();
+  var os2ip = utils_ts_1.bytesToNumberBE;
   function i2osp(value, length) {
     anum(value);
     anum(length);
@@ -6120,42 +6311,42 @@ var require_hash_to_curve = __commonJS((exports) => {
       throw new Error("number expected");
   }
   function expand_message_xmd(msg, DST, lenInBytes, H) {
-    (0, utils_js_1.abytes)(msg);
-    (0, utils_js_1.abytes)(DST);
+    (0, utils_ts_1.abytes)(msg);
+    (0, utils_ts_1.abytes)(DST);
     anum(lenInBytes);
     if (DST.length > 255)
-      DST = H((0, utils_js_1.concatBytes)((0, utils_js_1.utf8ToBytes)("H2C-OVERSIZE-DST-"), DST));
+      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_js_1.concatBytes)(DST, i2osp(DST.length, 1));
+    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_js_1.concatBytes)(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
-    b[0] = H((0, utils_js_1.concatBytes)(b_0, i2osp(1, 1), DST_prime));
+    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_js_1.concatBytes)(...args));
+      b[i] = H((0, utils_ts_1.concatBytes)(...args));
     }
-    const pseudo_random_bytes = (0, utils_js_1.concatBytes)(...b);
+    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_js_1.abytes)(msg);
-    (0, utils_js_1.abytes)(DST);
+    (0, utils_ts_1.abytes)(msg);
+    (0, utils_ts_1.abytes)(DST);
     anum(lenInBytes);
     if (DST.length > 255) {
       const dkLen = Math.ceil(2 * k / 8);
-      DST = H.create({ dkLen }).update((0, utils_js_1.utf8ToBytes)("H2C-OVERSIZE-DST-")).update(DST).digest();
+      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_js_1.validateObject)(options, {
+    (0, utils_ts_1.validateObject)(options, {
       DST: "stringOrUint8Array",
       p: "bigint",
       m: "isSafeInteger",
@@ -6163,9 +6354,9 @@ var require_hash_to_curve = __commonJS((exports) => {
       hash: "hash"
     });
     const { p, k, m, hash, expand, DST: _DST } = options;
-    (0, utils_js_1.abytes)(msg);
+    (0, utils_ts_1.abytes)(msg);
     anum(count);
-    const DST = typeof _DST === "string" ? (0, utils_js_1.utf8ToBytes)(_DST) : _DST;
+    const DST = typeof _DST === "string" ? (0, utils_ts_1.utf8ToBytes)(_DST) : _DST;
     const log2p = p.toString(2).length;
     const L = Math.ceil((log2p + k) / 8);
     const len_in_bytes = count * m * L;
@@ -6185,7 +6376,7 @@ var require_hash_to_curve = __commonJS((exports) => {
       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_js_1.mod)(os2ip(tv), p);
+        e[j] = (0, modular_ts_1.mod)(os2ip(tv), p);
       }
       u[i] = e;
     }
@@ -6195,6 +6386,8 @@ var require_hash_to_curve = __commonJS((exports) => {
     const COEFF = map.map((i) => Array.from(i).reverse());
     return (x, y) => {
       const [xNum, xDen, yNum, yDen] = COEFF.map((val) => val.reduce((acc, i) => field.add(field.mul(acc, x), i)));
+      if (field.is0(xDen) || field.is0(yDen))
+        throw new Error("bad point: ZERO");
       x = field.div(xNum, xDen);
       y = field.mul(y, field.div(yNum, yDen));
       return { x, y };
@@ -6237,12 +6430,12 @@ var require_montgomery = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.montgomery = montgomery;
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-  var modular_js_1 = require_modular();
-  var utils_js_1 = require_utils5();
+  var modular_ts_1 = require_modular();
+  var utils_ts_1 = require_utils5();
   var _0n = BigInt(0);
   var _1n = BigInt(1);
   function validateOpts(curve) {
-    (0, utils_js_1.validateObject)(curve, {
+    (0, utils_ts_1.validateObject)(curve, {
       a: "bigint"
     }, {
       montgomeryBits: "isSafeInteger",
@@ -6257,12 +6450,12 @@ var require_montgomery = __commonJS((exports) => {
   function montgomery(curveDef) {
     const CURVE = validateOpts(curveDef);
     const { P } = CURVE;
-    const modP = (n) => (0, modular_js_1.mod)(n, P);
+    const modP = (n) => (0, modular_ts_1.mod)(n, P);
     const montgomeryBits = CURVE.montgomeryBits;
     const montgomeryBytes = Math.ceil(montgomeryBits / 8);
     const fieldLen = CURVE.nByteLength;
     const adjustScalarBytes = CURVE.adjustScalarBytes || ((bytes) => bytes);
-    const powPminus2 = CURVE.powPminus2 || ((x) => (0, modular_js_1.pow)(x, P - BigInt(2), P));
+    const powPminus2 = CURVE.powPminus2 || ((x) => (0, modular_ts_1.pow)(x, P - BigInt(2), P));
     function cswap(swap, x_2, x_3) {
       const dummy = modP(swap * (x_2 - x_3));
       x_2 = modP(x_2 - dummy);
@@ -6271,8 +6464,8 @@ var require_montgomery = __commonJS((exports) => {
     }
     const a24 = (CURVE.a - BigInt(2)) / BigInt(4);
     function montgomeryLadder(u, scalar) {
-      (0, utils_js_1.aInRange)("u", u, _0n, P);
-      (0, utils_js_1.aInRange)("scalar", scalar, _0n, P);
+      (0, utils_ts_1.aInRange)("u", u, _0n, P);
+      (0, utils_ts_1.aInRange)("scalar", scalar, _0n, P);
       const k = scalar;
       const x_1 = u;
       let x_2 = _1n;
@@ -6317,22 +6510,22 @@ var require_montgomery = __commonJS((exports) => {
       return modP(x_2 * z2);
     }
     function encodeUCoordinate(u) {
-      return (0, utils_js_1.numberToBytesLE)(modP(u), montgomeryBytes);
+      return (0, utils_ts_1.numberToBytesLE)(modP(u), montgomeryBytes);
     }
     function decodeUCoordinate(uEnc) {
-      const u = (0, utils_js_1.ensureBytes)("u coordinate", uEnc, montgomeryBytes);
+      const u = (0, utils_ts_1.ensureBytes)("u coordinate", uEnc, montgomeryBytes);
       if (fieldLen === 32)
         u[31] &= 127;
-      return (0, utils_js_1.bytesToNumberLE)(u);
+      return (0, utils_ts_1.bytesToNumberLE)(u);
     }
     function decodeScalar(n) {
-      const bytes = (0, utils_js_1.ensureBytes)("scalar", n);
+      const bytes = (0, utils_ts_1.ensureBytes)("scalar", n);
       const len = bytes.length;
       if (len !== montgomeryBytes && len !== fieldLen) {
         let valid = "" + montgomeryBytes + " or " + fieldLen;
         throw new Error("invalid scalar, expected " + valid + " bytes, got " + len);
       }
-      return (0, utils_js_1.bytesToNumberLE)(adjustScalarBytes(bytes));
+      return (0, utils_ts_1.bytesToNumberLE)(adjustScalarBytes(bytes));
     }
     function scalarMult(scalar, u) {
       const pointU = decodeUCoordinate(u);
@@ -6364,14 +6557,14 @@ var require_ed25519 = __commonJS((exports) => {
   exports.edwardsToMontgomeryPub = edwardsToMontgomeryPub;
   exports.edwardsToMontgomeryPriv = edwardsToMontgomeryPriv;
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-  var sha512_1 = require_sha512();
+  var sha2_1 = require_sha2();
   var utils_1 = require_utils4();
-  var curve_js_1 = require_curve();
-  var edwards_js_1 = require_edwards();
-  var hash_to_curve_js_1 = require_hash_to_curve();
-  var modular_js_1 = require_modular();
-  var montgomery_js_1 = require_montgomery();
-  var utils_js_1 = require_utils5();
+  var curve_ts_1 = require_curve();
+  var edwards_ts_1 = require_edwards();
+  var hash_to_curve_ts_1 = require_hash_to_curve();
+  var modular_ts_1 = require_modular();
+  var montgomery_ts_1 = require_montgomery();
+  var utils_ts_1 = require_utils5();
   var ED25519_P = BigInt("57896044618658097711785492504343953926634992332820282019728792003956564819949");
   var ED25519_SQRT_M1 = /* @__PURE__ */ BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752");
   var _0n = BigInt(0);
@@ -6385,16 +6578,16 @@ var require_ed25519 = __commonJS((exports) => {
     const P = ED25519_P;
     const x2 = x * x % P;
     const b2 = x2 * x % P;
-    const b4 = (0, modular_js_1.pow2)(b2, _2n, P) * b2 % P;
-    const b5 = (0, modular_js_1.pow2)(b4, _1n, P) * x % P;
-    const b10 = (0, modular_js_1.pow2)(b5, _5n, P) * b5 % P;
-    const b20 = (0, modular_js_1.pow2)(b10, _10n, P) * b10 % P;
-    const b40 = (0, modular_js_1.pow2)(b20, _20n, P) * b20 % P;
-    const b80 = (0, modular_js_1.pow2)(b40, _40n, P) * b40 % P;
-    const b160 = (0, modular_js_1.pow2)(b80, _80n, P) * b80 % P;
-    const b240 = (0, modular_js_1.pow2)(b160, _80n, P) * b80 % P;
-    const b250 = (0, modular_js_1.pow2)(b240, _10n, P) * b10 % P;
-    const pow_p_5_8 = (0, modular_js_1.pow2)(b250, _2n, P) * x % P;
+    const b4 = (0, modular_ts_1.pow2)(b2, _2n, P) * b2 % P;
+    const b5 = (0, modular_ts_1.pow2)(b4, _1n, P) * x % P;
+    const b10 = (0, modular_ts_1.pow2)(b5, _5n, P) * b5 % P;
+    const b20 = (0, modular_ts_1.pow2)(b10, _10n, P) * b10 % P;
+    const b40 = (0, modular_ts_1.pow2)(b20, _20n, P) * b20 % P;
+    const b80 = (0, modular_ts_1.pow2)(b40, _40n, P) * b40 % P;
+    const b160 = (0, modular_ts_1.pow2)(b80, _80n, P) * b80 % P;
+    const b240 = (0, modular_ts_1.pow2)(b160, _80n, P) * b80 % P;
+    const b250 = (0, modular_ts_1.pow2)(b240, _10n, P) * b10 % P;
+    const pow_p_5_8 = (0, modular_ts_1.pow2)(b250, _2n, P) * x % P;
     return { pow_p_5_8, b2 };
   }
   function adjustScalarBytes(bytes) {
@@ -6405,22 +6598,22 @@ var require_ed25519 = __commonJS((exports) => {
   }
   function uvRatio(u, v) {
     const P = ED25519_P;
-    const v3 = (0, modular_js_1.mod)(v * v * v, P);
-    const v7 = (0, modular_js_1.mod)(v3 * v3 * v, P);
+    const v3 = (0, modular_ts_1.mod)(v * v * v, P);
+    const v7 = (0, modular_ts_1.mod)(v3 * v3 * v, P);
     const pow = ed25519_pow_2_252_3(u * v7).pow_p_5_8;
-    let x = (0, modular_js_1.mod)(u * v3 * pow, P);
-    const vx2 = (0, modular_js_1.mod)(v * x * x, P);
+    let x = (0, modular_ts_1.mod)(u * v3 * pow, P);
+    const vx2 = (0, modular_ts_1.mod)(v * x * x, P);
     const root1 = x;
-    const root2 = (0, modular_js_1.mod)(x * ED25519_SQRT_M1, P);
+    const root2 = (0, modular_ts_1.mod)(x * ED25519_SQRT_M1, P);
     const useRoot1 = vx2 === u;
-    const useRoot2 = vx2 === (0, modular_js_1.mod)(-u, P);
-    const noRoot = vx2 === (0, modular_js_1.mod)(-u * ED25519_SQRT_M1, P);
+    const useRoot2 = vx2 === (0, modular_ts_1.mod)(-u, P);
+    const noRoot = vx2 === (0, modular_ts_1.mod)(-u * ED25519_SQRT_M1, P);
     if (useRoot1)
       x = root1;
     if (useRoot2 || noRoot)
       x = root2;
-    if ((0, modular_js_1.isNegativeLE)(x, P))
-      x = (0, modular_js_1.mod)(-x, P);
+    if ((0, modular_ts_1.isNegativeLE)(x, P))
+      x = (0, modular_ts_1.mod)(-x, P);
     return { isValid: useRoot1 || useRoot2, value: x };
   }
   exports.ED25519_TORSION_SUBGROUP = [
@@ -6433,35 +6626,35 @@ var require_ed25519 = __commonJS((exports) => {
     "0000000000000000000000000000000000000000000000000000000000000000",
     "c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac03fa"
   ];
-  var Fp = /* @__PURE__ */ (() => (0, modular_js_1.Field)(ED25519_P, undefined, true))();
+  var Fp = /* @__PURE__ */ (() => (0, modular_ts_1.Field)(ED25519_P, undefined, true))();
   var ed25519Defaults = /* @__PURE__ */ (() => ({
-    a: BigInt(-1),
+    a: Fp.create(BigInt(-1)),
     d: BigInt("37095705934669439343138083508754565189542113879843219016388785533085940283555"),
     Fp,
     n: BigInt("7237005577332262213973186563042994240857116359379907606001950938285454250989"),
     h: _8n,
     Gx: BigInt("15112221349535400772501151409588531511454012693041857206046113283949847762202"),
     Gy: BigInt("46316835694926478169428394003475163141307993866256225615783033603165251855960"),
-    hash: sha512_1.sha512,
+    hash: sha2_1.sha512,
     randomBytes: utils_1.randomBytes,
     adjustScalarBytes,
     uvRatio
   }))();
-  exports.ed25519 = (() => (0, edwards_js_1.twistedEdwards)(ed25519Defaults))();
+  exports.ed25519 = (() => (0, edwards_ts_1.twistedEdwards)(ed25519Defaults))();
   function ed25519_domain(data, ctx, phflag) {
     if (ctx.length > 255)
       throw new Error("Context is too big");
     return (0, utils_1.concatBytes)((0, utils_1.utf8ToBytes)("SigEd25519 no Ed25519 collisions"), new Uint8Array([phflag ? 1 : 0, ctx.length]), ctx, data);
   }
-  exports.ed25519ctx = (() => (0, edwards_js_1.twistedEdwards)({
+  exports.ed25519ctx = (() => (0, edwards_ts_1.twistedEdwards)({
     ...ed25519Defaults,
     domain: ed25519_domain
   }))();
-  exports.ed25519ph = (() => (0, edwards_js_1.twistedEdwards)(Object.assign({}, ed25519Defaults, {
+  exports.ed25519ph = (() => (0, edwards_ts_1.twistedEdwards)(Object.assign({}, ed25519Defaults, {
     domain: ed25519_domain,
-    prehash: sha512_1.sha512
+    prehash: sha2_1.sha512
   })))();
-  exports.x25519 = (() => (0, montgomery_js_1.montgomery)({
+  exports.x25519 = (() => (0, montgomery_ts_1.montgomery)({
     P: ED25519_P,
     a: BigInt(486662),
     montgomeryBits: 255,
@@ -6470,7 +6663,7 @@ var require_ed25519 = __commonJS((exports) => {
     powPminus2: (x) => {
       const P = ED25519_P;
       const { pow_p_5_8, b2 } = ed25519_pow_2_252_3(x);
-      return (0, modular_js_1.mod)((0, modular_js_1.pow2)(pow_p_5_8, _3n, P) * b2, P);
+      return (0, modular_ts_1.mod)((0, modular_ts_1.pow2)(pow_p_5_8, _3n, P) * b2, P);
     },
     adjustScalarBytes,
     randomBytes: utils_1.randomBytes
@@ -6531,7 +6724,7 @@ var require_ed25519 = __commonJS((exports) => {
     y = Fp.cmov(y, Fp.neg(y), e3 !== e4);
     return { xMn: xn, xMd: xd, yMn: y, yMd: _1n };
   }
-  var ELL2_C1_EDWARDS = /* @__PURE__ */ (() => (0, modular_js_1.FpSqrtEven)(Fp, Fp.neg(BigInt(486664))))();
+  var ELL2_C1_EDWARDS = /* @__PURE__ */ (() => (0, modular_ts_1.FpSqrtEven)(Fp, Fp.neg(BigInt(486664))))();
   function map_to_curve_elligator2_edwards25519(u) {
     const { xMn, xMd, yMn, yMd } = map_to_curve_elligator2_curve25519(u);
     let xn = Fp.mul(xMn, yMd);
@@ -6548,18 +6741,18 @@ var require_ed25519 = __commonJS((exports) => {
     const inv = Fp.invertBatch([xd, yd]);
     return { x: Fp.mul(xn, inv[0]), y: Fp.mul(yn, inv[1]) };
   }
-  var htf = /* @__PURE__ */ (() => (0, hash_to_curve_js_1.createHasher)(exports.ed25519.ExtendedPoint, (scalars) => map_to_curve_elligator2_edwards25519(scalars[0]), {
+  var htf = /* @__PURE__ */ (() => (0, hash_to_curve_ts_1.createHasher)(exports.ed25519.ExtendedPoint, (scalars) => map_to_curve_elligator2_edwards25519(scalars[0]), {
     DST: "edwards25519_XMD:SHA-512_ELL2_RO_",
     encodeDST: "edwards25519_XMD:SHA-512_ELL2_NU_",
     p: Fp.ORDER,
     m: 1,
     k: 128,
     expand: "xmd",
-    hash: sha512_1.sha512
+    hash: sha2_1.sha512
   }))();
   exports.hashToCurve = (() => htf.hashToCurve)();
   exports.encodeToCurve = (() => htf.encodeToCurve)();
-  function assertRstPoint(other) {
+  function aristp(other) {
     if (!(other instanceof RistPoint))
       throw new Error("RistrettoPoint expected");
   }
@@ -6570,7 +6763,7 @@ var require_ed25519 = __commonJS((exports) => {
   var D_MINUS_ONE_SQ = /* @__PURE__ */ BigInt("40440834346308536858101042469323190826248399146238708352240133220865137265952");
   var invertSqrt = (number) => uvRatio(_1n, number);
   var MAX_255B = /* @__PURE__ */ BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-  var bytes255ToNumberLE = (bytes) => exports.ed25519.CURVE.Fp.create((0, utils_js_1.bytesToNumberLE)(bytes) & MAX_255B);
+  var bytes255ToNumberLE = (bytes) => exports.ed25519.CURVE.Fp.create((0, utils_ts_1.bytesToNumberLE)(bytes) & MAX_255B);
   function calcElligatorRistrettoMap(r0) {
     const { d } = exports.ed25519.CURVE;
     const P = exports.ed25519.CURVE.Fp.ORDER;
@@ -6581,7 +6774,7 @@ var require_ed25519 = __commonJS((exports) => {
     const D = mod((c - d * r) * mod(r + d));
     let { isValid: Ns_D_is_sq, value: s } = uvRatio(Ns, D);
     let s_ = mod(s * r0);
-    if (!(0, modular_js_1.isNegativeLE)(s_, P))
+    if (!(0, modular_ts_1.isNegativeLE)(s_, P))
       s_ = mod(-s_);
     if (!Ns_D_is_sq)
       s = s_;
@@ -6604,7 +6797,7 @@ var require_ed25519 = __commonJS((exports) => {
       return new RistPoint(exports.ed25519.ExtendedPoint.fromAffine(ap));
     }
     static hashToCurve(hex) {
-      hex = (0, utils_js_1.ensureBytes)("ristrettoHash", hex, 64);
+      hex = (0, utils_ts_1.ensureBytes)("ristrettoHash", hex, 64);
       const r1 = bytes255ToNumberLE(hex.slice(0, 32));
       const R1 = calcElligatorRistrettoMap(r1);
       const r2 = bytes255ToNumberLE(hex.slice(32, 64));
@@ -6612,13 +6805,13 @@ var require_ed25519 = __commonJS((exports) => {
       return new RistPoint(R1.add(R2));
     }
     static fromHex(hex) {
-      hex = (0, utils_js_1.ensureBytes)("ristrettoHex", hex, 32);
+      hex = (0, utils_ts_1.ensureBytes)("ristrettoHex", hex, 32);
       const { a, d } = exports.ed25519.CURVE;
       const P = exports.ed25519.CURVE.Fp.ORDER;
       const mod = exports.ed25519.CURVE.Fp.create;
       const emsg = "RistrettoPoint.fromHex: the hex is not valid encoding of RistrettoPoint";
       const s = bytes255ToNumberLE(hex);
-      if (!(0, utils_js_1.equalBytes)((0, utils_js_1.numberToBytesLE)(s, 32), hex) || (0, modular_js_1.isNegativeLE)(s, P))
+      if (!(0, utils_ts_1.equalBytes)((0, utils_ts_1.numberToBytesLE)(s, 32), hex) || (0, modular_ts_1.isNegativeLE)(s, P))
         throw new Error(emsg);
       const s2 = mod(s * s);
       const u1 = mod(_1n + a * s2);
@@ -6630,17 +6823,17 @@ var require_ed25519 = __commonJS((exports) => {
       const Dx = mod(I * u2);
       const Dy = mod(I * Dx * v);
       let x = mod((s + s) * Dx);
-      if ((0, modular_js_1.isNegativeLE)(x, P))
+      if ((0, modular_ts_1.isNegativeLE)(x, P))
         x = mod(-x);
       const y = mod(u1 * Dy);
       const t = mod(x * y);
-      if (!isValid2 || (0, modular_js_1.isNegativeLE)(t, P) || y === _0n)
+      if (!isValid2 || (0, modular_ts_1.isNegativeLE)(t, P) || y === _0n)
         throw new Error(emsg);
       return new RistPoint(new exports.ed25519.ExtendedPoint(x, y, _1n, t));
     }
     static msm(points, scalars) {
-      const Fn = (0, modular_js_1.Field)(exports.ed25519.CURVE.n, exports.ed25519.CURVE.nBitLength);
-      return (0, curve_js_1.pippenger)(RistPoint, Fn, points, scalars);
+      const Fn = (0, modular_ts_1.Field)(exports.ed25519.CURVE.n, exports.ed25519.CURVE.nBitLength);
+      return (0, curve_ts_1.pippenger)(RistPoint, Fn, points, scalars);
     }
     toRawBytes() {
       let { ex: x, ey: y, ez: z2, et: t } = this.ep;
@@ -6654,7 +6847,7 @@ var require_ed25519 = __commonJS((exports) => {
       const D2 = mod(invsqrt * u2);
       const zInv = mod(D1 * D2 * t);
       let D;
-      if ((0, modular_js_1.isNegativeLE)(t * zInv, P)) {
+      if ((0, modular_ts_1.isNegativeLE)(t * zInv, P)) {
         let _x = mod(y * SQRT_M1);
         let _y = mod(x * SQRT_M1);
         x = _x;
@@ -6663,21 +6856,21 @@ var require_ed25519 = __commonJS((exports) => {
       } else {
         D = D2;
       }
-      if ((0, modular_js_1.isNegativeLE)(x * zInv, P))
+      if ((0, modular_ts_1.isNegativeLE)(x * zInv, P))
         y = mod(-y);
       let s = mod((z2 - y) * D);
-      if ((0, modular_js_1.isNegativeLE)(s, P))
+      if ((0, modular_ts_1.isNegativeLE)(s, P))
         s = mod(-s);
-      return (0, utils_js_1.numberToBytesLE)(s, 32);
+      return (0, utils_ts_1.numberToBytesLE)(s, 32);
     }
     toHex() {
-      return (0, utils_js_1.bytesToHex)(this.toRawBytes());
+      return (0, utils_ts_1.bytesToHex)(this.toRawBytes());
     }
     toString() {
       return this.toHex();
     }
     equals(other) {
-      assertRstPoint(other);
+      aristp(other);
       const { ex: X1, ey: Y1 } = this.ep;
       const { ex: X2, ey: Y2 } = other.ep;
       const mod = exports.ed25519.CURVE.Fp.create;
@@ -6686,11 +6879,11 @@ var require_ed25519 = __commonJS((exports) => {
       return one || two;
     }
     add(other) {
-      assertRstPoint(other);
+      aristp(other);
       return new RistPoint(this.ep.add(other.ep));
     }
     subtract(other) {
-      assertRstPoint(other);
+      aristp(other);
       return new RistPoint(this.ep.subtract(other.ep));
     }
     multiply(scalar) {
@@ -6716,7 +6909,7 @@ var require_ed25519 = __commonJS((exports) => {
   var hashToRistretto255 = (msg, options) => {
     const d = options.DST;
     const DST = typeof d === "string" ? (0, utils_1.utf8ToBytes)(d) : d;
-    const uniform_bytes = (0, hash_to_curve_js_1.expand_message_xmd)(msg, DST, 64, sha512_1.sha512);
+    const uniform_bytes = (0, hash_to_curve_ts_1.expand_message_xmd)(msg, DST, 64, sha2_1.sha512);
     const P = RistPoint.hashToCurve(uniform_bytes);
     return P;
   };
@@ -6724,193 +6917,20 @@ var require_ed25519 = __commonJS((exports) => {
   exports.hash_to_ristretto255 = exports.hashToRistretto255;
 });
 
-// ../../node_modules/@noble/hashes/sha256.js
-var require_sha256 = __commonJS((exports) => {
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.sha224 = exports.sha256 = exports.SHA256 = undefined;
-  var _md_js_1 = require__md();
-  var utils_js_1 = require_utils4();
-  var SHA256_K = /* @__PURE__ */ new Uint32Array([
-    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_IV = /* @__PURE__ */ new Uint32Array([
-    1779033703,
-    3144134277,
-    1013904242,
-    2773480762,
-    1359893119,
-    2600822924,
-    528734635,
-    1541459225
-  ]);
-  var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-
-  class SHA256 extends _md_js_1.HashMD {
-    constructor() {
-      super(64, 32, 8, false);
-      this.A = SHA256_IV[0] | 0;
-      this.B = SHA256_IV[1] | 0;
-      this.C = SHA256_IV[2] | 0;
-      this.D = SHA256_IV[3] | 0;
-      this.E = SHA256_IV[4] | 0;
-      this.F = SHA256_IV[5] | 0;
-      this.G = SHA256_IV[6] | 0;
-      this.H = SHA256_IV[7] | 0;
-    }
-    get() {
-      const { A, B, C, D, E, F, G, H } = this;
-      return [A, B, C, D, E, F, G, H];
-    }
-    set(A, B, C, D, E, F, G, H) {
-      this.A = A | 0;
-      this.B = B | 0;
-      this.C = C | 0;
-      this.D = D | 0;
-      this.E = E | 0;
-      this.F = F | 0;
-      this.G = G | 0;
-      this.H = H | 0;
-    }
-    process(view, offset) {
-      for (let i = 0;i < 16; i++, offset += 4)
-        SHA256_W[i] = view.getUint32(offset, false);
-      for (let i = 16;i < 64; i++) {
-        const W15 = SHA256_W[i - 15];
-        const W2 = SHA256_W[i - 2];
-        const s0 = (0, utils_js_1.rotr)(W15, 7) ^ (0, utils_js_1.rotr)(W15, 18) ^ W15 >>> 3;
-        const s1 = (0, utils_js_1.rotr)(W2, 17) ^ (0, utils_js_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_js_1.rotr)(E, 6) ^ (0, utils_js_1.rotr)(E, 11) ^ (0, utils_js_1.rotr)(E, 25);
-        const T1 = H + sigma1 + (0, _md_js_1.Chi)(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
-        const sigma0 = (0, utils_js_1.rotr)(A, 2) ^ (0, utils_js_1.rotr)(A, 13) ^ (0, utils_js_1.rotr)(A, 22);
-        const T2 = sigma0 + (0, _md_js_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() {
-      SHA256_W.fill(0);
-    }
-    destroy() {
-      this.set(0, 0, 0, 0, 0, 0, 0, 0);
-      this.buffer.fill(0);
-    }
-  }
-  exports.SHA256 = SHA256;
-
-  class SHA224 extends SHA256 {
-    constructor() {
-      super();
-      this.A = 3238371032 | 0;
-      this.B = 914150663 | 0;
-      this.C = 812702999 | 0;
-      this.D = 4144912697 | 0;
-      this.E = 4290775857 | 0;
-      this.F = 1750603025 | 0;
-      this.G = 1694076839 | 0;
-      this.H = 3204075428 | 0;
-      this.outputLen = 28;
-    }
-  }
-  exports.sha256 = (0, utils_js_1.wrapConstructor)(() => new SHA256);
-  exports.sha224 = (0, utils_js_1.wrapConstructor)(() => new SHA224);
-});
-
 // ../../node_modules/@noble/hashes/hmac.js
 var require_hmac = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.hmac = exports.HMAC = undefined;
-  var _assert_js_1 = require__assert2();
-  var utils_js_1 = require_utils4();
+  var _assert_ts_1 = require__assert2();
+  var utils_ts_1 = require_utils4();
 
-  class HMAC extends utils_js_1.Hash {
+  class HMAC extends utils_ts_1.Hash {
     constructor(hash, _key) {
       super();
       this.finished = false;
       this.destroyed = false;
-      (0, _assert_js_1.ahash)(hash);
-      const key = (0, utils_js_1.toBytes)(_key);
+      (0, _assert_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");
@@ -6929,13 +6949,13 @@ var require_hmac = __commonJS((exports) => {
       pad.fill(0);
     }
     update(buf) {
-      (0, _assert_js_1.aexists)(this);
+      (0, _assert_ts_1.aexists)(this);
       this.iHash.update(buf);
       return this;
     }
     digestInto(out) {
-      (0, _assert_js_1.aexists)(this);
-      (0, _assert_js_1.abytes)(out, this.outputLen);
+      (0, _assert_ts_1.aexists)(this);
+      (0, _assert_ts_1.abytes)(out, this.outputLen);
       this.finished = true;
       this.iHash.digestInto(out);
       this.oHash.update(out);
@@ -6980,19 +7000,18 @@ var require_weierstrass = __commonJS((exports) => {
   exports.SWUFpSqrtRatio = SWUFpSqrtRatio;
   exports.mapToCurveSimpleSWU = mapToCurveSimpleSWU;
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-  var curve_js_1 = require_curve();
-  var modular_js_1 = require_modular();
-  var ut = require_utils5();
-  var utils_js_1 = require_utils5();
+  var curve_ts_1 = require_curve();
+  var modular_ts_1 = require_modular();
+  var utils_ts_1 = require_utils5();
   function validateSigVerOpts(opts) {
     if (opts.lowS !== undefined)
-      (0, utils_js_1.abool)("lowS", opts.lowS);
+      (0, utils_ts_1.abool)("lowS", opts.lowS);
     if (opts.prehash !== undefined)
-      (0, utils_js_1.abool)("prehash", opts.prehash);
+      (0, utils_ts_1.abool)("prehash", opts.prehash);
   }
   function validatePointOpts(curve) {
-    const opts = (0, curve_js_1.validateBasic)(curve);
-    ut.validateObject(opts, {
+    const opts = (0, curve_ts_1.validateBasic)(curve);
+    (0, utils_ts_1.validateObject)(opts, {
       a: "field",
       b: "field"
     }, {
@@ -7015,7 +7034,6 @@ var require_weierstrass = __commonJS((exports) => {
     }
     return Object.freeze({ ...opts });
   }
-  var { bytesToNumberBE: b2n, hexToBytes: h2b } = ut;
 
   class DERErr extends Error {
     constructor(m = "") {
@@ -7033,11 +7051,11 @@ var require_weierstrass = __commonJS((exports) => {
         if (data.length & 1)
           throw new E("tlv.encode: unpadded data");
         const dataLen = data.length / 2;
-        const len = ut.numberToHexUnpadded(dataLen);
+        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 ? ut.numberToHexUnpadded(len.length / 2 | 128) : "";
-        const t = ut.numberToHexUnpadded(tag);
+        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;
       },
       decode(tag, data) {
@@ -7080,7 +7098,7 @@ var require_weierstrass = __commonJS((exports) => {
         const { Err: E } = exports.DER;
         if (num < _0n)
           throw new E("integer: negative integers are not allowed");
-        let hex = ut.numberToHexUnpadded(num);
+        let hex = (0, utils_ts_1.numberToHexUnpadded)(num);
         if (Number.parseInt(hex[0], 16) & 8)
           hex = "00" + hex;
         if (hex.length & 1)
@@ -7093,13 +7111,12 @@ var require_weierstrass = __commonJS((exports) => {
           throw new E("invalid signature integer: negative");
         if (data[0] === 0 && !(data[1] & 128))
           throw new E("invalid signature integer: unnecessary leading zero");
-        return b2n(data);
+        return (0, utils_ts_1.bytesToNumberBE)(data);
       }
     },
     toSig(hex) {
       const { Err: E, _int: int, _tlv: tlv } = exports.DER;
-      const data = typeof hex === "string" ? h2b(hex) : hex;
-      ut.abytes(data);
+      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");
@@ -7125,10 +7142,10 @@ var require_weierstrass = __commonJS((exports) => {
   function weierstrassPoints(opts) {
     const CURVE = validatePointOpts(opts);
     const { Fp } = CURVE;
-    const Fn = (0, modular_js_1.Field)(CURVE.n, CURVE.nBitLength);
+    const Fn = (0, modular_ts_1.Field)(CURVE.n, CURVE.nBitLength);
     const toBytes = CURVE.toBytes || ((_c, point, _isCompressed) => {
       const a = point.toAffine();
-      return ut.concatBytes(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
+      return (0, utils_ts_1.concatBytes)(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
     });
     const fromBytes = CURVE.fromBytes || ((bytes) => {
       const tail = bytes.subarray(1);
@@ -7145,33 +7162,33 @@ var require_weierstrass = __commonJS((exports) => {
     if (!Fp.eql(Fp.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))
       throw new Error("bad generator point: equation left != right");
     function isWithinCurveOrder(num) {
-      return ut.inRange(num, _1n, CURVE.n);
+      return (0, utils_ts_1.inRange)(num, _1n, CURVE.n);
     }
     function normPrivateKeyToScalar(key) {
       const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;
       if (lengths && typeof key !== "bigint") {
-        if (ut.isBytes(key))
-          key = ut.bytesToHex(key);
+        if ((0, utils_ts_1.isBytes)(key))
+          key = (0, utils_ts_1.bytesToHex)(key);
         if (typeof key !== "string" || !lengths.includes(key.length))
           throw new Error("invalid private key");
         key = key.padStart(nByteLength * 2, "0");
       }
       let num;
       try {
-        num = typeof key === "bigint" ? key : ut.bytesToNumberBE((0, utils_js_1.ensureBytes)("private key", key, nByteLength));
+        num = typeof key === "bigint" ? key : (0, utils_ts_1.bytesToNumberBE)((0, utils_ts_1.ensureBytes)("private key", key, nByteLength));
       } catch (error) {
         throw new Error("invalid private key, expected hex or " + nByteLength + " bytes, got " + typeof key);
       }
       if (wrapPrivateKey)
-        num = (0, modular_js_1.mod)(num, N);
-      ut.aInRange("private key", num, _1n, N);
+        num = (0, modular_ts_1.mod)(num, N);
+      (0, utils_ts_1.aInRange)("private key", num, _1n, N);
       return num;
     }
-    function assertPrjPoint(other) {
+    function aprjpoint(other) {
       if (!(other instanceof Point))
         throw new Error("ProjectivePoint expected");
     }
-    const toAffineMemo = (0, utils_js_1.memoized)((p, iz) => {
+    const toAffineMemo = (0, utils_ts_1.memoized)((p, iz) => {
       const { px: x, py: y, pz: z2 } = p;
       if (Fp.eql(z2, Fp.ONE))
         return { x, y };
@@ -7187,7 +7204,7 @@ var require_weierstrass = __commonJS((exports) => {
         throw new Error("invZ was invalid");
       return { x: ax, y: ay };
     });
-    const assertValidMemo = (0, utils_js_1.memoized)((p) => {
+    const assertValidMemo = (0, utils_ts_1.memoized)((p) => {
       if (p.is0()) {
         if (CURVE.allowInfinityPoint && !Fp.is0(p.py))
           return;
@@ -7207,15 +7224,15 @@ var require_weierstrass = __commonJS((exports) => {
 
     class Point {
       constructor(px, py, pz) {
-        this.px = px;
-        this.py = py;
-        this.pz = pz;
         if (px == null || !Fp.isValid(px))
           throw new Error("x required");
         if (py == null || !Fp.isValid(py))
           throw new Error("y required");
         if (pz == null || !Fp.isValid(pz))
           throw new Error("z required");
+        this.px = px;
+        this.py = py;
+        this.pz = pz;
         Object.freeze(this);
       }
       static fromAffine(p) {
@@ -7240,7 +7257,7 @@ var require_weierstrass = __commonJS((exports) => {
         return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
       }
       static fromHex(hex) {
-        const P = Point.fromAffine(fromBytes((0, utils_js_1.ensureBytes)("pointHex", hex)));
+        const P = Point.fromAffine(fromBytes((0, utils_ts_1.ensureBytes)("pointHex", hex)));
         P.assertValidity();
         return P;
       }
@@ -7248,7 +7265,7 @@ var require_weierstrass = __commonJS((exports) => {
         return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));
       }
       static msm(points, scalars) {
-        return (0, curve_js_1.pippenger)(Point, Fn, points, scalars);
+        return (0, curve_ts_1.pippenger)(Point, Fn, points, scalars);
       }
       _setWindowSize(windowSize) {
         wnaf.setWindowSize(this, windowSize);
@@ -7263,7 +7280,7 @@ var require_weierstrass = __commonJS((exports) => {
         throw new Error("Field doesn't support isOdd");
       }
       equals(other) {
-        assertPrjPoint(other);
+        aprjpoint(other);
         const { px: X1, py: Y1, pz: Z1 } = this;
         const { px: X2, py: Y2, pz: Z2 } = other;
         const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));
@@ -7312,7 +7329,7 @@ var require_weierstrass = __commonJS((exports) => {
         return new Point(X3, Y3, Z3);
       }
       add(other) {
-        assertPrjPoint(other);
+        aprjpoint(other);
         const { px: X1, py: Y1, pz: Z1 } = this;
         const { px: X2, py: Y2, pz: Z2 } = other;
         let { ZERO: X3, ZERO: Y3, ZERO: Z3 } = Fp;
@@ -7371,7 +7388,7 @@ var require_weierstrass = __commonJS((exports) => {
       }
       multiplyUnsafe(sc) {
         const { endo, n: N } = CURVE;
-        ut.aInRange("scalar", sc, _0n, N);
+        (0, utils_ts_1.aInRange)("scalar", sc, _0n, N);
         const I = Point.ZERO;
         if (sc === _0n)
           return I;
@@ -7401,7 +7418,7 @@ var require_weierstrass = __commonJS((exports) => {
       }
       multiply(scalar) {
         const { endo, n: N } = CURVE;
-        ut.aInRange("scalar", scalar, _1n, N);
+        (0, utils_ts_1.aInRange)("scalar", scalar, _1n, N);
         let point, fake;
         if (endo) {
           const { k1neg, k1, k2neg, k2 } = endo.splitScalar(scalar);
@@ -7445,19 +7462,19 @@ var require_weierstrass = __commonJS((exports) => {
         return this.multiplyUnsafe(CURVE.h);
       }
       toRawBytes(isCompressed = true) {
-        (0, utils_js_1.abool)("isCompressed", isCompressed);
+        (0, utils_ts_1.abool)("isCompressed", isCompressed);
         this.assertValidity();
         return toBytes(Point, this, isCompressed);
       }
       toHex(isCompressed = true) {
-        (0, utils_js_1.abool)("isCompressed", isCompressed);
-        return ut.bytesToHex(this.toRawBytes(isCompressed));
+        (0, utils_ts_1.abool)("isCompressed", isCompressed);
+        return (0, utils_ts_1.bytesToHex)(this.toRawBytes(isCompressed));
       }
     }
     Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);
     Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
     const _bits = CURVE.nBitLength;
-    const wnaf = (0, curve_js_1.wNAF)(Point, CURVE.endo ? Math.ceil(_bits / 2) : _bits);
+    const wnaf = (0, curve_ts_1.wNAF)(Point, CURVE.endo ? Math.ceil(_bits / 2) : _bits);
     return {
       CURVE,
       ProjectivePoint: Point,
@@ -7467,8 +7484,8 @@ var require_weierstrass = __commonJS((exports) => {
     };
   }
   function validateOpts(curve) {
-    const opts = (0, curve_js_1.validateBasic)(curve);
-    ut.validateObject(opts, {
+    const opts = (0, curve_ts_1.validateBasic)(curve);
+    (0, utils_ts_1.validateObject)(opts, {
       hash: "hash",
       hmac: "function",
       randomBytes: "function"
@@ -7485,18 +7502,18 @@ var require_weierstrass = __commonJS((exports) => {
     const compressedLen = Fp.BYTES + 1;
     const uncompressedLen = 2 * Fp.BYTES + 1;
     function modN(a) {
-      return (0, modular_js_1.mod)(a, CURVE_ORDER);
+      return (0, modular_ts_1.mod)(a, CURVE_ORDER);
     }
     function invN(a) {
-      return (0, modular_js_1.invert)(a, CURVE_ORDER);
+      return (0, modular_ts_1.invert)(a, CURVE_ORDER);
     }
     const { ProjectivePoint: Point, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
       ...CURVE,
       toBytes(_c, point, isCompressed) {
         const a = point.toAffine();
         const x = Fp.toBytes(a.x);
-        const cat = ut.concatBytes;
-        (0, utils_js_1.abool)("isCompressed", isCompressed);
+        const cat = utils_ts_1.concatBytes;
+        (0, utils_ts_1.abool)("isCompressed", isCompressed);
         if (isCompressed) {
           return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
         } else {
@@ -7508,8 +7525,8 @@ var require_weierstrass = __commonJS((exports) => {
         const head = bytes[0];
         const tail = bytes.subarray(1);
         if (len === compressedLen && (head === 2 || head === 3)) {
-          const x = ut.bytesToNumberBE(tail);
-          if (!ut.inRange(x, _1n, Fp.ORDER))
+          const x = (0, utils_ts_1.bytesToNumberBE)(tail);
+          if (!(0, utils_ts_1.inRange)(x, _1n, Fp.ORDER))
             throw new Error("Point is not on curve");
           const y2 = weierstrassEquation(x);
           let y;
@@ -7535,7 +7552,7 @@ var require_weierstrass = __commonJS((exports) => {
         }
       }
     });
-    const numToNByteStr = (num) => ut.bytesToHex(ut.numberToBytesBE(num, CURVE.nByteLength));
+    const numToNByteHex = (num) => (0, utils_ts_1.bytesToHex)((0, utils_ts_1.numberToBytesBE)(num, CURVE.nByteLength));
     function isBiggerThanHalfOrder(number) {
       const HALF = CURVE_ORDER >> _1n;
       return number > HALF;
@@ -7543,41 +7560,41 @@ var require_weierstrass = __commonJS((exports) => {
     function normalizeS(s) {
       return isBiggerThanHalfOrder(s) ? modN(-s) : s;
     }
-    const slcNum = (b, from, to) => ut.bytesToNumberBE(b.slice(from, to));
+    const slcNum = (b, from, to) => (0, utils_ts_1.bytesToNumberBE)(b.slice(from, to));
 
     class Signature {
       constructor(r, s, recovery) {
+        (0, utils_ts_1.aInRange)("r", r, _1n, CURVE_ORDER);
+        (0, utils_ts_1.aInRange)("s", s, _1n, CURVE_ORDER);
         this.r = r;
         this.s = s;
-        this.recovery = recovery;
-        this.assertValidity();
+        if (recovery != null)
+          this.recovery = recovery;
+        Object.freeze(this);
       }
       static fromCompact(hex) {
         const l = CURVE.nByteLength;
-        hex = (0, utils_js_1.ensureBytes)("compactSignature", hex, l * 2);
+        hex = (0, utils_ts_1.ensureBytes)("compactSignature", hex, l * 2);
         return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
       }
       static fromDER(hex) {
-        const { r, s } = exports.DER.toSig((0, utils_js_1.ensureBytes)("DER", hex));
+        const { r, s } = exports.DER.toSig((0, utils_ts_1.ensureBytes)("DER", hex));
         return new Signature(r, s);
       }
-      assertValidity() {
-        ut.aInRange("r", this.r, _1n, CURVE_ORDER);
-        ut.aInRange("s", this.s, _1n, CURVE_ORDER);
-      }
+      assertValidity() {}
       addRecoveryBit(recovery) {
         return new Signature(this.r, this.s, recovery);
       }
       recoverPublicKey(msgHash) {
         const { r, s, recovery: rec } = this;
-        const h = bits2int_modN((0, utils_js_1.ensureBytes)("msgHash", msgHash));
+        const h = bits2int_modN((0, utils_ts_1.ensureBytes)("msgHash", msgHash));
         if (rec == null || ![0, 1, 2, 3].includes(rec))
           throw new Error("recovery id invalid");
         const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;
         if (radj >= Fp.ORDER)
           throw new Error("recovery id 2 or 3 invalid");
         const prefix = (rec & 1) === 0 ? "02" : "03";
-        const R = Point.fromHex(prefix + numToNByteStr(radj));
+        const R = Point.fromHex(prefix + numToNByteHex(radj));
         const ir = invN(radj);
         const u1 = modN(-h * ir);
         const u2 = modN(s * ir);
@@ -7594,16 +7611,16 @@ var require_weierstrass = __commonJS((exports) => {
         return this.hasHighS() ? new Signature(this.r, modN(-this.s), this.recovery) : this;
       }
       toDERRawBytes() {
-        return ut.hexToBytes(this.toDERHex());
+        return (0, utils_ts_1.hexToBytes)(this.toDERHex());
       }
       toDERHex() {
         return exports.DER.hexFromSig({ r: this.r, s: this.s });
       }
       toCompactRawBytes() {
-        return ut.hexToBytes(this.toCompactHex());
+        return (0, utils_ts_1.hexToBytes)(this.toCompactHex());
       }
       toCompactHex() {
-        return numToNByteStr(this.r) + numToNByteStr(this.s);
+        return numToNByteHex(this.r) + numToNByteHex(this.s);
       }
     }
     const utils = {
@@ -7617,8 +7634,8 @@ var require_weierstrass = __commonJS((exports) => {
       },
       normPrivateKeyToScalar,
       randomPrivateKey: () => {
-        const length = (0, modular_js_1.getMinHashLength)(CURVE.n);
-        return (0, modular_js_1.mapHashToField)(CURVE.randomBytes(length), CURVE.n);
+        const length = (0, modular_ts_1.getMinHashLength)(CURVE.n);
+        return (0, modular_ts_1.mapHashToField)(CURVE.randomBytes(length), CURVE.n);
       },
       precompute(windowSize = 8, point = Point.BASE) {
         point._setWindowSize(windowSize);
@@ -7630,7 +7647,7 @@ var require_weierstrass = __commonJS((exports) => {
       return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);
     }
     function isProbPub(item) {
-      const arr = ut.isBytes(item);
+      const arr = (0, utils_ts_1.isBytes)(item);
       const str = typeof item === "string";
       const len = (arr || str) && item.length;
       if (arr)
@@ -7652,17 +7669,17 @@ var require_weierstrass = __commonJS((exports) => {
     const bits2int = CURVE.bits2int || function(bytes) {
       if (bytes.length > 8192)
         throw new Error("input is too large");
-      const num = ut.bytesToNumberBE(bytes);
+      const num = (0, utils_ts_1.bytesToNumberBE)(bytes);
       const delta = bytes.length * 8 - CURVE.nBitLength;
       return delta > 0 ? num >> BigInt(delta) : num;
     };
     const bits2int_modN = CURVE.bits2int_modN || function(bytes) {
       return modN(bits2int(bytes));
     };
-    const ORDER_MASK = ut.bitMask(CURVE.nBitLength);
+    const ORDER_MASK = (0, utils_ts_1.bitMask)(CURVE.nBitLength);
     function int2octets(num) {
-      ut.aInRange("num < 2^" + CURVE.nBitLength, num, _0n, ORDER_MASK);
-      return ut.numberToBytesBE(num, CURVE.nByteLength);
+      (0, utils_ts_1.aInRange)("num < 2^" + CURVE.nBitLength, num, _0n, ORDER_MASK);
+      return (0, utils_ts_1.numberToBytesBE)(num, CURVE.nByteLength);
     }
     function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
       if (["recovered", "canonical"].some((k) => (k in opts)))
@@ -7671,18 +7688,18 @@ var require_weierstrass = __commonJS((exports) => {
       let { lowS, prehash, extraEntropy: ent } = opts;
       if (lowS == null)
         lowS = true;
-      msgHash = (0, utils_js_1.ensureBytes)("msgHash", msgHash);
+      msgHash = (0, utils_ts_1.ensureBytes)("msgHash", msgHash);
       validateSigVerOpts(opts);
       if (prehash)
-        msgHash = (0, utils_js_1.ensureBytes)("prehashed msgHash", hash(msgHash));
+        msgHash = (0, utils_ts_1.ensureBytes)("prehashed msgHash", hash(msgHash));
       const h1int = bits2int_modN(msgHash);
       const d = normPrivateKeyToScalar(privateKey);
       const seedArgs = [int2octets(d), int2octets(h1int)];
       if (ent != null && ent !== false) {
         const e = ent === true ? randomBytes(Fp.BYTES) : ent;
-        seedArgs.push((0, utils_js_1.ensureBytes)("extraEntropy", e));
+        seedArgs.push((0, utils_ts_1.ensureBytes)("extraEntropy", e));
       }
-      const seed = ut.concatBytes(...seedArgs);
+      const seed = (0, utils_ts_1.concatBytes)(...seedArgs);
       const m = h1int;
       function k2sig(kBytes) {
         const k = bits2int(kBytes);
@@ -7711,21 +7728,21 @@ var require_weierstrass = __commonJS((exports) => {
     function sign(msgHash, privKey, opts = defaultSigOpts) {
       const { seed, k2sig } = prepSig(msgHash, privKey, opts);
       const C = CURVE;
-      const drbg = ut.createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);
+      const drbg = (0, utils_ts_1.createHmacDrbg)(C.hash.outputLen, C.nByteLength, C.hmac);
       return drbg(seed, k2sig);
     }
     Point.BASE._setWindowSize(8);
     function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
       const sg = signature;
-      msgHash = (0, utils_js_1.ensureBytes)("msgHash", msgHash);
-      publicKey = (0, utils_js_1.ensureBytes)("publicKey", publicKey);
+      msgHash = (0, utils_ts_1.ensureBytes)("msgHash", msgHash);
+      publicKey = (0, utils_ts_1.ensureBytes)("publicKey", publicKey);
       const { lowS, prehash, format: format2 } = opts;
       validateSigVerOpts(opts);
       if ("strict" in opts)
         throw new Error("options.strict was renamed to lowS");
       if (format2 !== undefined && format2 !== "compact" && format2 !== "der")
         throw new Error("format must be compact or der");
-      const isHex = typeof sg === "string" || ut.isBytes(sg);
+      const isHex = typeof sg === "string" || (0, utils_ts_1.isBytes)(sg);
       const isObj = !isHex && !format2 && typeof sg === "object" && sg !== null && typeof sg.r === "bigint" && typeof sg.s === "bigint";
       if (!isHex && !isObj)
         throw new Error("invalid signature, expected Uint8Array, hex string or Signature instance");
@@ -7840,7 +7857,7 @@ var require_weierstrass = __commonJS((exports) => {
     return sqrtRatio;
   }
   function mapToCurveSimpleSWU(Fp, opts) {
-    (0, modular_js_1.validateField)(Fp);
+    (0, modular_ts_1.validateField)(Fp);
     if (!Fp.isValid(opts.A) || !Fp.isValid(opts.B) || !Fp.isValid(opts.Z))
       throw new Error("mapToCurveSimpleSWU: invalid opts");
     const sqrtRatio = SWUFpSqrtRatio(Fp, opts.Z);
@@ -7886,7 +7903,7 @@ var require__shortw_utils = __commonJS((exports) => {
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   var hmac_1 = require_hmac();
   var utils_1 = require_utils4();
-  var weierstrass_js_1 = require_weierstrass();
+  var weierstrass_ts_1 = require_weierstrass();
   function getHash(hash) {
     return {
       hash,
@@ -7895,7 +7912,7 @@ var require__shortw_utils = __commonJS((exports) => {
     };
   }
   function createCurve(curveDef, defHash) {
-    const create = (hash) => (0, weierstrass_js_1.weierstrass)({ ...curveDef, ...getHash(hash) });
+    const create = (hash) => (0, weierstrass_ts_1.weierstrass)({ ...curveDef, ...getHash(hash) });
     return { ...create(defHash), create };
   }
 });
@@ -7905,13 +7922,13 @@ var require_secp256k1 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.encodeToCurve = exports.hashToCurve = exports.schnorr = exports.secp256k1 = undefined;
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-  var sha256_1 = require_sha256();
+  var sha2_1 = require_sha2();
   var utils_1 = require_utils4();
-  var _shortw_utils_js_1 = require__shortw_utils();
-  var hash_to_curve_js_1 = require_hash_to_curve();
-  var modular_js_1 = require_modular();
-  var utils_js_1 = require_utils5();
-  var weierstrass_js_1 = require_weierstrass();
+  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 utils_ts_1 = require_utils5();
+  var weierstrass_ts_1 = require_weierstrass();
   var secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
   var secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
   var _1n = BigInt(1);
@@ -7923,24 +7940,24 @@ var require_secp256k1 = __commonJS((exports) => {
     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_js_1.pow2)(b3, _3n, P) * b3 % P;
-    const b9 = (0, modular_js_1.pow2)(b6, _3n, P) * b3 % P;
-    const b11 = (0, modular_js_1.pow2)(b9, _2n, P) * b2 % P;
-    const b22 = (0, modular_js_1.pow2)(b11, _11n, P) * b11 % P;
-    const b44 = (0, modular_js_1.pow2)(b22, _22n, P) * b22 % P;
-    const b88 = (0, modular_js_1.pow2)(b44, _44n, P) * b44 % P;
-    const b176 = (0, modular_js_1.pow2)(b88, _88n, P) * b88 % P;
-    const b220 = (0, modular_js_1.pow2)(b176, _44n, P) * b44 % P;
-    const b223 = (0, modular_js_1.pow2)(b220, _3n, P) * b3 % P;
-    const t1 = (0, modular_js_1.pow2)(b223, _23n, P) * b22 % P;
-    const t2 = (0, modular_js_1.pow2)(t1, _6n, P) * b2 % P;
-    const root = (0, modular_js_1.pow2)(t2, _2n, 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_js_1.Field)(secp256k1P, undefined, undefined, { sqrt: sqrtMod });
-  exports.secp256k1 = (0, _shortw_utils_js_1.createCurve)({
+  var Fpk1 = (0, modular_ts_1.Field)(secp256k1P, undefined, undefined, { sqrt: sqrtMod });
+  exports.secp256k1 = (0, _shortw_utils_ts_1.createCurve)({
     a: BigInt(0),
     b: BigInt(7),
     Fp: Fpk1,
@@ -7960,8 +7977,8 @@ var require_secp256k1 = __commonJS((exports) => {
         const POW_2_128 = BigInt("0x100000000000000000000000000000000");
         const c1 = divNearest(b2 * k, n);
         const c2 = divNearest(-b1 * k, n);
-        let k1 = (0, modular_js_1.mod)(k - c1 * a1 - c2 * a2, n);
-        let k2 = (0, modular_js_1.mod)(-c1 * b1 - c2 * b2, n);
+        let k1 = (0, modular_ts_1.mod)(k - c1 * a1 - c2 * a2, n);
+        let k2 = (0, modular_ts_1.mod)(-c1 * b1 - c2 * b2, n);
         const k1neg = k1 > POW_2_128;
         const k2neg = k2 > POW_2_128;
         if (k1neg)
@@ -7974,22 +7991,22 @@ var require_secp256k1 = __commonJS((exports) => {
         return { k1neg, k1, k2neg, k2 };
       }
     }
-  }, sha256_1.sha256);
+  }, sha2_1.sha256);
   var _0n = BigInt(0);
   var TAGGED_HASH_PREFIXES = {};
   function taggedHash(tag, ...messages) {
     let tagP = TAGGED_HASH_PREFIXES[tag];
     if (tagP === undefined) {
-      const tagH = (0, sha256_1.sha256)(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
-      tagP = (0, utils_js_1.concatBytes)(tagH, tagH);
+      const tagH = (0, sha2_1.sha256)(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
+      tagP = (0, utils_ts_1.concatBytes)(tagH, tagH);
       TAGGED_HASH_PREFIXES[tag] = tagP;
     }
-    return (0, sha256_1.sha256)((0, utils_js_1.concatBytes)(tagP, ...messages));
+    return (0, sha2_1.sha256)((0, utils_ts_1.concatBytes)(tagP, ...messages));
   }
   var pointToBytes = (point) => point.toRawBytes(true).slice(1);
-  var numTo32b = (n) => (0, utils_js_1.numberToBytesBE)(n, 32);
-  var modP = (x) => (0, modular_js_1.mod)(x, secp256k1P);
-  var modN = (x) => (0, modular_js_1.mod)(x, secp256k1N);
+  var numTo32b = (n) => (0, utils_ts_1.numberToBytesBE)(n, 32);
+  var modP = (x) => (0, modular_ts_1.mod)(x, secp256k1P);
+  var modN = (x) => (0, modular_ts_1.mod)(x, secp256k1N);
   var Point = exports.secp256k1.ProjectivePoint;
   var GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);
   function schnorrGetExtPubKey(priv) {
@@ -7999,7 +8016,7 @@ var require_secp256k1 = __commonJS((exports) => {
     return { scalar, bytes: pointToBytes(p) };
   }
   function lift_x(x) {
-    (0, utils_js_1.aInRange)("x", x, _1n, secp256k1P);
+    (0, utils_ts_1.aInRange)("x", x, _1n, secp256k1P);
     const xx = modP(x * x);
     const c = modP(xx * x + BigInt(7));
     let y = sqrtMod(c);
@@ -8009,7 +8026,7 @@ var require_secp256k1 = __commonJS((exports) => {
     p.assertValidity();
     return p;
   }
-  var num = utils_js_1.bytesToNumberBE;
+  var num = utils_ts_1.bytesToNumberBE;
   function challenge(...args) {
     return modN(num(taggedHash("BIP0340/challenge", ...args)));
   }
@@ -8017,9 +8034,9 @@ var require_secp256k1 = __commonJS((exports) => {
     return schnorrGetExtPubKey(privateKey).bytes;
   }
   function schnorrSign(message, privateKey, auxRand = (0, utils_1.randomBytes)(32)) {
-    const m = (0, utils_js_1.ensureBytes)("message", message);
+    const m = (0, utils_ts_1.ensureBytes)("message", message);
     const { bytes: px, scalar: d } = schnorrGetExtPubKey(privateKey);
-    const a = (0, utils_js_1.ensureBytes)("auxRand", auxRand, 32);
+    const a = (0, utils_ts_1.ensureBytes)("auxRand", auxRand, 32);
     const t = numTo32b(d ^ num(taggedHash("BIP0340/aux", a)));
     const rand = taggedHash("BIP0340/nonce", t, px, m);
     const k_ = modN(num(rand));
@@ -8035,16 +8052,16 @@ var require_secp256k1 = __commonJS((exports) => {
     return sig;
   }
   function schnorrVerify(signature, message, publicKey) {
-    const sig = (0, utils_js_1.ensureBytes)("signature", signature, 64);
-    const m = (0, utils_js_1.ensureBytes)("message", message);
-    const pub = (0, utils_js_1.ensureBytes)("publicKey", publicKey, 32);
+    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_js_1.inRange)(r, _1n, secp256k1P))
+      if (!(0, utils_ts_1.inRange)(r, _1n, secp256k1P))
         return false;
       const s = num(sig.subarray(32, 64));
-      if (!(0, utils_js_1.inRange)(s, _1n, secp256k1N))
+      if (!(0, utils_ts_1.inRange)(s, _1n, secp256k1N))
         return false;
       const e = challenge(numTo32b(r), pointToBytes(P), m);
       const R = GmulAdd(P, s, modN(-e));
@@ -8063,13 +8080,13 @@ var require_secp256k1 = __commonJS((exports) => {
       randomPrivateKey: exports.secp256k1.utils.randomPrivateKey,
       lift_x,
       pointToBytes,
-      numberToBytesBE: utils_js_1.numberToBytesBE,
-      bytesToNumberBE: utils_js_1.bytesToNumberBE,
+      numberToBytesBE: utils_ts_1.numberToBytesBE,
+      bytesToNumberBE: utils_ts_1.bytesToNumberBE,
       taggedHash,
-      mod: modular_js_1.mod
+      mod: modular_ts_1.mod
     }
   }))();
-  var isoMap = /* @__PURE__ */ (() => (0, hash_to_curve_js_1.isogenyMap)(Fpk1, [
+  var isoMap = /* @__PURE__ */ (() => (0, hash_to_curve_ts_1.isogenyMap)(Fpk1, [
     [
       "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
       "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
@@ -8094,12 +8111,12 @@ var require_secp256k1 = __commonJS((exports) => {
       "0x0000000000000000000000000000000000000000000000000000000000000001"
     ]
   ].map((i) => i.map((j) => BigInt(j)))))();
-  var mapSWU = /* @__PURE__ */ (() => (0, weierstrass_js_1.mapToCurveSimpleSWU)(Fpk1, {
+  var mapSWU = /* @__PURE__ */ (() => (0, weierstrass_ts_1.mapToCurveSimpleSWU)(Fpk1, {
     A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"),
     B: BigInt("1771"),
     Z: Fpk1.create(BigInt("-11"))
   }))();
-  var htf = /* @__PURE__ */ (() => (0, hash_to_curve_js_1.createHasher)(exports.secp256k1.ProjectivePoint, (scalars) => {
+  var htf = /* @__PURE__ */ (() => (0, hash_to_curve_ts_1.createHasher)(exports.secp256k1.ProjectivePoint, (scalars) => {
     const { x, y } = mapSWU(Fpk1.create(scalars[0]));
     return isoMap(x, y);
   }, {
@@ -8109,7 +8126,7 @@ var require_secp256k1 = __commonJS((exports) => {
     m: 1,
     k: 128,
     expand: "xmd",
-    hash: sha256_1.sha256
+    hash: sha2_1.sha256
   }))();
   exports.hashToCurve = (() => htf.hashToCurve)();
   exports.encodeToCurve = (() => htf.encodeToCurve)();
@@ -8232,27 +8249,27 @@ var require_hkdf = __commonJS((exports) => {
   exports.hkdf = undefined;
   exports.extract = extract;
   exports.expand = expand;
-  var _assert_js_1 = require__assert2();
-  var hmac_js_1 = require_hmac();
-  var utils_js_1 = require_utils4();
+  var _assert_ts_1 = require__assert2();
+  var hmac_ts_1 = require_hmac();
+  var utils_ts_1 = require_utils4();
   function extract(hash, ikm, salt) {
-    (0, _assert_js_1.ahash)(hash);
+    (0, _assert_ts_1.ahash)(hash);
     if (salt === undefined)
       salt = new Uint8Array(hash.outputLen);
-    return (0, hmac_js_1.hmac)(hash, (0, utils_js_1.toBytes)(salt), (0, utils_js_1.toBytes)(ikm));
+    return (0, hmac_ts_1.hmac)(hash, (0, utils_ts_1.toBytes)(salt), (0, utils_ts_1.toBytes)(ikm));
   }
   var HKDF_COUNTER = /* @__PURE__ */ new Uint8Array([0]);
   var EMPTY_BUFFER = /* @__PURE__ */ new Uint8Array;
   function expand(hash, prk, info, length = 32) {
-    (0, _assert_js_1.ahash)(hash);
-    (0, _assert_js_1.anumber)(length);
+    (0, _assert_ts_1.ahash)(hash);
+    (0, _assert_ts_1.anumber)(length);
     if (length > 255 * hash.outputLen)
       throw new Error("Length should be <= 255*HashLen");
     const blocks = Math.ceil(length / hash.outputLen);
     if (info === undefined)
       info = EMPTY_BUFFER;
     const okm = new Uint8Array(blocks * hash.outputLen);
-    const HMAC = hmac_js_1.hmac.create(hash, prk);
+    const HMAC = hmac_ts_1.hmac.create(hash, prk);
     const HMACTmp = HMAC._cloneInto();
     const T = new Uint8Array(HMAC.outputLen);
     for (let counter = 0;counter < blocks; counter++) {
@@ -9088,7 +9105,7 @@ var require_parse2 = __commonJS((exports, module) => {
 // ../../node_modules/@dotenvx/dotenvx/src/lib/helpers/dotenvParse.js
 var require_dotenvParse = __commonJS((exports, module) => {
   var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
-  function dotenvParse(src, skipExpandForDoubleQuotes = false, skipConvertingWindowsNewlines = false) {
+  function dotenvParse(src, skipExpandForDoubleQuotes = false, skipConvertingWindowsNewlines = false, collectAllValues = false) {
     const obj = {};
     let lines = src.toString();
     if (!skipConvertingWindowsNewlines) {
@@ -9108,7 +9125,12 @@ var require_dotenvParse = __commonJS((exports, module) => {
         value = value.replace(/\\r/g, "\r");
         value = value.replace(/\\t/g, "\t");
       }
-      obj[key] = value;
+      if (collectAllValues) {
+        obj[key] = obj[key] || [];
+        obj[key].push(value);
+      } else {
+        obj[key] = value;
+      }
     }
     return obj;
   }
@@ -31162,6 +31184,23 @@ var require_lib4 = __commonJS((exports, module) => {
   var fromUrl = require_from_url();
   var parseUrl = require_parse_url();
   var cache = new LRUCache2({ max: 1000 });
+  function unknownHostedUrl(url) {
+    try {
+      const {
+        protocol,
+        hostname,
+        pathname
+      } = new URL(url);
+      if (!hostname) {
+        return null;
+      }
+      const proto = /(?:git\+)http:$/.test(protocol) ? "http:" : "https:";
+      const path6 = pathname.replace(/\.git$/, "");
+      return `${proto}//${hostname}${path6}`;
+    } catch {
+      return null;
+    }
+  }
 
   class GitHost {
     constructor(type2, user, auth, project, committish, defaultRepresentation, opts = {}) {
@@ -31205,6 +31244,22 @@ var require_lib4 = __commonJS((exports, module) => {
       }
       return cache.get(key2);
     }
+    static fromManifest(manifest, opts = {}) {
+      if (!manifest || typeof manifest !== "object") {
+        return;
+      }
+      const r2 = manifest.repository;
+      const rurl = r2 && (typeof r2 === "string" ? r2 : typeof r2 === "object" && typeof r2.url === "string" ? r2.url : null);
+      if (!rurl) {
+        throw new Error("no repository");
+      }
+      const info = rurl && GitHost.fromUrl(rurl.replace(/^git\+/, ""), opts) || null;
+      if (info) {
+        return info;
+      }
+      const unk = unknownHostedUrl(rurl);
+      return GitHost.fromUrl(unk, opts) || unk;
+    }
     static parseUrl(url) {
       return parseUrl(url);
     }
@@ -245278,7 +245333,7 @@ function pruneCurrentEnv(currentEnv, env2) {
 var package_default = {
   name: "@settlemint/sdk-cli",
   description: "Command-line interface for SettleMint SDK, providing development tools and project management capabilities",
-  version: "2.1.1-prc71cad32",
+  version: "2.1.1-prcb1d9c8d",
   type: "module",
   private: false,
   license: "FSL-1.1-MIT",
@@ -245327,8 +245382,8 @@ var package_default = {
     "@inquirer/input": "4.1.9",
     "@inquirer/password": "4.0.12",
     "@inquirer/select": "4.1.1",
-    "@settlemint/sdk-js": "2.1.1-prc71cad32",
-    "@settlemint/sdk-utils": "2.1.1-prc71cad32",
+    "@settlemint/sdk-js": "2.1.1-prcb1d9c8d",
+    "@settlemint/sdk-utils": "2.1.1-prcb1d9c8d",
     "@types/node": "22.14.1",
     "@types/semver": "7.7.0",
     "@types/which": "3.0.4",
@@ -248684,24 +248739,18 @@ function generateResponse(pincode, salt, challenge) {
   const hashedPincode = hashPincode(pincode, salt);
   return createHash("sha256").update(`${hashedPincode}_${challenge}`).digest("hex");
 }
-async function getPincodeVerificationResponse({
+async function getPincodeVerificationChallenges({
   userWalletAddress,
-  pincode,
   accessToken,
   instance,
   nodeId
 }) {
-  const response = await fetch(`${instance}/cm/nodes/${encodeURIComponent(nodeId)}/user-wallets/${encodeURIComponent(userWalletAddress)}/verifications/challenges`, {
+  const response = await fetch(`${instance}/cm/nodes/${encodeURIComponent(nodeId)}/user-wallets/${encodeURIComponent(userWalletAddress)}/verifications/challenges?type=PINCODE`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
       "x-auth-token": accessToken
-    },
-    body: JSON.stringify({
-      pincode,
-      verificationType: "PINCODE",
-      name: "pincode"
-    })
+    }
   });
   if (!response.ok) {
     if (response.status === 404) {
@@ -248710,15 +248759,16 @@ async function getPincodeVerificationResponse({
     throw new Error("Failed to get verification challenge");
   }
   const verificationChallenges = await response.json();
-  if (!verificationChallenges.length) {
-    throw new Error("No verification challenges received");
-  }
-  const firstChallenge = verificationChallenges[0];
-  const challenge = firstChallenge?.challenge;
-  if (!challenge?.secret || !challenge?.salt) {
+  return verificationChallenges;
+}
+function getPincodeVerificationChallengeResponse({
+  verificationChallenge,
+  pincode
+}) {
+  if (!verificationChallenge?.challenge?.secret || !verificationChallenge?.challenge?.salt) {
     throw new Error("Could not authenticate pin code, invalid challenge format");
   }
-  const { secret, salt } = challenge;
+  const { secret, salt } = verificationChallenge.challenge;
   return generateResponse(pincode, salt, secret);
 }
 function createSettleMintClient(options) {
@@ -248820,7 +248870,8 @@ function createSettleMintClient(options) {
       config: getPlatformConfig(gqlClient)
     },
     wallet: {
-      pincodeVerificationResponse: (args) => getPincodeVerificationResponse({
+      pincodeVerificationChallengeResponse: getPincodeVerificationChallengeResponse,
+      pincodeVerificationChallenges: (args) => getPincodeVerificationChallenges({
         ...args,
         instance: validatedOptions.instance,
         accessToken: validatedOptions.accessToken
@@ -248855,6 +248906,7 @@ var LOCKS = {
   "bun.lockb": "bun",
   "deno.lock": "deno",
   "pnpm-lock.yaml": "pnpm",
+  "pnpm-workspace.yaml": "pnpm",
   "yarn.lock": "yarn",
   "package-lock.json": "npm",
   "npm-shrinkwrap.json": "npm"
@@ -251894,7 +251946,6 @@ async function codegenMinio(env2) {
 
 export const { client } = createServerMinioClient({
   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,
-  accessToken: process.env.SETTLEMINT_ACCESS_TOKEN!,
   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,
   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!
 });`;
@@ -256500,6 +256551,27 @@ function logoutCommand() {
   });
 }
 
+// src/prompts/pincode-verification.prompt.ts
+async function pincodeVerificationPrompt(verificationChallenges) {
+  if (verificationChallenges.length === 0) {
+    cancel2("No pincode is configured");
+  }
+  if (verificationChallenges.length === 1) {
+    return verificationChallenges[0];
+  }
+  const verificationChallenge = await esm_default3({
+    message: "Which pincode verification do you want to use?",
+    choices: verificationChallenges.map((verificationChallenge2) => ({
+      name: verificationChallenge2.name,
+      value: verificationChallenge2
+    }))
+  });
+  if (!verificationChallenge) {
+    cancel2("No pincode verification challenge selected");
+  }
+  return verificationChallenge;
+}
+
 // src/commands/pincode-verification-response.ts
 function pincodeVerificationResponseCommand() {
   return new Command("pincode-verification-response").alias("pvr").description("Get pincode verification response for a blockchain node").requiredOption("--wallet-address <walletAddress>", "The wallet address to get pincode verification response for").option("-i, --instance <instance>", "The instance to connect to (defaults to the instance in the .env file)").option("--blockchain-node <blockchainNode>", "Blockchain Node unique name to get pincode verification response for").action(async ({ instance, blockchainNode, walletAddress }) => {
@@ -256531,6 +256603,11 @@ function pincodeVerificationResponseCommand() {
         return nothingSelectedError("blockchain node");
       }
     }
+    const pincodeVerificationChallenges = await settlemint.wallet.pincodeVerificationChallenges({
+      userWalletAddress: walletAddress,
+      nodeId: selectedBlockchainNode.id
+    });
+    const verificationChallenge = await pincodeVerificationPrompt(pincodeVerificationChallenges);
     const pincode = await esm_default5({
       message: "Enter your pincode",
       validate(value4) {
@@ -256540,10 +256617,9 @@ function pincodeVerificationResponseCommand() {
         return true;
       }
     });
-    const pincodeVerificationResponse = await settlemint.wallet.pincodeVerificationResponse({
-      userWalletAddress: walletAddress,
-      pincode,
-      nodeId: selectedBlockchainNode.id
+    const pincodeVerificationResponse = settlemint.wallet.pincodeVerificationChallengeResponse({
+      verificationChallenge,
+      pincode
     });
     note(`Pincode verification response: ${pincodeVerificationResponse}`);
     outro("Pincode verification response generated");
@@ -256597,7 +256673,7 @@ async function waitForCompletion({
               } else {
                 note(`${capitalizeFirstLetter2(type4)} failed to ${getActionLabel(action)}`);
               }
-              return true;
+              return false;
             }
             if (spinner2) {
               spinner2.text = `${capitalizeFirstLetter2(type4)} is not ready yet (status: ${resource.status})`;
@@ -259873,4 +259949,4 @@ async function sdkCliCommand(argv = process.argv) {
 // src/cli.ts
 sdkCliCommand();
 
-//# debugId=74B3AFA75E7CA76164756E2164756E21
+//# debugId=557B9B3595B2199D64756E2164756E21