routstrd 0.1.4 → 0.1.5

package/dist/index.js

@@ -22480,16 +22480,33 @@ var require_webSocket2 = __commonJS((exports) => {
   } });
 });
 
+// ../routstr-chat/node_modules/@noble/hashes/esm/cryptoNode.js
+import * as nc3 from "crypto";
+var crypto4;
+var init_cryptoNode3 = __esm(() => {
+  crypto4 = nc3 && typeof nc3 === "object" && "webcrypto" in nc3 ? nc3.webcrypto : nc3 && typeof nc3 === "object" && ("randomBytes" in nc3) ? nc3 : undefined;
+});
+
 // ../routstr-chat/node_modules/@noble/hashes/esm/utils.js
 function isBytes2(a) {
   return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
 }
+function anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
+}
 function abytes(b, ...lengths) {
   if (!isBytes2(b))
     throw new Error("Uint8Array expected");
   if (lengths.length > 0 && !lengths.includes(b.length))
     throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
 }
+function ahash(h) {
+  if (typeof h !== "function" || typeof h.create !== "function")
+    throw new Error("Hash should be wrapped by utils.createHasher");
+  anumber(h.outputLen);
+  anumber(h.blockLen);
+}
 function aexists(instance, checkFinished = true) {
   if (instance.destroyed)
     throw new Error("Hash instance has been destroyed");
@@ -22514,6 +22531,49 @@ function createView4(arr) {
 function rotr3(word, shift) {
   return word << 32 - shift | word >>> shift;
 }
+function rotl2(word, shift) {
+  return word << shift | word >>> 32 - shift >>> 0;
+}
+function bytesToHex4(bytes4) {
+  abytes(bytes4);
+  if (hasHexBuiltin)
+    return bytes4.toHex();
+  let hex2 = "";
+  for (let i4 = 0;i4 < bytes4.length; i4++) {
+    hex2 += hexes4[bytes4[i4]];
+  }
+  return hex2;
+}
+function asciiToBase162(ch) {
+  if (ch >= asciis2._0 && ch <= asciis2._9)
+    return ch - asciis2._0;
+  if (ch >= asciis2.A && ch <= asciis2.F)
+    return ch - (asciis2.A - 10);
+  if (ch >= asciis2.a && ch <= asciis2.f)
+    return ch - (asciis2.a - 10);
+  return;
+}
+function hexToBytes4(hex2) {
+  if (typeof hex2 !== "string")
+    throw new Error("hex string expected, got " + typeof hex2);
+  if (hasHexBuiltin)
+    return Uint8Array.fromHex(hex2);
+  const hl = hex2.length;
+  const al = hl / 2;
+  if (hl % 2)
+    throw new Error("hex string expected, got unpadded hex of length " + hl);
+  const array = new Uint8Array(al);
+  for (let ai = 0, hi = 0;ai < al; ai++, hi += 2) {
+    const n1 = asciiToBase162(hex2.charCodeAt(hi));
+    const n2 = asciiToBase162(hex2.charCodeAt(hi + 1));
+    if (n1 === undefined || n2 === undefined) {
+      const char = hex2[hi] + hex2[hi + 1];
+      throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+    }
+    array[ai] = n1 * 16 + n2;
+  }
+  return array;
+}
 function utf8ToBytes5(str) {
   if (typeof str !== "string")
     throw new Error("string expected");
@@ -22525,6 +22585,21 @@ function toBytes4(data) {
   abytes(data);
   return data;
 }
+function concatBytes4(...arrays) {
+  let sum = 0;
+  for (let i4 = 0;i4 < arrays.length; i4++) {
+    const a = arrays[i4];
+    abytes(a);
+    sum += a.length;
+  }
+  const res = new Uint8Array(sum);
+  for (let i4 = 0, pad2 = 0;i4 < arrays.length; i4++) {
+    const a = arrays[i4];
+    res.set(a, pad2);
+    pad2 += a.length;
+  }
+  return res;
+}
 
 class Hash3 {
 }
@@ -22536,8 +22611,22 @@ function createHasher(hashCons) {
   hashC.create = () => hashCons();
   return hashC;
 }
+function randomBytes4(bytesLength = 32) {
+  if (crypto4 && typeof crypto4.getRandomValues === "function") {
+    return crypto4.getRandomValues(new Uint8Array(bytesLength));
+  }
+  if (crypto4 && typeof crypto4.randomBytes === "function") {
+    return Uint8Array.from(crypto4.randomBytes(bytesLength));
+  }
+  throw new Error("crypto.getRandomValues must be defined");
+}
+var hasHexBuiltin, hexes4, asciis2;
 var init_utils6 = __esm(() => {
+  init_cryptoNode3();
   /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+  hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
+  hexes4 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i4) => i4.toString(16).padStart(2, "0"));
+  asciis2 = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
 });
 
 // ../routstr-chat/node_modules/@noble/hashes/esm/_md.js
@@ -22559,7 +22648,7 @@ function Chi3(a, b, c) {
 function Maj3(a, b, c) {
   return a & b ^ a & c ^ b & c;
 }
-var HashMD, SHA256_IV;
+var HashMD, SHA256_IV, SHA512_IV;
 var init__md = __esm(() => {
   init_utils6();
   HashMD = class HashMD extends Hash3 {
@@ -22662,12 +22751,57 @@ var init__md = __esm(() => {
     528734635,
     1541459225
   ]);
+  SHA512_IV = /* @__PURE__ */ Uint32Array.from([
+    1779033703,
+    4089235720,
+    3144134277,
+    2227873595,
+    1013904242,
+    4271175723,
+    2773480762,
+    1595750129,
+    1359893119,
+    2917565137,
+    2600822924,
+    725511199,
+    528734635,
+    4215389547,
+    1541459225,
+    327033209
+  ]);
+});
+
+// ../routstr-chat/node_modules/@noble/hashes/esm/_u64.js
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+  const len = lst.length;
+  let Ah = new Uint32Array(len);
+  let Al = new Uint32Array(len);
+  for (let i4 = 0;i4 < len; i4++) {
+    const { h, l } = fromBig(lst[i4], le);
+    [Ah[i4], Al[i4]] = [h, l];
+  }
+  return [Ah, Al];
+}
+function add(Ah, Al, Bh, Bl) {
+  const l = (Al >>> 0) + (Bl >>> 0);
+  return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
+}
+var U32_MASK64, _32n, shrSH = (h, _l, s) => h >>> s, shrSL = (h, l, s) => h << 32 - s | l >>> s, rotrSH = (h, l, s) => h >>> s | l << 32 - s, rotrSL = (h, l, s) => h << 32 - s | l >>> s, rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32, rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s, add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0), add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0, add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0), add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0, add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0), add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+var init__u64 = __esm(() => {
+  U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+  _32n = /* @__PURE__ */ BigInt(32);
 });
 
 // ../routstr-chat/node_modules/@noble/hashes/esm/sha2.js
-var SHA256_K3, SHA256_W3, SHA2563, sha2563;
+var SHA256_K3, SHA256_W3, SHA2563, K512, SHA512_Kh, SHA512_Kl, SHA512_W_H, SHA512_W_L, SHA512, sha2563, sha512;
 var init_sha2 = __esm(() => {
   init__md();
+  init__u64();
   init_utils6();
   SHA256_K3 = /* @__PURE__ */ Uint32Array.from([
     1116352408,
@@ -22805,7 +22939,203 @@ var init_sha2 = __esm(() => {
       clean(this.buffer);
     }
   };
+  K512 = /* @__PURE__ */ (() => split([
+    "0x428a2f98d728ae22",
+    "0x7137449123ef65cd",
+    "0xb5c0fbcfec4d3b2f",
+    "0xe9b5dba58189dbbc",
+    "0x3956c25bf348b538",
+    "0x59f111f1b605d019",
+    "0x923f82a4af194f9b",
+    "0xab1c5ed5da6d8118",
+    "0xd807aa98a3030242",
+    "0x12835b0145706fbe",
+    "0x243185be4ee4b28c",
+    "0x550c7dc3d5ffb4e2",
+    "0x72be5d74f27b896f",
+    "0x80deb1fe3b1696b1",
+    "0x9bdc06a725c71235",
+    "0xc19bf174cf692694",
+    "0xe49b69c19ef14ad2",
+    "0xefbe4786384f25e3",
+    "0x0fc19dc68b8cd5b5",
+    "0x240ca1cc77ac9c65",
+    "0x2de92c6f592b0275",
+    "0x4a7484aa6ea6e483",
+    "0x5cb0a9dcbd41fbd4",
+    "0x76f988da831153b5",
+    "0x983e5152ee66dfab",
+    "0xa831c66d2db43210",
+    "0xb00327c898fb213f",
+    "0xbf597fc7beef0ee4",
+    "0xc6e00bf33da88fc2",
+    "0xd5a79147930aa725",
+    "0x06ca6351e003826f",
+    "0x142929670a0e6e70",
+    "0x27b70a8546d22ffc",
+    "0x2e1b21385c26c926",
+    "0x4d2c6dfc5ac42aed",
+    "0x53380d139d95b3df",
+    "0x650a73548baf63de",
+    "0x766a0abb3c77b2a8",
+    "0x81c2c92e47edaee6",
+    "0x92722c851482353b",
+    "0xa2bfe8a14cf10364",
+    "0xa81a664bbc423001",
+    "0xc24b8b70d0f89791",
+    "0xc76c51a30654be30",
+    "0xd192e819d6ef5218",
+    "0xd69906245565a910",
+    "0xf40e35855771202a",
+    "0x106aa07032bbd1b8",
+    "0x19a4c116b8d2d0c8",
+    "0x1e376c085141ab53",
+    "0x2748774cdf8eeb99",
+    "0x34b0bcb5e19b48a8",
+    "0x391c0cb3c5c95a63",
+    "0x4ed8aa4ae3418acb",
+    "0x5b9cca4f7763e373",
+    "0x682e6ff3d6b2b8a3",
+    "0x748f82ee5defb2fc",
+    "0x78a5636f43172f60",
+    "0x84c87814a1f0ab72",
+    "0x8cc702081a6439ec",
+    "0x90befffa23631e28",
+    "0xa4506cebde82bde9",
+    "0xbef9a3f7b2c67915",
+    "0xc67178f2e372532b",
+    "0xca273eceea26619c",
+    "0xd186b8c721c0c207",
+    "0xeada7dd6cde0eb1e",
+    "0xf57d4f7fee6ed178",
+    "0x06f067aa72176fba",
+    "0x0a637dc5a2c898a6",
+    "0x113f9804bef90dae",
+    "0x1b710b35131c471b",
+    "0x28db77f523047d84",
+    "0x32caab7b40c72493",
+    "0x3c9ebe0a15c9bebc",
+    "0x431d67c49c100d4c",
+    "0x4cc5d4becb3e42b6",
+    "0x597f299cfc657e2a",
+    "0x5fcb6fab3ad6faec",
+    "0x6c44198c4a475817"
+  ].map((n) => BigInt(n))))();
+  SHA512_Kh = /* @__PURE__ */ (() => K512[0])();
+  SHA512_Kl = /* @__PURE__ */ (() => K512[1])();
+  SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
+  SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
+  SHA512 = class SHA512 extends HashMD {
+    constructor(outputLen = 64) {
+      super(128, outputLen, 16, false);
+      this.Ah = SHA512_IV[0] | 0;
+      this.Al = SHA512_IV[1] | 0;
+      this.Bh = SHA512_IV[2] | 0;
+      this.Bl = SHA512_IV[3] | 0;
+      this.Ch = SHA512_IV[4] | 0;
+      this.Cl = SHA512_IV[5] | 0;
+      this.Dh = SHA512_IV[6] | 0;
+      this.Dl = SHA512_IV[7] | 0;
+      this.Eh = SHA512_IV[8] | 0;
+      this.El = SHA512_IV[9] | 0;
+      this.Fh = SHA512_IV[10] | 0;
+      this.Fl = SHA512_IV[11] | 0;
+      this.Gh = SHA512_IV[12] | 0;
+      this.Gl = SHA512_IV[13] | 0;
+      this.Hh = SHA512_IV[14] | 0;
+      this.Hl = SHA512_IV[15] | 0;
+    }
+    get() {
+      const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+      return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
+    }
+    set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+      this.Ah = Ah | 0;
+      this.Al = Al | 0;
+      this.Bh = Bh | 0;
+      this.Bl = Bl | 0;
+      this.Ch = Ch | 0;
+      this.Cl = Cl | 0;
+      this.Dh = Dh | 0;
+      this.Dl = Dl | 0;
+      this.Eh = Eh | 0;
+      this.El = El | 0;
+      this.Fh = Fh | 0;
+      this.Fl = Fl | 0;
+      this.Gh = Gh | 0;
+      this.Gl = Gl | 0;
+      this.Hh = Hh | 0;
+      this.Hl = Hl | 0;
+    }
+    process(view, offset) {
+      for (let i4 = 0;i4 < 16; i4++, offset += 4) {
+        SHA512_W_H[i4] = view.getUint32(offset);
+        SHA512_W_L[i4] = view.getUint32(offset += 4);
+      }
+      for (let i4 = 16;i4 < 80; i4++) {
+        const W15h = SHA512_W_H[i4 - 15] | 0;
+        const W15l = SHA512_W_L[i4 - 15] | 0;
+        const s0h = rotrSH(W15h, W15l, 1) ^ rotrSH(W15h, W15l, 8) ^ shrSH(W15h, W15l, 7);
+        const s0l = rotrSL(W15h, W15l, 1) ^ rotrSL(W15h, W15l, 8) ^ shrSL(W15h, W15l, 7);
+        const W2h = SHA512_W_H[i4 - 2] | 0;
+        const W2l = SHA512_W_L[i4 - 2] | 0;
+        const s1h = rotrSH(W2h, W2l, 19) ^ rotrBH(W2h, W2l, 61) ^ shrSH(W2h, W2l, 6);
+        const s1l = rotrSL(W2h, W2l, 19) ^ rotrBL(W2h, W2l, 61) ^ shrSL(W2h, W2l, 6);
+        const SUMl = add4L(s0l, s1l, SHA512_W_L[i4 - 7], SHA512_W_L[i4 - 16]);
+        const SUMh = add4H(SUMl, s0h, s1h, SHA512_W_H[i4 - 7], SHA512_W_H[i4 - 16]);
+        SHA512_W_H[i4] = SUMh | 0;
+        SHA512_W_L[i4] = SUMl | 0;
+      }
+      let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+      for (let i4 = 0;i4 < 80; i4++) {
+        const sigma1h = rotrSH(Eh, El, 14) ^ rotrSH(Eh, El, 18) ^ rotrBH(Eh, El, 41);
+        const sigma1l = rotrSL(Eh, El, 14) ^ rotrSL(Eh, El, 18) ^ rotrBL(Eh, El, 41);
+        const CHIh = Eh & Fh ^ ~Eh & Gh;
+        const CHIl = El & Fl ^ ~El & Gl;
+        const T1ll = add5L(Hl, sigma1l, CHIl, SHA512_Kl[i4], SHA512_W_L[i4]);
+        const T1h = add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i4], SHA512_W_H[i4]);
+        const T1l = T1ll | 0;
+        const sigma0h = rotrSH(Ah, Al, 28) ^ rotrBH(Ah, Al, 34) ^ rotrBH(Ah, Al, 39);
+        const sigma0l = rotrSL(Ah, Al, 28) ^ rotrBL(Ah, Al, 34) ^ rotrBL(Ah, Al, 39);
+        const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
+        const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
+        Hh = Gh | 0;
+        Hl = Gl | 0;
+        Gh = Fh | 0;
+        Gl = Fl | 0;
+        Fh = Eh | 0;
+        Fl = El | 0;
+        ({ h: Eh, l: El } = add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+        Dh = Ch | 0;
+        Dl = Cl | 0;
+        Ch = Bh | 0;
+        Cl = Bl | 0;
+        Bh = Ah | 0;
+        Bl = Al | 0;
+        const All = add3L(T1l, sigma0l, MAJl);
+        Ah = add3H(All, T1h, sigma0h, MAJh);
+        Al = All | 0;
+      }
+      ({ h: Ah, l: Al } = add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+      ({ h: Bh, l: Bl } = add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+      ({ h: Ch, l: Cl } = add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+      ({ h: Dh, l: Dl } = add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+      ({ h: Eh, l: El } = add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+      ({ h: Fh, l: Fl } = add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+      ({ h: Gh, l: Gl } = add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+      ({ h: Hh, l: Hl } = add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+      this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+    }
+    roundClean() {
+      clean(SHA512_W_H, SHA512_W_L);
+    }
+    destroy() {
+      clean(this.buffer);
+      this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+    }
+  };
   sha2563 = /* @__PURE__ */ createHasher(() => new SHA2563);
+  sha512 = /* @__PURE__ */ createHasher(() => new SHA512);
 });
 
 // ../routstr-chat/node_modules/applesauce-relay/dist/lib/negentropy.js
@@ -23542,9 +23872,9 @@ var require_bit_buffer = __commonJS((exports, module) => {
       const bufIndex = Math.floor(index / 8);
       return (this.buffer[bufIndex] >>> 7 - index % 8 & 1) === 1;
     },
-    put: function(num, length) {
+    put: function(num2, length) {
       for (let i4 = 0;i4 < length; i4++) {
-        this.putBit((num >>> length - i4 - 1 & 1) === 1);
+        this.putBit((num2 >>> length - i4 - 1 & 1) === 1);
       }
     },
     getLengthInBits: function() {
@@ -24702,15 +25032,15 @@ var require_dijkstra = __commonJS((exports, module) => {
     },
     PriorityQueue: {
       make: function(opts) {
-        var T = dijkstra.PriorityQueue, t = {}, key;
+        var T2 = dijkstra.PriorityQueue, t = {}, key;
         opts = opts || {};
-        for (key in T) {
-          if (T.hasOwnProperty(key)) {
-            t[key] = T[key];
+        for (key in T2) {
+          if (T2.hasOwnProperty(key)) {
+            t[key] = T2[key];
           }
         }
         t.queue = [];
-        t.sorter = opts.sorter || T.default_sorter;
+        t.sorter = opts.sorter || T2.default_sorter;
         return t;
       },
       default_sorter: function(a, b) {
@@ -24981,34 +25311,34 @@ var require_qrcode = __commonJS((exports) => {
   function setupVersionInfo(matrix, version) {
     const size = matrix.size;
     const bits = Version.getEncodedBits(version);
-    let row, col, mod2;
+    let row, col, mod3;
     for (let i4 = 0;i4 < 18; i4++) {
       row = Math.floor(i4 / 3);
       col = i4 % 3 + size - 8 - 3;
-      mod2 = (bits >> i4 & 1) === 1;
-      matrix.set(row, col, mod2, true);
-      matrix.set(col, row, mod2, true);
+      mod3 = (bits >> i4 & 1) === 1;
+      matrix.set(row, col, mod3, true);
+      matrix.set(col, row, mod3, true);
     }
   }
   function setupFormatInfo(matrix, errorCorrectionLevel, maskPattern) {
     const size = matrix.size;
     const bits = FormatInfo.getEncodedBits(errorCorrectionLevel, maskPattern);
-    let i4, mod2;
+    let i4, mod3;
     for (i4 = 0;i4 < 15; i4++) {
-      mod2 = (bits >> i4 & 1) === 1;
+      mod3 = (bits >> i4 & 1) === 1;
       if (i4 < 6) {
-        matrix.set(i4, 8, mod2, true);
+        matrix.set(i4, 8, mod3, true);
       } else if (i4 < 8) {
-        matrix.set(i4 + 1, 8, mod2, true);
+        matrix.set(i4 + 1, 8, mod3, true);
       } else {
-        matrix.set(size - 15 + i4, 8, mod2, true);
+        matrix.set(size - 15 + i4, 8, mod3, true);
       }
       if (i4 < 8) {
-        matrix.set(8, size - i4 - 1, mod2, true);
+        matrix.set(8, size - i4 - 1, mod3, true);
       } else if (i4 < 9) {
-        matrix.set(8, 15 - i4 - 1 + 1, mod2, true);
+        matrix.set(8, 15 - i4 - 1 + 1, mod3, true);
       } else {
-        matrix.set(8, 15 - i4 - 1, mod2, true);
+        matrix.set(8, 15 - i4 - 1, mod3, true);
       }
     }
     matrix.set(size - 8, 8, 1, true);
@@ -25915,7 +26245,7 @@ var require_bitmapper = __commonJS((exports) => {
   function bitRetriever(data, depth) {
     let leftOver = [];
     let i4 = 0;
-    function split() {
+    function split2() {
       if (i4 === data.length) {
         throw new Error("Ran out of data");
       }
@@ -25958,7 +26288,7 @@ var require_bitmapper = __commonJS((exports) => {
     return {
       get: function(count) {
         while (leftOver.length < count) {
-          split();
+          split2();
         }
         let returner = leftOver.slice(0, count);
         leftOver = leftOver.slice(count);
@@ -27067,16 +27397,16 @@ var require_png = __commonJS((exports) => {
 
 // node_modules/qrcode/lib/renderer/utils.js
 var require_utils2 = __commonJS((exports) => {
-  function hex2rgba(hex2) {
-    if (typeof hex2 === "number") {
-      hex2 = hex2.toString();
+  function hex2rgba(hex3) {
+    if (typeof hex3 === "number") {
+      hex3 = hex3.toString();
     }
-    if (typeof hex2 !== "string") {
+    if (typeof hex3 !== "string") {
       throw new Error("Color should be defined as hex string");
     }
-    let hexCode = hex2.slice().replace("#", "").split("");
+    let hexCode = hex3.slice().replace("#", "").split("");
     if (hexCode.length < 3 || hexCode.length === 5 || hexCode.length > 8) {
-      throw new Error("Invalid hex color: " + hex2);
+      throw new Error("Invalid hex color: " + hex3);
     }
     if (hexCode.length === 3 || hexCode.length === 4) {
       hexCode = Array.prototype.concat.apply([], hexCode.map(function(c) {
@@ -27569,7 +27899,7 @@ var require_browser2 = __commonJS((exports) => {
   exports.create = QRCode.create;
   exports.toCanvas = renderCanvas.bind(null, CanvasRenderer.render);
   exports.toDataURL = renderCanvas.bind(null, CanvasRenderer.renderToDataURL);
-  exports.toString = renderCanvas.bind(null, function(data, _, opts) {
+  exports.toString = renderCanvas.bind(null, function(data, _2, opts) {
     return SvgRenderer.render(data, opts);
   });
 });
@@ -27994,8 +28324,8 @@ function renderBox(lines, width, title) {
     result.push(`\u250C${"\u2500".repeat(Math.max(0, width - 2))}\u2510`);
   }
   for (const line of lines) {
-    const padding2 = Math.max(0, innerWidth - stripAnsi(line).length);
-    result.push(`\u2502 ${line}${" ".repeat(padding2)} \u2502`);
+    const padding3 = Math.max(0, innerWidth - stripAnsi(line).length);
+    result.push(`\u2502 ${line}${" ".repeat(padding3)} \u2502`);
   }
   result.push(`\u2514${"\u2500".repeat(Math.max(0, width - 2))}\u2518`);
   return result.join(`
@@ -30392,6 +30722,4324 @@ init_observable();
 // ../routstr-chat/sdk/dist/index.mjs
 init_dist();
 
+// ../routstr-chat/node_modules/@noble/curves/esm/secp256k1.js
+init_sha2();
+init_utils6();
+
+// ../routstr-chat/node_modules/@noble/hashes/esm/hmac.js
+init_utils6();
+
+class HMAC3 extends Hash3 {
+  constructor(hash3, _key) {
+    super();
+    this.finished = false;
+    this.destroyed = false;
+    ahash(hash3);
+    const key = toBytes4(_key);
+    this.iHash = hash3.create();
+    if (typeof this.iHash.update !== "function")
+      throw new Error("Expected instance of class which extends utils.Hash");
+    this.blockLen = this.iHash.blockLen;
+    this.outputLen = this.iHash.outputLen;
+    const blockLen = this.blockLen;
+    const pad2 = new Uint8Array(blockLen);
+    pad2.set(key.length > blockLen ? hash3.create().update(key).digest() : key);
+    for (let i4 = 0;i4 < pad2.length; i4++)
+      pad2[i4] ^= 54;
+    this.iHash.update(pad2);
+    this.oHash = hash3.create();
+    for (let i4 = 0;i4 < pad2.length; i4++)
+      pad2[i4] ^= 54 ^ 92;
+    this.oHash.update(pad2);
+    clean(pad2);
+  }
+  update(buf) {
+    aexists(this);
+    this.iHash.update(buf);
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    abytes(out, this.outputLen);
+    this.finished = true;
+    this.iHash.digestInto(out);
+    this.oHash.update(out);
+    this.oHash.digestInto(out);
+    this.destroy();
+  }
+  digest() {
+    const out = new Uint8Array(this.oHash.outputLen);
+    this.digestInto(out);
+    return out;
+  }
+  _cloneInto(to) {
+    to || (to = Object.create(Object.getPrototypeOf(this), {}));
+    const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+    to = to;
+    to.finished = finished;
+    to.destroyed = destroyed;
+    to.blockLen = blockLen;
+    to.outputLen = outputLen;
+    to.oHash = oHash._cloneInto(to.oHash);
+    to.iHash = iHash._cloneInto(to.iHash);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = true;
+    this.oHash.destroy();
+    this.iHash.destroy();
+  }
+}
+var hmac3 = (hash3, key, message) => new HMAC3(hash3, key).update(message).digest();
+hmac3.create = (hash3, key) => new HMAC3(hash3, key);
+
+// ../routstr-chat/node_modules/@noble/curves/esm/abstract/weierstrass.js
+init_utils6();
+
+// ../routstr-chat/node_modules/@noble/curves/esm/utils.js
+init_utils6();
+init_utils6();
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+var _0n6 = /* @__PURE__ */ BigInt(0);
+var _1n6 = /* @__PURE__ */ BigInt(1);
+function _abool2(value, title = "") {
+  if (typeof value !== "boolean") {
+    const prefix = title && `"${title}"`;
+    throw new Error(prefix + "expected boolean, got type=" + typeof value);
+  }
+  return value;
+}
+function _abytes2(value, length, title = "") {
+  const bytes4 = isBytes2(value);
+  const len = value?.length;
+  const needsLen = length !== undefined;
+  if (!bytes4 || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes4 ? `length=${len}` : `type=${typeof value}`;
+    throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+  }
+  return value;
+}
+function numberToHexUnpadded2(num) {
+  const hex2 = num.toString(16);
+  return hex2.length & 1 ? "0" + hex2 : hex2;
+}
+function hexToNumber2(hex2) {
+  if (typeof hex2 !== "string")
+    throw new Error("hex string expected, got " + typeof hex2);
+  return hex2 === "" ? _0n6 : BigInt("0x" + hex2);
+}
+function bytesToNumberBE2(bytes4) {
+  return hexToNumber2(bytesToHex4(bytes4));
+}
+function bytesToNumberLE2(bytes4) {
+  abytes(bytes4);
+  return hexToNumber2(bytesToHex4(Uint8Array.from(bytes4).reverse()));
+}
+function numberToBytesBE2(n, len) {
+  return hexToBytes4(n.toString(16).padStart(len * 2, "0"));
+}
+function numberToBytesLE2(n, len) {
+  return numberToBytesBE2(n, len).reverse();
+}
+function ensureBytes2(title, hex2, expectedLength) {
+  let res;
+  if (typeof hex2 === "string") {
+    try {
+      res = hexToBytes4(hex2);
+    } catch (e) {
+      throw new Error(title + " must be hex string or Uint8Array, cause: " + e);
+    }
+  } else if (isBytes2(hex2)) {
+    res = Uint8Array.from(hex2);
+  } else {
+    throw new Error(title + " must be hex string or Uint8Array");
+  }
+  const len = res.length;
+  if (typeof expectedLength === "number" && len !== expectedLength)
+    throw new Error(title + " of length " + expectedLength + " expected, got " + len);
+  return res;
+}
+var isPosBig = (n) => typeof n === "bigint" && _0n6 <= n;
+function inRange(n, min, max) {
+  return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
+}
+function aInRange(title, n, min, max) {
+  if (!inRange(n, min, max))
+    throw new Error("expected valid " + title + ": " + min + " <= n < " + max + ", got " + n);
+}
+function bitLen2(n) {
+  let len;
+  for (len = 0;n > _0n6; n >>= _1n6, len += 1)
+    ;
+  return len;
+}
+var bitMask2 = (n) => (_1n6 << BigInt(n)) - _1n6;
+function createHmacDrbg2(hashLen, qByteLen, hmacFn) {
+  if (typeof hashLen !== "number" || hashLen < 2)
+    throw new Error("hashLen must be a number");
+  if (typeof qByteLen !== "number" || qByteLen < 2)
+    throw new Error("qByteLen must be a number");
+  if (typeof hmacFn !== "function")
+    throw new Error("hmacFn must be a function");
+  const u8n2 = (len) => new Uint8Array(len);
+  const u8of = (byte) => Uint8Array.of(byte);
+  let v = u8n2(hashLen);
+  let k = u8n2(hashLen);
+  let i4 = 0;
+  const reset = () => {
+    v.fill(1);
+    k.fill(0);
+    i4 = 0;
+  };
+  const h = (...b) => hmacFn(k, v, ...b);
+  const reseed = (seed = u8n2(0)) => {
+    k = h(u8of(0), seed);
+    v = h();
+    if (seed.length === 0)
+      return;
+    k = h(u8of(1), seed);
+    v = h();
+  };
+  const gen = () => {
+    if (i4++ >= 1000)
+      throw new Error("drbg: tried 1000 values");
+    let len = 0;
+    const out = [];
+    while (len < qByteLen) {
+      v = h();
+      const sl = v.slice();
+      out.push(sl);
+      len += v.length;
+    }
+    return concatBytes4(...out);
+  };
+  const genUntil = (seed, pred) => {
+    reset();
+    reseed(seed);
+    let res = undefined;
+    while (!(res = pred(gen())))
+      reseed();
+    reset();
+    return res;
+  };
+  return genUntil;
+}
+function _validateObject(object, fields, optFields = {}) {
+  if (!object || typeof object !== "object")
+    throw new Error("expected valid options object");
+  function checkField(fieldName, expectedType, isOpt) {
+    const val = object[fieldName];
+    if (isOpt && val === undefined)
+      return;
+    const current = typeof val;
+    if (current !== expectedType || val === null)
+      throw new Error(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`);
+  }
+  Object.entries(fields).forEach(([k, v]) => checkField(k, v, false));
+  Object.entries(optFields).forEach(([k, v]) => checkField(k, v, true));
+}
+function memoized(fn) {
+  const map13 = new WeakMap;
+  return (arg, ...args) => {
+    const val = map13.get(arg);
+    if (val !== undefined)
+      return val;
+    const computed = fn(arg, ...args);
+    map13.set(arg, computed);
+    return computed;
+  };
+}
+
+// ../routstr-chat/node_modules/@noble/curves/esm/abstract/modular.js
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+var _0n7 = BigInt(0);
+var _1n7 = BigInt(1);
+var _2n5 = /* @__PURE__ */ BigInt(2);
+var _3n3 = /* @__PURE__ */ BigInt(3);
+var _4n3 = /* @__PURE__ */ BigInt(4);
+var _5n2 = /* @__PURE__ */ BigInt(5);
+var _7n = /* @__PURE__ */ BigInt(7);
+var _8n2 = /* @__PURE__ */ BigInt(8);
+var _9n2 = /* @__PURE__ */ BigInt(9);
+var _16n2 = /* @__PURE__ */ BigInt(16);
+function mod2(a, b) {
+  const result = a % b;
+  return result >= _0n7 ? result : b + result;
+}
+function pow22(x, power, modulo) {
+  let res = x;
+  while (power-- > _0n7) {
+    res *= res;
+    res %= modulo;
+  }
+  return res;
+}
+function invert2(number4, modulo) {
+  if (number4 === _0n7)
+    throw new Error("invert: expected non-zero number");
+  if (modulo <= _0n7)
+    throw new Error("invert: expected positive modulus, got " + modulo);
+  let a = mod2(number4, modulo);
+  let b = modulo;
+  let x = _0n7, y = _1n7, u = _1n7, v = _0n7;
+  while (a !== _0n7) {
+    const q = b / a;
+    const r = b % a;
+    const m = x - u * q;
+    const n = y - v * q;
+    b = a, a = r, x = u, y = v, u = m, v = n;
+  }
+  const gcd2 = b;
+  if (gcd2 !== _1n7)
+    throw new Error("invert: does not exist");
+  return mod2(x, modulo);
+}
+function assertIsSquare(Fp2, root, n) {
+  if (!Fp2.eql(Fp2.sqr(root), n))
+    throw new Error("Cannot find square root");
+}
+function sqrt3mod4(Fp2, n) {
+  const p1div4 = (Fp2.ORDER + _1n7) / _4n3;
+  const root = Fp2.pow(n, p1div4);
+  assertIsSquare(Fp2, root, n);
+  return root;
+}
+function sqrt5mod8(Fp2, n) {
+  const p5div8 = (Fp2.ORDER - _5n2) / _8n2;
+  const n2 = Fp2.mul(n, _2n5);
+  const v = Fp2.pow(n2, p5div8);
+  const nv = Fp2.mul(n, v);
+  const i4 = Fp2.mul(Fp2.mul(nv, _2n5), v);
+  const root = Fp2.mul(nv, Fp2.sub(i4, Fp2.ONE));
+  assertIsSquare(Fp2, root, n);
+  return root;
+}
+function sqrt9mod16(P) {
+  const Fp_ = Field2(P);
+  const tn = tonelliShanks2(P);
+  const c1 = tn(Fp_, Fp_.neg(Fp_.ONE));
+  const c2 = tn(Fp_, c1);
+  const c3 = tn(Fp_, Fp_.neg(c1));
+  const c4 = (P + _7n) / _16n2;
+  return (Fp2, n) => {
+    let tv1 = Fp2.pow(n, c4);
+    let tv2 = Fp2.mul(tv1, c1);
+    const tv3 = Fp2.mul(tv1, c2);
+    const tv4 = Fp2.mul(tv1, c3);
+    const e1 = Fp2.eql(Fp2.sqr(tv2), n);
+    const e2 = Fp2.eql(Fp2.sqr(tv3), n);
+    tv1 = Fp2.cmov(tv1, tv2, e1);
+    tv2 = Fp2.cmov(tv4, tv3, e2);
+    const e3 = Fp2.eql(Fp2.sqr(tv2), n);
+    const root = Fp2.cmov(tv1, tv2, e3);
+    assertIsSquare(Fp2, root, n);
+    return root;
+  };
+}
+function tonelliShanks2(P) {
+  if (P < _3n3)
+    throw new Error("sqrt is not defined for small field");
+  let Q = P - _1n7;
+  let S = 0;
+  while (Q % _2n5 === _0n7) {
+    Q /= _2n5;
+    S++;
+  }
+  let Z = _2n5;
+  const _Fp = Field2(P);
+  while (FpLegendre(_Fp, Z) === 1) {
+    if (Z++ > 1000)
+      throw new Error("Cannot find square root: probably non-prime P");
+  }
+  if (S === 1)
+    return sqrt3mod4;
+  let cc = _Fp.pow(Z, Q);
+  const Q1div2 = (Q + _1n7) / _2n5;
+  return function tonelliSlow(Fp2, n) {
+    if (Fp2.is0(n))
+      return n;
+    if (FpLegendre(Fp2, n) !== 1)
+      throw new Error("Cannot find square root");
+    let M = S;
+    let c = Fp2.mul(Fp2.ONE, cc);
+    let t = Fp2.pow(n, Q);
+    let R = Fp2.pow(n, Q1div2);
+    while (!Fp2.eql(t, Fp2.ONE)) {
+      if (Fp2.is0(t))
+        return Fp2.ZERO;
+      let i4 = 1;
+      let t_tmp = Fp2.sqr(t);
+      while (!Fp2.eql(t_tmp, Fp2.ONE)) {
+        i4++;
+        t_tmp = Fp2.sqr(t_tmp);
+        if (i4 === M)
+          throw new Error("Cannot find square root");
+      }
+      const exponent = _1n7 << BigInt(M - i4 - 1);
+      const b = Fp2.pow(c, exponent);
+      M = i4;
+      c = Fp2.sqr(b);
+      t = Fp2.mul(t, c);
+      R = Fp2.mul(R, b);
+    }
+    return R;
+  };
+}
+function FpSqrt2(P) {
+  if (P % _4n3 === _3n3)
+    return sqrt3mod4;
+  if (P % _8n2 === _5n2)
+    return sqrt5mod8;
+  if (P % _16n2 === _9n2)
+    return sqrt9mod16(P);
+  return tonelliShanks2(P);
+}
+var FIELD_FIELDS2 = [
+  "create",
+  "isValid",
+  "is0",
+  "neg",
+  "inv",
+  "sqrt",
+  "sqr",
+  "eql",
+  "add",
+  "sub",
+  "mul",
+  "pow",
+  "div",
+  "addN",
+  "subN",
+  "mulN",
+  "sqrN"
+];
+function validateField2(field) {
+  const initial = {
+    ORDER: "bigint",
+    MASK: "bigint",
+    BYTES: "number",
+    BITS: "number"
+  };
+  const opts = FIELD_FIELDS2.reduce((map13, val) => {
+    map13[val] = "function";
+    return map13;
+  }, initial);
+  _validateObject(field, opts);
+  return field;
+}
+function FpPow2(Fp2, num, power) {
+  if (power < _0n7)
+    throw new Error("invalid exponent, negatives unsupported");
+  if (power === _0n7)
+    return Fp2.ONE;
+  if (power === _1n7)
+    return num;
+  let p = Fp2.ONE;
+  let d = num;
+  while (power > _0n7) {
+    if (power & _1n7)
+      p = Fp2.mul(p, d);
+    d = Fp2.sqr(d);
+    power >>= _1n7;
+  }
+  return p;
+}
+function FpInvertBatch2(Fp2, nums, passZero = false) {
+  const inverted = new Array(nums.length).fill(passZero ? Fp2.ZERO : undefined);
+  const multipliedAcc = nums.reduce((acc, num, i4) => {
+    if (Fp2.is0(num))
+      return acc;
+    inverted[i4] = acc;
+    return Fp2.mul(acc, num);
+  }, Fp2.ONE);
+  const invertedAcc = Fp2.inv(multipliedAcc);
+  nums.reduceRight((acc, num, i4) => {
+    if (Fp2.is0(num))
+      return acc;
+    inverted[i4] = Fp2.mul(acc, inverted[i4]);
+    return Fp2.mul(acc, num);
+  }, invertedAcc);
+  return inverted;
+}
+function FpLegendre(Fp2, n) {
+  const p1mod2 = (Fp2.ORDER - _1n7) / _2n5;
+  const powered = Fp2.pow(n, p1mod2);
+  const yes = Fp2.eql(powered, Fp2.ONE);
+  const zero = Fp2.eql(powered, Fp2.ZERO);
+  const no = Fp2.eql(powered, Fp2.neg(Fp2.ONE));
+  if (!yes && !zero && !no)
+    throw new Error("invalid Legendre symbol result");
+  return yes ? 1 : zero ? 0 : -1;
+}
+function nLength2(n, nBitLength) {
+  if (nBitLength !== undefined)
+    anumber(nBitLength);
+  const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;
+  const nByteLength = Math.ceil(_nBitLength / 8);
+  return { nBitLength: _nBitLength, nByteLength };
+}
+function Field2(ORDER, bitLenOrOpts, isLE4 = false, opts = {}) {
+  if (ORDER <= _0n7)
+    throw new Error("invalid field: expected ORDER > 0, got " + ORDER);
+  let _nbitLength = undefined;
+  let _sqrt = undefined;
+  let modFromBytes = false;
+  let allowedLengths = undefined;
+  if (typeof bitLenOrOpts === "object" && bitLenOrOpts != null) {
+    if (opts.sqrt || isLE4)
+      throw new Error("cannot specify opts in two arguments");
+    const _opts = bitLenOrOpts;
+    if (_opts.BITS)
+      _nbitLength = _opts.BITS;
+    if (_opts.sqrt)
+      _sqrt = _opts.sqrt;
+    if (typeof _opts.isLE === "boolean")
+      isLE4 = _opts.isLE;
+    if (typeof _opts.modFromBytes === "boolean")
+      modFromBytes = _opts.modFromBytes;
+    allowedLengths = _opts.allowedLengths;
+  } else {
+    if (typeof bitLenOrOpts === "number")
+      _nbitLength = bitLenOrOpts;
+    if (opts.sqrt)
+      _sqrt = opts.sqrt;
+  }
+  const { nBitLength: BITS, nByteLength: BYTES } = nLength2(ORDER, _nbitLength);
+  if (BYTES > 2048)
+    throw new Error("invalid field: expected ORDER of <= 2048 bytes");
+  let sqrtP;
+  const f = Object.freeze({
+    ORDER,
+    isLE: isLE4,
+    BITS,
+    BYTES,
+    MASK: bitMask2(BITS),
+    ZERO: _0n7,
+    ONE: _1n7,
+    allowedLengths,
+    create: (num) => mod2(num, ORDER),
+    isValid: (num) => {
+      if (typeof num !== "bigint")
+        throw new Error("invalid field element: expected bigint, got " + typeof num);
+      return _0n7 <= num && num < ORDER;
+    },
+    is0: (num) => num === _0n7,
+    isValidNot0: (num) => !f.is0(num) && f.isValid(num),
+    isOdd: (num) => (num & _1n7) === _1n7,
+    neg: (num) => mod2(-num, ORDER),
+    eql: (lhs, rhs) => lhs === rhs,
+    sqr: (num) => mod2(num * num, ORDER),
+    add: (lhs, rhs) => mod2(lhs + rhs, ORDER),
+    sub: (lhs, rhs) => mod2(lhs - rhs, ORDER),
+    mul: (lhs, rhs) => mod2(lhs * rhs, ORDER),
+    pow: (num, power) => FpPow2(f, num, power),
+    div: (lhs, rhs) => mod2(lhs * invert2(rhs, ORDER), ORDER),
+    sqrN: (num) => num * num,
+    addN: (lhs, rhs) => lhs + rhs,
+    subN: (lhs, rhs) => lhs - rhs,
+    mulN: (lhs, rhs) => lhs * rhs,
+    inv: (num) => invert2(num, ORDER),
+    sqrt: _sqrt || ((n) => {
+      if (!sqrtP)
+        sqrtP = FpSqrt2(ORDER);
+      return sqrtP(f, n);
+    }),
+    toBytes: (num) => isLE4 ? numberToBytesLE2(num, BYTES) : numberToBytesBE2(num, BYTES),
+    fromBytes: (bytes4, skipValidation = true) => {
+      if (allowedLengths) {
+        if (!allowedLengths.includes(bytes4.length) || bytes4.length > BYTES) {
+          throw new Error("Field.fromBytes: expected " + allowedLengths + " bytes, got " + bytes4.length);
+        }
+        const padded = new Uint8Array(BYTES);
+        padded.set(bytes4, isLE4 ? 0 : padded.length - bytes4.length);
+        bytes4 = padded;
+      }
+      if (bytes4.length !== BYTES)
+        throw new Error("Field.fromBytes: expected " + BYTES + " bytes, got " + bytes4.length);
+      let scalar = isLE4 ? bytesToNumberLE2(bytes4) : bytesToNumberBE2(bytes4);
+      if (modFromBytes)
+        scalar = mod2(scalar, ORDER);
+      if (!skipValidation) {
+        if (!f.isValid(scalar))
+          throw new Error("invalid field element: outside of range 0..ORDER");
+      }
+      return scalar;
+    },
+    invertBatch: (lst) => FpInvertBatch2(f, lst),
+    cmov: (a, b, c) => c ? b : a
+  });
+  return Object.freeze(f);
+}
+function getFieldBytesLength2(fieldOrder) {
+  if (typeof fieldOrder !== "bigint")
+    throw new Error("field order must be bigint");
+  const bitLength = fieldOrder.toString(2).length;
+  return Math.ceil(bitLength / 8);
+}
+function getMinHashLength2(fieldOrder) {
+  const length = getFieldBytesLength2(fieldOrder);
+  return length + Math.ceil(length / 2);
+}
+function mapHashToField2(key, fieldOrder, isLE4 = false) {
+  const len = key.length;
+  const fieldLen = getFieldBytesLength2(fieldOrder);
+  const minLen = getMinHashLength2(fieldOrder);
+  if (len < 16 || len < minLen || len > 1024)
+    throw new Error("expected " + minLen + "-1024 bytes of input, got " + len);
+  const num = isLE4 ? bytesToNumberLE2(key) : bytesToNumberBE2(key);
+  const reduced = mod2(num, fieldOrder - _1n7) + _1n7;
+  return isLE4 ? numberToBytesLE2(reduced, fieldLen) : numberToBytesBE2(reduced, fieldLen);
+}
+
+// ../routstr-chat/node_modules/@noble/curves/esm/abstract/curve.js
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+var _0n8 = BigInt(0);
+var _1n8 = BigInt(1);
+function negateCt(condition, item) {
+  const neg = item.negate();
+  return condition ? neg : item;
+}
+function normalizeZ(c, points) {
+  const invertedZs = FpInvertBatch2(c.Fp, points.map((p) => p.Z));
+  return points.map((p, i4) => c.fromAffine(p.toAffine(invertedZs[i4])));
+}
+function validateW(W, bits) {
+  if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
+    throw new Error("invalid window size, expected [1.." + bits + "], got W=" + W);
+}
+function calcWOpts(W, scalarBits) {
+  validateW(W, scalarBits);
+  const windows = Math.ceil(scalarBits / W) + 1;
+  const windowSize = 2 ** (W - 1);
+  const maxNumber = 2 ** W;
+  const mask = bitMask2(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 += _1n8;
+  }
+  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))
+    throw new Error("array expected");
+  points.forEach((p, i4) => {
+    if (!(p instanceof c))
+      throw new Error("invalid point at index " + i4);
+  });
+}
+function validateMSMScalars(scalars, field) {
+  if (!Array.isArray(scalars))
+    throw new Error("array of scalars expected");
+  scalars.forEach((s, i4) => {
+    if (!field.isValid(s))
+      throw new Error("invalid scalar at index " + i4);
+  });
+}
+var pointPrecomputes = new WeakMap;
+var pointWindowSizes = new WeakMap;
+function getW(P) {
+  return pointWindowSizes.get(P) || 1;
+}
+function assert0(n) {
+  if (n !== _0n8)
+    throw new Error("invalid wNAF");
+}
+
+class wNAF2 {
+  constructor(Point2, bits) {
+    this.BASE = Point2.BASE;
+    this.ZERO = Point2.ZERO;
+    this.Fn = Point2.Fn;
+    this.bits = bits;
+  }
+  _unsafeLadder(elm, n, p = this.ZERO) {
+    let d = elm;
+    while (n > _0n8) {
+      if (n & _1n8)
+        p = p.add(d);
+      d = d.double();
+      n >>= _1n8;
+    }
+    return p;
+  }
+  precomputeWindow(point, W) {
+    const { windows, windowSize } = calcWOpts(W, this.bits);
+    const points = [];
+    let p = point;
+    let base2 = p;
+    for (let window2 = 0;window2 < windows; window2++) {
+      base2 = p;
+      points.push(base2);
+      for (let i4 = 1;i4 < windowSize; i4++) {
+        base2 = base2.add(p);
+        points.push(base2);
+      }
+      p = base2.double();
+    }
+    return points;
+  }
+  wNAF(W, precomputes, n) {
+    if (!this.Fn.isValid(n))
+      throw new Error("invalid scalar");
+    let p = this.ZERO;
+    let f = this.BASE;
+    const wo = calcWOpts(W, this.bits);
+    for (let window2 = 0;window2 < wo.windows; window2++) {
+      const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window2, wo);
+      n = nextN;
+      if (isZero) {
+        f = f.add(negateCt(isNegF, precomputes[offsetF]));
+      } else {
+        p = p.add(negateCt(isNeg, precomputes[offset]));
+      }
+    }
+    assert0(n);
+    return { p, f };
+  }
+  wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {
+    const wo = calcWOpts(W, this.bits);
+    for (let window2 = 0;window2 < wo.windows; window2++) {
+      if (n === _0n8)
+        break;
+      const { nextN, offset, isZero, isNeg } = calcOffsets(n, window2, wo);
+      n = nextN;
+      if (isZero) {
+        continue;
+      } else {
+        const item = precomputes[offset];
+        acc = acc.add(isNeg ? item.negate() : item);
+      }
+    }
+    assert0(n);
+    return acc;
+  }
+  getPrecomputes(W, point, transform) {
+    let comp = pointPrecomputes.get(point);
+    if (!comp) {
+      comp = this.precomputeWindow(point, W);
+      if (W !== 1) {
+        if (typeof transform === "function")
+          comp = transform(comp);
+        pointPrecomputes.set(point, comp);
+      }
+    }
+    return comp;
+  }
+  cached(point, scalar, transform) {
+    const W = getW(point);
+    return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar);
+  }
+  unsafe(point, scalar, transform, prev) {
+    const W = getW(point);
+    if (W === 1)
+      return this._unsafeLadder(point, scalar, prev);
+    return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, prev);
+  }
+  createCache(P, W) {
+    validateW(W, this.bits);
+    pointWindowSizes.set(P, W);
+    pointPrecomputes.delete(P);
+  }
+  hasCache(elm) {
+    return getW(elm) !== 1;
+  }
+}
+function mulEndoUnsafe(Point2, point, k1, k2) {
+  let acc = point;
+  let p1 = Point2.ZERO;
+  let p2 = Point2.ZERO;
+  while (k1 > _0n8 || k2 > _0n8) {
+    if (k1 & _1n8)
+      p1 = p1.add(acc);
+    if (k2 & _1n8)
+      p2 = p2.add(acc);
+    acc = acc.double();
+    k1 >>= _1n8;
+    k2 >>= _1n8;
+  }
+  return { p1, p2 };
+}
+function pippenger(c, fieldN, points, scalars) {
+  validateMSMPoints(points, c);
+  validateMSMScalars(scalars, fieldN);
+  const plength = points.length;
+  const slength = scalars.length;
+  if (plength !== slength)
+    throw new Error("arrays of points and scalars must have equal length");
+  const zero = c.ZERO;
+  const wbits = bitLen2(BigInt(plength));
+  let windowSize = 1;
+  if (wbits > 12)
+    windowSize = wbits - 3;
+  else if (wbits > 4)
+    windowSize = wbits - 2;
+  else if (wbits > 0)
+    windowSize = 2;
+  const MASK = bitMask2(windowSize);
+  const buckets = new Array(Number(MASK) + 1).fill(zero);
+  const lastBits = Math.floor((fieldN.BITS - 1) / windowSize) * windowSize;
+  let sum = zero;
+  for (let i4 = lastBits;i4 >= 0; i4 -= windowSize) {
+    buckets.fill(zero);
+    for (let j = 0;j < slength; j++) {
+      const scalar = scalars[j];
+      const wbits2 = Number(scalar >> BigInt(i4) & MASK);
+      buckets[wbits2] = buckets[wbits2].add(points[j]);
+    }
+    let resI = zero;
+    for (let j = buckets.length - 1, sumI = zero;j > 0; j--) {
+      sumI = sumI.add(buckets[j]);
+      resI = resI.add(sumI);
+    }
+    sum = sum.add(resI);
+    if (i4 !== 0)
+      for (let j = 0;j < windowSize; j++)
+        sum = sum.double();
+  }
+  return sum;
+}
+function createField(order, field, isLE4) {
+  if (field) {
+    if (field.ORDER !== order)
+      throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+    validateField2(field);
+    return field;
+  } else {
+    return Field2(order, { isLE: isLE4 });
+  }
+}
+function _createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {
+  if (FpFnLE === undefined)
+    FpFnLE = type === "edwards";
+  if (!CURVE || typeof CURVE !== "object")
+    throw new Error(`expected valid ${type} CURVE object`);
+  for (const p of ["p", "n", "h"]) {
+    const val = CURVE[p];
+    if (!(typeof val === "bigint" && val > _0n8))
+      throw new Error(`CURVE.${p} must be positive bigint`);
+  }
+  const Fp2 = createField(CURVE.p, curveOpts.Fp, FpFnLE);
+  const Fn = createField(CURVE.n, curveOpts.Fn, FpFnLE);
+  const _b = type === "weierstrass" ? "b" : "d";
+  const params = ["Gx", "Gy", "a", _b];
+  for (const p of params) {
+    if (!Fp2.isValid(CURVE[p]))
+      throw new Error(`CURVE.${p} must be valid field element of CURVE.Fp`);
+  }
+  CURVE = Object.freeze(Object.assign({}, CURVE));
+  return { CURVE, Fp: Fp2, Fn };
+}
+
+// ../routstr-chat/node_modules/@noble/curves/esm/abstract/weierstrass.js
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+var divNearest2 = (num, den) => (num + (num >= 0 ? den : -den) / _2n6) / den;
+function _splitEndoScalar(k, basis, n) {
+  const [[a1, b1], [a2, b2]] = basis;
+  const c1 = divNearest2(b2 * k, n);
+  const c2 = divNearest2(-b1 * k, n);
+  let k1 = k - c1 * a1 - c2 * a2;
+  let k2 = -c1 * b1 - c2 * b2;
+  const k1neg = k1 < _0n9;
+  const k2neg = k2 < _0n9;
+  if (k1neg)
+    k1 = -k1;
+  if (k2neg)
+    k2 = -k2;
+  const MAX_NUM = bitMask2(Math.ceil(bitLen2(n) / 2)) + _1n9;
+  if (k1 < _0n9 || k1 >= MAX_NUM || k2 < _0n9 || k2 >= MAX_NUM) {
+    throw new Error("splitScalar (endomorphism): failed, k=" + k);
+  }
+  return { k1neg, k1, k2neg, k2 };
+}
+function validateSigFormat(format) {
+  if (!["compact", "recovered", "der"].includes(format))
+    throw new Error('Signature format must be "compact", "recovered", or "der"');
+  return format;
+}
+function validateSigOpts(opts, def) {
+  const optsn = {};
+  for (let optName of Object.keys(def)) {
+    optsn[optName] = opts[optName] === undefined ? def[optName] : opts[optName];
+  }
+  _abool2(optsn.lowS, "lowS");
+  _abool2(optsn.prehash, "prehash");
+  if (optsn.format !== undefined)
+    validateSigFormat(optsn.format);
+  return optsn;
+}
+
+class DERErr2 extends Error {
+  constructor(m = "") {
+    super(m);
+  }
+}
+var DER2 = {
+  Err: DERErr2,
+  _tlv: {
+    encode: (tag, data) => {
+      const { Err: E } = DER2;
+      if (tag < 0 || tag > 256)
+        throw new E("tlv.encode: wrong tag");
+      if (data.length & 1)
+        throw new E("tlv.encode: unpadded data");
+      const dataLen = data.length / 2;
+      const len = numberToHexUnpadded2(dataLen);
+      if (len.length / 2 & 128)
+        throw new E("tlv.encode: long form length too big");
+      const lenLen = dataLen > 127 ? numberToHexUnpadded2(len.length / 2 | 128) : "";
+      const t = numberToHexUnpadded2(tag);
+      return t + lenLen + len + data;
+    },
+    decode(tag, data) {
+      const { Err: E } = DER2;
+      let pos = 0;
+      if (tag < 0 || tag > 256)
+        throw new E("tlv.encode: wrong tag");
+      if (data.length < 2 || data[pos++] !== tag)
+        throw new E("tlv.decode: wrong tlv");
+      const first = data[pos++];
+      const isLong = !!(first & 128);
+      let length = 0;
+      if (!isLong)
+        length = first;
+      else {
+        const lenLen = first & 127;
+        if (!lenLen)
+          throw new E("tlv.decode(long): indefinite length not supported");
+        if (lenLen > 4)
+          throw new E("tlv.decode(long): byte length is too big");
+        const lengthBytes = data.subarray(pos, pos + lenLen);
+        if (lengthBytes.length !== lenLen)
+          throw new E("tlv.decode: length bytes not complete");
+        if (lengthBytes[0] === 0)
+          throw new E("tlv.decode(long): zero leftmost byte");
+        for (const b of lengthBytes)
+          length = length << 8 | b;
+        pos += lenLen;
+        if (length < 128)
+          throw new E("tlv.decode(long): not minimal encoding");
+      }
+      const v = data.subarray(pos, pos + length);
+      if (v.length !== length)
+        throw new E("tlv.decode: wrong value length");
+      return { v, l: data.subarray(pos + length) };
+    }
+  },
+  _int: {
+    encode(num) {
+      const { Err: E } = DER2;
+      if (num < _0n9)
+        throw new E("integer: negative integers are not allowed");
+      let hex2 = numberToHexUnpadded2(num);
+      if (Number.parseInt(hex2[0], 16) & 8)
+        hex2 = "00" + hex2;
+      if (hex2.length & 1)
+        throw new E("unexpected DER parsing assertion: unpadded hex");
+      return hex2;
+    },
+    decode(data) {
+      const { Err: E } = DER2;
+      if (data[0] & 128)
+        throw new E("invalid signature integer: negative");
+      if (data[0] === 0 && !(data[1] & 128))
+        throw new E("invalid signature integer: unnecessary leading zero");
+      return bytesToNumberBE2(data);
+    }
+  },
+  toSig(hex2) {
+    const { Err: E, _int: int, _tlv: tlv } = DER2;
+    const data = ensureBytes2("signature", hex2);
+    const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data);
+    if (seqLeftBytes.length)
+      throw new E("invalid signature: left bytes after parsing");
+    const { v: rBytes, l: rLeftBytes } = tlv.decode(2, seqBytes);
+    const { v: sBytes, l: sLeftBytes } = tlv.decode(2, rLeftBytes);
+    if (sLeftBytes.length)
+      throw new E("invalid signature: left bytes after parsing");
+    return { r: int.decode(rBytes), s: int.decode(sBytes) };
+  },
+  hexFromSig(sig) {
+    const { _tlv: tlv, _int: int } = DER2;
+    const rs = tlv.encode(2, int.encode(sig.r));
+    const ss = tlv.encode(2, int.encode(sig.s));
+    const seq = rs + ss;
+    return tlv.encode(48, seq);
+  }
+};
+var _0n9 = BigInt(0);
+var _1n9 = BigInt(1);
+var _2n6 = BigInt(2);
+var _3n4 = BigInt(3);
+var _4n4 = BigInt(4);
+function _normFnElement(Fn, key) {
+  const { BYTES: expected } = Fn;
+  let num;
+  if (typeof key === "bigint") {
+    num = key;
+  } else {
+    let bytes4 = ensureBytes2("private key", key);
+    try {
+      num = Fn.fromBytes(bytes4);
+    } catch (error) {
+      throw new Error(`invalid private key: expected ui8a of size ${expected}, got ${typeof key}`);
+    }
+  }
+  if (!Fn.isValidNot0(num))
+    throw new Error("invalid private key: out of range [1..N-1]");
+  return num;
+}
+function weierstrassN(params, extraOpts = {}) {
+  const validated = _createCurveFields("weierstrass", params, extraOpts);
+  const { Fp: Fp2, Fn } = validated;
+  let CURVE = validated.CURVE;
+  const { h: cofactor, n: CURVE_ORDER } = CURVE;
+  _validateObject(extraOpts, {}, {
+    allowInfinityPoint: "boolean",
+    clearCofactor: "function",
+    isTorsionFree: "function",
+    fromBytes: "function",
+    toBytes: "function",
+    endo: "object",
+    wrapPrivateKey: "boolean"
+  });
+  const { endo } = extraOpts;
+  if (endo) {
+    if (!Fp2.is0(CURVE.a) || typeof endo.beta !== "bigint" || !Array.isArray(endo.basises)) {
+      throw new Error('invalid endo: expected "beta": bigint and "basises": array');
+    }
+  }
+  const lengths = getWLengths(Fp2, Fn);
+  function assertCompressionIsSupported() {
+    if (!Fp2.isOdd)
+      throw new Error("compression is not supported: Field does not have .isOdd()");
+  }
+  function pointToBytes2(_c, point, isCompressed) {
+    const { x, y } = point.toAffine();
+    const bx = Fp2.toBytes(x);
+    _abool2(isCompressed, "isCompressed");
+    if (isCompressed) {
+      assertCompressionIsSupported();
+      const hasEvenY = !Fp2.isOdd(y);
+      return concatBytes4(pprefix(hasEvenY), bx);
+    } else {
+      return concatBytes4(Uint8Array.of(4), bx, Fp2.toBytes(y));
+    }
+  }
+  function pointFromBytes(bytes4) {
+    _abytes2(bytes4, undefined, "Point");
+    const { publicKey: comp, publicKeyUncompressed: uncomp } = lengths;
+    const length = bytes4.length;
+    const head = bytes4[0];
+    const tail = bytes4.subarray(1);
+    if (length === comp && (head === 2 || head === 3)) {
+      const x = Fp2.fromBytes(tail);
+      if (!Fp2.isValid(x))
+        throw new Error("bad point: is not on curve, wrong x");
+      const y2 = weierstrassEquation(x);
+      let y;
+      try {
+        y = Fp2.sqrt(y2);
+      } catch (sqrtError) {
+        const err = sqrtError instanceof Error ? ": " + sqrtError.message : "";
+        throw new Error("bad point: is not on curve, sqrt error" + err);
+      }
+      assertCompressionIsSupported();
+      const isYOdd = Fp2.isOdd(y);
+      const isHeadOdd = (head & 1) === 1;
+      if (isHeadOdd !== isYOdd)
+        y = Fp2.neg(y);
+      return { x, y };
+    } else if (length === uncomp && head === 4) {
+      const L = Fp2.BYTES;
+      const x = Fp2.fromBytes(tail.subarray(0, L));
+      const y = Fp2.fromBytes(tail.subarray(L, L * 2));
+      if (!isValidXY(x, y))
+        throw new Error("bad point: is not on curve");
+      return { x, y };
+    } else {
+      throw new Error(`bad point: got length ${length}, expected compressed=${comp} or uncompressed=${uncomp}`);
+    }
+  }
+  const encodePoint = extraOpts.toBytes || pointToBytes2;
+  const decodePoint = extraOpts.fromBytes || pointFromBytes;
+  function weierstrassEquation(x) {
+    const x2 = Fp2.sqr(x);
+    const x3 = Fp2.mul(x2, x);
+    return Fp2.add(Fp2.add(x3, Fp2.mul(x, CURVE.a)), CURVE.b);
+  }
+  function isValidXY(x, y) {
+    const left = Fp2.sqr(y);
+    const right = weierstrassEquation(x);
+    return Fp2.eql(left, right);
+  }
+  if (!isValidXY(CURVE.Gx, CURVE.Gy))
+    throw new Error("bad curve params: generator point");
+  const _4a3 = Fp2.mul(Fp2.pow(CURVE.a, _3n4), _4n4);
+  const _27b2 = Fp2.mul(Fp2.sqr(CURVE.b), BigInt(27));
+  if (Fp2.is0(Fp2.add(_4a3, _27b2)))
+    throw new Error("bad curve params: a or b");
+  function acoord(title, n, banZero = false) {
+    if (!Fp2.isValid(n) || banZero && Fp2.is0(n))
+      throw new Error(`bad point coordinate ${title}`);
+    return n;
+  }
+  function aprjpoint(other) {
+    if (!(other instanceof Point2))
+      throw new Error("ProjectivePoint expected");
+  }
+  function splitEndoScalarN(k) {
+    if (!endo || !endo.basises)
+      throw new Error("no endo");
+    return _splitEndoScalar(k, endo.basises, Fn.ORDER);
+  }
+  const toAffineMemo = memoized((p, iz) => {
+    const { X, Y, Z } = p;
+    if (Fp2.eql(Z, Fp2.ONE))
+      return { x: X, y: Y };
+    const is0 = p.is0();
+    if (iz == null)
+      iz = is0 ? Fp2.ONE : Fp2.inv(Z);
+    const x = Fp2.mul(X, iz);
+    const y = Fp2.mul(Y, iz);
+    const zz = Fp2.mul(Z, iz);
+    if (is0)
+      return { x: Fp2.ZERO, y: Fp2.ZERO };
+    if (!Fp2.eql(zz, Fp2.ONE))
+      throw new Error("invZ was invalid");
+    return { x, y };
+  });
+  const assertValidMemo = memoized((p) => {
+    if (p.is0()) {
+      if (extraOpts.allowInfinityPoint && !Fp2.is0(p.Y))
+        return;
+      throw new Error("bad point: ZERO");
+    }
+    const { x, y } = p.toAffine();
+    if (!Fp2.isValid(x) || !Fp2.isValid(y))
+      throw new Error("bad point: x or y not field elements");
+    if (!isValidXY(x, y))
+      throw new Error("bad point: equation left != right");
+    if (!p.isTorsionFree())
+      throw new Error("bad point: not in prime-order subgroup");
+    return true;
+  });
+  function finishEndo(endoBeta, k1p, k2p, k1neg, k2neg) {
+    k2p = new Point2(Fp2.mul(k2p.X, endoBeta), k2p.Y, k2p.Z);
+    k1p = negateCt(k1neg, k1p);
+    k2p = negateCt(k2neg, k2p);
+    return k1p.add(k2p);
+  }
+
+  class Point2 {
+    constructor(X, Y, Z) {
+      this.X = acoord("x", X);
+      this.Y = acoord("y", Y, true);
+      this.Z = acoord("z", Z);
+      Object.freeze(this);
+    }
+    static CURVE() {
+      return CURVE;
+    }
+    static fromAffine(p) {
+      const { x, y } = p || {};
+      if (!p || !Fp2.isValid(x) || !Fp2.isValid(y))
+        throw new Error("invalid affine point");
+      if (p instanceof Point2)
+        throw new Error("projective point not allowed");
+      if (Fp2.is0(x) && Fp2.is0(y))
+        return Point2.ZERO;
+      return new Point2(x, y, Fp2.ONE);
+    }
+    static fromBytes(bytes4) {
+      const P = Point2.fromAffine(decodePoint(_abytes2(bytes4, undefined, "point")));
+      P.assertValidity();
+      return P;
+    }
+    static fromHex(hex2) {
+      return Point2.fromBytes(ensureBytes2("pointHex", hex2));
+    }
+    get x() {
+      return this.toAffine().x;
+    }
+    get y() {
+      return this.toAffine().y;
+    }
+    precompute(windowSize = 8, isLazy = true) {
+      wnaf.createCache(this, windowSize);
+      if (!isLazy)
+        this.multiply(_3n4);
+      return this;
+    }
+    assertValidity() {
+      assertValidMemo(this);
+    }
+    hasEvenY() {
+      const { y } = this.toAffine();
+      if (!Fp2.isOdd)
+        throw new Error("Field doesn't support isOdd");
+      return !Fp2.isOdd(y);
+    }
+    equals(other) {
+      aprjpoint(other);
+      const { X: X1, Y: Y1, Z: Z1 } = this;
+      const { X: X2, Y: Y2, Z: Z2 } = other;
+      const U1 = Fp2.eql(Fp2.mul(X1, Z2), Fp2.mul(X2, Z1));
+      const U2 = Fp2.eql(Fp2.mul(Y1, Z2), Fp2.mul(Y2, Z1));
+      return U1 && U2;
+    }
+    negate() {
+      return new Point2(this.X, Fp2.neg(this.Y), this.Z);
+    }
+    double() {
+      const { a, b } = CURVE;
+      const b3 = Fp2.mul(b, _3n4);
+      const { X: X1, Y: Y1, Z: Z1 } = this;
+      let { ZERO: X3, ZERO: Y3, ZERO: Z3 } = Fp2;
+      let t0 = Fp2.mul(X1, X1);
+      let t1 = Fp2.mul(Y1, Y1);
+      let t2 = Fp2.mul(Z1, Z1);
+      let t3 = Fp2.mul(X1, Y1);
+      t3 = Fp2.add(t3, t3);
+      Z3 = Fp2.mul(X1, Z1);
+      Z3 = Fp2.add(Z3, Z3);
+      X3 = Fp2.mul(a, Z3);
+      Y3 = Fp2.mul(b3, t2);
+      Y3 = Fp2.add(X3, Y3);
+      X3 = Fp2.sub(t1, Y3);
+      Y3 = Fp2.add(t1, Y3);
+      Y3 = Fp2.mul(X3, Y3);
+      X3 = Fp2.mul(t3, X3);
+      Z3 = Fp2.mul(b3, Z3);
+      t2 = Fp2.mul(a, t2);
+      t3 = Fp2.sub(t0, t2);
+      t3 = Fp2.mul(a, t3);
+      t3 = Fp2.add(t3, Z3);
+      Z3 = Fp2.add(t0, t0);
+      t0 = Fp2.add(Z3, t0);
+      t0 = Fp2.add(t0, t2);
+      t0 = Fp2.mul(t0, t3);
+      Y3 = Fp2.add(Y3, t0);
+      t2 = Fp2.mul(Y1, Z1);
+      t2 = Fp2.add(t2, t2);
+      t0 = Fp2.mul(t2, t3);
+      X3 = Fp2.sub(X3, t0);
+      Z3 = Fp2.mul(t2, t1);
+      Z3 = Fp2.add(Z3, Z3);
+      Z3 = Fp2.add(Z3, Z3);
+      return new Point2(X3, Y3, Z3);
+    }
+    add(other) {
+      aprjpoint(other);
+      const { X: X1, Y: Y1, Z: Z1 } = this;
+      const { X: X2, Y: Y2, Z: Z2 } = other;
+      let { ZERO: X3, ZERO: Y3, ZERO: Z3 } = Fp2;
+      const a = CURVE.a;
+      const b3 = Fp2.mul(CURVE.b, _3n4);
+      let t0 = Fp2.mul(X1, X2);
+      let t1 = Fp2.mul(Y1, Y2);
+      let t2 = Fp2.mul(Z1, Z2);
+      let t3 = Fp2.add(X1, Y1);
+      let t4 = Fp2.add(X2, Y2);
+      t3 = Fp2.mul(t3, t4);
+      t4 = Fp2.add(t0, t1);
+      t3 = Fp2.sub(t3, t4);
+      t4 = Fp2.add(X1, Z1);
+      let t5 = Fp2.add(X2, Z2);
+      t4 = Fp2.mul(t4, t5);
+      t5 = Fp2.add(t0, t2);
+      t4 = Fp2.sub(t4, t5);
+      t5 = Fp2.add(Y1, Z1);
+      X3 = Fp2.add(Y2, Z2);
+      t5 = Fp2.mul(t5, X3);
+      X3 = Fp2.add(t1, t2);
+      t5 = Fp2.sub(t5, X3);
+      Z3 = Fp2.mul(a, t4);
+      X3 = Fp2.mul(b3, t2);
+      Z3 = Fp2.add(X3, Z3);
+      X3 = Fp2.sub(t1, Z3);
+      Z3 = Fp2.add(t1, Z3);
+      Y3 = Fp2.mul(X3, Z3);
+      t1 = Fp2.add(t0, t0);
+      t1 = Fp2.add(t1, t0);
+      t2 = Fp2.mul(a, t2);
+      t4 = Fp2.mul(b3, t4);
+      t1 = Fp2.add(t1, t2);
+      t2 = Fp2.sub(t0, t2);
+      t2 = Fp2.mul(a, t2);
+      t4 = Fp2.add(t4, t2);
+      t0 = Fp2.mul(t1, t4);
+      Y3 = Fp2.add(Y3, t0);
+      t0 = Fp2.mul(t5, t4);
+      X3 = Fp2.mul(t3, X3);
+      X3 = Fp2.sub(X3, t0);
+      t0 = Fp2.mul(t3, t1);
+      Z3 = Fp2.mul(t5, Z3);
+      Z3 = Fp2.add(Z3, t0);
+      return new Point2(X3, Y3, Z3);
+    }
+    subtract(other) {
+      return this.add(other.negate());
+    }
+    is0() {
+      return this.equals(Point2.ZERO);
+    }
+    multiply(scalar) {
+      const { endo: endo2 } = extraOpts;
+      if (!Fn.isValidNot0(scalar))
+        throw new Error("invalid scalar: out of range");
+      let point, fake;
+      const mul3 = (n) => wnaf.cached(this, n, (p) => normalizeZ(Point2, p));
+      if (endo2) {
+        const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(scalar);
+        const { p: k1p, f: k1f } = mul3(k1);
+        const { p: k2p, f: k2f } = mul3(k2);
+        fake = k1f.add(k2f);
+        point = finishEndo(endo2.beta, k1p, k2p, k1neg, k2neg);
+      } else {
+        const { p, f } = mul3(scalar);
+        point = p;
+        fake = f;
+      }
+      return normalizeZ(Point2, [point, fake])[0];
+    }
+    multiplyUnsafe(sc) {
+      const { endo: endo2 } = extraOpts;
+      const p = this;
+      if (!Fn.isValid(sc))
+        throw new Error("invalid scalar: out of range");
+      if (sc === _0n9 || p.is0())
+        return Point2.ZERO;
+      if (sc === _1n9)
+        return p;
+      if (wnaf.hasCache(this))
+        return this.multiply(sc);
+      if (endo2) {
+        const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(sc);
+        const { p1, p2 } = mulEndoUnsafe(Point2, p, k1, k2);
+        return finishEndo(endo2.beta, p1, p2, k1neg, k2neg);
+      } else {
+        return wnaf.unsafe(p, sc);
+      }
+    }
+    multiplyAndAddUnsafe(Q, a, b) {
+      const sum = this.multiplyUnsafe(a).add(Q.multiplyUnsafe(b));
+      return sum.is0() ? undefined : sum;
+    }
+    toAffine(invertedZ) {
+      return toAffineMemo(this, invertedZ);
+    }
+    isTorsionFree() {
+      const { isTorsionFree } = extraOpts;
+      if (cofactor === _1n9)
+        return true;
+      if (isTorsionFree)
+        return isTorsionFree(Point2, this);
+      return wnaf.unsafe(this, CURVE_ORDER).is0();
+    }
+    clearCofactor() {
+      const { clearCofactor } = extraOpts;
+      if (cofactor === _1n9)
+        return this;
+      if (clearCofactor)
+        return clearCofactor(Point2, this);
+      return this.multiplyUnsafe(cofactor);
+    }
+    isSmallOrder() {
+      return this.multiplyUnsafe(cofactor).is0();
+    }
+    toBytes(isCompressed = true) {
+      _abool2(isCompressed, "isCompressed");
+      this.assertValidity();
+      return encodePoint(Point2, this, isCompressed);
+    }
+    toHex(isCompressed = true) {
+      return bytesToHex4(this.toBytes(isCompressed));
+    }
+    toString() {
+      return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+    }
+    get px() {
+      return this.X;
+    }
+    get py() {
+      return this.X;
+    }
+    get pz() {
+      return this.Z;
+    }
+    toRawBytes(isCompressed = true) {
+      return this.toBytes(isCompressed);
+    }
+    _setWindowSize(windowSize) {
+      this.precompute(windowSize);
+    }
+    static normalizeZ(points) {
+      return normalizeZ(Point2, points);
+    }
+    static msm(points, scalars) {
+      return pippenger(Point2, Fn, points, scalars);
+    }
+    static fromPrivateKey(privateKey) {
+      return Point2.BASE.multiply(_normFnElement(Fn, privateKey));
+    }
+  }
+  Point2.BASE = new Point2(CURVE.Gx, CURVE.Gy, Fp2.ONE);
+  Point2.ZERO = new Point2(Fp2.ZERO, Fp2.ONE, Fp2.ZERO);
+  Point2.Fp = Fp2;
+  Point2.Fn = Fn;
+  const bits = Fn.BITS;
+  const wnaf = new wNAF2(Point2, extraOpts.endo ? Math.ceil(bits / 2) : bits);
+  Point2.BASE.precompute(8);
+  return Point2;
+}
+function pprefix(hasEvenY) {
+  return Uint8Array.of(hasEvenY ? 2 : 3);
+}
+function getWLengths(Fp2, Fn) {
+  return {
+    secretKey: Fn.BYTES,
+    publicKey: 1 + Fp2.BYTES,
+    publicKeyUncompressed: 1 + 2 * Fp2.BYTES,
+    publicKeyHasPrefix: true,
+    signature: 2 * Fn.BYTES
+  };
+}
+function ecdh(Point2, ecdhOpts = {}) {
+  const { Fn } = Point2;
+  const randomBytes_ = ecdhOpts.randomBytes || randomBytes4;
+  const lengths = Object.assign(getWLengths(Point2.Fp, Fn), { seed: getMinHashLength2(Fn.ORDER) });
+  function isValidSecretKey(secretKey) {
+    try {
+      return !!_normFnElement(Fn, secretKey);
+    } catch (error) {
+      return false;
+    }
+  }
+  function isValidPublicKey(publicKey, isCompressed) {
+    const { publicKey: comp, publicKeyUncompressed } = lengths;
+    try {
+      const l = publicKey.length;
+      if (isCompressed === true && l !== comp)
+        return false;
+      if (isCompressed === false && l !== publicKeyUncompressed)
+        return false;
+      return !!Point2.fromBytes(publicKey);
+    } catch (error) {
+      return false;
+    }
+  }
+  function randomSecretKey(seed = randomBytes_(lengths.seed)) {
+    return mapHashToField2(_abytes2(seed, lengths.seed, "seed"), Fn.ORDER);
+  }
+  function getPublicKey4(secretKey, isCompressed = true) {
+    return Point2.BASE.multiply(_normFnElement(Fn, secretKey)).toBytes(isCompressed);
+  }
+  function keygen(seed) {
+    const secretKey = randomSecretKey(seed);
+    return { secretKey, publicKey: getPublicKey4(secretKey) };
+  }
+  function isProbPub(item) {
+    if (typeof item === "bigint")
+      return false;
+    if (item instanceof Point2)
+      return true;
+    const { secretKey, publicKey, publicKeyUncompressed } = lengths;
+    if (Fn.allowedLengths || secretKey === publicKey)
+      return;
+    const l = ensureBytes2("key", item).length;
+    return l === publicKey || l === publicKeyUncompressed;
+  }
+  function getSharedSecret(secretKeyA, publicKeyB, isCompressed = true) {
+    if (isProbPub(secretKeyA) === true)
+      throw new Error("first arg must be private key");
+    if (isProbPub(publicKeyB) === false)
+      throw new Error("second arg must be public key");
+    const s = _normFnElement(Fn, secretKeyA);
+    const b = Point2.fromHex(publicKeyB);
+    return b.multiply(s).toBytes(isCompressed);
+  }
+  const utils = {
+    isValidSecretKey,
+    isValidPublicKey,
+    randomSecretKey,
+    isValidPrivateKey: isValidSecretKey,
+    randomPrivateKey: randomSecretKey,
+    normPrivateKeyToScalar: (key) => _normFnElement(Fn, key),
+    precompute(windowSize = 8, point = Point2.BASE) {
+      return point.precompute(windowSize, false);
+    }
+  };
+  return Object.freeze({ getPublicKey: getPublicKey4, getSharedSecret, keygen, Point: Point2, utils, lengths });
+}
+function ecdsa(Point2, hash3, ecdsaOpts = {}) {
+  ahash(hash3);
+  _validateObject(ecdsaOpts, {}, {
+    hmac: "function",
+    lowS: "boolean",
+    randomBytes: "function",
+    bits2int: "function",
+    bits2int_modN: "function"
+  });
+  const randomBytes5 = ecdsaOpts.randomBytes || randomBytes4;
+  const hmac4 = ecdsaOpts.hmac || ((key, ...msgs) => hmac3(hash3, key, concatBytes4(...msgs)));
+  const { Fp: Fp2, Fn } = Point2;
+  const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;
+  const { keygen, getPublicKey: getPublicKey4, getSharedSecret, utils, lengths } = ecdh(Point2, ecdsaOpts);
+  const defaultSigOpts = {
+    prehash: false,
+    lowS: typeof ecdsaOpts.lowS === "boolean" ? ecdsaOpts.lowS : false,
+    format: undefined,
+    extraEntropy: false
+  };
+  const defaultSigOpts_format = "compact";
+  function isBiggerThanHalfOrder(number4) {
+    const HALF = CURVE_ORDER >> _1n9;
+    return number4 > HALF;
+  }
+  function validateRS(title, num) {
+    if (!Fn.isValidNot0(num))
+      throw new Error(`invalid signature ${title}: out of range 1..Point.Fn.ORDER`);
+    return num;
+  }
+  function validateSigLength(bytes4, format) {
+    validateSigFormat(format);
+    const size = lengths.signature;
+    const sizer = format === "compact" ? size : format === "recovered" ? size + 1 : undefined;
+    return _abytes2(bytes4, sizer, `${format} signature`);
+  }
+
+  class Signature {
+    constructor(r, s, recovery) {
+      this.r = validateRS("r", r);
+      this.s = validateRS("s", s);
+      if (recovery != null)
+        this.recovery = recovery;
+      Object.freeze(this);
+    }
+    static fromBytes(bytes4, format = defaultSigOpts_format) {
+      validateSigLength(bytes4, format);
+      let recid;
+      if (format === "der") {
+        const { r: r2, s: s2 } = DER2.toSig(_abytes2(bytes4));
+        return new Signature(r2, s2);
+      }
+      if (format === "recovered") {
+        recid = bytes4[0];
+        format = "compact";
+        bytes4 = bytes4.subarray(1);
+      }
+      const L = Fn.BYTES;
+      const r = bytes4.subarray(0, L);
+      const s = bytes4.subarray(L, L * 2);
+      return new Signature(Fn.fromBytes(r), Fn.fromBytes(s), recid);
+    }
+    static fromHex(hex2, format) {
+      return this.fromBytes(hexToBytes4(hex2), format);
+    }
+    addRecoveryBit(recovery) {
+      return new Signature(this.r, this.s, recovery);
+    }
+    recoverPublicKey(messageHash) {
+      const FIELD_ORDER = Fp2.ORDER;
+      const { r, s, recovery: rec } = this;
+      if (rec == null || ![0, 1, 2, 3].includes(rec))
+        throw new Error("recovery id invalid");
+      const hasCofactor = CURVE_ORDER * _2n6 < FIELD_ORDER;
+      if (hasCofactor && rec > 1)
+        throw new Error("recovery id is ambiguous for h>1 curve");
+      const radj = rec === 2 || rec === 3 ? r + CURVE_ORDER : r;
+      if (!Fp2.isValid(radj))
+        throw new Error("recovery id 2 or 3 invalid");
+      const x = Fp2.toBytes(radj);
+      const R = Point2.fromBytes(concatBytes4(pprefix((rec & 1) === 0), x));
+      const ir = Fn.inv(radj);
+      const h = bits2int_modN(ensureBytes2("msgHash", messageHash));
+      const u1 = Fn.create(-h * ir);
+      const u2 = Fn.create(s * ir);
+      const Q = Point2.BASE.multiplyUnsafe(u1).add(R.multiplyUnsafe(u2));
+      if (Q.is0())
+        throw new Error("point at infinify");
+      Q.assertValidity();
+      return Q;
+    }
+    hasHighS() {
+      return isBiggerThanHalfOrder(this.s);
+    }
+    toBytes(format = defaultSigOpts_format) {
+      validateSigFormat(format);
+      if (format === "der")
+        return hexToBytes4(DER2.hexFromSig(this));
+      const r = Fn.toBytes(this.r);
+      const s = Fn.toBytes(this.s);
+      if (format === "recovered") {
+        if (this.recovery == null)
+          throw new Error("recovery bit must be present");
+        return concatBytes4(Uint8Array.of(this.recovery), r, s);
+      }
+      return concatBytes4(r, s);
+    }
+    toHex(format) {
+      return bytesToHex4(this.toBytes(format));
+    }
+    assertValidity() {}
+    static fromCompact(hex2) {
+      return Signature.fromBytes(ensureBytes2("sig", hex2), "compact");
+    }
+    static fromDER(hex2) {
+      return Signature.fromBytes(ensureBytes2("sig", hex2), "der");
+    }
+    normalizeS() {
+      return this.hasHighS() ? new Signature(this.r, Fn.neg(this.s), this.recovery) : this;
+    }
+    toDERRawBytes() {
+      return this.toBytes("der");
+    }
+    toDERHex() {
+      return bytesToHex4(this.toBytes("der"));
+    }
+    toCompactRawBytes() {
+      return this.toBytes("compact");
+    }
+    toCompactHex() {
+      return bytesToHex4(this.toBytes("compact"));
+    }
+  }
+  const bits2int = ecdsaOpts.bits2int || function bits2int_def(bytes4) {
+    if (bytes4.length > 8192)
+      throw new Error("input is too large");
+    const num = bytesToNumberBE2(bytes4);
+    const delta = bytes4.length * 8 - fnBits;
+    return delta > 0 ? num >> BigInt(delta) : num;
+  };
+  const bits2int_modN = ecdsaOpts.bits2int_modN || function bits2int_modN_def(bytes4) {
+    return Fn.create(bits2int(bytes4));
+  };
+  const ORDER_MASK = bitMask2(fnBits);
+  function int2octets(num) {
+    aInRange("num < 2^" + fnBits, num, _0n9, ORDER_MASK);
+    return Fn.toBytes(num);
+  }
+  function validateMsgAndHash(message, prehash) {
+    _abytes2(message, undefined, "message");
+    return prehash ? _abytes2(hash3(message), undefined, "prehashed message") : message;
+  }
+  function prepSig(message, privateKey, opts) {
+    if (["recovered", "canonical"].some((k) => (k in opts)))
+      throw new Error("sign() legacy options not supported");
+    const { lowS, prehash, extraEntropy } = validateSigOpts(opts, defaultSigOpts);
+    message = validateMsgAndHash(message, prehash);
+    const h1int = bits2int_modN(message);
+    const d = _normFnElement(Fn, privateKey);
+    const seedArgs = [int2octets(d), int2octets(h1int)];
+    if (extraEntropy != null && extraEntropy !== false) {
+      const e = extraEntropy === true ? randomBytes5(lengths.secretKey) : extraEntropy;
+      seedArgs.push(ensureBytes2("extraEntropy", e));
+    }
+    const seed = concatBytes4(...seedArgs);
+    const m = h1int;
+    function k2sig(kBytes) {
+      const k = bits2int(kBytes);
+      if (!Fn.isValidNot0(k))
+        return;
+      const ik = Fn.inv(k);
+      const q = Point2.BASE.multiply(k).toAffine();
+      const r = Fn.create(q.x);
+      if (r === _0n9)
+        return;
+      const s = Fn.create(ik * Fn.create(m + r * d));
+      if (s === _0n9)
+        return;
+      let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n9);
+      let normS = s;
+      if (lowS && isBiggerThanHalfOrder(s)) {
+        normS = Fn.neg(s);
+        recovery ^= 1;
+      }
+      return new Signature(r, normS, recovery);
+    }
+    return { seed, k2sig };
+  }
+  function sign2(message, secretKey, opts = {}) {
+    message = ensureBytes2("message", message);
+    const { seed, k2sig } = prepSig(message, secretKey, opts);
+    const drbg = createHmacDrbg2(hash3.outputLen, Fn.BYTES, hmac4);
+    const sig = drbg(seed, k2sig);
+    return sig;
+  }
+  function tryParsingSig(sg) {
+    let sig = undefined;
+    const isHex = typeof sg === "string" || isBytes2(sg);
+    const isObj = !isHex && sg !== null && typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint";
+    if (!isHex && !isObj)
+      throw new Error("invalid signature, expected Uint8Array, hex string or Signature instance");
+    if (isObj) {
+      sig = new Signature(sg.r, sg.s);
+    } else if (isHex) {
+      try {
+        sig = Signature.fromBytes(ensureBytes2("sig", sg), "der");
+      } catch (derError) {
+        if (!(derError instanceof DER2.Err))
+          throw derError;
+      }
+      if (!sig) {
+        try {
+          sig = Signature.fromBytes(ensureBytes2("sig", sg), "compact");
+        } catch (error) {
+          return false;
+        }
+      }
+    }
+    if (!sig)
+      return false;
+    return sig;
+  }
+  function verify(signature, message, publicKey, opts = {}) {
+    const { lowS, prehash, format } = validateSigOpts(opts, defaultSigOpts);
+    publicKey = ensureBytes2("publicKey", publicKey);
+    message = validateMsgAndHash(ensureBytes2("message", message), prehash);
+    if ("strict" in opts)
+      throw new Error("options.strict was renamed to lowS");
+    const sig = format === undefined ? tryParsingSig(signature) : Signature.fromBytes(ensureBytes2("sig", signature), format);
+    if (sig === false)
+      return false;
+    try {
+      const P = Point2.fromBytes(publicKey);
+      if (lowS && sig.hasHighS())
+        return false;
+      const { r, s } = sig;
+      const h = bits2int_modN(message);
+      const is = Fn.inv(s);
+      const u1 = Fn.create(h * is);
+      const u2 = Fn.create(r * is);
+      const R = Point2.BASE.multiplyUnsafe(u1).add(P.multiplyUnsafe(u2));
+      if (R.is0())
+        return false;
+      const v = Fn.create(R.x);
+      return v === r;
+    } catch (e) {
+      return false;
+    }
+  }
+  function recoverPublicKey(signature, message, opts = {}) {
+    const { prehash } = validateSigOpts(opts, defaultSigOpts);
+    message = validateMsgAndHash(message, prehash);
+    return Signature.fromBytes(signature, "recovered").recoverPublicKey(message).toBytes();
+  }
+  return Object.freeze({
+    keygen,
+    getPublicKey: getPublicKey4,
+    getSharedSecret,
+    utils,
+    lengths,
+    Point: Point2,
+    sign: sign2,
+    verify,
+    recoverPublicKey,
+    Signature,
+    hash: hash3
+  });
+}
+function _weierstrass_legacy_opts_to_new(c) {
+  const CURVE = {
+    a: c.a,
+    b: c.b,
+    p: c.Fp.ORDER,
+    n: c.n,
+    h: c.h,
+    Gx: c.Gx,
+    Gy: c.Gy
+  };
+  const Fp2 = c.Fp;
+  let allowedLengths = c.allowedPrivateKeyLengths ? Array.from(new Set(c.allowedPrivateKeyLengths.map((l) => Math.ceil(l / 2)))) : undefined;
+  const Fn = Field2(CURVE.n, {
+    BITS: c.nBitLength,
+    allowedLengths,
+    modFromBytes: c.wrapPrivateKey
+  });
+  const curveOpts = {
+    Fp: Fp2,
+    Fn,
+    allowInfinityPoint: c.allowInfinityPoint,
+    endo: c.endo,
+    isTorsionFree: c.isTorsionFree,
+    clearCofactor: c.clearCofactor,
+    fromBytes: c.fromBytes,
+    toBytes: c.toBytes
+  };
+  return { CURVE, curveOpts };
+}
+function _ecdsa_legacy_opts_to_new(c) {
+  const { CURVE, curveOpts } = _weierstrass_legacy_opts_to_new(c);
+  const ecdsaOpts = {
+    hmac: c.hmac,
+    randomBytes: c.randomBytes,
+    lowS: c.lowS,
+    bits2int: c.bits2int,
+    bits2int_modN: c.bits2int_modN
+  };
+  return { CURVE, curveOpts, hash: c.hash, ecdsaOpts };
+}
+function _ecdsa_new_output_to_legacy(c, _ecdsa) {
+  const Point2 = _ecdsa.Point;
+  return Object.assign({}, _ecdsa, {
+    ProjectivePoint: Point2,
+    CURVE: Object.assign({}, c, nLength2(Point2.Fn.ORDER, Point2.Fn.BITS))
+  });
+}
+function weierstrass2(c) {
+  const { CURVE, curveOpts, hash: hash3, ecdsaOpts } = _ecdsa_legacy_opts_to_new(c);
+  const Point2 = weierstrassN(CURVE, curveOpts);
+  const signs = ecdsa(Point2, hash3, ecdsaOpts);
+  return _ecdsa_new_output_to_legacy(c, signs);
+}
+
+// ../routstr-chat/node_modules/@noble/curves/esm/_shortw_utils.js
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function createCurve2(curveDef, defHash) {
+  const create = (hash3) => weierstrass2({ ...curveDef, hash: hash3 });
+  return { ...create(defHash), create };
+}
+
+// ../routstr-chat/node_modules/@noble/curves/esm/secp256k1.js
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+var secp256k1_CURVE = {
+  p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),
+  n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),
+  h: BigInt(1),
+  a: BigInt(0),
+  b: BigInt(7),
+  Gx: BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
+  Gy: BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")
+};
+var secp256k1_ENDO = {
+  beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
+  basises: [
+    [BigInt("0x3086d221a7d46bcde86c90e49284eb15"), -BigInt("0xe4437ed6010e88286f547fa90abfe4c3")],
+    [BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), BigInt("0x3086d221a7d46bcde86c90e49284eb15")]
+  ]
+};
+var _0n10 = /* @__PURE__ */ BigInt(0);
+var _1n10 = /* @__PURE__ */ BigInt(1);
+var _2n7 = /* @__PURE__ */ BigInt(2);
+function sqrtMod2(y) {
+  const P = secp256k1_CURVE.p;
+  const _3n5 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
+  const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
+  const b2 = y * y * y % P;
+  const b3 = b2 * b2 * y % P;
+  const b6 = pow22(b3, _3n5, P) * b3 % P;
+  const b9 = pow22(b6, _3n5, P) * b3 % P;
+  const b11 = pow22(b9, _2n7, P) * b2 % P;
+  const b22 = pow22(b11, _11n, P) * b11 % P;
+  const b44 = pow22(b22, _22n, P) * b22 % P;
+  const b88 = pow22(b44, _44n, P) * b44 % P;
+  const b176 = pow22(b88, _88n, P) * b88 % P;
+  const b220 = pow22(b176, _44n, P) * b44 % P;
+  const b223 = pow22(b220, _3n5, P) * b3 % P;
+  const t1 = pow22(b223, _23n, P) * b22 % P;
+  const t2 = pow22(t1, _6n, P) * b2 % P;
+  const root = pow22(t2, _2n7, P);
+  if (!Fpk1.eql(Fpk1.sqr(root), y))
+    throw new Error("Cannot find square root");
+  return root;
+}
+var Fpk1 = Field2(secp256k1_CURVE.p, { sqrt: sqrtMod2 });
+var secp256k12 = createCurve2({ ...secp256k1_CURVE, Fp: Fpk1, lowS: true, endo: secp256k1_ENDO }, sha2563);
+var TAGGED_HASH_PREFIXES2 = {};
+function taggedHash2(tag, ...messages) {
+  let tagP = TAGGED_HASH_PREFIXES2[tag];
+  if (tagP === undefined) {
+    const tagH = sha2563(utf8ToBytes5(tag));
+    tagP = concatBytes4(tagH, tagH);
+    TAGGED_HASH_PREFIXES2[tag] = tagP;
+  }
+  return sha2563(concatBytes4(tagP, ...messages));
+}
+var pointToBytes2 = (point) => point.toBytes(true).slice(1);
+var Pointk1 = /* @__PURE__ */ (() => secp256k12.Point)();
+var hasEven = (y) => y % _2n7 === _0n10;
+function schnorrGetExtPubKey2(priv) {
+  const { Fn, BASE } = Pointk1;
+  const d_ = _normFnElement(Fn, priv);
+  const p = BASE.multiply(d_);
+  const scalar = hasEven(p.y) ? d_ : Fn.neg(d_);
+  return { scalar, bytes: pointToBytes2(p) };
+}
+function lift_x2(x) {
+  const Fp2 = Fpk1;
+  if (!Fp2.isValidNot0(x))
+    throw new Error("invalid x: Fail if x \u2265 p");
+  const xx = Fp2.create(x * x);
+  const c = Fp2.create(xx * x + BigInt(7));
+  let y = Fp2.sqrt(c);
+  if (!hasEven(y))
+    y = Fp2.neg(y);
+  const p = Pointk1.fromAffine({ x, y });
+  p.assertValidity();
+  return p;
+}
+var num = bytesToNumberBE2;
+function challenge2(...args) {
+  return Pointk1.Fn.create(num(taggedHash2("BIP0340/challenge", ...args)));
+}
+function schnorrGetPublicKey2(secretKey) {
+  return schnorrGetExtPubKey2(secretKey).bytes;
+}
+function schnorrSign2(message, secretKey, auxRand = randomBytes4(32)) {
+  const { Fn } = Pointk1;
+  const m = ensureBytes2("message", message);
+  const { bytes: px, scalar: d } = schnorrGetExtPubKey2(secretKey);
+  const a = ensureBytes2("auxRand", auxRand, 32);
+  const t = Fn.toBytes(d ^ num(taggedHash2("BIP0340/aux", a)));
+  const rand = taggedHash2("BIP0340/nonce", t, px, m);
+  const { bytes: rx, scalar: k } = schnorrGetExtPubKey2(rand);
+  const e = challenge2(rx, px, m);
+  const sig = new Uint8Array(64);
+  sig.set(rx, 0);
+  sig.set(Fn.toBytes(Fn.create(k + e * d)), 32);
+  if (!schnorrVerify2(sig, m, px))
+    throw new Error("sign: Invalid signature produced");
+  return sig;
+}
+function schnorrVerify2(signature, message, publicKey) {
+  const { Fn, BASE } = Pointk1;
+  const sig = ensureBytes2("signature", signature, 64);
+  const m = ensureBytes2("message", message);
+  const pub = ensureBytes2("publicKey", publicKey, 32);
+  try {
+    const P = lift_x2(num(pub));
+    const r = num(sig.subarray(0, 32));
+    if (!inRange(r, _1n10, secp256k1_CURVE.p))
+      return false;
+    const s = num(sig.subarray(32, 64));
+    if (!inRange(s, _1n10, secp256k1_CURVE.n))
+      return false;
+    const e = challenge2(Fn.toBytes(r), pointToBytes2(P), m);
+    const R = BASE.multiplyUnsafe(s).add(P.multiplyUnsafe(Fn.neg(e)));
+    const { x, y } = R.toAffine();
+    if (R.is0() || !hasEven(y) || x !== r)
+      return false;
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+var schnorr2 = /* @__PURE__ */ (() => {
+  const size = 32;
+  const seedLength = 48;
+  const randomSecretKey = (seed = randomBytes4(seedLength)) => {
+    return mapHashToField2(seed, secp256k1_CURVE.n);
+  };
+  secp256k12.utils.randomSecretKey;
+  function keygen(seed) {
+    const secretKey = randomSecretKey(seed);
+    return { secretKey, publicKey: schnorrGetPublicKey2(secretKey) };
+  }
+  return {
+    keygen,
+    getPublicKey: schnorrGetPublicKey2,
+    sign: schnorrSign2,
+    verify: schnorrVerify2,
+    Point: Pointk1,
+    utils: {
+      randomSecretKey,
+      randomPrivateKey: randomSecretKey,
+      taggedHash: taggedHash2,
+      lift_x: lift_x2,
+      pointToBytes: pointToBytes2,
+      numberToBytesBE: numberToBytesBE2,
+      bytesToNumberBE: bytesToNumberBE2,
+      mod: mod2
+    },
+    lengths: {
+      secretKey: size,
+      publicKey: size,
+      publicKeyHasPrefix: false,
+      signature: size * 2,
+      seed: seedLength
+    }
+  };
+})();
+
+// ../routstr-chat/node_modules/@cashu/cashu-ts/lib/cashu-ts.es.js
+init_sha2();
+init_utils6();
+
+// ../routstr-chat/node_modules/@noble/hashes/esm/legacy.js
+init__md();
+init_utils6();
+var Rho160 = /* @__PURE__ */ Uint8Array.from([
+  7,
+  4,
+  13,
+  1,
+  10,
+  6,
+  15,
+  3,
+  12,
+  0,
+  9,
+  5,
+  2,
+  14,
+  11,
+  8
+]);
+var Id160 = /* @__PURE__ */ (() => Uint8Array.from(new Array(16).fill(0).map((_, i4) => i4)))();
+var Pi160 = /* @__PURE__ */ (() => Id160.map((i4) => (9 * i4 + 5) % 16))();
+var idxLR = /* @__PURE__ */ (() => {
+  const L = [Id160];
+  const R = [Pi160];
+  const res = [L, R];
+  for (let i4 = 0;i4 < 4; i4++)
+    for (let j of res)
+      j.push(j[i4].map((k) => Rho160[k]));
+  return res;
+})();
+var idxL = /* @__PURE__ */ (() => idxLR[0])();
+var idxR = /* @__PURE__ */ (() => idxLR[1])();
+var shifts160 = /* @__PURE__ */ [
+  [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
+  [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
+  [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
+  [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
+  [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
+].map((i4) => Uint8Array.from(i4));
+var shiftsL160 = /* @__PURE__ */ idxL.map((idx, i4) => idx.map((j) => shifts160[i4][j]));
+var shiftsR160 = /* @__PURE__ */ idxR.map((idx, i4) => idx.map((j) => shifts160[i4][j]));
+var Kl160 = /* @__PURE__ */ Uint32Array.from([
+  0,
+  1518500249,
+  1859775393,
+  2400959708,
+  2840853838
+]);
+var Kr160 = /* @__PURE__ */ Uint32Array.from([
+  1352829926,
+  1548603684,
+  1836072691,
+  2053994217,
+  0
+]);
+function ripemd_f(group2, x, y, z) {
+  if (group2 === 0)
+    return x ^ y ^ z;
+  if (group2 === 1)
+    return x & y | ~x & z;
+  if (group2 === 2)
+    return (x | ~y) ^ z;
+  if (group2 === 3)
+    return x & z | y & ~z;
+  return x ^ (y | ~z);
+}
+var BUF_160 = /* @__PURE__ */ new Uint32Array(16);
+
+class RIPEMD160 extends HashMD {
+  constructor() {
+    super(64, 20, 8, true);
+    this.h0 = 1732584193 | 0;
+    this.h1 = 4023233417 | 0;
+    this.h2 = 2562383102 | 0;
+    this.h3 = 271733878 | 0;
+    this.h4 = 3285377520 | 0;
+  }
+  get() {
+    const { h0, h1, h2, h3, h4 } = this;
+    return [h0, h1, h2, h3, h4];
+  }
+  set(h0, h1, h2, h3, h4) {
+    this.h0 = h0 | 0;
+    this.h1 = h1 | 0;
+    this.h2 = h2 | 0;
+    this.h3 = h3 | 0;
+    this.h4 = h4 | 0;
+  }
+  process(view, offset) {
+    for (let i4 = 0;i4 < 16; i4++, offset += 4)
+      BUF_160[i4] = view.getUint32(offset, true);
+    let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
+    for (let group2 = 0;group2 < 5; group2++) {
+      const rGroup = 4 - group2;
+      const hbl = Kl160[group2], hbr = Kr160[group2];
+      const rl = idxL[group2], rr = idxR[group2];
+      const sl = shiftsL160[group2], sr = shiftsR160[group2];
+      for (let i4 = 0;i4 < 16; i4++) {
+        const tl = rotl2(al + ripemd_f(group2, bl, cl, dl) + BUF_160[rl[i4]] + hbl, sl[i4]) + el | 0;
+        al = el, el = dl, dl = rotl2(cl, 10) | 0, cl = bl, bl = tl;
+      }
+      for (let i4 = 0;i4 < 16; i4++) {
+        const tr = rotl2(ar + ripemd_f(rGroup, br, cr, dr) + BUF_160[rr[i4]] + hbr, sr[i4]) + er | 0;
+        ar = er, er = dr, dr = rotl2(cr, 10) | 0, cr = br, br = tr;
+      }
+    }
+    this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
+  }
+  roundClean() {
+    clean(BUF_160);
+  }
+  destroy() {
+    this.destroyed = true;
+    clean(this.buffer);
+    this.set(0, 0, 0, 0, 0);
+  }
+}
+var ripemd160 = /* @__PURE__ */ createHasher(() => new RIPEMD160);
+
+// ../routstr-chat/node_modules/@scure/bip32/lib/esm/index.js
+init_sha2();
+init_utils6();
+
+// ../routstr-chat/node_modules/@scure/base/lib/esm/index.js
+/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function isBytes3(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes2(b, ...lengths) {
+  if (!isBytes3(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function isArrayOf(isString, arr) {
+  if (!Array.isArray(arr))
+    return false;
+  if (arr.length === 0)
+    return true;
+  if (isString) {
+    return arr.every((item) => typeof item === "string");
+  } else {
+    return arr.every((item) => Number.isSafeInteger(item));
+  }
+}
+function afn(input) {
+  if (typeof input !== "function")
+    throw new Error("function expected");
+  return true;
+}
+function astr(label, input) {
+  if (typeof input !== "string")
+    throw new Error(`${label}: string expected`);
+  return true;
+}
+function anumber2(n) {
+  if (!Number.isSafeInteger(n))
+    throw new Error(`invalid integer: ${n}`);
+}
+function aArr(input) {
+  if (!Array.isArray(input))
+    throw new Error("array expected");
+}
+function astrArr(label, input) {
+  if (!isArrayOf(true, input))
+    throw new Error(`${label}: array of strings expected`);
+}
+function anumArr(label, input) {
+  if (!isArrayOf(false, input))
+    throw new Error(`${label}: array of numbers expected`);
+}
+function chain2(...args) {
+  const id = (a) => a;
+  const wrap = (a, b) => (c) => a(b(c));
+  const encode = args.map((x) => x.encode).reduceRight(wrap, id);
+  const decode2 = args.map((x) => x.decode).reduce(wrap, id);
+  return { encode, decode: decode2 };
+}
+function alphabet2(letters) {
+  const lettersA = typeof letters === "string" ? letters.split("") : letters;
+  const len = lettersA.length;
+  astrArr("alphabet", lettersA);
+  const indexes = new Map(lettersA.map((l, i4) => [l, i4]));
+  return {
+    encode: (digits) => {
+      aArr(digits);
+      return digits.map((i4) => {
+        if (!Number.isSafeInteger(i4) || i4 < 0 || i4 >= len)
+          throw new Error(`alphabet.encode: digit index outside alphabet "${i4}". Allowed: ${letters}`);
+        return lettersA[i4];
+      });
+    },
+    decode: (input) => {
+      aArr(input);
+      return input.map((letter) => {
+        astr("alphabet.decode", letter);
+        const i4 = indexes.get(letter);
+        if (i4 === undefined)
+          throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
+        return i4;
+      });
+    }
+  };
+}
+function join4(separator = "") {
+  astr("join", separator);
+  return {
+    encode: (from7) => {
+      astrArr("join.decode", from7);
+      return from7.join(separator);
+    },
+    decode: (to) => {
+      astr("join.decode", to);
+      return to.split(separator);
+    }
+  };
+}
+function padding2(bits, chr = "=") {
+  anumber2(bits);
+  astr("padding", chr);
+  return {
+    encode(data) {
+      astrArr("padding.encode", data);
+      while (data.length * bits % 8)
+        data.push(chr);
+      return data;
+    },
+    decode(input) {
+      astrArr("padding.decode", input);
+      let end = input.length;
+      if (end * bits % 8)
+        throw new Error("padding: invalid, string should have whole number of bytes");
+      for (;end > 0 && input[end - 1] === chr; end--) {
+        const last = end - 1;
+        const byte = last * bits;
+        if (byte % 8 === 0)
+          throw new Error("padding: invalid, string has too much padding");
+      }
+      return input.slice(0, end);
+    }
+  };
+}
+function normalize2(fn) {
+  afn(fn);
+  return { encode: (from7) => from7, decode: (to) => fn(to) };
+}
+function convertRadix3(data, from7, to) {
+  if (from7 < 2)
+    throw new Error(`convertRadix: invalid from=${from7}, base cannot be less than 2`);
+  if (to < 2)
+    throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
+  aArr(data);
+  if (!data.length)
+    return [];
+  let pos = 0;
+  const res = [];
+  const digits = Array.from(data, (d) => {
+    anumber2(d);
+    if (d < 0 || d >= from7)
+      throw new Error(`invalid integer: ${d}`);
+    return d;
+  });
+  const dlen = digits.length;
+  while (true) {
+    let carry = 0;
+    let done = true;
+    for (let i4 = pos;i4 < dlen; i4++) {
+      const digit = digits[i4];
+      const fromCarry = from7 * carry;
+      const digitBase = fromCarry + digit;
+      if (!Number.isSafeInteger(digitBase) || fromCarry / from7 !== carry || digitBase - digit !== fromCarry) {
+        throw new Error("convertRadix: carry overflow");
+      }
+      const div = digitBase / to;
+      carry = digitBase % to;
+      const rounded = Math.floor(div);
+      digits[i4] = rounded;
+      if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)
+        throw new Error("convertRadix: carry overflow");
+      if (!done)
+        continue;
+      else if (!rounded)
+        pos = i4;
+      else
+        done = false;
+    }
+    res.push(carry);
+    if (done)
+      break;
+  }
+  for (let i4 = 0;i4 < data.length - 1 && data[i4] === 0; i4++)
+    res.push(0);
+  return res.reverse();
+}
+var gcd2 = (a, b) => b === 0 ? a : gcd2(b, a % b);
+var radix2carry2 = (from7, to) => from7 + (to - gcd2(from7, to));
+var powers = /* @__PURE__ */ (() => {
+  let res = [];
+  for (let i4 = 0;i4 < 40; i4++)
+    res.push(2 ** i4);
+  return res;
+})();
+function convertRadix22(data, from7, to, padding3) {
+  aArr(data);
+  if (from7 <= 0 || from7 > 32)
+    throw new Error(`convertRadix2: wrong from=${from7}`);
+  if (to <= 0 || to > 32)
+    throw new Error(`convertRadix2: wrong to=${to}`);
+  if (radix2carry2(from7, to) > 32) {
+    throw new Error(`convertRadix2: carry overflow from=${from7} to=${to} carryBits=${radix2carry2(from7, to)}`);
+  }
+  let carry = 0;
+  let pos = 0;
+  const max = powers[from7];
+  const mask = powers[to] - 1;
+  const res = [];
+  for (const n of data) {
+    anumber2(n);
+    if (n >= max)
+      throw new Error(`convertRadix2: invalid data word=${n} from=${from7}`);
+    carry = carry << from7 | n;
+    if (pos + from7 > 32)
+      throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from7}`);
+    pos += from7;
+    for (;pos >= to; pos -= to)
+      res.push((carry >> pos - to & mask) >>> 0);
+    const pow3 = powers[pos];
+    if (pow3 === undefined)
+      throw new Error("invalid carry");
+    carry &= pow3 - 1;
+  }
+  carry = carry << to - pos & mask;
+  if (!padding3 && pos >= from7)
+    throw new Error("Excess padding");
+  if (!padding3 && carry > 0)
+    throw new Error(`Non-zero padding: ${carry}`);
+  if (padding3 && pos > 0)
+    res.push(carry >>> 0);
+  return res;
+}
+function radix3(num2) {
+  anumber2(num2);
+  const _256 = 2 ** 8;
+  return {
+    encode: (bytes4) => {
+      if (!isBytes3(bytes4))
+        throw new Error("radix.encode input should be Uint8Array");
+      return convertRadix3(Array.from(bytes4), _256, num2);
+    },
+    decode: (digits) => {
+      anumArr("radix.decode", digits);
+      return Uint8Array.from(convertRadix3(digits, num2, _256));
+    }
+  };
+}
+function radix22(bits, revPadding = false) {
+  anumber2(bits);
+  if (bits <= 0 || bits > 32)
+    throw new Error("radix2: bits should be in (0..32]");
+  if (radix2carry2(8, bits) > 32 || radix2carry2(bits, 8) > 32)
+    throw new Error("radix2: carry overflow");
+  return {
+    encode: (bytes4) => {
+      if (!isBytes3(bytes4))
+        throw new Error("radix2.encode input should be Uint8Array");
+      return convertRadix22(Array.from(bytes4), 8, bits, !revPadding);
+    },
+    decode: (digits) => {
+      anumArr("radix2.decode", digits);
+      return Uint8Array.from(convertRadix22(digits, bits, 8, revPadding));
+    }
+  };
+}
+function unsafeWrapper2(fn) {
+  afn(fn);
+  return function(...args) {
+    try {
+      return fn.apply(null, args);
+    } catch (e) {}
+  };
+}
+function checksum(len, fn) {
+  anumber2(len);
+  afn(fn);
+  return {
+    encode(data) {
+      if (!isBytes3(data))
+        throw new Error("checksum.encode: input should be Uint8Array");
+      const sum = fn(data).slice(0, len);
+      const res = new Uint8Array(data.length + len);
+      res.set(data);
+      res.set(sum, data.length);
+      return res;
+    },
+    decode(data) {
+      if (!isBytes3(data))
+        throw new Error("checksum.decode: input should be Uint8Array");
+      const payload = data.slice(0, -len);
+      const oldChecksum = data.slice(-len);
+      const newChecksum = fn(payload).slice(0, len);
+      for (let i4 = 0;i4 < len; i4++)
+        if (newChecksum[i4] !== oldChecksum[i4])
+          throw new Error("Invalid checksum");
+      return payload;
+    }
+  };
+}
+var base162 = chain2(radix22(4), alphabet2("0123456789ABCDEF"), join4(""));
+var base322 = chain2(radix22(5), alphabet2("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), padding2(5), join4(""));
+var base32nopad = chain2(radix22(5), alphabet2("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), join4(""));
+var base32hex2 = chain2(radix22(5), alphabet2("0123456789ABCDEFGHIJKLMNOPQRSTUV"), padding2(5), join4(""));
+var base32hexnopad = chain2(radix22(5), alphabet2("0123456789ABCDEFGHIJKLMNOPQRSTUV"), join4(""));
+var base32crockford2 = chain2(radix22(5), alphabet2("0123456789ABCDEFGHJKMNPQRSTVWXYZ"), join4(""), normalize2((s) => s.toUpperCase().replace(/O/g, "0").replace(/[IL]/g, "1")));
+var hasBase64Builtin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toBase64 === "function" && typeof Uint8Array.fromBase64 === "function")();
+var decodeBase64Builtin = (s, isUrl) => {
+  astr("base64", s);
+  const re = isUrl ? /^[A-Za-z0-9=_-]+$/ : /^[A-Za-z0-9=+/]+$/;
+  const alphabet3 = isUrl ? "base64url" : "base64";
+  if (s.length > 0 && !re.test(s))
+    throw new Error("invalid base64");
+  return Uint8Array.fromBase64(s, { alphabet: alphabet3, lastChunkHandling: "strict" });
+};
+var base642 = hasBase64Builtin ? {
+  encode(b) {
+    abytes2(b);
+    return b.toBase64();
+  },
+  decode(s) {
+    return decodeBase64Builtin(s, false);
+  }
+} : chain2(radix22(6), alphabet2("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), padding2(6), join4(""));
+var base64nopad = chain2(radix22(6), alphabet2("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), join4(""));
+var base64url2 = hasBase64Builtin ? {
+  encode(b) {
+    abytes2(b);
+    return b.toBase64({ alphabet: "base64url" });
+  },
+  decode(s) {
+    return decodeBase64Builtin(s, true);
+  }
+} : chain2(radix22(6), alphabet2("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), padding2(6), join4(""));
+var base64urlnopad = chain2(radix22(6), alphabet2("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), join4(""));
+var genBase582 = (abc) => chain2(radix3(58), alphabet2(abc), join4(""));
+var base582 = genBase582("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
+var base58flickr2 = genBase582("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ");
+var base58xrp2 = genBase582("rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz");
+var createBase58check = (sha2564) => chain2(checksum(4, (data) => sha2564(sha2564(data))), base582);
+var BECH_ALPHABET2 = chain2(alphabet2("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), join4(""));
+var POLYMOD_GENERATORS2 = [996825010, 642813549, 513874426, 1027748829, 705979059];
+function bech32Polymod2(pre) {
+  const b = pre >> 25;
+  let chk = (pre & 33554431) << 5;
+  for (let i4 = 0;i4 < POLYMOD_GENERATORS2.length; i4++) {
+    if ((b >> i4 & 1) === 1)
+      chk ^= POLYMOD_GENERATORS2[i4];
+  }
+  return chk;
+}
+function bechChecksum2(prefix, words, encodingConst = 1) {
+  const len = prefix.length;
+  let chk = 1;
+  for (let i4 = 0;i4 < len; i4++) {
+    const c = prefix.charCodeAt(i4);
+    if (c < 33 || c > 126)
+      throw new Error(`Invalid prefix (${prefix})`);
+    chk = bech32Polymod2(chk) ^ c >> 5;
+  }
+  chk = bech32Polymod2(chk);
+  for (let i4 = 0;i4 < len; i4++)
+    chk = bech32Polymod2(chk) ^ prefix.charCodeAt(i4) & 31;
+  for (let v of words)
+    chk = bech32Polymod2(chk) ^ v;
+  for (let i4 = 0;i4 < 6; i4++)
+    chk = bech32Polymod2(chk);
+  chk ^= encodingConst;
+  return BECH_ALPHABET2.encode(convertRadix22([chk % powers[30]], 30, 5, false));
+}
+function genBech322(encoding) {
+  const ENCODING_CONST = encoding === "bech32" ? 1 : 734539939;
+  const _words = radix22(5);
+  const fromWords = _words.decode;
+  const toWords = _words.encode;
+  const fromWordsUnsafe = unsafeWrapper2(fromWords);
+  function encode(prefix, words, limit2 = 90) {
+    astr("bech32.encode prefix", prefix);
+    if (isBytes3(words))
+      words = Array.from(words);
+    anumArr("bech32.encode", words);
+    const plen = prefix.length;
+    if (plen === 0)
+      throw new TypeError(`Invalid prefix length ${plen}`);
+    const actualLength = plen + 7 + words.length;
+    if (limit2 !== false && actualLength > limit2)
+      throw new TypeError(`Length ${actualLength} exceeds limit ${limit2}`);
+    const lowered = prefix.toLowerCase();
+    const sum = bechChecksum2(lowered, words, ENCODING_CONST);
+    return `${lowered}1${BECH_ALPHABET2.encode(words)}${sum}`;
+  }
+  function decode2(str, limit2 = 90) {
+    astr("bech32.decode input", str);
+    const slen = str.length;
+    if (slen < 8 || limit2 !== false && slen > limit2)
+      throw new TypeError(`invalid string length: ${slen} (${str}). Expected (8..${limit2})`);
+    const lowered = str.toLowerCase();
+    if (str !== lowered && str !== str.toUpperCase())
+      throw new Error(`String must be lowercase or uppercase`);
+    const sepIndex = lowered.lastIndexOf("1");
+    if (sepIndex === 0 || sepIndex === -1)
+      throw new Error(`Letter "1" must be present between prefix and data only`);
+    const prefix = lowered.slice(0, sepIndex);
+    const data = lowered.slice(sepIndex + 1);
+    if (data.length < 6)
+      throw new Error("Data must be at least 6 characters long");
+    const words = BECH_ALPHABET2.decode(data).slice(0, -6);
+    const sum = bechChecksum2(prefix, words, ENCODING_CONST);
+    if (!data.endsWith(sum))
+      throw new Error(`Invalid checksum in ${str}: expected "${sum}"`);
+    return { prefix, words };
+  }
+  const decodeUnsafe = unsafeWrapper2(decode2);
+  function decodeToBytes(str) {
+    const { prefix, words } = decode2(str, false);
+    return { prefix, words, bytes: fromWords(words) };
+  }
+  function encodeFromBytes(prefix, bytes4) {
+    return encode(prefix, toWords(bytes4));
+  }
+  return {
+    encode,
+    decode: decode2,
+    encodeFromBytes,
+    decodeToBytes,
+    decodeUnsafe,
+    fromWords,
+    fromWordsUnsafe,
+    toWords
+  };
+}
+var bech322 = genBech322("bech32");
+var bech32m2 = genBech322("bech32m");
+var hasHexBuiltin2 = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
+var hexBuiltin = {
+  encode(data) {
+    abytes2(data);
+    return data.toHex();
+  },
+  decode(s) {
+    astr("hex", s);
+    return Uint8Array.fromHex(s);
+  }
+};
+var hex2 = hasHexBuiltin2 ? hexBuiltin : chain2(radix22(4), alphabet2("0123456789abcdef"), join4(""), normalize2((s) => {
+  if (typeof s !== "string" || s.length % 2 !== 0)
+    throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`);
+  return s.toLowerCase();
+}));
+
+// ../routstr-chat/node_modules/@scure/bip32/lib/esm/index.js
+/*! scure-bip32 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */
+var Point2 = secp256k12.ProjectivePoint;
+var base58check = createBase58check(sha2563);
+function bytesToNumber(bytes4) {
+  abytes(bytes4);
+  const h = bytes4.length === 0 ? "0" : bytesToHex4(bytes4);
+  return BigInt("0x" + h);
+}
+function numberToBytes(num2) {
+  if (typeof num2 !== "bigint")
+    throw new Error("bigint expected");
+  return hexToBytes4(num2.toString(16).padStart(64, "0"));
+}
+var MASTER_SECRET = utf8ToBytes5("Bitcoin seed");
+var BITCOIN_VERSIONS = { private: 76066276, public: 76067358 };
+var HARDENED_OFFSET = 2147483648;
+var hash160 = (data) => ripemd160(sha2563(data));
+var fromU32 = (data) => createView4(data).getUint32(0, false);
+var toU32 = (n) => {
+  if (!Number.isSafeInteger(n) || n < 0 || n > 2 ** 32 - 1) {
+    throw new Error("invalid number, should be from 0 to 2**32-1, got " + n);
+  }
+  const buf = new Uint8Array(4);
+  createView4(buf).setUint32(0, n, false);
+  return buf;
+};
+
+class HDKey {
+  get fingerprint() {
+    if (!this.pubHash) {
+      throw new Error("No publicKey set!");
+    }
+    return fromU32(this.pubHash);
+  }
+  get identifier() {
+    return this.pubHash;
+  }
+  get pubKeyHash() {
+    return this.pubHash;
+  }
+  get privateKey() {
+    return this.privKeyBytes || null;
+  }
+  get publicKey() {
+    return this.pubKey || null;
+  }
+  get privateExtendedKey() {
+    const priv = this.privateKey;
+    if (!priv) {
+      throw new Error("No private key");
+    }
+    return base58check.encode(this.serialize(this.versions.private, concatBytes4(new Uint8Array([0]), priv)));
+  }
+  get publicExtendedKey() {
+    if (!this.pubKey) {
+      throw new Error("No public key");
+    }
+    return base58check.encode(this.serialize(this.versions.public, this.pubKey));
+  }
+  static fromMasterSeed(seed, versions = BITCOIN_VERSIONS) {
+    abytes(seed);
+    if (8 * seed.length < 128 || 8 * seed.length > 512) {
+      throw new Error("HDKey: seed length must be between 128 and 512 bits; 256 bits is advised, got " + seed.length);
+    }
+    const I = hmac3(sha512, MASTER_SECRET, seed);
+    return new HDKey({
+      versions,
+      chainCode: I.slice(32),
+      privateKey: I.slice(0, 32)
+    });
+  }
+  static fromExtendedKey(base58key, versions = BITCOIN_VERSIONS) {
+    const keyBuffer = base58check.decode(base58key);
+    const keyView = createView4(keyBuffer);
+    const version = keyView.getUint32(0, false);
+    const opt = {
+      versions,
+      depth: keyBuffer[4],
+      parentFingerprint: keyView.getUint32(5, false),
+      index: keyView.getUint32(9, false),
+      chainCode: keyBuffer.slice(13, 45)
+    };
+    const key = keyBuffer.slice(45);
+    const isPriv = key[0] === 0;
+    if (version !== versions[isPriv ? "private" : "public"]) {
+      throw new Error("Version mismatch");
+    }
+    if (isPriv) {
+      return new HDKey({ ...opt, privateKey: key.slice(1) });
+    } else {
+      return new HDKey({ ...opt, publicKey: key });
+    }
+  }
+  static fromJSON(json2) {
+    return HDKey.fromExtendedKey(json2.xpriv);
+  }
+  constructor(opt) {
+    this.depth = 0;
+    this.index = 0;
+    this.chainCode = null;
+    this.parentFingerprint = 0;
+    if (!opt || typeof opt !== "object") {
+      throw new Error("HDKey.constructor must not be called directly");
+    }
+    this.versions = opt.versions || BITCOIN_VERSIONS;
+    this.depth = opt.depth || 0;
+    this.chainCode = opt.chainCode || null;
+    this.index = opt.index || 0;
+    this.parentFingerprint = opt.parentFingerprint || 0;
+    if (!this.depth) {
+      if (this.parentFingerprint || this.index) {
+        throw new Error("HDKey: zero depth with non-zero index/parent fingerprint");
+      }
+    }
+    if (opt.publicKey && opt.privateKey) {
+      throw new Error("HDKey: publicKey and privateKey at same time.");
+    }
+    if (opt.privateKey) {
+      if (!secp256k12.utils.isValidPrivateKey(opt.privateKey)) {
+        throw new Error("Invalid private key");
+      }
+      this.privKey = typeof opt.privateKey === "bigint" ? opt.privateKey : bytesToNumber(opt.privateKey);
+      this.privKeyBytes = numberToBytes(this.privKey);
+      this.pubKey = secp256k12.getPublicKey(opt.privateKey, true);
+    } else if (opt.publicKey) {
+      this.pubKey = Point2.fromHex(opt.publicKey).toRawBytes(true);
+    } else {
+      throw new Error("HDKey: no public or private key provided");
+    }
+    this.pubHash = hash160(this.pubKey);
+  }
+  derive(path) {
+    if (!/^[mM]'?/.test(path)) {
+      throw new Error('Path must start with "m" or "M"');
+    }
+    if (/^[mM]'?$/.test(path)) {
+      return this;
+    }
+    const parts = path.replace(/^[mM]'?\//, "").split("/");
+    let child = this;
+    for (const c of parts) {
+      const m = /^(\d+)('?)$/.exec(c);
+      const m1 = m && m[1];
+      if (!m || m.length !== 3 || typeof m1 !== "string")
+        throw new Error("invalid child index: " + c);
+      let idx = +m1;
+      if (!Number.isSafeInteger(idx) || idx >= HARDENED_OFFSET) {
+        throw new Error("Invalid index");
+      }
+      if (m[2] === "'") {
+        idx += HARDENED_OFFSET;
+      }
+      child = child.deriveChild(idx);
+    }
+    return child;
+  }
+  deriveChild(index) {
+    if (!this.pubKey || !this.chainCode) {
+      throw new Error("No publicKey or chainCode set");
+    }
+    let data = toU32(index);
+    if (index >= HARDENED_OFFSET) {
+      const priv = this.privateKey;
+      if (!priv) {
+        throw new Error("Could not derive hardened child key");
+      }
+      data = concatBytes4(new Uint8Array([0]), priv, data);
+    } else {
+      data = concatBytes4(this.pubKey, data);
+    }
+    const I = hmac3(sha512, this.chainCode, data);
+    const childTweak = bytesToNumber(I.slice(0, 32));
+    const chainCode = I.slice(32);
+    if (!secp256k12.utils.isValidPrivateKey(childTweak)) {
+      throw new Error("Tweak bigger than curve order");
+    }
+    const opt = {
+      versions: this.versions,
+      chainCode,
+      depth: this.depth + 1,
+      parentFingerprint: this.fingerprint,
+      index
+    };
+    try {
+      if (this.privateKey) {
+        const added = mod2(this.privKey + childTweak, secp256k12.CURVE.n);
+        if (!secp256k12.utils.isValidPrivateKey(added)) {
+          throw new Error("The tweak was out of range or the resulted private key is invalid");
+        }
+        opt.privateKey = added;
+      } else {
+        const added = Point2.fromHex(this.pubKey).add(Point2.fromPrivateKey(childTweak));
+        if (added.equals(Point2.ZERO)) {
+          throw new Error("The tweak was equal to negative P, which made the result key invalid");
+        }
+        opt.publicKey = added.toRawBytes(true);
+      }
+      return new HDKey(opt);
+    } catch (err) {
+      return this.deriveChild(index + 1);
+    }
+  }
+  sign(hash3) {
+    if (!this.privateKey) {
+      throw new Error("No privateKey set!");
+    }
+    abytes(hash3, 32);
+    return secp256k12.sign(hash3, this.privKey).toCompactRawBytes();
+  }
+  verify(hash3, signature) {
+    abytes(hash3, 32);
+    abytes(signature, 64);
+    if (!this.publicKey) {
+      throw new Error("No publicKey set!");
+    }
+    let sig;
+    try {
+      sig = secp256k12.Signature.fromCompact(signature);
+    } catch (error) {
+      return false;
+    }
+    return secp256k12.verify(sig, hash3, this.publicKey);
+  }
+  wipePrivateData() {
+    this.privKey = undefined;
+    if (this.privKeyBytes) {
+      this.privKeyBytes.fill(0);
+      this.privKeyBytes = undefined;
+    }
+    return this;
+  }
+  toJSON() {
+    return {
+      xpriv: this.privateExtendedKey,
+      xpub: this.publicExtendedKey
+    };
+  }
+  serialize(version, key) {
+    if (!this.chainCode) {
+      throw new Error("No chainCode set");
+    }
+    abytes(key, 33);
+    return concatBytes4(toU32(version), new Uint8Array([this.depth]), toU32(this.parentFingerprint), toU32(this.index), this.chainCode, key);
+  }
+}
+
+// ../routstr-chat/node_modules/@cashu/cashu-ts/lib/cashu-ts.es.js
+var ut = {
+  UNPAID: "UNPAID",
+  PENDING: "PENDING",
+  PAID: "PAID"
+};
+var Tt = {
+  UNPAID: "UNPAID",
+  PAID: "PAID",
+  ISSUED: "ISSUED"
+};
+
+class ht extends Error {
+  constructor(t, e) {
+    super(t), this.status = e, this.name = "HttpResponseError", Object.setPrototypeOf(this, ht.prototype);
+  }
+}
+
+class Kt extends Error {
+  constructor(t) {
+    super(t), this.name = "NetworkError", Object.setPrototypeOf(this, Kt.prototype);
+  }
+}
+
+class Dt extends ht {
+  constructor(t, e) {
+    super(e || "Unknown mint operation error", 400), this.code = t, this.name = "MintOperationError", Object.setPrototypeOf(this, Dt.prototype);
+  }
+}
+var L = {
+  error() {},
+  warn() {},
+  info() {},
+  debug() {},
+  trace() {},
+  log() {}
+};
+function lt(s, t, e = L, n) {
+  if (s)
+    try {
+      const r = s(t);
+      r && typeof r.then == "function" && r.catch((i4) => {
+        try {
+          e.warn("callback failed", {
+            ...n ?? {},
+            error: i4,
+            cb: s.name ?? ""
+          });
+        } catch {}
+      });
+    } catch (r) {
+      try {
+        e.warn("callback failed", {
+          ...n ?? {},
+          error: r,
+          cb: s.name ?? ""
+        });
+      } catch {}
+    }
+}
+var fe2 = {};
+var ge2 = L;
+function je(s) {
+  ge2 = s;
+}
+async function Qe({
+  endpoint: s,
+  requestBody: t,
+  headers: e,
+  ...n
+}) {
+  const r = t ? JSON.stringify(t) : undefined, i4 = {
+    Accept: "application/json, text/plain, */*",
+    ...r ? { "Content-Type": "application/json" } : undefined,
+    ...e
+  };
+  let o;
+  try {
+    o = await fetch(s, { body: r, headers: i4, ...n });
+  } catch (a) {
+    throw new Kt(a instanceof Error ? a.message : "Network request failed");
+  }
+  if (!o.ok) {
+    let a;
+    try {
+      a = await o.json();
+    } catch {
+      a = { error: "bad response" };
+    }
+    if (o.status === 400 && "code" in a && typeof a.code == "number" && "detail" in a && typeof a.detail == "string")
+      throw new Dt(a.code, a.detail);
+    let c = "HTTP request failed";
+    throw "error" in a && typeof a.error == "string" ? c = a.error : ("detail" in a) && typeof a.detail == "string" && (c = a.detail), new ht(c, o.status);
+  }
+  try {
+    return await o.json();
+  } catch (a) {
+    throw ge2.error("Failed to parse HTTP response", { err: a }), new ht("bad response", o.status);
+  }
+}
+async function pe(s) {
+  return await Qe({ ...s, ...fe2 });
+}
+var pt;
+typeof WebSocket < "u" && (pt = WebSocket);
+function ze() {
+  if (pt === undefined)
+    throw new Error("WebSocket implementation not initialized");
+  return pt;
+}
+
+class _ {
+  static fromHex(t) {
+    if (t = t.trim(), t.length === 0)
+      return new Uint8Array(0);
+    if (t.length < 2 || t.length & 1)
+      throw new Error("Invalid hex string: odd length.");
+    if ((t.startsWith("0x") || t.startsWith("0X")) && (t = t.slice(2)), !t.match(/^[0-9a-fA-F]*$/))
+      throw new Error("Invalid hex string: contains non-hex characters");
+    const n = t.match(/.{1,2}/g);
+    if (!n)
+      throw new Error("Invalid hex string");
+    return new Uint8Array(n.map((r) => parseInt(r, 16)));
+  }
+  static toHex(t) {
+    return Array.from(t, (e) => e.toString(16).padStart(2, "0")).join("");
+  }
+  static fromString(t) {
+    return t = t.trim(), new TextEncoder().encode(t);
+  }
+  static toString(t) {
+    return new TextDecoder("utf-8").decode(t);
+  }
+  static concat(...t) {
+    const e = t.reduce((i4, o) => i4 + o.length, 0), n = new Uint8Array(e);
+    let r = 0;
+    for (const i4 of t)
+      n.set(i4, r), r += i4.length;
+    return n;
+  }
+  static alloc(t) {
+    return new Uint8Array(t);
+  }
+  static writeBigUint64BE(t) {
+    const e = new ArrayBuffer(8);
+    return new DataView(e).setBigUint64(0, t, false), new Uint8Array(e);
+  }
+  static toBase64(t) {
+    if (typeof Buffer < "u")
+      return Buffer.from(t).toString("base64");
+    if (t.length > 32768) {
+      let e = "";
+      for (let n = 0;n < t.length; n += 32768) {
+        const r = t.slice(n, n + 32768);
+        e += btoa(String.fromCharCode(...r));
+      }
+      return e;
+    }
+    return btoa(String.fromCharCode(...t));
+  }
+  static fromBase64(t) {
+    t = t.trim();
+    let e = t.replace(/-/g, "+").replace(/_/g, "/");
+    for (;e.length % 4; )
+      e += "=";
+    return typeof Buffer < "u" ? new Uint8Array(Buffer.from(e, "base64")) : new Uint8Array([...atob(e)].map((n) => n.charCodeAt(0)));
+  }
+  static equals(t, e) {
+    if (t.length !== e.length)
+      return false;
+    let n = 0;
+    for (let r = 0;r < t.length; r++)
+      n |= t[r] ^ e[r];
+    return n === 0;
+  }
+  static compare(t, e) {
+    const n = Math.min(t.length, e.length);
+    for (let r = 0;r < n; r++) {
+      if (t[r] < e[r])
+        return -1;
+      if (t[r] > e[r])
+        return 1;
+    }
+    return t.length - e.length;
+  }
+}
+function It(s) {
+  return _.toBase64(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function qt(s) {
+  return _.fromBase64(s);
+}
+function me(s) {
+  const t = JSON.stringify(s);
+  return Je(_.toBase64(_.fromString(t)));
+}
+function Je(s) {
+  return s.replace(/\+/g, "-").replace(/\//g, "_").split("=")[0];
+}
+function Ut(s) {
+  if (typeof s != "string" || s.length === 0)
+    return false;
+  const t = /^[A-Za-z0-9\-_]+={0,2}$/, e = /^[A-Za-z0-9+/]+={0,2}$/;
+  if (!t.test(s) && !e.test(s))
+    return false;
+  const n = s.replace(/-/g, "+").replace(/_/g, "/"), r = (4 - n.length % 4) % 4;
+  if (r > 2)
+    return false;
+  const i4 = n + "=".repeat(r);
+  try {
+    const o = _.fromBase64(i4), a = _.toBase64(o), c = a.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, ""), u = n.replace(/=+$/, "");
+    return a.replace(/=+$/, "") === u || c === u;
+  } catch {
+    return false;
+  }
+}
+var Zt = utf8ToBytes5("Cashu_P2BK_v1");
+function gn(s, t, e) {
+  if (!s.length)
+    return { blinded: [], Ehex: "" };
+  e = e ?? secp256k12.utils.randomSecretKey();
+  const n = secp256k12.Point.Fn.fromBytes(e), r = secp256k12.getPublicKey(e, true), i4 = hexToBytes4(t);
+  return { blinded: s.map((a, c) => {
+    const u = X(a), l = we(u, n, i4, c), h = u.add(secp256k12.Point.BASE.multiply(l));
+    if (h.equals(secp256k12.Point.ZERO))
+      throw new Error("Blinded key at infinity");
+    return h.toHex(true);
+  }), Ehex: bytesToHex4(r) };
+}
+function we(s, t, e, n) {
+  const r = s.multiply(t).toBytes(true).slice(1), i4 = new Uint8Array([n & 255]);
+  let o = $(sha2563(_.concat(Zt, r, e, i4)));
+  if ((o === 0n || o >= secp256k12.Point.CURVE().n) && (o = $(sha2563(_.concat(Zt, r, e, i4, new Uint8Array([255])))), o === 0n || o >= secp256k12.Point.CURVE().n))
+    throw new Error("P2BK: tweak derivation failed");
+  return o;
+}
+var wn = (s, t) => {
+  const e = sha2563(s), n = schnorr2.sign(e, t);
+  return bytesToHex4(n);
+};
+var Pe = (s, t) => {
+  const e = s.B_.toHex(true), n = wn(e, t);
+  return s.witness = { signatures: [n] }, s;
+};
+var An = hexToBytes4("536563703235366b315f48617368546f43757276655f43617368755f");
+function ft(s) {
+  const t = sha2563(_.concat(An, s)), e = new Uint32Array(1), n = 2 ** 16;
+  for (let r = 0;r < n; r++) {
+    const i4 = new Uint8Array(e.buffer), o = sha2563(_.concat(t, i4));
+    try {
+      return X(bytesToHex4(_.concat(new Uint8Array([2]), o)));
+    } catch {
+      e[0]++;
+    }
+  }
+  throw new Error("No valid point found");
+}
+function Ae(s) {
+  const e = s.map((n) => n.toHex(false)).join("");
+  return sha2563(new TextEncoder().encode(e));
+}
+function X(s) {
+  return secp256k12.Point.fromHex(s);
+}
+var vn = (s) => {
+  let t;
+  return /^[a-fA-F0-9]+$/.test(s) ? t = dt(s) % BigInt(2 ** 31 - 1) : t = $(qt(s)) % BigInt(2 ** 31 - 1), t;
+};
+function gt(s, t, e) {
+  const n = ft(s);
+  t || (t = $(secp256k12.utils.randomSecretKey()));
+  const r = secp256k12.Point.BASE.multiply(t), i4 = n.add(r);
+  return e !== undefined ? Pe({ B_: i4, r: t, secret: s }, e) : { B_: i4, r: t, secret: s };
+}
+function En(s, t, e) {
+  return s.subtract(e.multiply(t));
+}
+function Sn(s, t, e, n) {
+  const r = n, i4 = En(s.C_, t, r);
+  return {
+    id: s.id,
+    amount: s.amount,
+    secret: e,
+    C: i4
+  };
+}
+var Tn = (s) => ({
+  amount: s.amount,
+  C: s.C.toHex(true),
+  id: s.id,
+  secret: new TextDecoder().decode(s.secret),
+  witness: JSON.stringify(s.witness)
+});
+var Cn = "m/129372'/0'";
+var xn = (s, t, e) => {
+  const n = /^[a-fA-F0-9]+$/.test(t);
+  if (!n && Ut(t) || n && t.startsWith("00"))
+    return yt(s, t, e, 0);
+  if (n && t.startsWith("01"))
+    return Ee(s, t, e, 0);
+  throw new Error(`Unrecognized keyset ID version ${t.slice(0, 2)}`);
+};
+var Bn = (s, t, e) => {
+  const n = /^[a-fA-F0-9]+$/.test(t);
+  if (!n && Ut(t) || n && t.startsWith("00"))
+    return yt(s, t, e, 1);
+  if (n && t.startsWith("01"))
+    return Ee(s, t, e, 1);
+  throw new Error(`Unrecognized keyset ID version ${t.slice(0, 2)}`);
+};
+var Ee = (s, t, e, n) => {
+  let r = _.concat(_.fromString("Cashu_KDF_HMAC_SHA256"), _.fromHex(t), _.writeBigUint64BE(BigInt(e)));
+  switch (n) {
+    case 0:
+      r = _.concat(r, _.fromHex("00"));
+      break;
+    case 1:
+      r = _.concat(r, _.fromHex("01"));
+  }
+  return hmac3(sha2563, s, r);
+};
+var yt = (s, t, e, n) => {
+  const r = HDKey.fromMasterSeed(s), i4 = vn(t), o = `${Cn}/${i4}'/${e}'/${n}`, a = r.derive(o);
+  if (a.privateKey === null)
+    throw new Error("Could not derive private key");
+  return a.privateKey;
+};
+function On(s, t) {
+  if (s.length !== t.length)
+    return false;
+  for (let e = 0;e < s.length; e++)
+    if (s[e] !== t[e])
+      return false;
+  return true;
+}
+var Kn = (s, t, e, n) => {
+  const r = secp256k12.Point.BASE.multiply(secp256k12.Point.Fn.fromBytes(s.s)), i4 = n.multiply($(s.e)), o = t.multiply($(s.s)), a = e.multiply($(s.e)), c = r.subtract(i4), u = o.subtract(a), l = Ae([c, u, n, e]);
+  return On(l, s.e);
+};
+var Dn = (s, t, e, n) => {
+  if (t.r === undefined)
+    throw new Error("verifyDLEQProof_reblind: Undefined blinding factor");
+  const r = ft(s), i4 = e.add(n.multiply(t.r)), o = secp256k12.Point.BASE.multiply(t.r), a = r.add(o);
+  return Kn(t, a, i4, n);
+};
+function G(s, t, e, n) {
+  if (e) {
+    const i4 = ee(e);
+    if (s === 0 && i4 === 0)
+      return e;
+    const o = e.filter((c) => c > 0), a = ee(o);
+    if (a > s)
+      throw new Error(`Split is greater than total amount: ${a} > ${s}`);
+    if (o.some((c) => !Ie(c, t)))
+      throw new Error("Provided amount preferences do not match the amounts of the mint keyset.");
+    if (a === s)
+      return o;
+    e = o, s -= a;
+  } else
+    e = [];
+  const r = Te(t, "desc");
+  if (!r || r.length === 0)
+    throw new Error("Cannot split amount, keyset is inactive or contains no keys");
+  for (const i4 of r) {
+    if (i4 <= 0)
+      continue;
+    const o = Math.floor(s / i4);
+    if (e.push(...Array(o).fill(i4)), s -= i4 * o, s === 0)
+      break;
+  }
+  if (s !== 0)
+    throw new Error(`Unable to split remaining amount: ${s}`);
+  return n ? e.sort((i4, o) => n === "desc" ? o - i4 : i4 - o) : e;
+}
+function Te(s, t = "desc") {
+  return t == "desc" ? Object.keys(s).map((e) => parseInt(e)).sort((e, n) => n - e) : Object.keys(s).map((e) => parseInt(e)).sort((e, n) => e - n);
+}
+function Ie(s, t) {
+  return s in t;
+}
+function $(s) {
+  return dt(bytesToHex4(s));
+}
+function dt(s) {
+  return BigInt(`0x${s}`);
+}
+function Mt(s) {
+  return s.toString(16).padStart(64, "0");
+}
+function Ct(s) {
+  return /^[a-f0-9]*$/i.test(s);
+}
+function Qt(s, t, e, n = 0, r = false) {
+  if (r) {
+    const c = Object.entries(s).sort((h, d) => +h[0] - +d[0]).map(([, h]) => h).reduce((h, d) => h + d, ""), u = sha2563(c);
+    return _.toBase64(u).slice(0, 12);
+  }
+  let i4 = Object.entries(s).sort((c, u) => +c[0] - +u[0]).map(([, c]) => hexToBytes4(c)).reduce((c, u) => Pt(c, u), new Uint8Array), o, a;
+  switch (n) {
+    case 0:
+      return o = sha2563(i4), a = _.toHex(o).slice(0, 14), "00" + a;
+    case 1:
+      if (!t)
+        throw new Error("Cannot compute keyset ID version 01: unit is required.");
+      return i4 = Pt(i4, _.fromString("unit:" + t)), e && (i4 = Pt(i4, _.fromString("final_expiry:" + e.toString()))), o = sha2563(i4), a = _.toHex(o), "01" + a;
+    default:
+      throw new Error(`Unrecognized keyset ID version: ${n}`);
+  }
+}
+function Pt(s, t) {
+  const e = new Uint8Array(s.length + t.length);
+  return e.set(s), e.set(t, s.length), e;
+}
+function T(s) {
+  return typeof s == "object";
+}
+function W(...s) {
+  return s.map((t) => t.replace(/(^\/+|\/+$)/g, "")).join("/");
+}
+function Oe(s) {
+  return s.replace(/\/$/, "");
+}
+class Ln {
+  get value() {
+    return this._value;
+  }
+  set value(t) {
+    this._value = t;
+  }
+  get next() {
+    return this._next;
+  }
+  set next(t) {
+    this._next = t;
+  }
+  constructor(t) {
+    this._value = t, this._next = null;
+  }
+}
+
+class $n {
+  get first() {
+    return this._first;
+  }
+  set first(t) {
+    this._first = t;
+  }
+  get last() {
+    return this._last;
+  }
+  set last(t) {
+    this._last = t;
+  }
+  get size() {
+    return this._size;
+  }
+  set size(t) {
+    this._size = t;
+  }
+  constructor() {
+    this._first = null, this._last = null, this._size = 0;
+  }
+  enqueue(t) {
+    const e = new Ln(t);
+    return this._size === 0 || !this._last ? (this._first = e, this._last = e) : (this._last.next = e, this._last = e), this._size++, true;
+  }
+  dequeue() {
+    if (this._size === 0 || !this._first)
+      return null;
+    const t = this._first;
+    return this._first = t.next, t.next = null, this._size--, t.value;
+  }
+}
+function De(s, t) {
+  if (s.dleq == null)
+    return false;
+  const e = {
+    e: hexToBytes4(s.dleq.e),
+    s: hexToBytes4(s.dleq.s),
+    r: dt(s.dleq.r ?? "00")
+  };
+  if (!Ie(s.amount, t.keys))
+    throw new Error(`undefined key for amount ${s.amount}`);
+  const n = t.keys[s.amount];
+  return Dn(new TextEncoder().encode(s.secret), e, X(s.C), X(n));
+}
+function ee(s) {
+  return s.reduce((t, e) => t + e, 0);
+}
+class it {
+  constructor() {
+    this.connectionMap = /* @__PURE__ */ new Map;
+  }
+  static getInstance() {
+    return it.instance || (it.instance = new it), it.instance;
+  }
+  getConnection(t, e) {
+    if (this.connectionMap.has(t))
+      return this.connectionMap.get(t);
+    const n = new jn(t, e);
+    return this.connectionMap.set(t, n), n;
+  }
+}
+
+class jn {
+  constructor(t, e) {
+    this.subListeners = {}, this.rpcListeners = {}, this.rpcId = 0, this.onCloseCallbacks = [], this._WS = ze(), this.url = new URL(t), this.messageQueue = new $n, this._logger = e ?? L;
+  }
+  connect() {
+    return this.connectionPromise || (this.connectionPromise = new Promise((t, e) => {
+      try {
+        this.ws = new this._WS(this.url.toString()), this.onCloseCallbacks = [];
+      } catch (n) {
+        e(n instanceof Error ? n : new Error(String(n)));
+        return;
+      }
+      this.ws.onopen = () => {
+        t();
+      }, this.ws.onerror = () => {
+        e(new Error("Failed to open WebSocket"));
+      }, this.ws.onmessage = (n) => {
+        this.messageQueue.enqueue(n.data), this.handlingInterval || (this.handlingInterval = setInterval(this.handleNextMessage.bind(this), 0));
+      }, this.ws.onclose = (n) => {
+        this.connectionPromise = undefined, this.onCloseCallbacks.forEach((r) => r(n));
+      };
+    })), this.connectionPromise;
+  }
+  sendRequest(t, e) {
+    if (this.ws?.readyState !== 1) {
+      if (t === "unsubscribe")
+        return;
+      throw this._logger.error("Attempted sendRequest, but socket was not open"), new Error("Socket not open");
+    }
+    const n = this.rpcId;
+    this.rpcId++;
+    const r = JSON.stringify({ jsonrpc: "2.0", method: t, params: e, id: n });
+    this.ws?.send(r);
+  }
+  closeSubscription(t) {
+    this.ws?.send(JSON.stringify(["CLOSE", t]));
+  }
+  addSubListener(t, e) {
+    (this.subListeners[t] = this.subListeners[t] || []).push(e);
+  }
+  addRpcListener(t, e, n) {
+    this.rpcListeners[n] = { callback: t, errorCallback: e };
+  }
+  removeRpcListener(t) {
+    delete this.rpcListeners[t];
+  }
+  removeListener(t, e) {
+    if (this.subListeners[t]) {
+      if (this.subListeners[t].length === 1) {
+        delete this.subListeners[t];
+        return;
+      }
+      this.subListeners[t] = this.subListeners[t].filter((n) => n !== e);
+    }
+  }
+  async ensureConnection() {
+    this.ws?.readyState !== 1 && await this.connect();
+  }
+  handleNextMessage() {
+    if (this.messageQueue.size === 0) {
+      clearInterval(this.handlingInterval), this.handlingInterval = undefined;
+      return;
+    }
+    const t = this.messageQueue.dequeue();
+    let e;
+    try {
+      if (e = JSON.parse(t), "result" in e && e.id != null)
+        this.rpcListeners[e.id] && (this.rpcListeners[e.id].callback(), this.removeRpcListener(e.id));
+      else if ("error" in e && e.id != null)
+        this.rpcListeners[e.id] && (this.rpcListeners[e.id].errorCallback(new Error(e.error.message)), this.removeRpcListener(e.id));
+      else if ("method" in e && !("id" in e)) {
+        const n = e.params?.subId;
+        if (!n)
+          return;
+        if (this.subListeners[n]?.length > 0) {
+          const r = e;
+          this.subListeners[n].forEach((i4) => i4(r.params?.payload));
+        }
+      }
+    } catch (n) {
+      this._logger.error("Error doing handleNextMessage", { e: n });
+      return;
+    }
+  }
+  createSubscription(t, e, n) {
+    if (this.ws?.readyState !== 1)
+      throw this._logger.error("Attempted createSubscription, but socket was not open"), new Error("Socket is not open");
+    const r = (Math.random() + 1).toString(36).substring(7);
+    return this.addRpcListener(() => {
+      this.addSubListener(r, e);
+    }, n, this.rpcId), this.sendRequest("subscribe", { ...t, subId: r }), this.rpcId++, r;
+  }
+  cancelSubscription(t, e, n) {
+    this.removeListener(t, e), this.addRpcListener(() => {
+      this._logger.info("Unsubscribed {subId}", { subId: t });
+    }, n || ((r) => this._logger.error("Unsubscribe failed", { e: r })), this.rpcId), this.sendRequest("unsubscribe", { subId: t });
+  }
+  get activeSubscriptions() {
+    return Object.keys(this.subListeners);
+  }
+  close() {
+    this.ws && this.ws?.close();
+  }
+  onClose(t) {
+    this.onCloseCallbacks.push(t);
+  }
+}
+function At(s, t) {
+  return s.state || (t.warn("Field 'state' not found in MeltQuoteResponse. Update NUT-05 of mint: https://github.com/cashubtc/nuts/pull/136)"), typeof s.paid == "boolean" && (s.state = s.paid ? ut.PAID : ut.UNPAID)), s;
+}
+function se(s, t) {
+  return s.state || (t.warn("Field 'state' not found in MintQuoteResponse. Update NUT-04 of mint: https://github.com/cashubtc/nuts/pull/141)"), typeof s.paid == "boolean" && (s.state = s.paid ? Tt.PAID : Tt.UNPAID)), s;
+}
+function Qn(s, t) {
+  return Array.isArray(s?.contact) && s?.contact.length > 0 && (s.contact = s.contact.map((e) => Array.isArray(e) && e.length === 2 && typeof e[0] == "string" && typeof e[1] == "string" ? (t.warn("Mint returned deprecated 'contact' field: Update NUT-06: https://github.com/cashubtc/nuts/pull/117"), { method: e[0], info: e[1] }) : e)), s;
+}
+
+class wt {
+  constructor(t) {
+    this.REGEX_METACHAR = /[\\^$.*+?()[\]{}|]/, this._mintInfo = t;
+    const e = this.toEndpoints(t?.nuts?.[22]?.protected_endpoints);
+    this._protected22 = this.buildIndex(e);
+    const n = this.toEndpoints(t?.nuts?.[21]?.protected_endpoints);
+    this._protected21 = this.buildIndex(n);
+  }
+  isSupported(t) {
+    switch (t) {
+      case 4:
+      case 5:
+        return this.checkMintMelt(t);
+      case 7:
+      case 8:
+      case 9:
+      case 10:
+      case 11:
+      case 12:
+      case 14:
+      case 20:
+        return this.checkGenericNut(t);
+      case 17:
+        return this.checkNut17();
+      case 15:
+        return this.checkNut15();
+      default:
+        throw new Error("nut is not supported by cashu-ts");
+    }
+  }
+  requiresBlindAuthToken(t, e) {
+    return this.matchesProtected(this._protected22, t, e);
+  }
+  requiresClearAuthToken(t, e) {
+    return this.matchesProtected(this._protected21, t, e);
+  }
+  matchesProtected(t, e, n) {
+    if (!t)
+      return false;
+    const r = `${e} ${n}`, i4 = t.cache[r];
+    if (typeof i4 == "boolean")
+      return i4;
+    const o = t.exact.some((u) => u.method === e && u.path === n), a = o ? false : t.regex.some((u) => u.method === e && u.regex.test(n)), c = o || a;
+    return t.cache[r] = c, c;
+  }
+  checkGenericNut(t) {
+    return this._mintInfo.nuts[t]?.supported ? { supported: true } : { supported: false };
+  }
+  checkMintMelt(t) {
+    const e = this._mintInfo.nuts[t];
+    return e && e.methods.length > 0 && !e.disabled ? { disabled: false, params: e.methods } : { disabled: true, params: e?.methods ?? [] };
+  }
+  checkNut17() {
+    return this._mintInfo.nuts[17] && this._mintInfo.nuts[17].supported.length > 0 ? { supported: true, params: this._mintInfo.nuts[17].supported } : { supported: false };
+  }
+  checkNut15() {
+    return this._mintInfo.nuts[15] && this._mintInfo.nuts[15].methods.length > 0 ? { supported: true, params: this._mintInfo.nuts[15].methods } : { supported: false };
+  }
+  toEndpoints(t) {
+    if (!Array.isArray(t))
+      return [];
+    const e = [];
+    for (const n of t)
+      if (n && typeof n == "object") {
+        const r = n, i4 = r.method, o = r.path;
+        if (typeof i4 == "string" && typeof o == "string") {
+          const a = i4.toUpperCase();
+          (a === "GET" || a === "POST") && e.push({ method: a, path: o });
+        }
+      }
+    return e;
+  }
+  buildIndex(t) {
+    if (!t || t.length === 0)
+      return;
+    const e = [], n = [], r = this.REGEX_METACHAR;
+    for (const o of t) {
+      if (o.path.startsWith("^") || o.path.endsWith("$") || r.test(o.path))
+        try {
+          n.push({ method: o.method, regex: new RegExp(o.path) });
+          continue;
+        } catch {}
+      e.push({ method: o.method, path: o.path });
+    }
+    return { cache: {}, exact: e, regex: n };
+  }
+  get contact() {
+    return this._mintInfo.contact;
+  }
+  get description() {
+    return this._mintInfo.description;
+  }
+  get description_long() {
+    return this._mintInfo.description_long;
+  }
+  get name() {
+    return this._mintInfo.name;
+  }
+  get pubkey() {
+    return this._mintInfo.pubkey;
+  }
+  get nuts() {
+    return this._mintInfo.nuts;
+  }
+  get version() {
+    return this._mintInfo.version;
+  }
+  get motd() {
+    return this._mintInfo.motd;
+  }
+  get supportsBolt12Description() {
+    return this.supportsNut04Description("bolt12");
+  }
+  supportsNut04Description(t, e) {
+    return this._mintInfo.nuts[4]?.methods.some((n) => n.method === t && (e ? n.unit === e : true) && (n.options?.description === true || n.description === true));
+  }
+}
+
+class zt {
+  constructor(t, e) {
+    this.tokenListeners = [], this.discoveryUrl = t, this.logger = e?.logger ?? L, this.clientId = e?.clientId ?? "cashu-client", this.scope = e?.scope ?? "openid", this.onTokens = e?.onTokens;
+  }
+  static fromMintInfo(t, e) {
+    const n = t?.nuts?.["21"];
+    if (!n?.openid_discovery)
+      throw new Error("OIDCAuth: mint does not advertise NUT-21 openid_discovery");
+    const r = e?.clientId ?? n.client_id ?? "cashu-client";
+    return new zt(n.openid_discovery, { ...e, clientId: r });
+  }
+  setClient(t) {
+    this.clientId = t;
+  }
+  setScope(t) {
+    this.scope = t ?? "openid";
+  }
+  addTokenListener(t) {
+    this.tokenListeners.push(t);
+  }
+  async loadConfig() {
+    if (this.config)
+      return this.config;
+    const t = await fetch(this.discoveryUrl, {
+      method: "GET",
+      headers: { Accept: "application/json" }
+    }), e = await t.text();
+    let n;
+    try {
+      n = e ? JSON.parse(e) : undefined;
+    } catch (i4) {
+      this.logger.warn("OIDCAuth: bad discovery JSON", { err: i4 });
+    }
+    if (!t.ok || !n)
+      throw new Error("OIDCAuth: invalid discovery document");
+    const r = n;
+    if (typeof r.token_endpoint != "string" || r.token_endpoint.length === 0)
+      throw new Error("OIDCAuth: invalid discovery document, missing token_endpoint");
+    return this.config = r, r;
+  }
+  generatePKCE() {
+    const t = randomBytes4(48), e = It(t), n = _.fromString(e), r = sha2563(n), i4 = It(r);
+    return { verifier: e, challenge: i4 };
+  }
+  async buildAuthCodeUrl(t) {
+    const e = await this.loadConfig(), n = t.scope ?? this.scope, r = new URLSearchParams({
+      response_type: "code",
+      client_id: this.clientId,
+      redirect_uri: t.redirectUri,
+      scope: n,
+      code_challenge_method: t.codeChallengeMethod ?? "S256",
+      code_challenge: t.codeChallenge
+    });
+    if (t.state && r.set("state", t.state), !e.authorization_endpoint)
+      throw new Error("OIDCAuth: discovery lacks authorization_endpoint");
+    return `${e.authorization_endpoint}?${r.toString()}`;
+  }
+  async exchangeAuthCode(t) {
+    const e = await this.loadConfig(), n = this.toForm({
+      grant_type: "authorization_code",
+      code: t.code,
+      redirect_uri: t.redirectUri,
+      client_id: this.clientId,
+      code_verifier: t.codeVerifier
+    }), r = await this.postFormStrict(e.token_endpoint, n);
+    return this.handleTokens(r), r;
+  }
+  async deviceStart() {
+    const e = (await this.loadConfig()).device_authorization_endpoint;
+    if (!e)
+      throw new Error("OIDCAuth: provider lacks device_authorization_endpoint");
+    const n = this.toForm({ client_id: this.clientId, scope: this.scope });
+    return this.postFormStrict(e, n);
+  }
+  async devicePoll(t, e = 5) {
+    const n = await this.loadConfig();
+    let r = Math.max(1, e);
+    for (;; ) {
+      await this.sleep(r * 1000);
+      const i4 = this.toForm({
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: t,
+        client_id: this.clientId
+      }), o = await this.postFormLoose(n.token_endpoint, i4);
+      if (o.access_token)
+        return this.handleTokens(o), o;
+      const a = (o.error ?? "").toString();
+      if (a === "authorization_pending")
+        continue;
+      if (a === "slow_down") {
+        r = Math.max(r + 5, r * 2);
+        continue;
+      }
+      const c = o.error_description || a || "device authorization failed";
+      throw new Error(`OIDCAuth: ${c}`);
+    }
+  }
+  async startDeviceAuth(t = 5) {
+    const e = await this.deviceStart(), n = Math.max(e.interval ?? 1, t);
+    let r = false;
+    return { ...e, poll: async () => {
+      const a = await this.loadConfig();
+      let c = Math.max(1, n);
+      for (;; ) {
+        if (r)
+          throw new Error("OIDCAuth: device polling cancelled");
+        await this.sleep(c * 1000);
+        const u = this.toForm({
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+          device_code: e.device_code,
+          client_id: this.clientId
+        }), l = await this.postFormLoose(a.token_endpoint, u);
+        if (l.access_token)
+          return this.handleTokens(l), l;
+        const h = (l.error ?? "").toString();
+        if (h === "authorization_pending")
+          continue;
+        if (h === "slow_down") {
+          c = Math.max(c + 5, c * 2);
+          continue;
+        }
+        const d = l.error_description || h || "device authorization failed";
+        throw new Error(`OIDCAuth: ${d}`);
+      }
+    }, cancel: () => {
+      r = true;
+    } };
+  }
+  async refresh(t) {
+    const e = await this.loadConfig(), n = this.toForm({
+      grant_type: "refresh_token",
+      refresh_token: t,
+      client_id: this.clientId
+    }), r = await this.postFormStrict(e.token_endpoint, n);
+    return this.handleTokens(r), r;
+  }
+  async passwordGrant(t, e) {
+    const n = await this.loadConfig(), r = this.toForm({
+      grant_type: "password",
+      client_id: this.clientId,
+      username: t,
+      password: e,
+      scope: this.scope
+    }), i4 = await this.postFormStrict(n.token_endpoint, r);
+    return this.handleTokens(i4), i4;
+  }
+  handleTokens(t) {
+    if (!t.access_token) {
+      const e = t.error_description || t.error || "token response missing access_token";
+      throw new Error(`OIDCAuth: ${e}`);
+    }
+    queueMicrotask(() => lt(this.onTokens, t, this.logger, { where: "OIDCAuth.handleTokens" }));
+    for (const e of this.tokenListeners)
+      queueMicrotask(() => lt(e, t, this.logger, {
+        where: "OIDCAuth.handleTokens.listener"
+      }));
+  }
+  toForm(t) {
+    const e = (n) => encodeURIComponent(n).replace(/%20/g, "+");
+    return Object.entries(t).map(([n, r]) => `${e(n)}=${e(r)}`).join("&");
+  }
+  async postFormStrict(t, e) {
+    try {
+      this.logger.debug("OIDCAuth Request", { formBody: e });
+      const n = await fetch(t, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          Accept: "application/json"
+        },
+        body: e
+      }), r = await n.text();
+      let i4;
+      try {
+        i4 = r ? JSON.parse(r) : undefined;
+      } catch (o) {
+        this.logger.warn("OIDCAuth: bad JSON (strict)", { err: o });
+      }
+      if (!n.ok) {
+        const o = i4 ?? {}, a = o.error_description || o.error || `HTTP ${n.status}`;
+        throw new Error(`OIDCAuth: ${a}`);
+      }
+      return this.logger.debug("OIDCAuth Response", { json: i4 }), i4 ?? {};
+    } catch (n) {
+      throw this.logger.error("OIDCAuth: postFormStrict failed", { err: n }), n;
+    }
+  }
+  async postFormLoose(t, e) {
+    try {
+      this.logger.debug("OIDCAuth Request", { formBody: e });
+      const r = await (await fetch(t, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          Accept: "application/json"
+        },
+        body: e
+      })).text();
+      let i4;
+      try {
+        i4 = r ? JSON.parse(r) : undefined;
+      } catch (o) {
+        this.logger.warn("OIDCAuth: bad JSON (loose)", { err: o });
+      }
+      return this.logger.debug("OIDCAuth Response", { json: i4 }), i4 ?? {};
+    } catch (n) {
+      return this.logger.error("OIDCAuth: postFormLoose network error", { err: n }), { error: "network_error", error_description: String(n) };
+    }
+  }
+  sleep(t) {
+    return new Promise((e) => setTimeout(e, t));
+  }
+}
+
+class Vt {
+  constructor(t, e) {
+    this._mintUrl = Oe(t), this._request = e?.customRequest ?? pe, this._authProvider = e?.authProvider, this._logger = e?.logger ?? L, je(this._logger);
+  }
+  get mintUrl() {
+    return this._mintUrl;
+  }
+  async oidcAuth(t) {
+    const e = (await this.getLazyMintInfo()).nuts[21];
+    if (!e?.openid_discovery)
+      throw new Error("Mint: no NUT-21 openid_discovery");
+    return new zt(e.openid_discovery, {
+      ...t,
+      clientId: t?.clientId ?? e.client_id ?? "cashu-client"
+    });
+  }
+  async getInfo(t) {
+    const n = await (t ?? this._request)({
+      endpoint: W(this._mintUrl, "/v1/info")
+    });
+    return Qn(n, this._logger);
+  }
+  async getLazyMintInfo() {
+    if (this._mintInfo)
+      return this._mintInfo;
+    const t = await this.getInfo();
+    return this._mintInfo = new wt(t), this._mintInfo;
+  }
+  async swap(t, e) {
+    const n = await this.requestWithAuth("POST", "/v1/swap", { requestBody: t }, e);
+    if (!T(n) || !Array.isArray(n?.signatures)) {
+      const r = T(n) && "detail" in n ? n.detail : undefined;
+      throw new Error(r ?? "bad response");
+    }
+    return n;
+  }
+  async createMintQuoteBolt11(t, e) {
+    const n = await this.requestWithAuth("POST", "/v1/mint/quote/bolt11", { requestBody: t }, e);
+    return se(n, this._logger);
+  }
+  async createMintQuoteBolt12(t, e) {
+    return await this.requestWithAuth("POST", "/v1/mint/quote/bolt12", { requestBody: t }, e);
+  }
+  async checkMintQuoteBolt11(t, e) {
+    const n = await this.requestWithAuth("GET", `/v1/mint/quote/bolt11/${t}`, {}, e);
+    return se(n, this._logger);
+  }
+  async checkMintQuoteBolt12(t, e) {
+    return await this.requestWithAuth("GET", `/v1/mint/quote/bolt12/${t}`, {}, e);
+  }
+  async mintBolt11(t, e) {
+    const n = await this.requestWithAuth("POST", "/v1/mint/bolt11", { requestBody: t }, e);
+    if (!T(n) || !Array.isArray(n?.signatures)) {
+      const r = T(n) && "detail" in n ? n.detail : undefined;
+      throw new Error(r ?? "bad response");
+    }
+    return n;
+  }
+  async mintBolt12(t, e) {
+    const n = await this.requestWithAuth("POST", "/v1/mint/bolt12", { requestBody: t }, e);
+    if (!T(n) || !Array.isArray(n?.signatures)) {
+      const r = T(n) && "detail" in n ? n.detail : undefined;
+      throw new Error(r ?? "bad response");
+    }
+    return n;
+  }
+  async createMeltQuoteBolt11(t, e) {
+    const n = await this.requestWithAuth("POST", "/v1/melt/quote/bolt11", { requestBody: t }, e), r = At(n, this._logger);
+    if (!T(r) || typeof r?.amount != "number" || typeof r?.fee_reserve != "number" || typeof r?.quote != "string") {
+      const i4 = T(r) && "detail" in r ? r.detail : undefined;
+      throw new Error(i4 ?? "bad response");
+    }
+    return r;
+  }
+  async createMeltQuoteBolt12(t, e) {
+    return await this.requestWithAuth("POST", "/v1/melt/quote/bolt12", { requestBody: t }, e);
+  }
+  async checkMeltQuoteBolt11(t, e) {
+    const n = await this.requestWithAuth("GET", `/v1/melt/quote/bolt11/${t}`, {}, e), r = At(n, this._logger);
+    if (!T(r) || typeof r?.amount != "number" || typeof r?.fee_reserve != "number" || typeof r?.quote != "string" || typeof r?.state != "string" || !Object.values(ut).includes(r.state)) {
+      const i4 = T(r) && "detail" in r ? r.detail : undefined;
+      throw new Error(i4 ?? "bad response");
+    }
+    return r;
+  }
+  async checkMeltQuoteBolt12(t, e) {
+    return await this.requestWithAuth("GET", `/v1/melt/quote/bolt12/${t}`, {}, e);
+  }
+  async meltBolt11(t, e) {
+    const n = {
+      ...e?.preferAsync ? { Prefer: "respond-async" } : {}
+    }, r = await this.requestWithAuth("POST", "/v1/melt/bolt11", {
+      requestBody: t,
+      headers: n
+    }, e?.customRequest), i4 = At(r, this._logger);
+    if (!T(i4) || typeof i4?.state != "string" || !Object.values(ut).includes(i4.state)) {
+      const o = T(i4) && "detail" in i4 ? i4.detail : undefined;
+      throw new Error(o ?? "bad response");
+    }
+    return i4;
+  }
+  async meltBolt12(t, e) {
+    const n = {
+      ...e?.preferAsync ? { Prefer: "respond-async" } : {}
+    };
+    return await this.requestWithAuth("POST", "/v1/melt/bolt12", {
+      requestBody: t,
+      headers: n
+    }, e?.customRequest);
+  }
+  async check(t, e) {
+    const n = await this.requestWithAuth("POST", "/v1/checkstate", { requestBody: t }, e);
+    if (!T(n) || !Array.isArray(n?.states)) {
+      const r = T(n) && "detail" in n ? n.detail : undefined;
+      throw new Error(r ?? "bad response");
+    }
+    return n;
+  }
+  async getKeys(t, e, n) {
+    const r = e || this._mintUrl;
+    t && (t = t.replace(/\//g, "_").replace(/\+/g, "-"));
+    const o = await (n ?? this._request)({
+      endpoint: t ? W(r, "/v1/keys", t) : W(r, "/v1/keys")
+    });
+    if (!T(o) || !Array.isArray(o.keysets)) {
+      const a = T(o) && "detail" in o ? o.detail : undefined;
+      throw new Error(a ?? "bad response");
+    }
+    return o;
+  }
+  async getKeySets(t) {
+    return (t ?? this._request)({ endpoint: W(this._mintUrl, "/v1/keysets") });
+  }
+  async restore(t, e) {
+    const r = await (e ?? this._request)({
+      endpoint: W(this._mintUrl, "/v1/restore"),
+      method: "POST",
+      requestBody: t
+    });
+    if (!T(r) || !Array.isArray(r?.outputs) || !Array.isArray(r?.signatures)) {
+      const i4 = T(r) && "detail" in r ? r.detail : undefined;
+      throw new Error(i4 ?? "bad response");
+    }
+    return r;
+  }
+  async connectWebSocket() {
+    if (this.ws)
+      await this.ws.ensureConnection();
+    else {
+      const t = new URL(this._mintUrl), e = "v1/ws";
+      t.pathname && (t.pathname.endsWith("/") ? t.pathname += e : t.pathname += "/" + e), this.ws = it.getInstance().getConnection(`${t.protocol === "https:" ? "wss" : "ws"}://${t.host}${t.pathname}`);
+      try {
+        await this.ws.connect();
+      } catch (n) {
+        throw this._logger.error("Failed to connect to WebSocket...", { e: n }), new Error("Failed to connect to WebSocket...");
+      }
+    }
+  }
+  disconnectWebSocket() {
+    this.ws && this.ws.close();
+  }
+  get webSocketConnection() {
+    return this.ws;
+  }
+  async handleClearAuth(t, e) {
+    if (!(!this._authProvider || !(await this.getLazyMintInfo()).requiresClearAuthToken(t, e)))
+      return this._logger.error("Clear Authentication Token...", { cat: this._authProvider.getCAT() }), this._authProvider.getCAT();
+  }
+  async handleBlindAuth(t, e) {
+    if (!this._authProvider || !(await this.getLazyMintInfo()).requiresBlindAuthToken(t, e))
+      return;
+    const r = await this._authProvider.getBlindAuthToken({ method: t, path: e });
+    return this._logger.error("Blind Authentication Token...", { bat: r }), r;
+  }
+  async requestWithAuth(t, e, n = {}, r) {
+    const i4 = r ?? this._request, o = await this.handleBlindAuth(t, e), a = await this.handleClearAuth(t, e), c = {
+      ...n.headers ?? {},
+      ...o ? { "Blind-auth": o } : {},
+      ...a ? { "Clear-auth": a } : {}
+    };
+    return i4({
+      ...n,
+      endpoint: W(this._mintUrl, e),
+      method: t,
+      headers: c
+    });
+  }
+}
+
+class zn {
+  constructor(t, e, n, r, i4) {
+    this._keys = {}, this._id = t, this._unit = e, this._active = n, this._input_fee_ppk = r, this._final_expiry = i4;
+  }
+  get id() {
+    return this._id;
+  }
+  get unit() {
+    return this._unit;
+  }
+  get isActive() {
+    return this._active;
+  }
+  get fee() {
+    return this._input_fee_ppk ?? 0;
+  }
+  get expiry() {
+    return this._final_expiry;
+  }
+  get hasKeys() {
+    return Object.keys(this._keys).length > 0;
+  }
+  get hasHexId() {
+    return Ct(this._id);
+  }
+  get keys() {
+    return this._keys;
+  }
+  set keys(t) {
+    this._keys = t;
+  }
+  get active() {
+    return this._active;
+  }
+  get input_fee_ppk() {
+    return this._input_fee_ppk ?? 0;
+  }
+  get final_expiry() {
+    return this._final_expiry;
+  }
+  toMintKeyset() {
+    return {
+      id: this._id,
+      unit: this._unit,
+      active: this._active,
+      input_fee_ppk: this._input_fee_ppk,
+      final_expiry: this._final_expiry
+    };
+  }
+  toMintKeys() {
+    return this.hasKeys ? {
+      id: this._id,
+      unit: this._unit,
+      keys: this._keys
+    } : null;
+  }
+  verify() {
+    if (!this.hasKeys)
+      return false;
+    const t = hexToBytes4(this._id)[0];
+    return Qt(this._keys, this._unit, this._final_expiry, t) === this._id;
+  }
+}
+
+class Ue {
+  constructor(t, e, n, r) {
+    if (this.keysets = {}, this.mint = typeof t == "string" ? new Vt(t) : t, this.unit = e, n && r) {
+      const i4 = Array.isArray(r) ? r : [r];
+      this.buildKeychain(n, i4);
+    }
+  }
+  async init(t) {
+    if (Object.keys(this.keysets).length > 0 && !t)
+      return;
+    const [e, n] = await Promise.all([this.mint.getKeySets(), this.mint.getKeys()]);
+    this.buildKeychain(e.keysets, n.keysets), this.getCheapestKeyset();
+  }
+  buildKeychain(t, e) {
+    this.keysets = {}, t.filter((i4) => i4.unit === this.unit).forEach((i4) => {
+      this.keysets[i4.id] = new zn(i4.id, i4.unit, i4.active, i4.input_fee_ppk, i4.final_expiry);
+    });
+    const r = new Map(e.filter((i4) => i4.unit === this.unit).map((i4) => [i4.id, i4]));
+    Object.values(this.keysets).forEach((i4) => {
+      if (!i4.hasHexId || !i4.isActive)
+        return;
+      const o = r.get(i4.id);
+      if (o && (i4.keys = o.keys, !i4.verify()))
+        throw new Error(`Keyset verification failed for ID ${i4.id}`);
+    });
+  }
+  getKeyset(t) {
+    const e = t ? this.keysets[t] : this.getCheapestKeyset();
+    if (!e)
+      throw new Error(`Keyset '${t}' not found`);
+    return e;
+  }
+  getCheapestKeyset() {
+    if (Object.keys(this.keysets).length === 0)
+      throw new Error("KeyChain not initialized");
+    const t = Object.values(this.keysets).filter((e) => e.isActive && e.hasHexId && e.hasKeys);
+    if (t.length === 0)
+      throw new Error("No active keyset found");
+    return t.sort((e, n) => e.fee - n.fee)[0];
+  }
+  getKeysets() {
+    if (Object.keys(this.keysets).length === 0)
+      throw new Error("KeyChain not initialized");
+    return Object.values(this.keysets);
+  }
+  getCache() {
+    const t = this.getKeysets(), e = t.filter((n) => n.hasKeys).map((n) => n.toMintKeys()).filter((n) => n !== null);
+    return {
+      keysets: t.map((n) => n.toMintKeyset()),
+      keys: e,
+      unit: this.unit,
+      mintUrl: this.mint.mintUrl
+    };
+  }
+}
+
+class vt {
+  constructor(t, e, n) {
+    this.amount = t, this.B_ = e, this.id = n;
+  }
+  getSerializedBlindedMessage() {
+    return { amount: this.amount, B_: this.B_.toHex(true), id: this.id };
+  }
+}
+var Vn = /* @__PURE__ */ new Set([
+  "locktime",
+  "pubkeys",
+  "n_sigs",
+  "refund",
+  "n_sigs_refund"
+]);
+function Re(s) {
+  if (!s || typeof s != "string")
+    throw new Error("tag key must be a non empty string");
+  if (Vn.has(s))
+    throw new Error(`additionalTags must not use reserved key "${s}"`);
+}
+var re = 1024;
+var xt = /* @__PURE__ */ new WeakMap;
+function Gn(s, t) {
+  t && xt.set(s, t);
+}
+function Jn(s) {
+  const t = xt.get(s);
+  if (t)
+    return xt.delete(s), t;
+}
+
+class N {
+  constructor(t, e, n) {
+    this.secret = n, this.blindingFactor = e, this.blindedMessage = t;
+  }
+  toProof(t, e) {
+    let n;
+    t.dleq && (n = {
+      s: hexToBytes4(t.dleq.s),
+      e: hexToBytes4(t.dleq.e),
+      r: this.blindingFactor
+    });
+    const r = {
+      id: t.id,
+      amount: t.amount,
+      C_: X(t.C_)
+    }, i4 = X(e.keys[t.amount]), o = Sn(r, this.blindingFactor, this.secret, i4), a = {
+      ...Tn(o),
+      ...n && {
+        dleq: {
+          s: bytesToHex4(n.s),
+          e: bytesToHex4(n.e),
+          r: Mt(n.r ?? BigInt(0))
+        }
+      }
+    }, c = Jn(this);
+    return c && (a.p2pk_e = c), a;
+  }
+  static createP2PKData(t, e, n, r) {
+    return G(e, n.keys, r).map((o) => this.createSingleP2PKData(t, o, n.id));
+  }
+  static createSingleP2PKData(t, e, n) {
+    const r = Array.isArray(t.pubkey) ? t.pubkey : [t.pubkey], i4 = t.refundKeys ?? [], o = Math.max(1, Math.min(t.requiredSignatures ?? 1, r.length)), a = Math.max(1, Math.min(t.requiredRefundSignatures ?? 1, i4.length || 1));
+    let c = r[0], u = r.slice(1), l = i4, h;
+    if (t.blindKeys) {
+      const x = [c, ...u, ...i4], { blinded: S, Ehex: B } = gn(x, n);
+      c = S[0], u = S.slice(1, r.length), l = S.slice(r.length), h = B;
+    }
+    const d = [], p = t.locktime ?? NaN;
+    if (Number.isSafeInteger(p) && p >= 0 && d.push(["locktime", String(p)]), u.length > 0 && (d.push(["pubkeys", ...u]), o > 1 && d.push(["n_sigs", String(o)])), l.length > 0 && (d.push(["refund", ...l]), a > 1 && d.push(["n_sigs_refund", String(a)])), t.additionalTags?.length) {
+      const x = t.additionalTags.map(([S, ...B]) => (Re(S), [S, ...B.map(String)]));
+      d.push(...x);
+    }
+    const m = [
+      "P2PK",
+      {
+        nonce: bytesToHex4(randomBytes4(32)),
+        data: c,
+        tags: d
+      }
+    ], P = JSON.stringify(m), A = [...P].length;
+    if (A > re)
+      throw new Error(`Secret too long (${A} characters), maximum is ${re}`);
+    const w = new TextEncoder().encode(P), { r: v, B_: I } = gt(w), U = new N(new vt(e, I, n).getSerializedBlindedMessage(), v, w);
+    return t.blindKeys && h && Gn(U, h), U;
+  }
+  static createRandomData(t, e, n) {
+    return G(t, e.keys, n).map((i4) => this.createSingleRandomData(i4, e.id));
+  }
+  static createSingleRandomData(t, e) {
+    const n = bytesToHex4(randomBytes4(32)), r = new TextEncoder().encode(n), { r: i4, B_: o } = gt(r);
+    return new N(new vt(t, o, e).getSerializedBlindedMessage(), i4, r);
+  }
+  static createDeterministicData(t, e, n, r, i4) {
+    return G(t, r.keys, i4).map((a, c) => this.createSingleDeterministicData(a, e, n + c, r.id));
+  }
+  static createSingleDeterministicData(t, e, n, r) {
+    const i4 = xn(e, r, n), o = bytesToHex4(i4), a = new TextEncoder().encode(o), c = $(Bn(e, r, n)), { r: u, B_: l } = gt(a, c);
+    return new N(new vt(t, l, r).getSerializedBlindedMessage(), u, a);
+  }
+  static sumOutputAmounts(t) {
+    return t.reduce((e, n) => e + n.blindedMessage.amount, 0);
+  }
+}
+var kt = class kt2 {
+  constructor(t, e) {
+    this.tokens = {}, this.pool = [], this.desiredPoolSize = 10, this.maxPerMint = 10, this.mintUrl = t, this.req = e?.request ?? pe, this.logger = e?.logger ?? L, this.desiredPoolSize = Math.max(1, e?.desiredPoolSize ?? this.desiredPoolSize), this.maxPerMint = Math.max(1, e?.maxPerMint ?? this.maxPerMint);
+  }
+  attachOIDC(t) {
+    return this.oidc = t, this.oidc.addTokenListener((e) => this.updateFromOIDC(e)), this;
+  }
+  get poolSize() {
+    return this.pool.length;
+  }
+  get poolTarget() {
+    return this.desiredPoolSize;
+  }
+  get activeAuthKeysetId() {
+    try {
+      return this.keychain?.getCheapestKeyset().id;
+    } catch {
+      return;
+    }
+  }
+  get hasCAT() {
+    return !!this.tokens.accessToken;
+  }
+  getCAT() {
+    return this.tokens.accessToken;
+  }
+  setCAT(t) {
+    this.tokens.accessToken = t, t || (this.tokens.refreshToken = undefined, this.tokens.expiresAt = undefined);
+  }
+  async ensureCAT(t) {
+    return this.validForAtLeast(t) ? this.tokens.accessToken : !this.oidc || !this.tokens.refreshToken ? this.tokens.accessToken : (this.inflightRefresh || (this.inflightRefresh = (async () => {
+      try {
+        const e = await this.oidc.refresh(this.tokens.refreshToken);
+        this.updateFromOIDC(e);
+      } catch (e) {
+        this.logger.warn("AuthManager: CAT refresh failed", { err: e });
+      } finally {
+        this.inflightRefresh = undefined;
+      }
+    })()), await this.inflightRefresh, this.validForAtLeast(0) ? this.tokens.accessToken : undefined);
+  }
+  validForAtLeast(t = kt2.MIN_VALID_SECS) {
+    const { accessToken: e, expiresAt: n } = this.tokens;
+    return e ? n ? Date.now() + t * 1000 < n : true : false;
+  }
+  updateFromOIDC(t) {
+    if (!t.access_token)
+      return;
+    const e = Date.now();
+    if (this.tokens.accessToken = t.access_token, t.refresh_token && (this.tokens.refreshToken = t.refresh_token), typeof t.expires_in == "number" && t.expires_in > 0)
+      this.tokens.expiresAt = e + t.expires_in * 1000;
+    else {
+      const n = this.parseJwtExpSec(t.access_token);
+      this.tokens.expiresAt = n ? n * 1000 : undefined;
+    }
+    this.logger.debug("AuthManager: OIDC tokens updated", { expiresAt: this.tokens.expiresAt });
+  }
+  async ensure(t) {
+    if (await this.init(), this.pool.length >= t)
+      return;
+    const e = Math.max(this.desiredPoolSize, t), n = this.getBatMaxMint(), r = Math.min(e - this.pool.length, n);
+    r <= 0 || await this.topUp(r);
+  }
+  async getBlindAuthToken({
+    method: t,
+    path: e
+  }) {
+    return this.info && !this.info.requiresBlindAuthToken(t, e) && this.logger.warn("Endpoint is not marked as protected by NUT-22; still issuing BAT", {
+      method: t,
+      path: e
+    }), this.withLock(async () => {
+      if (await this.ensure(1), this.pool.length === 0)
+        throw new Error("AuthManager: no BATs available and minting failed");
+      const n = this.pool.pop();
+      return this.logger.debug("AuthManager: BAT requested", {
+        method: t,
+        path: e,
+        remaining: this.pool.length
+      }), as(n);
+    });
+  }
+  importPool(t, e = "replace") {
+    e === "replace" && (this.pool = []);
+    const n = new Map(this.pool.map((r) => [r.secret, r]));
+    for (const r of t)
+      !r || !r.secret || !r.C || !r.id || n.has(r.secret) || (this.pool.push(r), n.set(r.secret, r));
+  }
+  exportPool() {
+    return this.pool.map((t) => ({ ...t, dleq: t.dleq ? { ...t.dleq } : undefined }));
+  }
+  parseJwtExpSec(t) {
+    if (!t)
+      return;
+    const e = t.split(".");
+    if (e.length === 3)
+      try {
+        const n = _.toString(_.fromBase64(e[1])), r = JSON.parse(n), i4 = typeof r.exp == "number" ? r.exp : Number(r.exp);
+        if (Number.isFinite(i4) && i4 > 0)
+          return i4;
+      } catch {
+        this.logger.warn("JWT access token was malformed.", {
+          token: t
+        });
+      }
+  }
+  async withLock(t) {
+    const e = this.lockChain ?? Promise.resolve();
+    let n;
+    const r = new Promise((o) => {
+      n = o;
+    }), i4 = e.then(() => r);
+    this.lockChain = i4;
+    try {
+      return await e, await t();
+    } finally {
+      n(), this.lockChain === i4 && (this.lockChain = undefined);
+    }
+  }
+  async init() {
+    if (!this.info) {
+      const t = await this.req({
+        endpoint: W(this.mintUrl, "/v1/info"),
+        method: "GET"
+      });
+      this.info = new wt(t);
+    }
+    if (!this.keychain) {
+      const [t, e] = await Promise.all([
+        this.req({
+          endpoint: W(this.mintUrl, "/v1/auth/blind/keysets"),
+          method: "GET"
+        }),
+        this.req({
+          endpoint: W(this.mintUrl, "/v1/auth/blind/keys"),
+          method: "GET"
+        })
+      ]);
+      this.keychain = new Ue(this.mintUrl, "auth", t.keysets, e.keysets), this.keychain.getCheapestKeyset();
+    }
+  }
+  getBatMaxMint() {
+    if (!this.info)
+      throw new Error("AuthManager: mint info not loaded");
+    const e = this.info.nuts[22]?.bat_max_mint ?? this.maxPerMint;
+    return Math.max(1, Math.min(this.maxPerMint, e));
+  }
+  getActiveKeys() {
+    if (!this.keychain)
+      throw new Error("AuthManager: keyset not loaded for active keyset");
+    return this.keychain.getCheapestKeyset();
+  }
+  async topUp(t) {
+    if (!this.info)
+      throw new Error("AuthManager: mint info not loaded");
+    const e = this.info.requiresClearAuthToken("POST", "/v1/auth/blind/mint");
+    let n;
+    if (e && (n = await this.ensureCAT(), !n))
+      throw new Error("AuthManager: Clear-auth token required for /v1/auth/blind/mint but not available. Authenticate with the mint to obtain a CAT first.");
+    const r = this.getActiveKeys(), i4 = N.createRandomData(t, r), o = { outputs: i4.map((l) => l.blindedMessage) }, a = {};
+    n && (a["Clear-auth"] = n);
+    const c = await this.req({
+      endpoint: W(this.mintUrl, "/v1/auth/blind/mint"),
+      method: "POST",
+      headers: a,
+      requestBody: o
+    });
+    if (!Array.isArray(c?.signatures) || c.signatures.length !== i4.length)
+      throw new Error("AuthManager: bad BAT mint response");
+    const u = i4.map((l, h) => l.toProof(c.signatures[h], r));
+    for (const l of u)
+      if (!De(l, r))
+        throw new Error("AuthManager: mint returned BAT with invalid DLEQ");
+    this.pool.push(...u), this.logger.debug("AuthManager: performed topUp", {
+      minted: u.length,
+      pool: this.pool.length
+    });
+  }
+};
+kt.MIN_VALID_SECS = 30;
+function as(s) {
+  const t = { id: s.id, secret: s.secret, C: s.C };
+  return `authA${me(t)}`;
+}
+
 // ../routstr-chat/node_modules/zustand/esm/vanilla.mjs
 var createStoreImpl = (createState) => {
   let state;
@@ -31479,8 +36127,8 @@ Current mode: ${currentMode}`);
     rl.question(`
 Enter choice (1-2): `, (answer) => {
       rl.close();
-      const num = parseInt(answer, 10);
-      resolve(Number.isFinite(num) && num >= 1 && num <= 2 ? num - 1 : 0);
+      const num2 = parseInt(answer, 10);
+      resolve(Number.isFinite(num2) && num2 >= 1 && num2 <= 2 ? num2 - 1 : 0);
     });
   });
   const selectedMode = modes[selectedIndex];