bitcoin-wallet-connector 0.1.0

package/lib/index-D7YwhNAG.mjs

@@ -0,0 +1,3946 @@
+import { a as dt, B as Nt, b as zt, W as er } from "./WalletAdapters.types-CnvOqHFH.mjs";
+function Pt({
+  getPrecondition: t,
+  initializer: e,
+  pollIntervalMs: n = 300
+}) {
+  let r = null, o = null, s = !1;
+  const i = /* @__PURE__ */ new Set(), c = () => {
+    o != null && (clearInterval(o), o = null);
+  }, a = (u) => {
+    r = u;
+    for (const g of i)
+      g(u);
+  }, f = async () => {
+    if (r != null || s) return;
+    const u = t();
+    if (u != null) {
+      s = !0;
+      try {
+        const g = await e(u.value);
+        a(g), c();
+      } catch (g) {
+        console.warn("[WalletAdapter] Failed to initialize adapter", g);
+      } finally {
+        s = !1;
+      }
+    }
+  }, d = () => {
+    r == null && (f(), !(r != null || o != null) && (o = setInterval(() => {
+      f();
+    }, n)));
+  };
+  return {
+    subscribe: (u) => r != null ? (u(r), { unsubscribe: () => {
+    } }) : (i.add(u), d(), {
+      unsubscribe: () => {
+        i.delete(u), i.size === 0 && c();
+      }
+    })
+  };
+}
+const Pn = "bitget.bitcoin", _n = {
+  name: "Bitget",
+  iconUrl: import("./bitget-C7oB4Ffq.mjs").then((t) => t.default),
+  websiteUrl: "https://web3.bitget.com/",
+  downloadUrl: "https://web3.bitget.com/en/wallet-download"
+}, Hn = Pt({
+  getPrecondition: () => window.bitkeep?.unisat == null ? null : { value: window.bitkeep.unisat },
+  initializer: async (t) => {
+    const { BitgetWalletAdapterImpl: e } = await import("./BitgetWalletAdapter.impl-C_HLO7Oi.mjs");
+    return new e(t);
+  }
+}), Qs = {
+  adapterId: Pn,
+  metadata: _n,
+  getAdapter: () => Hn
+}, Ln = "LeatherProvider.BitcoinProvider", Tn = {
+  name: "Leather",
+  iconUrl: import("./leather-BoQG_CPn.mjs").then((t) => t.default),
+  websiteUrl: "https://leather.io/",
+  downloadUrl: "https://leather.io/wallet"
+}, Nn = Pt({
+  getPrecondition: () => {
+    const t = window.LeatherProvider?.request;
+    return t == null ? null : { value: t };
+  },
+  initializer: async (t) => {
+    const { LeatherWalletAdapterImpl: e } = await import("./LeatherWalletAdapter.impl-RUYx555r.mjs");
+    return new e(t);
+  }
+}), Js = {
+  adapterId: Ln,
+  metadata: Tn,
+  getAdapter: () => Nn
+}, Cn = "magiceden.bitcoin", Dn = (t) => Pt({
+  getPrecondition: () => {
+    const e = window.magicEden?.bitcoin;
+    return e?.isMagicEden ? { value: e } : null;
+  },
+  initializer: async (e) => {
+    const { MagicEdenWalletAdapterImpl: n } = await import("./MagicEdenWalletAdapter.impl-CrA6SGvG.mjs");
+    return new n(t, e);
+  }
+}), ti = (t) => {
+  const e = Dn(t);
+  return {
+    adapterId: Cn,
+    /**
+     * https://docs-wallet.magiceden.io/resources/logos-and-brand-assets
+     */
+    metadata: {
+      name: "Magic Eden",
+      iconUrl: import("./magiceden-Cg7d3agI.mjs").then((n) => n.default),
+      websiteUrl: "https://wallet.magiceden.io/",
+      downloadUrl: "https://wallet.magiceden.io/download"
+    },
+    getAdapter: () => e
+  };
+}, Kn = "okxwallet.bitcoin", Vn = {
+  name: "OKX Wallet",
+  iconUrl: import("./okx-DWbHwazu.mjs").then((t) => t.default),
+  websiteUrl: "https://web3.okx.com/",
+  downloadUrl: "https://web3.okx.com/download"
+}, Mn = Pt({
+  getPrecondition: () => {
+    const t = window.okxwallet?.bitcoin;
+    return t == null ? null : { value: t };
+  },
+  initializer: async (t) => {
+    const { OkxWalletAdapterImpl: e } = await import("./OkxWalletAdapter.impl-BepoUL1B.mjs");
+    return new e(t);
+  }
+}), ei = {
+  adapterId: Kn,
+  metadata: Vn,
+  getAdapter: () => Mn
+}, Wn = "unisat", qn = {
+  name: "UniSat",
+  /**
+   * https://next-cdn.unisat.io/_/2025-v965/UniSat%20Logo.zip
+   */
+  iconUrl: import("./unisat-pLgab4nG.mjs").then((t) => t.default),
+  websiteUrl: "https://unisat.io/",
+  downloadUrl: "https://unisat.io/download"
+}, jn = Pt({
+  getPrecondition: () => {
+    const t = window.unisat;
+    return t == null ? null : { value: t };
+  },
+  initializer: async (t) => {
+    const { UnisatWalletAdapterImpl: e } = await import("./UnisatWalletAdapter.impl-CJB22se8.mjs");
+    return new e(t);
+  }
+}), ri = {
+  adapterId: Wn,
+  metadata: qn,
+  getAdapter: () => jn
+}, Sr = "XverseProviders.BitcoinProvider", Fn = {
+  name: "Xverse",
+  iconUrl: import("./xverse-iHLNanCB.mjs").then((t) => t.default),
+  websiteUrl: "https://xverse.app/",
+  downloadUrl: "https://www.xverse.app/download"
+}, Zn = Pt({
+  getPrecondition: () => {
+    const t = (window.btc_providers ?? []).find(
+      (e) => e.id === Sr
+    );
+    return t == null ? null : { value: t };
+  },
+  initializer: async () => {
+    const { XverseWalletAdapterImpl: t } = await import("./XverseWalletAdapter.impl-CZO0RQva.mjs");
+    return new t();
+  }
+}), ni = {
+  adapterId: Sr,
+  metadata: Fn,
+  getAdapter: () => Zn
+};
+function $t(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function vr(t) {
+  if (!$t(t))
+    throw new Error("Uint8Array expected");
+}
+function Ir(t, e) {
+  return Array.isArray(e) ? e.length === 0 ? !0 : t ? e.every((n) => typeof n == "string") : e.every((n) => Number.isSafeInteger(n)) : !1;
+}
+function Ne(t) {
+  if (typeof t != "function")
+    throw new Error("function expected");
+  return !0;
+}
+function wt(t, e) {
+  if (typeof e != "string")
+    throw new Error(`${t}: string expected`);
+  return !0;
+}
+function _t(t) {
+  if (!Number.isSafeInteger(t))
+    throw new Error(`invalid integer: ${t}`);
+}
+function ee(t) {
+  if (!Array.isArray(t))
+    throw new Error("array expected");
+}
+function re(t, e) {
+  if (!Ir(!0, e))
+    throw new Error(`${t}: array of strings expected`);
+}
+function Ce(t, e) {
+  if (!Ir(!1, e))
+    throw new Error(`${t}: array of numbers expected`);
+}
+// @__NO_SIDE_EFFECTS__
+function Mt(...t) {
+  const e = (s) => s, n = (s, i) => (c) => s(i(c)), r = t.map((s) => s.encode).reduceRight(n, e), o = t.map((s) => s.decode).reduce(n, e);
+  return { encode: r, decode: o };
+}
+// @__NO_SIDE_EFFECTS__
+function de(t) {
+  const e = typeof t == "string" ? t.split("") : t, n = e.length;
+  re("alphabet", e);
+  const r = new Map(e.map((o, s) => [o, s]));
+  return {
+    encode: (o) => (ee(o), o.map((s) => {
+      if (!Number.isSafeInteger(s) || s < 0 || s >= n)
+        throw new Error(`alphabet.encode: digit index outside alphabet "${s}". Allowed: ${t}`);
+      return e[s];
+    })),
+    decode: (o) => (ee(o), o.map((s) => {
+      wt("alphabet.decode", s);
+      const i = r.get(s);
+      if (i === void 0)
+        throw new Error(`Unknown letter: "${s}". Allowed: ${t}`);
+      return i;
+    }))
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function he(t = "") {
+  return wt("join", t), {
+    encode: (e) => (re("join.decode", e), e.join(t)),
+    decode: (e) => (wt("join.decode", e), e.split(t))
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function zn(t, e = "=") {
+  return _t(t), wt("padding", e), {
+    encode(n) {
+      for (re("padding.encode", n); n.length * t % 8; )
+        n.push(e);
+      return n;
+    },
+    decode(n) {
+      re("padding.decode", n);
+      let r = n.length;
+      if (r * t % 8)
+        throw new Error("padding: invalid, string should have whole number of bytes");
+      for (; r > 0 && n[r - 1] === e; r--)
+        if ((r - 1) * t % 8 === 0)
+          throw new Error("padding: invalid, string has too much padding");
+      return n.slice(0, r);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Gn(t) {
+  return Ne(t), { encode: (e) => e, decode: (e) => t(e) };
+}
+function rr(t, e, n) {
+  if (e < 2)
+    throw new Error(`convertRadix: invalid from=${e}, base cannot be less than 2`);
+  if (n < 2)
+    throw new Error(`convertRadix: invalid to=${n}, base cannot be less than 2`);
+  if (ee(t), !t.length)
+    return [];
+  let r = 0;
+  const o = [], s = Array.from(t, (c) => {
+    if (_t(c), c < 0 || c >= e)
+      throw new Error(`invalid integer: ${c}`);
+    return c;
+  }), i = s.length;
+  for (; ; ) {
+    let c = 0, a = !0;
+    for (let f = r; f < i; f++) {
+      const d = s[f], u = e * c, g = u + d;
+      if (!Number.isSafeInteger(g) || u / e !== c || g - d !== u)
+        throw new Error("convertRadix: carry overflow");
+      const l = g / n;
+      c = g % n;
+      const b = Math.floor(l);
+      if (s[f] = b, !Number.isSafeInteger(b) || b * n + c !== g)
+        throw new Error("convertRadix: carry overflow");
+      if (a)
+        b ? a = !1 : r = f;
+      else continue;
+    }
+    if (o.push(c), a)
+      break;
+  }
+  for (let c = 0; c < t.length - 1 && t[c] === 0; c++)
+    o.push(0);
+  return o.reverse();
+}
+const $r = (t, e) => e === 0 ? t : $r(e, t % e), ne = /* @__NO_SIDE_EFFECTS__ */ (t, e) => t + (e - $r(t, e)), Jt = /* @__PURE__ */ (() => {
+  let t = [];
+  for (let e = 0; e < 40; e++)
+    t.push(2 ** e);
+  return t;
+})();
+function Re(t, e, n, r) {
+  if (ee(t), e <= 0 || e > 32)
+    throw new Error(`convertRadix2: wrong from=${e}`);
+  if (n <= 0 || n > 32)
+    throw new Error(`convertRadix2: wrong to=${n}`);
+  if (/* @__PURE__ */ ne(e, n) > 32)
+    throw new Error(`convertRadix2: carry overflow from=${e} to=${n} carryBits=${/* @__PURE__ */ ne(e, n)}`);
+  let o = 0, s = 0;
+  const i = Jt[e], c = Jt[n] - 1, a = [];
+  for (const f of t) {
+    if (_t(f), f >= i)
+      throw new Error(`convertRadix2: invalid data word=${f} from=${e}`);
+    if (o = o << e | f, s + e > 32)
+      throw new Error(`convertRadix2: carry overflow pos=${s} from=${e}`);
+    for (s += e; s >= n; s -= n)
+      a.push((o >> s - n & c) >>> 0);
+    const d = Jt[s];
+    if (d === void 0)
+      throw new Error("invalid carry");
+    o &= d - 1;
+  }
+  if (o = o << n - s & c, !r && s >= e)
+    throw new Error("Excess padding");
+  if (!r && o > 0)
+    throw new Error(`Non-zero padding: ${o}`);
+  return r && s > 0 && a.push(o >>> 0), a;
+}
+// @__NO_SIDE_EFFECTS__
+function Yn(t) {
+  _t(t);
+  const e = 2 ** 8;
+  return {
+    encode: (n) => {
+      if (!$t(n))
+        throw new Error("radix.encode input should be Uint8Array");
+      return rr(Array.from(n), e, t);
+    },
+    decode: (n) => (Ce("radix.decode", n), Uint8Array.from(rr(n, t, e)))
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function De(t, e = !1) {
+  if (_t(t), t <= 0 || t > 32)
+    throw new Error("radix2: bits should be in (0..32]");
+  if (/* @__PURE__ */ ne(8, t) > 32 || /* @__PURE__ */ ne(t, 8) > 32)
+    throw new Error("radix2: carry overflow");
+  return {
+    encode: (n) => {
+      if (!$t(n))
+        throw new Error("radix2.encode input should be Uint8Array");
+      return Re(Array.from(n), 8, t, !e);
+    },
+    decode: (n) => (Ce("radix2.decode", n), Uint8Array.from(Re(n, t, 8, e)))
+  };
+}
+function nr(t) {
+  return Ne(t), function(...e) {
+    try {
+      return t.apply(null, e);
+    } catch {
+    }
+  };
+}
+function Xn(t, e) {
+  return _t(t), Ne(e), {
+    encode(n) {
+      if (!$t(n))
+        throw new Error("checksum.encode: input should be Uint8Array");
+      const r = e(n).slice(0, t), o = new Uint8Array(n.length + t);
+      return o.set(n), o.set(r, n.length), o;
+    },
+    decode(n) {
+      if (!$t(n))
+        throw new Error("checksum.decode: input should be Uint8Array");
+      const r = n.slice(0, -t), o = n.slice(-t), s = e(r).slice(0, t);
+      for (let i = 0; i < t; i++)
+        if (s[i] !== o[i])
+          throw new Error("Invalid checksum");
+      return r;
+    }
+  };
+}
+const Qn = typeof Uint8Array.from([]).toBase64 == "function" && typeof Uint8Array.fromBase64 == "function", Jn = (t, e) => {
+  wt("base64", t);
+  const n = /^[A-Za-z0-9=+/]+$/, r = "base64";
+  if (t.length > 0 && !n.test(t))
+    throw new Error("invalid base64");
+  return Uint8Array.fromBase64(t, { alphabet: r, lastChunkHandling: "strict" });
+}, oi = Qn ? {
+  encode(t) {
+    return vr(t), t.toBase64();
+  },
+  decode(t) {
+    return Jn(t);
+  }
+} : /* @__PURE__ */ Mt(/* @__PURE__ */ De(6), /* @__PURE__ */ de("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), /* @__PURE__ */ zn(6), /* @__PURE__ */ he("")), to = /* @__NO_SIDE_EFFECTS__ */ (t) => /* @__PURE__ */ Mt(/* @__PURE__ */ Yn(58), /* @__PURE__ */ de(t), /* @__PURE__ */ he("")), eo = /* @__PURE__ */ to("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"), ro = (t) => /* @__PURE__ */ Mt(Xn(4, (e) => t(t(e))), eo), Ue = /* @__PURE__ */ Mt(/* @__PURE__ */ de("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), /* @__PURE__ */ he("")), or = [996825010, 642813549, 513874426, 1027748829, 705979059];
+function Ct(t) {
+  const e = t >> 25;
+  let n = (t & 33554431) << 5;
+  for (let r = 0; r < or.length; r++)
+    (e >> r & 1) === 1 && (n ^= or[r]);
+  return n;
+}
+function sr(t, e, n = 1) {
+  const r = t.length;
+  let o = 1;
+  for (let s = 0; s < r; s++) {
+    const i = t.charCodeAt(s);
+    if (i < 33 || i > 126)
+      throw new Error(`Invalid prefix (${t})`);
+    o = Ct(o) ^ i >> 5;
+  }
+  o = Ct(o);
+  for (let s = 0; s < r; s++)
+    o = Ct(o) ^ t.charCodeAt(s) & 31;
+  for (let s of e)
+    o = Ct(o) ^ s;
+  for (let s = 0; s < 6; s++)
+    o = Ct(o);
+  return o ^= n, Ue.encode(Re([o % Jt[30]], 30, 5, !1));
+}
+// @__NO_SIDE_EFFECTS__
+function Or(t) {
+  const e = t === "bech32" ? 1 : 734539939, n = /* @__PURE__ */ De(5), r = n.decode, o = n.encode, s = nr(r);
+  function i(u, g, l = 90) {
+    wt("bech32.encode prefix", u), $t(g) && (g = Array.from(g)), Ce("bech32.encode", g);
+    const b = u.length;
+    if (b === 0)
+      throw new TypeError(`Invalid prefix length ${b}`);
+    const v = b + 7 + g.length;
+    if (l !== !1 && v > l)
+      throw new TypeError(`Length ${v} exceeds limit ${l}`);
+    const S = u.toLowerCase(), O = sr(S, g, e);
+    return `${S}1${Ue.encode(g)}${O}`;
+  }
+  function c(u, g = 90) {
+    wt("bech32.decode input", u);
+    const l = u.length;
+    if (l < 8 || g !== !1 && l > g)
+      throw new TypeError(`invalid string length: ${l} (${u}). Expected (8..${g})`);
+    const b = u.toLowerCase();
+    if (u !== b && u !== u.toUpperCase())
+      throw new Error("String must be lowercase or uppercase");
+    const v = b.lastIndexOf("1");
+    if (v === 0 || v === -1)
+      throw new Error('Letter "1" must be present between prefix and data only');
+    const S = b.slice(0, v), O = b.slice(v + 1);
+    if (O.length < 6)
+      throw new Error("Data must be at least 6 characters long");
+    const V = Ue.decode(O).slice(0, -6), F = sr(S, V, e);
+    if (!O.endsWith(F))
+      throw new Error(`Invalid checksum in ${u}: expected "${F}"`);
+    return { prefix: S, words: V };
+  }
+  const a = nr(c);
+  function f(u) {
+    const { prefix: g, words: l } = c(u, !1);
+    return { prefix: g, words: l, bytes: r(l) };
+  }
+  function d(u, g) {
+    return i(u, o(g));
+  }
+  return {
+    encode: i,
+    decode: c,
+    encodeFromBytes: d,
+    decodeToBytes: f,
+    decodeUnsafe: a,
+    fromWords: r,
+    fromWordsUnsafe: s,
+    toWords: o
+  };
+}
+const ke = /* @__PURE__ */ Or("bech32"), Rr = /* @__PURE__ */ Or("bech32m"), no = {
+  encode: (t) => new TextDecoder().decode(t),
+  decode: (t) => new TextEncoder().encode(t)
+}, oo = typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", so = {
+  encode(t) {
+    return vr(t), t.toHex();
+  },
+  decode(t) {
+    return wt("hex", t), Uint8Array.fromHex(t);
+  }
+}, rt = oo ? so : /* @__PURE__ */ Mt(/* @__PURE__ */ De(4), /* @__PURE__ */ de("0123456789abcdef"), /* @__PURE__ */ he(""), /* @__PURE__ */ Gn((t) => {
+  if (typeof t != "string" || t.length % 2 !== 0)
+    throw new TypeError(`hex.decode: expected string, got ${typeof t} with length ${t.length}`);
+  return t.toLowerCase();
+}));
+function Ke(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function mt(t, e = "") {
+  if (!Number.isSafeInteger(t) || t < 0) {
+    const n = e && `"${e}" `;
+    throw new Error(`${n}expected integer >= 0, got ${t}`);
+  }
+}
+function k(t, e, n = "") {
+  const r = Ke(t), o = t?.length, s = e !== void 0;
+  if (!r || s && o !== e) {
+    const i = n && `"${n}" `, c = s ? ` of length ${e}` : "", a = r ? `length=${o}` : `type=${typeof t}`;
+    throw new Error(i + "expected Uint8Array" + c + ", got " + a);
+  }
+  return t;
+}
+function Ur(t) {
+  if (typeof t != "function" || typeof t.create != "function")
+    throw new Error("Hash must wrapped by utils.createHasher");
+  mt(t.outputLen), mt(t.blockLen);
+}
+function oe(t, e = !0) {
+  if (t.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (e && t.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function io(t, e) {
+  k(t, void 0, "digestInto() output");
+  const n = e.outputLen;
+  if (t.length < n)
+    throw new Error('"digestInto() output" expected to be of length >=' + n);
+}
+function Ot(...t) {
+  for (let e = 0; e < t.length; e++)
+    t[e].fill(0);
+}
+function Be(t) {
+  return new DataView(t.buffer, t.byteOffset, t.byteLength);
+}
+function tt(t, e) {
+  return t << 32 - e | t >>> e;
+}
+function Gt(t, e) {
+  return t << e | t >>> 32 - e >>> 0;
+}
+const kr = /* @ts-ignore */ typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", co = /* @__PURE__ */ Array.from({ length: 256 }, (t, e) => e.toString(16).padStart(2, "0"));
+function le(t) {
+  if (k(t), kr)
+    return t.toHex();
+  let e = "";
+  for (let n = 0; n < t.length; n++)
+    e += co[t[n]];
+  return e;
+}
+const st = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function ir(t) {
+  if (t >= st._0 && t <= st._9)
+    return t - st._0;
+  if (t >= st.A && t <= st.F)
+    return t - (st.A - 10);
+  if (t >= st.a && t <= st.f)
+    return t - (st.a - 10);
+}
+function se(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  if (kr)
+    return Uint8Array.fromHex(t);
+  const e = t.length, n = e / 2;
+  if (e % 2)
+    throw new Error("hex string expected, got unpadded hex of length " + e);
+  const r = new Uint8Array(n);
+  for (let o = 0, s = 0; o < n; o++, s += 2) {
+    const i = ir(t.charCodeAt(s)), c = ir(t.charCodeAt(s + 1));
+    if (i === void 0 || c === void 0) {
+      const a = t[s] + t[s + 1];
+      throw new Error('hex string expected, got non-hex character "' + a + '" at index ' + s);
+    }
+    r[o] = i * 16 + c;
+  }
+  return r;
+}
+function et(...t) {
+  let e = 0;
+  for (let r = 0; r < t.length; r++) {
+    const o = t[r];
+    k(o), e += o.length;
+  }
+  const n = new Uint8Array(e);
+  for (let r = 0, o = 0; r < t.length; r++) {
+    const s = t[r];
+    n.set(s, o), o += s.length;
+  }
+  return n;
+}
+function Pr(t, e = {}) {
+  const n = (o, s) => t(s).update(o).digest(), r = t(void 0);
+  return n.outputLen = r.outputLen, n.blockLen = r.blockLen, n.create = (o) => t(o), Object.assign(n, e), Object.freeze(n);
+}
+function pe(t = 32) {
+  const e = typeof globalThis == "object" ? globalThis.crypto : null;
+  if (typeof e?.getRandomValues != "function")
+    throw new Error("crypto.getRandomValues must be defined");
+  return e.getRandomValues(new Uint8Array(t));
+}
+const ao = (t) => ({
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, t])
+});
+function fo(t, e, n) {
+  return t & e ^ ~t & n;
+}
+function uo(t, e, n) {
+  return t & e ^ t & n ^ e & n;
+}
+class _r {
+  blockLen;
+  outputLen;
+  padOffset;
+  isLE;
+  // For partial updates less than block size
+  buffer;
+  view;
+  finished = !1;
+  length = 0;
+  pos = 0;
+  destroyed = !1;
+  constructor(e, n, r, o) {
+    this.blockLen = e, this.outputLen = n, this.padOffset = r, this.isLE = o, this.buffer = new Uint8Array(e), this.view = Be(this.buffer);
+  }
+  update(e) {
+    oe(this), k(e);
+    const { view: n, buffer: r, blockLen: o } = this, s = e.length;
+    for (let i = 0; i < s; ) {
+      const c = Math.min(o - this.pos, s - i);
+      if (c === o) {
+        const a = Be(e);
+        for (; o <= s - i; i += o)
+          this.process(a, i);
+        continue;
+      }
+      r.set(e.subarray(i, i + c), this.pos), this.pos += c, i += c, this.pos === o && (this.process(n, 0), this.pos = 0);
+    }
+    return this.length += e.length, this.roundClean(), this;
+  }
+  digestInto(e) {
+    oe(this), io(e, this), this.finished = !0;
+    const { buffer: n, view: r, blockLen: o, isLE: s } = this;
+    let { pos: i } = this;
+    n[i++] = 128, Ot(this.buffer.subarray(i)), this.padOffset > o - i && (this.process(r, 0), i = 0);
+    for (let u = i; u < o; u++)
+      n[u] = 0;
+    r.setBigUint64(o - 8, BigInt(this.length * 8), s), this.process(r, 0);
+    const c = Be(e), a = this.outputLen;
+    if (a % 4)
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
+    const f = a / 4, d = this.get();
+    if (f > d.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let u = 0; u < f; u++)
+      c.setUint32(4 * u, d[u], s);
+  }
+  digest() {
+    const { buffer: e, outputLen: n } = this;
+    this.digestInto(e);
+    const r = e.slice(0, n);
+    return this.destroy(), r;
+  }
+  _cloneInto(e) {
+    e ||= new this.constructor(), e.set(...this.get());
+    const { blockLen: n, buffer: r, length: o, finished: s, destroyed: i, pos: c } = this;
+    return e.destroyed = i, e.finished = s, e.length = o, e.pos = c, o % n && e.buffer.set(r), e;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+const ht = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]), ho = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]), lt = /* @__PURE__ */ new Uint32Array(64);
+class lo extends _r {
+  constructor(e) {
+    super(64, e, 8, !1);
+  }
+  get() {
+    const { A: e, B: n, C: r, D: o, E: s, F: i, G: c, H: a } = this;
+    return [e, n, r, o, s, i, c, a];
+  }
+  // prettier-ignore
+  set(e, n, r, o, s, i, c, a) {
+    this.A = e | 0, this.B = n | 0, this.C = r | 0, this.D = o | 0, this.E = s | 0, this.F = i | 0, this.G = c | 0, this.H = a | 0;
+  }
+  process(e, n) {
+    for (let u = 0; u < 16; u++, n += 4)
+      lt[u] = e.getUint32(n, !1);
+    for (let u = 16; u < 64; u++) {
+      const g = lt[u - 15], l = lt[u - 2], b = tt(g, 7) ^ tt(g, 18) ^ g >>> 3, v = tt(l, 17) ^ tt(l, 19) ^ l >>> 10;
+      lt[u] = v + lt[u - 7] + b + lt[u - 16] | 0;
+    }
+    let { A: r, B: o, C: s, D: i, E: c, F: a, G: f, H: d } = this;
+    for (let u = 0; u < 64; u++) {
+      const g = tt(c, 6) ^ tt(c, 11) ^ tt(c, 25), l = d + g + fo(c, a, f) + ho[u] + lt[u] | 0, v = (tt(r, 2) ^ tt(r, 13) ^ tt(r, 22)) + uo(r, o, s) | 0;
+      d = f, f = a, a = c, c = i + l | 0, i = s, s = o, o = r, r = l + v | 0;
+    }
+    r = r + this.A | 0, o = o + this.B | 0, s = s + this.C | 0, i = i + this.D | 0, c = c + this.E | 0, a = a + this.F | 0, f = f + this.G | 0, d = d + this.H | 0, this.set(r, o, s, i, c, a, f, d);
+  }
+  roundClean() {
+    Ot(lt);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), Ot(this.buffer);
+  }
+}
+class po extends lo {
+  // We cannot use array here since array allows indexing by variable
+  // which means optimizer/compiler cannot use registers.
+  A = ht[0] | 0;
+  B = ht[1] | 0;
+  C = ht[2] | 0;
+  D = ht[3] | 0;
+  E = ht[4] | 0;
+  F = ht[5] | 0;
+  G = ht[6] | 0;
+  H = ht[7] | 0;
+  constructor() {
+    super(32);
+  }
+}
+const at = /* @__PURE__ */ Pr(
+  () => new po(),
+  /* @__PURE__ */ ao(1)
+);
+const Ve = /* @__PURE__ */ BigInt(0), Pe = /* @__PURE__ */ BigInt(1);
+function ie(t, e = "") {
+  if (typeof t != "boolean") {
+    const n = e && `"${e}" `;
+    throw new Error(n + "expected boolean, got type=" + typeof t);
+  }
+  return t;
+}
+function Hr(t) {
+  if (typeof t == "bigint") {
+    if (!te(t))
+      throw new Error("positive bigint expected, got " + t);
+  } else
+    mt(t);
+  return t;
+}
+function Yt(t) {
+  const e = Hr(t).toString(16);
+  return e.length & 1 ? "0" + e : e;
+}
+function Lr(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  return t === "" ? Ve : BigInt("0x" + t);
+}
+function ut(t) {
+  return Lr(le(t));
+}
+function Tr(t) {
+  return Lr(le(wo(k(t)).reverse()));
+}
+function we(t, e) {
+  mt(e), t = Hr(t);
+  const n = se(t.toString(16).padStart(e * 2, "0"));
+  if (n.length !== e)
+    throw new Error("number too large");
+  return n;
+}
+function Nr(t, e) {
+  return we(t, e).reverse();
+}
+function wo(t) {
+  return Uint8Array.from(t);
+}
+function go(t) {
+  return Uint8Array.from(t, (e, n) => {
+    const r = e.charCodeAt(0);
+    if (e.length !== 1 || r > 127)
+      throw new Error(`string contains non-ASCII character "${t[n]}" with code ${r} at position ${n}`);
+    return r;
+  });
+}
+const te = (t) => typeof t == "bigint" && Ve <= t;
+function yo(t, e, n) {
+  return te(t) && te(e) && te(n) && e <= t && t < n;
+}
+function bo(t, e, n, r) {
+  if (!yo(e, n, r))
+    throw new Error("expected valid " + t + ": " + n + " <= n < " + r + ", got " + e);
+}
+function Eo(t) {
+  let e;
+  for (e = 0; t > Ve; t >>= Pe, e += 1)
+    ;
+  return e;
+}
+const Me = (t) => (Pe << BigInt(t)) - Pe;
+function mo(t, e, n) {
+  if (mt(t, "hashLen"), mt(e, "qByteLen"), typeof n != "function")
+    throw new Error("hmacFn must be a function");
+  const r = (S) => new Uint8Array(S), o = Uint8Array.of(), s = Uint8Array.of(0), i = Uint8Array.of(1), c = 1e3;
+  let a = r(t), f = r(t), d = 0;
+  const u = () => {
+    a.fill(1), f.fill(0), d = 0;
+  }, g = (...S) => n(f, et(a, ...S)), l = (S = o) => {
+    f = g(s, S), a = g(), S.length !== 0 && (f = g(i, S), a = g());
+  }, b = () => {
+    if (d++ >= c)
+      throw new Error("drbg: tried max amount of iterations");
+    let S = 0;
+    const O = [];
+    for (; S < e; ) {
+      a = g();
+      const V = a.slice();
+      O.push(V), S += a.length;
+    }
+    return et(...O);
+  };
+  return (S, O) => {
+    u(), l(S);
+    let V;
+    for (; !(V = O(b())); )
+      l();
+    return u(), V;
+  };
+}
+function We(t, e = {}, n = {}) {
+  if (!t || typeof t != "object")
+    throw new Error("expected valid options object");
+  function r(s, i, c) {
+    const a = t[s];
+    if (c && a === void 0)
+      return;
+    const f = typeof a;
+    if (f !== i || a === null)
+      throw new Error(`param "${s}" is invalid: expected ${i}, got ${f}`);
+  }
+  const o = (s, i) => Object.entries(s).forEach(([c, a]) => r(c, a, i));
+  o(e, !1), o(n, !0);
+}
+function cr(t) {
+  const e = /* @__PURE__ */ new WeakMap();
+  return (n, ...r) => {
+    const o = e.get(n);
+    if (o !== void 0)
+      return o;
+    const s = t(n, ...r);
+    return e.set(n, s), s;
+  };
+}
+const j = /* @__PURE__ */ BigInt(0), q = /* @__PURE__ */ BigInt(1), yt = /* @__PURE__ */ BigInt(2), Cr = /* @__PURE__ */ BigInt(3), Dr = /* @__PURE__ */ BigInt(4), Kr = /* @__PURE__ */ BigInt(5), xo = /* @__PURE__ */ BigInt(7), Vr = /* @__PURE__ */ BigInt(8), Ao = /* @__PURE__ */ BigInt(9), Mr = /* @__PURE__ */ BigInt(16);
+function X(t, e) {
+  const n = t % e;
+  return n >= j ? n : e + n;
+}
+function G(t, e, n) {
+  let r = t;
+  for (; e-- > j; )
+    r *= r, r %= n;
+  return r;
+}
+function ar(t, e) {
+  if (t === j)
+    throw new Error("invert: expected non-zero number");
+  if (e <= j)
+    throw new Error("invert: expected positive modulus, got " + e);
+  let n = X(t, e), r = e, o = j, s = q;
+  for (; n !== j; ) {
+    const c = r / n, a = r % n, f = o - s * c;
+    r = n, n = a, o = s, s = f;
+  }
+  if (r !== q)
+    throw new Error("invert: does not exist");
+  return X(o, e);
+}
+function qe(t, e, n) {
+  if (!t.eql(t.sqr(e), n))
+    throw new Error("Cannot find square root");
+}
+function Wr(t, e) {
+  const n = (t.ORDER + q) / Dr, r = t.pow(e, n);
+  return qe(t, r, e), r;
+}
+function Bo(t, e) {
+  const n = (t.ORDER - Kr) / Vr, r = t.mul(e, yt), o = t.pow(r, n), s = t.mul(e, o), i = t.mul(t.mul(s, yt), o), c = t.mul(s, t.sub(i, t.ONE));
+  return qe(t, c, e), c;
+}
+function So(t) {
+  const e = ge(t), n = qr(t), r = n(e, e.neg(e.ONE)), o = n(e, r), s = n(e, e.neg(r)), i = (t + xo) / Mr;
+  return (c, a) => {
+    let f = c.pow(a, i), d = c.mul(f, r);
+    const u = c.mul(f, o), g = c.mul(f, s), l = c.eql(c.sqr(d), a), b = c.eql(c.sqr(u), a);
+    f = c.cmov(f, d, l), d = c.cmov(g, u, b);
+    const v = c.eql(c.sqr(d), a), S = c.cmov(f, d, v);
+    return qe(c, S, a), S;
+  };
+}
+function qr(t) {
+  if (t < Cr)
+    throw new Error("sqrt is not defined for small field");
+  let e = t - q, n = 0;
+  for (; e % yt === j; )
+    e /= yt, n++;
+  let r = yt;
+  const o = ge(t);
+  for (; fr(o, r) === 1; )
+    if (r++ > 1e3)
+      throw new Error("Cannot find square root: probably non-prime P");
+  if (n === 1)
+    return Wr;
+  let s = o.pow(r, e);
+  const i = (e + q) / yt;
+  return function(a, f) {
+    if (a.is0(f))
+      return f;
+    if (fr(a, f) !== 1)
+      throw new Error("Cannot find square root");
+    let d = n, u = a.mul(a.ONE, s), g = a.pow(f, e), l = a.pow(f, i);
+    for (; !a.eql(g, a.ONE); ) {
+      if (a.is0(g))
+        return a.ZERO;
+      let b = 1, v = a.sqr(g);
+      for (; !a.eql(v, a.ONE); )
+        if (b++, v = a.sqr(v), b === d)
+          throw new Error("Cannot find square root");
+      const S = q << BigInt(d - b - 1), O = a.pow(u, S);
+      d = b, u = a.sqr(O), g = a.mul(g, u), l = a.mul(l, O);
+    }
+    return l;
+  };
+}
+function vo(t) {
+  return t % Dr === Cr ? Wr : t % Vr === Kr ? Bo : t % Mr === Ao ? So(t) : qr(t);
+}
+const Io = [
+  "create",
+  "isValid",
+  "is0",
+  "neg",
+  "inv",
+  "sqrt",
+  "sqr",
+  "eql",
+  "add",
+  "sub",
+  "mul",
+  "pow",
+  "div",
+  "addN",
+  "subN",
+  "mulN",
+  "sqrN"
+];
+function $o(t) {
+  const e = {
+    ORDER: "bigint",
+    BYTES: "number",
+    BITS: "number"
+  }, n = Io.reduce((r, o) => (r[o] = "function", r), e);
+  return We(t, n), t;
+}
+function Oo(t, e, n) {
+  if (n < j)
+    throw new Error("invalid exponent, negatives unsupported");
+  if (n === j)
+    return t.ONE;
+  if (n === q)
+    return e;
+  let r = t.ONE, o = e;
+  for (; n > j; )
+    n & q && (r = t.mul(r, o)), o = t.sqr(o), n >>= q;
+  return r;
+}
+function jr(t, e, n = !1) {
+  const r = new Array(e.length).fill(n ? t.ZERO : void 0), o = e.reduce((i, c, a) => t.is0(c) ? i : (r[a] = i, t.mul(i, c)), t.ONE), s = t.inv(o);
+  return e.reduceRight((i, c, a) => t.is0(c) ? i : (r[a] = t.mul(i, r[a]), t.mul(i, c)), s), r;
+}
+function fr(t, e) {
+  const n = (t.ORDER - q) / yt, r = t.pow(e, n), o = t.eql(r, t.ONE), s = t.eql(r, t.ZERO), i = t.eql(r, t.neg(t.ONE));
+  if (!o && !s && !i)
+    throw new Error("invalid Legendre symbol result");
+  return o ? 1 : s ? 0 : -1;
+}
+function Ro(t, e) {
+  e !== void 0 && mt(e);
+  const n = e !== void 0 ? e : t.toString(2).length, r = Math.ceil(n / 8);
+  return { nBitLength: n, nByteLength: r };
+}
+class Uo {
+  ORDER;
+  BITS;
+  BYTES;
+  isLE;
+  ZERO = j;
+  ONE = q;
+  _lengths;
+  _sqrt;
+  // cached sqrt
+  _mod;
+  constructor(e, n = {}) {
+    if (e <= j)
+      throw new Error("invalid field: expected ORDER > 0, got " + e);
+    let r;
+    this.isLE = !1, n != null && typeof n == "object" && (typeof n.BITS == "number" && (r = n.BITS), typeof n.sqrt == "function" && (this.sqrt = n.sqrt), typeof n.isLE == "boolean" && (this.isLE = n.isLE), n.allowedLengths && (this._lengths = n.allowedLengths?.slice()), typeof n.modFromBytes == "boolean" && (this._mod = n.modFromBytes));
+    const { nBitLength: o, nByteLength: s } = Ro(e, r);
+    if (s > 2048)
+      throw new Error("invalid field: expected ORDER of <= 2048 bytes");
+    this.ORDER = e, this.BITS = o, this.BYTES = s, this._sqrt = void 0, Object.preventExtensions(this);
+  }
+  create(e) {
+    return X(e, this.ORDER);
+  }
+  isValid(e) {
+    if (typeof e != "bigint")
+      throw new Error("invalid field element: expected bigint, got " + typeof e);
+    return j <= e && e < this.ORDER;
+  }
+  is0(e) {
+    return e === j;
+  }
+  // is valid and invertible
+  isValidNot0(e) {
+    return !this.is0(e) && this.isValid(e);
+  }
+  isOdd(e) {
+    return (e & q) === q;
+  }
+  neg(e) {
+    return X(-e, this.ORDER);
+  }
+  eql(e, n) {
+    return e === n;
+  }
+  sqr(e) {
+    return X(e * e, this.ORDER);
+  }
+  add(e, n) {
+    return X(e + n, this.ORDER);
+  }
+  sub(e, n) {
+    return X(e - n, this.ORDER);
+  }
+  mul(e, n) {
+    return X(e * n, this.ORDER);
+  }
+  pow(e, n) {
+    return Oo(this, e, n);
+  }
+  div(e, n) {
+    return X(e * ar(n, this.ORDER), this.ORDER);
+  }
+  // Same as above, but doesn't normalize
+  sqrN(e) {
+    return e * e;
+  }
+  addN(e, n) {
+    return e + n;
+  }
+  subN(e, n) {
+    return e - n;
+  }
+  mulN(e, n) {
+    return e * n;
+  }
+  inv(e) {
+    return ar(e, this.ORDER);
+  }
+  sqrt(e) {
+    return this._sqrt || (this._sqrt = vo(this.ORDER)), this._sqrt(this, e);
+  }
+  toBytes(e) {
+    return this.isLE ? Nr(e, this.BYTES) : we(e, this.BYTES);
+  }
+  fromBytes(e, n = !1) {
+    k(e);
+    const { _lengths: r, BYTES: o, isLE: s, ORDER: i, _mod: c } = this;
+    if (r) {
+      if (!r.includes(e.length) || e.length > o)
+        throw new Error("Field.fromBytes: expected " + r + " bytes, got " + e.length);
+      const f = new Uint8Array(o);
+      f.set(e, s ? 0 : f.length - e.length), e = f;
+    }
+    if (e.length !== o)
+      throw new Error("Field.fromBytes: expected " + o + " bytes, got " + e.length);
+    let a = s ? Tr(e) : ut(e);
+    if (c && (a = X(a, i)), !n && !this.isValid(a))
+      throw new Error("invalid field element: outside of range 0..ORDER");
+    return a;
+  }
+  // TODO: we don't need it here, move out to separate fn
+  invertBatch(e) {
+    return jr(this, e);
+  }
+  // We can't move this out because Fp6, Fp12 implement it
+  // and it's unclear what to return in there.
+  cmov(e, n, r) {
+    return r ? n : e;
+  }
+}
+function ge(t, e = {}) {
+  return new Uo(t, e);
+}
+function Fr(t) {
+  if (typeof t != "bigint")
+    throw new Error("field order must be bigint");
+  const e = t.toString(2).length;
+  return Math.ceil(e / 8);
+}
+function Zr(t) {
+  const e = Fr(t);
+  return e + Math.ceil(e / 2);
+}
+function zr(t, e, n = !1) {
+  k(t);
+  const r = t.length, o = Fr(e), s = Zr(e);
+  if (r < 16 || r < s || r > 1024)
+    throw new Error("expected " + s + "-1024 bytes of input, got " + r);
+  const i = n ? Tr(t) : ut(t), c = X(i, e - q) + q;
+  return n ? Nr(c, o) : we(c, o);
+}
+const Rt = /* @__PURE__ */ BigInt(0), bt = /* @__PURE__ */ BigInt(1);
+function ce(t, e) {
+  const n = e.negate();
+  return t ? n : e;
+}
+function ur(t, e) {
+  const n = jr(t.Fp, e.map((r) => r.Z));
+  return e.map((r, o) => t.fromAffine(r.toAffine(n[o])));
+}
+function Gr(t, e) {
+  if (!Number.isSafeInteger(t) || t <= 0 || t > e)
+    throw new Error("invalid window size, expected [1.." + e + "], got W=" + t);
+}
+function Se(t, e) {
+  Gr(t, e);
+  const n = Math.ceil(e / t) + 1, r = 2 ** (t - 1), o = 2 ** t, s = Me(t), i = BigInt(t);
+  return { windows: n, windowSize: r, mask: s, maxNumber: o, shiftBy: i };
+}
+function dr(t, e, n) {
+  const { windowSize: r, mask: o, maxNumber: s, shiftBy: i } = n;
+  let c = Number(t & o), a = t >> i;
+  c > r && (c -= s, a += bt);
+  const f = e * r, d = f + Math.abs(c) - 1, u = c === 0, g = c < 0, l = e % 2 !== 0;
+  return { nextN: a, offset: d, isZero: u, isNeg: g, isNegF: l, offsetF: f };
+}
+const ve = /* @__PURE__ */ new WeakMap(), Yr = /* @__PURE__ */ new WeakMap();
+function Ie(t) {
+  return Yr.get(t) || 1;
+}
+function hr(t) {
+  if (t !== Rt)
+    throw new Error("invalid wNAF");
+}
+class ko {
+  BASE;
+  ZERO;
+  Fn;
+  bits;
+  // Parametrized with a given Point class (not individual point)
+  constructor(e, n) {
+    this.BASE = e.BASE, this.ZERO = e.ZERO, this.Fn = e.Fn, this.bits = n;
+  }
+  // non-const time multiplication ladder
+  _unsafeLadder(e, n, r = this.ZERO) {
+    let o = e;
+    for (; n > Rt; )
+      n & bt && (r = r.add(o)), o = o.double(), n >>= bt;
+    return r;
+  }
+  /**
+   * Creates a wNAF precomputation window. Used for caching.
+   * Default window size is set by `utils.precompute()` and is equal to 8.
+   * Number of precomputed points depends on the curve size:
+   * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
+   * - 𝑊 is the window size
+   * - 𝑛 is the bitlength of the curve order.
+   * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
+   * @param point Point instance
+   * @param W window size
+   * @returns precomputed point tables flattened to a single array
+   */
+  precomputeWindow(e, n) {
+    const { windows: r, windowSize: o } = Se(n, this.bits), s = [];
+    let i = e, c = i;
+    for (let a = 0; a < r; a++) {
+      c = i, s.push(c);
+      for (let f = 1; f < o; f++)
+        c = c.add(i), s.push(c);
+      i = c.double();
+    }
+    return s;
+  }
+  /**
+   * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+   * More compact implementation:
+   * https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541
+   * @returns real and fake (for const-time) points
+   */
+  wNAF(e, n, r) {
+    if (!this.Fn.isValid(r))
+      throw new Error("invalid scalar");
+    let o = this.ZERO, s = this.BASE;
+    const i = Se(e, this.bits);
+    for (let c = 0; c < i.windows; c++) {
+      const { nextN: a, offset: f, isZero: d, isNeg: u, isNegF: g, offsetF: l } = dr(r, c, i);
+      r = a, d ? s = s.add(ce(g, n[l])) : o = o.add(ce(u, n[f]));
+    }
+    return hr(r), { p: o, f: s };
+  }
+  /**
+   * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.
+   * @param acc accumulator point to add result of multiplication
+   * @returns point
+   */
+  wNAFUnsafe(e, n, r, o = this.ZERO) {
+    const s = Se(e, this.bits);
+    for (let i = 0; i < s.windows && r !== Rt; i++) {
+      const { nextN: c, offset: a, isZero: f, isNeg: d } = dr(r, i, s);
+      if (r = c, !f) {
+        const u = n[a];
+        o = o.add(d ? u.negate() : u);
+      }
+    }
+    return hr(r), o;
+  }
+  getPrecomputes(e, n, r) {
+    let o = ve.get(n);
+    return o || (o = this.precomputeWindow(n, e), e !== 1 && (typeof r == "function" && (o = r(o)), ve.set(n, o))), o;
+  }
+  cached(e, n, r) {
+    const o = Ie(e);
+    return this.wNAF(o, this.getPrecomputes(o, e, r), n);
+  }
+  unsafe(e, n, r, o) {
+    const s = Ie(e);
+    return s === 1 ? this._unsafeLadder(e, n, o) : this.wNAFUnsafe(s, this.getPrecomputes(s, e, r), n, o);
+  }
+  // We calculate precomputes for elliptic curve point multiplication
+  // using windowed method. This specifies window size and
+  // stores precomputed values. Usually only base point would be precomputed.
+  createCache(e, n) {
+    Gr(n, this.bits), Yr.set(e, n), ve.delete(e);
+  }
+  hasCache(e) {
+    return Ie(e) !== 1;
+  }
+}
+function Po(t, e, n, r) {
+  let o = e, s = t.ZERO, i = t.ZERO;
+  for (; n > Rt || r > Rt; )
+    n & bt && (s = s.add(o)), r & bt && (i = i.add(o)), o = o.double(), n >>= bt, r >>= bt;
+  return { p1: s, p2: i };
+}
+function lr(t, e, n) {
+  if (e) {
+    if (e.ORDER !== t)
+      throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+    return $o(e), e;
+  } else
+    return ge(t, { isLE: n });
+}
+function _o(t, e, n = {}, r) {
+  if (r === void 0 && (r = t === "edwards"), !e || typeof e != "object")
+    throw new Error(`expected valid ${t} CURVE object`);
+  for (const a of ["p", "n", "h"]) {
+    const f = e[a];
+    if (!(typeof f == "bigint" && f > Rt))
+      throw new Error(`CURVE.${a} must be positive bigint`);
+  }
+  const o = lr(e.p, n.Fp, r), s = lr(e.n, n.Fn, r), c = ["Gx", "Gy", "a", "b"];
+  for (const a of c)
+    if (!o.isValid(e[a]))
+      throw new Error(`CURVE.${a} must be valid field element of CURVE.Fp`);
+  return e = Object.freeze(Object.assign({}, e)), { CURVE: e, Fp: o, Fn: s };
+}
+function Xr(t, e) {
+  return function(r) {
+    const o = t(r);
+    return { secretKey: o, publicKey: e(o) };
+  };
+}
+class Qr {
+  oHash;
+  iHash;
+  blockLen;
+  outputLen;
+  finished = !1;
+  destroyed = !1;
+  constructor(e, n) {
+    if (Ur(e), k(n, void 0, "key"), this.iHash = e.create(), 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 r = this.blockLen, o = new Uint8Array(r);
+    o.set(n.length > r ? e.create().update(n).digest() : n);
+    for (let s = 0; s < o.length; s++)
+      o[s] ^= 54;
+    this.iHash.update(o), this.oHash = e.create();
+    for (let s = 0; s < o.length; s++)
+      o[s] ^= 106;
+    this.oHash.update(o), Ot(o);
+  }
+  update(e) {
+    return oe(this), this.iHash.update(e), this;
+  }
+  digestInto(e) {
+    oe(this), k(e, this.outputLen, "output"), this.finished = !0, this.iHash.digestInto(e), this.oHash.update(e), this.oHash.digestInto(e), this.destroy();
+  }
+  digest() {
+    const e = new Uint8Array(this.oHash.outputLen);
+    return this.digestInto(e), e;
+  }
+  _cloneInto(e) {
+    e ||= Object.create(Object.getPrototypeOf(this), {});
+    const { oHash: n, iHash: r, finished: o, destroyed: s, blockLen: i, outputLen: c } = this;
+    return e = e, e.finished = o, e.destroyed = s, e.blockLen = i, e.outputLen = c, e.oHash = n._cloneInto(e.oHash), e.iHash = r._cloneInto(e.iHash), e;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+  }
+}
+const Jr = (t, e, n) => new Qr(t, e).update(n).digest();
+Jr.create = (t, e) => new Qr(t, e);
+const pr = (t, e) => (t + (t >= 0 ? e : -e) / tn) / e;
+function Ho(t, e, n) {
+  const [[r, o], [s, i]] = e, c = pr(i * t, n), a = pr(-o * t, n);
+  let f = t - c * r - a * s, d = -c * o - a * i;
+  const u = f < it, g = d < it;
+  u && (f = -f), g && (d = -d);
+  const l = Me(Math.ceil(Eo(n) / 2)) + It;
+  if (f < it || f >= l || d < it || d >= l)
+    throw new Error("splitScalar (endomorphism): failed, k=" + t);
+  return { k1neg: u, k1: f, k2neg: g, k2: d };
+}
+function _e(t) {
+  if (!["compact", "recovered", "der"].includes(t))
+    throw new Error('Signature format must be "compact", "recovered", or "der"');
+  return t;
+}
+function $e(t, e) {
+  const n = {};
+  for (let r of Object.keys(e))
+    n[r] = t[r] === void 0 ? e[r] : t[r];
+  return ie(n.lowS, "lowS"), ie(n.prehash, "prehash"), n.format !== void 0 && _e(n.format), n;
+}
+class Lo extends Error {
+  constructor(e = "") {
+    super(e);
+  }
+}
+const pt = {
+  // asn.1 DER encoding utils
+  Err: Lo,
+  // Basic building block is TLV (Tag-Length-Value)
+  _tlv: {
+    encode: (t, e) => {
+      const { Err: n } = pt;
+      if (t < 0 || t > 256)
+        throw new n("tlv.encode: wrong tag");
+      if (e.length & 1)
+        throw new n("tlv.encode: unpadded data");
+      const r = e.length / 2, o = Yt(r);
+      if (o.length / 2 & 128)
+        throw new n("tlv.encode: long form length too big");
+      const s = r > 127 ? Yt(o.length / 2 | 128) : "";
+      return Yt(t) + s + o + e;
+    },
+    // v - value, l - left bytes (unparsed)
+    decode(t, e) {
+      const { Err: n } = pt;
+      let r = 0;
+      if (t < 0 || t > 256)
+        throw new n("tlv.encode: wrong tag");
+      if (e.length < 2 || e[r++] !== t)
+        throw new n("tlv.decode: wrong tlv");
+      const o = e[r++], s = !!(o & 128);
+      let i = 0;
+      if (!s)
+        i = o;
+      else {
+        const a = o & 127;
+        if (!a)
+          throw new n("tlv.decode(long): indefinite length not supported");
+        if (a > 4)
+          throw new n("tlv.decode(long): byte length is too big");
+        const f = e.subarray(r, r + a);
+        if (f.length !== a)
+          throw new n("tlv.decode: length bytes not complete");
+        if (f[0] === 0)
+          throw new n("tlv.decode(long): zero leftmost byte");
+        for (const d of f)
+          i = i << 8 | d;
+        if (r += a, i < 128)
+          throw new n("tlv.decode(long): not minimal encoding");
+      }
+      const c = e.subarray(r, r + i);
+      if (c.length !== i)
+        throw new n("tlv.decode: wrong value length");
+      return { v: c, l: e.subarray(r + i) };
+    }
+  },
+  // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
+  // since we always use positive integers here. It must always be empty:
+  // - add zero byte if exists
+  // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
+  _int: {
+    encode(t) {
+      const { Err: e } = pt;
+      if (t < it)
+        throw new e("integer: negative integers are not allowed");
+      let n = Yt(t);
+      if (Number.parseInt(n[0], 16) & 8 && (n = "00" + n), n.length & 1)
+        throw new e("unexpected DER parsing assertion: unpadded hex");
+      return n;
+    },
+    decode(t) {
+      const { Err: e } = pt;
+      if (t[0] & 128)
+        throw new e("invalid signature integer: negative");
+      if (t[0] === 0 && !(t[1] & 128))
+        throw new e("invalid signature integer: unnecessary leading zero");
+      return ut(t);
+    }
+  },
+  toSig(t) {
+    const { Err: e, _int: n, _tlv: r } = pt, o = k(t, void 0, "signature"), { v: s, l: i } = r.decode(48, o);
+    if (i.length)
+      throw new e("invalid signature: left bytes after parsing");
+    const { v: c, l: a } = r.decode(2, s), { v: f, l: d } = r.decode(2, a);
+    if (d.length)
+      throw new e("invalid signature: left bytes after parsing");
+    return { r: n.decode(c), s: n.decode(f) };
+  },
+  hexFromSig(t) {
+    const { _tlv: e, _int: n } = pt, r = e.encode(2, n.encode(t.r)), o = e.encode(2, n.encode(t.s)), s = r + o;
+    return e.encode(48, s);
+  }
+}, it = BigInt(0), It = BigInt(1), tn = BigInt(2), Xt = BigInt(3), To = BigInt(4);
+function No(t, e = {}) {
+  const n = _o("weierstrass", t, e), { Fp: r, Fn: o } = n;
+  let s = n.CURVE;
+  const { h: i, n: c } = s;
+  We(e, {}, {
+    allowInfinityPoint: "boolean",
+    clearCofactor: "function",
+    isTorsionFree: "function",
+    fromBytes: "function",
+    toBytes: "function",
+    endo: "object"
+  });
+  const { endo: a } = e;
+  if (a && (!r.is0(s.a) || typeof a.beta != "bigint" || !Array.isArray(a.basises)))
+    throw new Error('invalid endo: expected "beta": bigint and "basises": array');
+  const f = rn(r, o);
+  function d() {
+    if (!r.isOdd)
+      throw new Error("compression is not supported: Field does not have .isOdd()");
+  }
+  function u(R, w, p) {
+    const { x: h, y } = w.toAffine(), m = r.toBytes(h);
+    if (ie(p, "isCompressed"), p) {
+      d();
+      const A = !r.isOdd(y);
+      return et(en(A), m);
+    } else
+      return et(Uint8Array.of(4), m, r.toBytes(y));
+  }
+  function g(R) {
+    k(R, void 0, "Point");
+    const { publicKey: w, publicKeyUncompressed: p } = f, h = R.length, y = R[0], m = R.subarray(1);
+    if (h === w && (y === 2 || y === 3)) {
+      const A = r.fromBytes(m);
+      if (!r.isValid(A))
+        throw new Error("bad point: is not on curve, wrong x");
+      const x = v(A);
+      let E;
+      try {
+        E = r.sqrt(x);
+      } catch (L) {
+        const P = L instanceof Error ? ": " + L.message : "";
+        throw new Error("bad point: is not on curve, sqrt error" + P);
+      }
+      d();
+      const B = r.isOdd(E);
+      return (y & 1) === 1 !== B && (E = r.neg(E)), { x: A, y: E };
+    } else if (h === p && y === 4) {
+      const A = r.BYTES, x = r.fromBytes(m.subarray(0, A)), E = r.fromBytes(m.subarray(A, A * 2));
+      if (!S(x, E))
+        throw new Error("bad point: is not on curve");
+      return { x, y: E };
+    } else
+      throw new Error(`bad point: got length ${h}, expected compressed=${w} or uncompressed=${p}`);
+  }
+  const l = e.toBytes || u, b = e.fromBytes || g;
+  function v(R) {
+    const w = r.sqr(R), p = r.mul(w, R);
+    return r.add(r.add(p, r.mul(R, s.a)), s.b);
+  }
+  function S(R, w) {
+    const p = r.sqr(w), h = v(R);
+    return r.eql(p, h);
+  }
+  if (!S(s.Gx, s.Gy))
+    throw new Error("bad curve params: generator point");
+  const O = r.mul(r.pow(s.a, Xt), To), V = r.mul(r.sqr(s.b), BigInt(27));
+  if (r.is0(r.add(O, V)))
+    throw new Error("bad curve params: a or b");
+  function F(R, w, p = !1) {
+    if (!r.isValid(w) || p && r.is0(w))
+      throw new Error(`bad point coordinate ${R}`);
+    return w;
+  }
+  function M(R) {
+    if (!(R instanceof U))
+      throw new Error("Weierstrass Point expected");
+  }
+  function C(R) {
+    if (!a || !a.basises)
+      throw new Error("no endo");
+    return Ho(R, a.basises, o.ORDER);
+  }
+  const z = cr((R, w) => {
+    const { X: p, Y: h, Z: y } = R;
+    if (r.eql(y, r.ONE))
+      return { x: p, y: h };
+    const m = R.is0();
+    w == null && (w = m ? r.ONE : r.inv(y));
+    const A = r.mul(p, w), x = r.mul(h, w), E = r.mul(y, w);
+    if (m)
+      return { x: r.ZERO, y: r.ZERO };
+    if (!r.eql(E, r.ONE))
+      throw new Error("invZ was invalid");
+    return { x: A, y: x };
+  }), Ae = cr((R) => {
+    if (R.is0()) {
+      if (e.allowInfinityPoint && !r.is0(R.Y))
+        return;
+      throw new Error("bad point: ZERO");
+    }
+    const { x: w, y: p } = R.toAffine();
+    if (!r.isValid(w) || !r.isValid(p))
+      throw new Error("bad point: x or y not field elements");
+    if (!S(w, p))
+      throw new Error("bad point: equation left != right");
+    if (!R.isTorsionFree())
+      throw new Error("bad point: not in prime-order subgroup");
+    return !0;
+  });
+  function Tt(R, w, p, h, y) {
+    return p = new U(r.mul(p.X, R), p.Y, p.Z), w = ce(h, w), p = ce(y, p), w.add(p);
+  }
+  class U {
+    // base / generator point
+    static BASE = new U(s.Gx, s.Gy, r.ONE);
+    // zero / infinity / identity point
+    static ZERO = new U(r.ZERO, r.ONE, r.ZERO);
+    // 0, 1, 0
+    // math field
+    static Fp = r;
+    // scalar field
+    static Fn = o;
+    X;
+    Y;
+    Z;
+    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+    constructor(w, p, h) {
+      this.X = F("x", w), this.Y = F("y", p, !0), this.Z = F("z", h), Object.freeze(this);
+    }
+    static CURVE() {
+      return s;
+    }
+    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+    static fromAffine(w) {
+      const { x: p, y: h } = w || {};
+      if (!w || !r.isValid(p) || !r.isValid(h))
+        throw new Error("invalid affine point");
+      if (w instanceof U)
+        throw new Error("projective point not allowed");
+      return r.is0(p) && r.is0(h) ? U.ZERO : new U(p, h, r.ONE);
+    }
+    static fromBytes(w) {
+      const p = U.fromAffine(b(k(w, void 0, "point")));
+      return p.assertValidity(), p;
+    }
+    static fromHex(w) {
+      return U.fromBytes(se(w));
+    }
+    get x() {
+      return this.toAffine().x;
+    }
+    get y() {
+      return this.toAffine().y;
+    }
+    /**
+     *
+     * @param windowSize
+     * @param isLazy true will defer table computation until the first multiplication
+     * @returns
+     */
+    precompute(w = 8, p = !0) {
+      return gt.createCache(this, w), p || this.multiply(Xt), this;
+    }
+    // TODO: return `this`
+    /** A point on curve is valid if it conforms to equation. */
+    assertValidity() {
+      Ae(this);
+    }
+    hasEvenY() {
+      const { y: w } = this.toAffine();
+      if (!r.isOdd)
+        throw new Error("Field doesn't support isOdd");
+      return !r.isOdd(w);
+    }
+    /** Compare one point to another. */
+    equals(w) {
+      M(w);
+      const { X: p, Y: h, Z: y } = this, { X: m, Y: A, Z: x } = w, E = r.eql(r.mul(p, x), r.mul(m, y)), B = r.eql(r.mul(h, x), r.mul(A, y));
+      return E && B;
+    }
+    /** Flips point to one corresponding to (x, -y) in Affine coordinates. */
+    negate() {
+      return new U(this.X, r.neg(this.Y), this.Z);
+    }
+    // Renes-Costello-Batina exception-free doubling formula.
+    // There is 30% faster Jacobian formula, but it is not complete.
+    // https://eprint.iacr.org/2015/1060, algorithm 3
+    // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
+    double() {
+      const { a: w, b: p } = s, h = r.mul(p, Xt), { X: y, Y: m, Z: A } = this;
+      let x = r.ZERO, E = r.ZERO, B = r.ZERO, I = r.mul(y, y), L = r.mul(m, m), P = r.mul(A, A), $ = r.mul(y, m);
+      return $ = r.add($, $), B = r.mul(y, A), B = r.add(B, B), x = r.mul(w, B), E = r.mul(h, P), E = r.add(x, E), x = r.sub(L, E), E = r.add(L, E), E = r.mul(x, E), x = r.mul($, x), B = r.mul(h, B), P = r.mul(w, P), $ = r.sub(I, P), $ = r.mul(w, $), $ = r.add($, B), B = r.add(I, I), I = r.add(B, I), I = r.add(I, P), I = r.mul(I, $), E = r.add(E, I), P = r.mul(m, A), P = r.add(P, P), I = r.mul(P, $), x = r.sub(x, I), B = r.mul(P, L), B = r.add(B, B), B = r.add(B, B), new U(x, E, B);
+    }
+    // Renes-Costello-Batina exception-free addition formula.
+    // There is 30% faster Jacobian formula, but it is not complete.
+    // https://eprint.iacr.org/2015/1060, algorithm 1
+    // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
+    add(w) {
+      M(w);
+      const { X: p, Y: h, Z: y } = this, { X: m, Y: A, Z: x } = w;
+      let E = r.ZERO, B = r.ZERO, I = r.ZERO;
+      const L = s.a, P = r.mul(s.b, Xt);
+      let $ = r.mul(p, m), _ = r.mul(h, A), D = r.mul(y, x), J = r.add(p, h), H = r.add(m, A);
+      J = r.mul(J, H), H = r.add($, _), J = r.sub(J, H), H = r.add(p, y);
+      let W = r.add(m, x);
+      return H = r.mul(H, W), W = r.add($, D), H = r.sub(H, W), W = r.add(h, y), E = r.add(A, x), W = r.mul(W, E), E = r.add(_, D), W = r.sub(W, E), I = r.mul(L, H), E = r.mul(P, D), I = r.add(E, I), E = r.sub(_, I), I = r.add(_, I), B = r.mul(E, I), _ = r.add($, $), _ = r.add(_, $), D = r.mul(L, D), H = r.mul(P, H), _ = r.add(_, D), D = r.sub($, D), D = r.mul(L, D), H = r.add(H, D), $ = r.mul(_, H), B = r.add(B, $), $ = r.mul(W, H), E = r.mul(J, E), E = r.sub(E, $), $ = r.mul(J, _), I = r.mul(W, I), I = r.add(I, $), new U(E, B, I);
+    }
+    subtract(w) {
+      return this.add(w.negate());
+    }
+    is0() {
+      return this.equals(U.ZERO);
+    }
+    /**
+     * Constant time multiplication.
+     * Uses wNAF method. Windowed method may be 10% faster,
+     * but takes 2x longer to generate and consumes 2x memory.
+     * Uses precomputes when available.
+     * Uses endomorphism for Koblitz curves.
+     * @param scalar by which the point would be multiplied
+     * @returns New point
+     */
+    multiply(w) {
+      const { endo: p } = e;
+      if (!o.isValidNot0(w))
+        throw new Error("invalid scalar: out of range");
+      let h, y;
+      const m = (A) => gt.cached(this, A, (x) => ur(U, x));
+      if (p) {
+        const { k1neg: A, k1: x, k2neg: E, k2: B } = C(w), { p: I, f: L } = m(x), { p: P, f: $ } = m(B);
+        y = L.add($), h = Tt(p.beta, I, P, A, E);
+      } else {
+        const { p: A, f: x } = m(w);
+        h = A, y = x;
+      }
+      return ur(U, [h, y])[0];
+    }
+    /**
+     * Non-constant-time multiplication. Uses double-and-add algorithm.
+     * It's faster, but should only be used when you don't care about
+     * an exposed secret key e.g. sig verification, which works over *public* keys.
+     */
+    multiplyUnsafe(w) {
+      const { endo: p } = e, h = this;
+      if (!o.isValid(w))
+        throw new Error("invalid scalar: out of range");
+      if (w === it || h.is0())
+        return U.ZERO;
+      if (w === It)
+        return h;
+      if (gt.hasCache(this))
+        return this.multiply(w);
+      if (p) {
+        const { k1neg: y, k1: m, k2neg: A, k2: x } = C(w), { p1: E, p2: B } = Po(U, h, m, x);
+        return Tt(p.beta, E, B, y, A);
+      } else
+        return gt.unsafe(h, w);
+    }
+    /**
+     * Converts Projective point to affine (x, y) coordinates.
+     * @param invertedZ Z^-1 (inverted zero) - optional, precomputation is useful for invertBatch
+     */
+    toAffine(w) {
+      return z(this, w);
+    }
+    /**
+     * Checks whether Point is free of torsion elements (is in prime subgroup).
+     * Always torsion-free for cofactor=1 curves.
+     */
+    isTorsionFree() {
+      const { isTorsionFree: w } = e;
+      return i === It ? !0 : w ? w(U, this) : gt.unsafe(this, c).is0();
+    }
+    clearCofactor() {
+      const { clearCofactor: w } = e;
+      return i === It ? this : w ? w(U, this) : this.multiplyUnsafe(i);
+    }
+    isSmallOrder() {
+      return this.multiplyUnsafe(i).is0();
+    }
+    toBytes(w = !0) {
+      return ie(w, "isCompressed"), this.assertValidity(), l(U, this, w);
+    }
+    toHex(w = !0) {
+      return le(this.toBytes(w));
+    }
+    toString() {
+      return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+    }
+  }
+  const Ft = o.BITS, gt = new ko(U, e.endo ? Math.ceil(Ft / 2) : Ft);
+  return U.BASE.precompute(8), U;
+}
+function en(t) {
+  return Uint8Array.of(t ? 2 : 3);
+}
+function rn(t, e) {
+  return {
+    secretKey: e.BYTES,
+    publicKey: 1 + t.BYTES,
+    publicKeyUncompressed: 1 + 2 * t.BYTES,
+    publicKeyHasPrefix: !0,
+    signature: 2 * e.BYTES
+  };
+}
+function Co(t, e = {}) {
+  const { Fn: n } = t, r = e.randomBytes || pe, o = Object.assign(rn(t.Fp, n), { seed: Zr(n.ORDER) });
+  function s(l) {
+    try {
+      const b = n.fromBytes(l);
+      return n.isValidNot0(b);
+    } catch {
+      return !1;
+    }
+  }
+  function i(l, b) {
+    const { publicKey: v, publicKeyUncompressed: S } = o;
+    try {
+      const O = l.length;
+      return b === !0 && O !== v || b === !1 && O !== S ? !1 : !!t.fromBytes(l);
+    } catch {
+      return !1;
+    }
+  }
+  function c(l = r(o.seed)) {
+    return zr(k(l, o.seed, "seed"), n.ORDER);
+  }
+  function a(l, b = !0) {
+    return t.BASE.multiply(n.fromBytes(l)).toBytes(b);
+  }
+  function f(l) {
+    const { secretKey: b, publicKey: v, publicKeyUncompressed: S } = o;
+    if (!Ke(l) || "_lengths" in n && n._lengths || b === v)
+      return;
+    const O = k(l, void 0, "key").length;
+    return O === v || O === S;
+  }
+  function d(l, b, v = !0) {
+    if (f(l) === !0)
+      throw new Error("first arg must be private key");
+    if (f(b) === !1)
+      throw new Error("second arg must be public key");
+    const S = n.fromBytes(l);
+    return t.fromBytes(b).multiply(S).toBytes(v);
+  }
+  const u = {
+    isValidSecretKey: s,
+    isValidPublicKey: i,
+    randomSecretKey: c
+  }, g = Xr(c, a);
+  return Object.freeze({ getPublicKey: a, getSharedSecret: d, keygen: g, Point: t, utils: u, lengths: o });
+}
+function Do(t, e, n = {}) {
+  Ur(e), We(n, {}, {
+    hmac: "function",
+    lowS: "boolean",
+    randomBytes: "function",
+    bits2int: "function",
+    bits2int_modN: "function"
+  }), n = Object.assign({}, n);
+  const r = n.randomBytes || pe, o = n.hmac || ((p, h) => Jr(e, p, h)), { Fp: s, Fn: i } = t, { ORDER: c, BITS: a } = i, { keygen: f, getPublicKey: d, getSharedSecret: u, utils: g, lengths: l } = Co(t, n), b = {
+    prehash: !0,
+    lowS: typeof n.lowS == "boolean" ? n.lowS : !0,
+    format: "compact",
+    extraEntropy: !1
+  }, v = c * tn < s.ORDER;
+  function S(p) {
+    const h = c >> It;
+    return p > h;
+  }
+  function O(p, h) {
+    if (!i.isValidNot0(h))
+      throw new Error(`invalid signature ${p}: out of range 1..Point.Fn.ORDER`);
+    return h;
+  }
+  function V() {
+    if (v)
+      throw new Error('"recovered" sig type is not supported for cofactor >2 curves');
+  }
+  function F(p, h) {
+    _e(h);
+    const y = l.signature, m = h === "compact" ? y : h === "recovered" ? y + 1 : void 0;
+    return k(p, m);
+  }
+  class M {
+    r;
+    s;
+    recovery;
+    constructor(h, y, m) {
+      if (this.r = O("r", h), this.s = O("s", y), m != null) {
+        if (V(), ![0, 1, 2, 3].includes(m))
+          throw new Error("invalid recovery id");
+        this.recovery = m;
+      }
+      Object.freeze(this);
+    }
+    static fromBytes(h, y = b.format) {
+      F(h, y);
+      let m;
+      if (y === "der") {
+        const { r: B, s: I } = pt.toSig(k(h));
+        return new M(B, I);
+      }
+      y === "recovered" && (m = h[0], y = "compact", h = h.subarray(1));
+      const A = l.signature / 2, x = h.subarray(0, A), E = h.subarray(A, A * 2);
+      return new M(i.fromBytes(x), i.fromBytes(E), m);
+    }
+    static fromHex(h, y) {
+      return this.fromBytes(se(h), y);
+    }
+    assertRecovery() {
+      const { recovery: h } = this;
+      if (h == null)
+        throw new Error("invalid recovery id: must be present");
+      return h;
+    }
+    addRecoveryBit(h) {
+      return new M(this.r, this.s, h);
+    }
+    recoverPublicKey(h) {
+      const { r: y, s: m } = this, A = this.assertRecovery(), x = A === 2 || A === 3 ? y + c : y;
+      if (!s.isValid(x))
+        throw new Error("invalid recovery id: sig.r+curve.n != R.x");
+      const E = s.toBytes(x), B = t.fromBytes(et(en((A & 1) === 0), E)), I = i.inv(x), L = z(k(h, void 0, "msgHash")), P = i.create(-L * I), $ = i.create(m * I), _ = t.BASE.multiplyUnsafe(P).add(B.multiplyUnsafe($));
+      if (_.is0())
+        throw new Error("invalid recovery: point at infinify");
+      return _.assertValidity(), _;
+    }
+    // Signatures should be low-s, to prevent malleability.
+    hasHighS() {
+      return S(this.s);
+    }
+    toBytes(h = b.format) {
+      if (_e(h), h === "der")
+        return se(pt.hexFromSig(this));
+      const { r: y, s: m } = this, A = i.toBytes(y), x = i.toBytes(m);
+      return h === "recovered" ? (V(), et(Uint8Array.of(this.assertRecovery()), A, x)) : et(A, x);
+    }
+    toHex(h) {
+      return le(this.toBytes(h));
+    }
+  }
+  const C = n.bits2int || function(h) {
+    if (h.length > 8192)
+      throw new Error("input is too large");
+    const y = ut(h), m = h.length * 8 - a;
+    return m > 0 ? y >> BigInt(m) : y;
+  }, z = n.bits2int_modN || function(h) {
+    return i.create(C(h));
+  }, Ae = Me(a);
+  function Tt(p) {
+    return bo("num < 2^" + a, p, it, Ae), i.toBytes(p);
+  }
+  function U(p, h) {
+    return k(p, void 0, "message"), h ? k(e(p), void 0, "prehashed message") : p;
+  }
+  function Ft(p, h, y) {
+    const { lowS: m, prehash: A, extraEntropy: x } = $e(y, b);
+    p = U(p, A);
+    const E = z(p), B = i.fromBytes(h);
+    if (!i.isValidNot0(B))
+      throw new Error("invalid private key");
+    const I = [Tt(B), Tt(E)];
+    if (x != null && x !== !1) {
+      const _ = x === !0 ? r(l.secretKey) : x;
+      I.push(k(_, void 0, "extraEntropy"));
+    }
+    const L = et(...I), P = E;
+    function $(_) {
+      const D = C(_);
+      if (!i.isValidNot0(D))
+        return;
+      const J = i.inv(D), H = t.BASE.multiply(D).toAffine(), W = i.create(H.x);
+      if (W === it)
+        return;
+      const Zt = i.create(J * i.create(P + W * B));
+      if (Zt === it)
+        return;
+      let Je = (H.x === W ? 0 : 2) | Number(H.y & It), tr = Zt;
+      return m && S(Zt) && (tr = i.neg(Zt), Je ^= 1), new M(W, tr, v ? void 0 : Je);
+    }
+    return { seed: L, k2sig: $ };
+  }
+  function gt(p, h, y = {}) {
+    const { seed: m, k2sig: A } = Ft(p, h, y);
+    return mo(e.outputLen, i.BYTES, o)(m, A).toBytes(y.format);
+  }
+  function R(p, h, y, m = {}) {
+    const { lowS: A, prehash: x, format: E } = $e(m, b);
+    if (y = k(y, void 0, "publicKey"), h = U(h, x), !Ke(p)) {
+      const B = p instanceof M ? ", use sig.toBytes()" : "";
+      throw new Error("verify expects Uint8Array signature" + B);
+    }
+    F(p, E);
+    try {
+      const B = M.fromBytes(p, E), I = t.fromBytes(y);
+      if (A && B.hasHighS())
+        return !1;
+      const { r: L, s: P } = B, $ = z(h), _ = i.inv(P), D = i.create($ * _), J = i.create(L * _), H = t.BASE.multiplyUnsafe(D).add(I.multiplyUnsafe(J));
+      return H.is0() ? !1 : i.create(H.x) === L;
+    } catch {
+      return !1;
+    }
+  }
+  function w(p, h, y = {}) {
+    const { prehash: m } = $e(y, b);
+    return h = U(h, m), M.fromBytes(p, "recovered").recoverPublicKey(h).toBytes();
+  }
+  return Object.freeze({
+    keygen: f,
+    getPublicKey: d,
+    getSharedSecret: u,
+    utils: g,
+    lengths: l,
+    Point: t,
+    sign: gt,
+    verify: R,
+    recoverPublicKey: w,
+    Signature: M,
+    hash: e
+  });
+}
+const ye = {
+  p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),
+  n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),
+  h: BigInt(1),
+  a: BigInt(0),
+  b: BigInt(7),
+  Gx: BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
+  Gy: BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")
+}, Ko = {
+  beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
+  basises: [
+    [BigInt("0x3086d221a7d46bcde86c90e49284eb15"), -BigInt("0xe4437ed6010e88286f547fa90abfe4c3")],
+    [BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), BigInt("0x3086d221a7d46bcde86c90e49284eb15")]
+  ]
+}, Vo = /* @__PURE__ */ BigInt(0), He = /* @__PURE__ */ BigInt(2);
+function Mo(t) {
+  const e = ye.p, n = BigInt(3), r = BigInt(6), o = BigInt(11), s = BigInt(22), i = BigInt(23), c = BigInt(44), a = BigInt(88), f = t * t * t % e, d = f * f * t % e, u = G(d, n, e) * d % e, g = G(u, n, e) * d % e, l = G(g, He, e) * f % e, b = G(l, o, e) * l % e, v = G(b, s, e) * b % e, S = G(v, c, e) * v % e, O = G(S, a, e) * S % e, V = G(O, c, e) * v % e, F = G(V, n, e) * d % e, M = G(F, i, e) * b % e, C = G(M, r, e) * f % e, z = G(C, He, e);
+  if (!ae.eql(ae.sqr(z), t))
+    throw new Error("Cannot find square root");
+  return z;
+}
+const ae = ge(ye.p, { sqrt: Mo }), Bt = /* @__PURE__ */ No(ye, {
+  Fp: ae,
+  endo: Ko
+}), vt = /* @__PURE__ */ Do(Bt, at), wr = {};
+function fe(t, ...e) {
+  let n = wr[t];
+  if (n === void 0) {
+    const r = at(go(t));
+    n = et(r, r), wr[t] = n;
+  }
+  return at(et(n, ...e));
+}
+const je = (t) => t.toBytes(!0).slice(1), Fe = (t) => t % He === Vo;
+function Le(t) {
+  const { Fn: e, BASE: n } = Bt, r = e.fromBytes(t), o = n.multiply(r);
+  return { scalar: Fe(o.y) ? r : e.neg(r), bytes: je(o) };
+}
+function nn(t) {
+  const e = ae;
+  if (!e.isValidNot0(t))
+    throw new Error("invalid x: Fail if x ≥ p");
+  const n = e.create(t * t), r = e.create(n * t + BigInt(7));
+  let o = e.sqrt(r);
+  Fe(o) || (o = e.neg(o));
+  const s = Bt.fromAffine({ x: t, y: o });
+  return s.assertValidity(), s;
+}
+const Dt = ut;
+function on(...t) {
+  return Bt.Fn.create(Dt(fe("BIP0340/challenge", ...t)));
+}
+function gr(t) {
+  return Le(t).bytes;
+}
+function Wo(t, e, n = pe(32)) {
+  const { Fn: r } = Bt, o = k(t, void 0, "message"), { bytes: s, scalar: i } = Le(e), c = k(n, 32, "auxRand"), a = r.toBytes(i ^ Dt(fe("BIP0340/aux", c))), f = fe("BIP0340/nonce", a, s, o), { bytes: d, scalar: u } = Le(f), g = on(d, s, o), l = new Uint8Array(64);
+  if (l.set(d, 0), l.set(r.toBytes(r.create(u + g * i)), 32), !sn(l, o, s))
+    throw new Error("sign: Invalid signature produced");
+  return l;
+}
+function sn(t, e, n) {
+  const { Fp: r, Fn: o, BASE: s } = Bt, i = k(t, 64, "signature"), c = k(e, void 0, "message"), a = k(n, 32, "publicKey");
+  try {
+    const f = nn(Dt(a)), d = Dt(i.subarray(0, 32));
+    if (!r.isValidNot0(d))
+      return !1;
+    const u = Dt(i.subarray(32, 64));
+    if (!o.isValidNot0(u))
+      return !1;
+    const g = on(o.toBytes(d), je(f), c), l = s.multiplyUnsafe(u).add(f.multiplyUnsafe(o.neg(g))), { x: b, y: v } = l.toAffine();
+    return !(l.is0() || !Fe(v) || b !== d);
+  } catch {
+    return !1;
+  }
+}
+const St = /* @__PURE__ */ (() => {
+  const n = (r = pe(48)) => zr(r, ye.n);
+  return {
+    keygen: Xr(n, gr),
+    getPublicKey: gr,
+    sign: Wo,
+    verify: sn,
+    Point: Bt,
+    utils: {
+      randomSecretKey: n,
+      taggedHash: fe,
+      lift_x: nn,
+      pointToBytes: je
+    },
+    lengths: {
+      secretKey: 32,
+      publicKey: 32,
+      publicKeyHasPrefix: !1,
+      signature: 64,
+      seed: 48
+    }
+  };
+})(), qo = /* @__PURE__ */ Uint8Array.from([
+  7,
+  4,
+  13,
+  1,
+  10,
+  6,
+  15,
+  3,
+  12,
+  0,
+  9,
+  5,
+  2,
+  14,
+  11,
+  8
+]), cn = Uint8Array.from(new Array(16).fill(0).map((t, e) => e)), jo = cn.map((t) => (9 * t + 5) % 16), an = /* @__PURE__ */ (() => {
+  const n = [[cn], [jo]];
+  for (let r = 0; r < 4; r++)
+    for (let o of n)
+      o.push(o[r].map((s) => qo[s]));
+  return n;
+})(), fn = an[0], un = an[1], dn = /* @__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((t) => Uint8Array.from(t)), Fo = /* @__PURE__ */ fn.map((t, e) => t.map((n) => dn[e][n])), Zo = /* @__PURE__ */ un.map((t, e) => t.map((n) => dn[e][n])), zo = /* @__PURE__ */ Uint32Array.from([
+  0,
+  1518500249,
+  1859775393,
+  2400959708,
+  2840853838
+]), Go = /* @__PURE__ */ Uint32Array.from([
+  1352829926,
+  1548603684,
+  1836072691,
+  2053994217,
+  0
+]);
+function yr(t, e, n, r) {
+  return t === 0 ? e ^ n ^ r : t === 1 ? e & n | ~e & r : t === 2 ? (e | ~n) ^ r : t === 3 ? e & r | n & ~r : e ^ (n | ~r);
+}
+const Qt = /* @__PURE__ */ new Uint32Array(16);
+class Yo extends _r {
+  h0 = 1732584193;
+  h1 = -271733879;
+  h2 = -1732584194;
+  h3 = 271733878;
+  h4 = -1009589776;
+  constructor() {
+    super(64, 20, 8, !0);
+  }
+  get() {
+    const { h0: e, h1: n, h2: r, h3: o, h4: s } = this;
+    return [e, n, r, o, s];
+  }
+  set(e, n, r, o, s) {
+    this.h0 = e | 0, this.h1 = n | 0, this.h2 = r | 0, this.h3 = o | 0, this.h4 = s | 0;
+  }
+  process(e, n) {
+    for (let l = 0; l < 16; l++, n += 4)
+      Qt[l] = e.getUint32(n, !0);
+    let r = this.h0 | 0, o = r, s = this.h1 | 0, i = s, c = this.h2 | 0, a = c, f = this.h3 | 0, d = f, u = this.h4 | 0, g = u;
+    for (let l = 0; l < 5; l++) {
+      const b = 4 - l, v = zo[l], S = Go[l], O = fn[l], V = un[l], F = Fo[l], M = Zo[l];
+      for (let C = 0; C < 16; C++) {
+        const z = Gt(r + yr(l, s, c, f) + Qt[O[C]] + v, F[C]) + u | 0;
+        r = u, u = f, f = Gt(c, 10) | 0, c = s, s = z;
+      }
+      for (let C = 0; C < 16; C++) {
+        const z = Gt(o + yr(b, i, a, d) + Qt[V[C]] + S, M[C]) + g | 0;
+        o = g, g = d, d = Gt(a, 10) | 0, a = i, i = z;
+      }
+    }
+    this.set(this.h1 + c + d | 0, this.h2 + f + g | 0, this.h3 + u + o | 0, this.h4 + r + i | 0, this.h0 + s + a | 0);
+  }
+  roundClean() {
+    Ot(Qt);
+  }
+  destroy() {
+    this.destroyed = !0, Ot(this.buffer), this.set(0, 0, 0, 0, 0);
+  }
+}
+const Xo = /* @__PURE__ */ Pr(() => new Yo()), Qo = /* @__PURE__ */ Uint8Array.of(), si = /* @__PURE__ */ Uint8Array.of(0);
+function Ut(t, e) {
+  if (t.length !== e.length)
+    return !1;
+  for (let n = 0; n < t.length; n++)
+    if (t[n] !== e[n])
+      return !1;
+  return !0;
+}
+function Y(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function Jo(...t) {
+  let e = 0;
+  for (let r = 0; r < t.length; r++) {
+    const o = t[r];
+    if (!Y(o))
+      throw new Error("Uint8Array expected");
+    e += o.length;
+  }
+  const n = new Uint8Array(e);
+  for (let r = 0, o = 0; r < t.length; r++) {
+    const s = t[r];
+    n.set(s, o), o += s.length;
+  }
+  return n;
+}
+const hn = (t) => new DataView(t.buffer, t.byteOffset, t.byteLength);
+function Wt(t) {
+  return Object.prototype.toString.call(t) === "[object Object]";
+}
+function ot(t) {
+  return Number.isSafeInteger(t);
+}
+const Ze = {
+  equalBytes: Ut,
+  isBytes: Y,
+  concatBytes: Jo
+}, ln = (t) => {
+  if (t !== null && typeof t != "string" && !Q(t) && !Y(t) && !ot(t))
+    throw new Error(`lengthCoder: expected null | number | Uint8Array | CoderType, got ${t} (${typeof t})`);
+  return {
+    encodeStream(e, n) {
+      if (t === null)
+        return;
+      if (Q(t))
+        return t.encodeStream(e, n);
+      let r;
+      if (typeof t == "number" ? r = t : typeof t == "string" && (r = ft.resolve(e.stack, t)), typeof r == "bigint" && (r = Number(r)), r === void 0 || r !== n)
+        throw e.err(`Wrong length: ${r} len=${t} exp=${n} (${typeof n})`);
+    },
+    decodeStream(e) {
+      let n;
+      if (Q(t) ? n = Number(t.decodeStream(e)) : typeof t == "number" ? n = t : typeof t == "string" && (n = ft.resolve(e.stack, t)), typeof n == "bigint" && (n = Number(n)), typeof n != "number")
+        throw e.err(`Wrong length: ${n}`);
+      return n;
+    }
+  };
+}, T = {
+  BITS: 32,
+  FULL_MASK: -1 >>> 0,
+  // 1<<32 will overflow
+  len: (t) => Math.ceil(t / 32),
+  create: (t) => new Uint32Array(T.len(t)),
+  clean: (t) => t.fill(0),
+  debug: (t) => Array.from(t).map((e) => (e >>> 0).toString(2).padStart(32, "0")),
+  checkLen: (t, e) => {
+    if (T.len(e) !== t.length)
+      throw new Error(`wrong length=${t.length}. Expected: ${T.len(e)}`);
+  },
+  chunkLen: (t, e, n) => {
+    if (e < 0)
+      throw new Error(`wrong pos=${e}`);
+    if (e + n > t)
+      throw new Error(`wrong range=${e}/${n} of ${t}`);
+  },
+  set: (t, e, n, r = !0) => !r && (t[e] & n) !== 0 ? !1 : (t[e] |= n, !0),
+  pos: (t, e) => ({
+    chunk: Math.floor((t + e) / 32),
+    mask: 1 << 32 - (t + e) % 32 - 1
+  }),
+  indices: (t, e, n = !1) => {
+    T.checkLen(t, e);
+    const { FULL_MASK: r, BITS: o } = T, s = o - e % o, i = s ? r >>> s << s : r, c = [];
+    for (let a = 0; a < t.length; a++) {
+      let f = t[a];
+      if (n && (f = ~f), a === t.length - 1 && (f &= i), f !== 0)
+        for (let d = 0; d < o; d++) {
+          const u = 1 << o - d - 1;
+          f & u && c.push(a * o + d);
+        }
+    }
+    return c;
+  },
+  range: (t) => {
+    const e = [];
+    let n;
+    for (const r of t)
+      n === void 0 || r !== n.pos + n.length ? e.push(n = { pos: r, length: 1 }) : n.length += 1;
+    return e;
+  },
+  rangeDebug: (t, e, n = !1) => `[${T.range(T.indices(t, e, n)).map((r) => `(${r.pos}/${r.length})`).join(", ")}]`,
+  setRange: (t, e, n, r, o = !0) => {
+    T.chunkLen(e, n, r);
+    const { FULL_MASK: s, BITS: i } = T, c = n % i ? Math.floor(n / i) : void 0, a = n + r, f = a % i ? Math.floor(a / i) : void 0;
+    if (c !== void 0 && c === f)
+      return T.set(t, c, s >>> i - r << i - r - n, o);
+    if (c !== void 0 && !T.set(t, c, s >>> n % i, o))
+      return !1;
+    const d = c !== void 0 ? c + 1 : n / i, u = f !== void 0 ? f : a / i;
+    for (let g = d; g < u; g++)
+      if (!T.set(t, g, s, o))
+        return !1;
+    return !(f !== void 0 && c !== f && !T.set(t, f, s << i - a % i, o));
+  }
+}, ft = {
+  /**
+   * Internal method for handling stack of paths (debug, errors, dynamic fields via path)
+   * This is looks ugly (callback), but allows us to force stack cleaning by construction (.pop always after function).
+   * Also, this makes impossible:
+   * - pushing field when stack is empty
+   * - pushing field inside of field (real bug)
+   * NOTE: we don't want to do '.pop' on error!
+   */
+  pushObj: (t, e, n) => {
+    const r = { obj: e };
+    t.push(r), n((o, s) => {
+      r.field = o, s(), r.field = void 0;
+    }), t.pop();
+  },
+  path: (t) => {
+    const e = [];
+    for (const n of t)
+      n.field !== void 0 && e.push(n.field);
+    return e.join("/");
+  },
+  err: (t, e, n) => {
+    const r = new Error(`${t}(${ft.path(e)}): ${typeof n == "string" ? n : n.message}`);
+    return n instanceof Error && n.stack && (r.stack = n.stack), r;
+  },
+  resolve: (t, e) => {
+    const n = e.split("/"), r = t.map((i) => i.obj);
+    let o = 0;
+    for (; o < n.length && n[o] === ".."; o++)
+      r.pop();
+    let s = r.pop();
+    for (; o < n.length; o++) {
+      if (!s || s[n[o]] === void 0)
+        return;
+      s = s[n[o]];
+    }
+    return s;
+  }
+};
+class ze {
+  pos = 0;
+  data;
+  opts;
+  stack;
+  parent;
+  parentOffset;
+  bitBuf = 0;
+  bitPos = 0;
+  bs;
+  // bitset
+  view;
+  constructor(e, n = {}, r = [], o = void 0, s = 0) {
+    this.data = e, this.opts = n, this.stack = r, this.parent = o, this.parentOffset = s, this.view = hn(e);
+  }
+  /** Internal method for pointers. */
+  _enablePointers() {
+    if (this.parent)
+      return this.parent._enablePointers();
+    this.bs || (this.bs = T.create(this.data.length), T.setRange(this.bs, this.data.length, 0, this.pos, this.opts.allowMultipleReads));
+  }
+  markBytesBS(e, n) {
+    return this.parent ? this.parent.markBytesBS(this.parentOffset + e, n) : !n || !this.bs ? !0 : T.setRange(this.bs, this.data.length, e, n, !1);
+  }
+  markBytes(e) {
+    const n = this.pos;
+    this.pos += e;
+    const r = this.markBytesBS(n, e);
+    if (!this.opts.allowMultipleReads && !r)
+      throw this.err(`multiple read pos=${this.pos} len=${e}`);
+    return r;
+  }
+  pushObj(e, n) {
+    return ft.pushObj(this.stack, e, n);
+  }
+  readView(e, n) {
+    if (!Number.isFinite(e))
+      throw this.err(`readView: wrong length=${e}`);
+    if (this.pos + e > this.data.length)
+      throw this.err("readView: Unexpected end of buffer");
+    const r = n(this.view, this.pos);
+    return this.markBytes(e), r;
+  }
+  // read bytes by absolute offset
+  absBytes(e) {
+    if (e > this.data.length)
+      throw new Error("Unexpected end of buffer");
+    return this.data.subarray(e);
+  }
+  finish() {
+    if (!this.opts.allowUnreadBytes) {
+      if (this.bitPos)
+        throw this.err(`${this.bitPos} bits left after unpack: ${rt.encode(this.data.slice(this.pos))}`);
+      if (this.bs && !this.parent) {
+        const e = T.indices(this.bs, this.data.length, !0);
+        if (e.length) {
+          const n = T.range(e).map(({ pos: r, length: o }) => `(${r}/${o})[${rt.encode(this.data.subarray(r, r + o))}]`).join(", ");
+          throw this.err(`unread byte ranges: ${n} (total=${this.data.length})`);
+        } else
+          return;
+      }
+      if (!this.isEnd())
+        throw this.err(`${this.leftBytes} bytes ${this.bitPos} bits left after unpack: ${rt.encode(this.data.slice(this.pos))}`);
+    }
+  }
+  // User methods
+  err(e) {
+    return ft.err("Reader", this.stack, e);
+  }
+  offsetReader(e) {
+    if (e > this.data.length)
+      throw this.err("offsetReader: Unexpected end of buffer");
+    return new ze(this.absBytes(e), this.opts, this.stack, this, e);
+  }
+  bytes(e, n = !1) {
+    if (this.bitPos)
+      throw this.err("readBytes: bitPos not empty");
+    if (!Number.isFinite(e))
+      throw this.err(`readBytes: wrong length=${e}`);
+    if (this.pos + e > this.data.length)
+      throw this.err("readBytes: Unexpected end of buffer");
+    const r = this.data.subarray(this.pos, this.pos + e);
+    return n || this.markBytes(e), r;
+  }
+  byte(e = !1) {
+    if (this.bitPos)
+      throw this.err("readByte: bitPos not empty");
+    if (this.pos + 1 > this.data.length)
+      throw this.err("readBytes: Unexpected end of buffer");
+    const n = this.data[this.pos];
+    return e || this.markBytes(1), n;
+  }
+  get leftBytes() {
+    return this.data.length - this.pos;
+  }
+  get totalBytes() {
+    return this.data.length;
+  }
+  isEnd() {
+    return this.pos >= this.data.length && !this.bitPos;
+  }
+  // bits are read in BE mode (left to right): (0b1000_0000).readBits(1) == 1
+  bits(e) {
+    if (e > 32)
+      throw this.err("BitReader: cannot read more than 32 bits in single call");
+    let n = 0;
+    for (; e; ) {
+      this.bitPos || (this.bitBuf = this.byte(), this.bitPos = 8);
+      const r = Math.min(e, this.bitPos);
+      this.bitPos -= r, n = n << r | this.bitBuf >> this.bitPos & 2 ** r - 1, this.bitBuf &= 2 ** this.bitPos - 1, e -= r;
+    }
+    return n >>> 0;
+  }
+  find(e, n = this.pos) {
+    if (!Y(e))
+      throw this.err(`find: needle is not bytes! ${e}`);
+    if (this.bitPos)
+      throw this.err("findByte: bitPos not empty");
+    if (!e.length)
+      throw this.err("find: needle is empty");
+    for (let r = n; (r = this.data.indexOf(e[0], r)) !== -1; r++) {
+      if (r === -1 || this.data.length - r < e.length)
+        return;
+      if (Ut(e, this.data.subarray(r, r + e.length)))
+        return r;
+    }
+  }
+}
+class ts {
+  pos = 0;
+  stack;
+  // We could have a single buffer here and re-alloc it with
+  // x1.5-2 size each time it full, but it will be slower:
+  // basic/encode bench: 395ns -> 560ns
+  buffers = [];
+  ptrs = [];
+  bitBuf = 0;
+  bitPos = 0;
+  viewBuf = new Uint8Array(8);
+  view;
+  finished = !1;
+  constructor(e = []) {
+    this.stack = e, this.view = hn(this.viewBuf);
+  }
+  pushObj(e, n) {
+    return ft.pushObj(this.stack, e, n);
+  }
+  writeView(e, n) {
+    if (this.finished)
+      throw this.err("buffer: finished");
+    if (!ot(e) || e > 8)
+      throw new Error(`wrong writeView length=${e}`);
+    n(this.view), this.bytes(this.viewBuf.slice(0, e)), this.viewBuf.fill(0);
+  }
+  // User methods
+  err(e) {
+    if (this.finished)
+      throw this.err("buffer: finished");
+    return ft.err("Reader", this.stack, e);
+  }
+  bytes(e) {
+    if (this.finished)
+      throw this.err("buffer: finished");
+    if (this.bitPos)
+      throw this.err("writeBytes: ends with non-empty bit buffer");
+    this.buffers.push(e), this.pos += e.length;
+  }
+  byte(e) {
+    if (this.finished)
+      throw this.err("buffer: finished");
+    if (this.bitPos)
+      throw this.err("writeByte: ends with non-empty bit buffer");
+    this.buffers.push(new Uint8Array([e])), this.pos++;
+  }
+  finish(e = !0) {
+    if (this.finished)
+      throw this.err("buffer: finished");
+    if (this.bitPos)
+      throw this.err("buffer: ends with non-empty bit buffer");
+    const n = this.buffers.concat(this.ptrs.map((s) => s.buffer)), r = n.map((s) => s.length).reduce((s, i) => s + i, 0), o = new Uint8Array(r);
+    for (let s = 0, i = 0; s < n.length; s++) {
+      const c = n[s];
+      o.set(c, i), i += c.length;
+    }
+    for (let s = this.pos, i = 0; i < this.ptrs.length; i++) {
+      const c = this.ptrs[i];
+      o.set(c.ptr.encode(s), c.pos), s += c.buffer.length;
+    }
+    if (e) {
+      this.buffers = [];
+      for (const s of this.ptrs)
+        s.buffer.fill(0);
+      this.ptrs = [], this.finished = !0, this.bitBuf = 0;
+    }
+    return o;
+  }
+  bits(e, n) {
+    if (n > 32)
+      throw this.err("writeBits: cannot write more than 32 bits in single call");
+    if (e >= 2 ** n)
+      throw this.err(`writeBits: value (${e}) >= 2**bits (${n})`);
+    for (; n; ) {
+      const r = Math.min(n, 8 - this.bitPos);
+      this.bitBuf = this.bitBuf << r | e >> n - r, this.bitPos += r, n -= r, e &= 2 ** n - 1, this.bitPos === 8 && (this.bitPos = 0, this.buffers.push(new Uint8Array([this.bitBuf])), this.pos++);
+    }
+  }
+}
+const Te = (t) => Uint8Array.from(t).reverse();
+function es(t, e, n) {
+  if (n) {
+    const r = 2n ** (e - 1n);
+    if (t < -r || t >= r)
+      throw new Error(`value out of signed bounds. Expected ${-r} <= ${t} < ${r}`);
+  } else if (0n > t || t >= 2n ** e)
+    throw new Error(`value out of unsigned bounds. Expected 0 <= ${t} < ${2n ** e}`);
+}
+function pn(t) {
+  return {
+    // NOTE: we cannot export validate here, since it is likely mistake.
+    encodeStream: t.encodeStream,
+    decodeStream: t.decodeStream,
+    size: t.size,
+    encode: (e) => {
+      const n = new ts();
+      return t.encodeStream(n, e), n.finish();
+    },
+    decode: (e, n = {}) => {
+      const r = new ze(e, n), o = t.decodeStream(r);
+      return r.finish(), o;
+    }
+  };
+}
+function be(t, e) {
+  if (!Q(t))
+    throw new Error(`validate: invalid inner value ${t}`);
+  if (typeof e != "function")
+    throw new Error("validate: fn should be function");
+  return pn({
+    size: t.size,
+    encodeStream: (n, r) => {
+      let o;
+      try {
+        o = e(r);
+      } catch (s) {
+        throw n.err(s);
+      }
+      t.encodeStream(n, o);
+    },
+    decodeStream: (n) => {
+      const r = t.decodeStream(n);
+      try {
+        return e(r);
+      } catch (o) {
+        throw n.err(o);
+      }
+    }
+  });
+}
+const Z = (t) => {
+  const e = pn(t);
+  return t.validate ? be(e, t.validate) : e;
+}, Ee = (t) => Wt(t) && typeof t.decode == "function" && typeof t.encode == "function";
+function Q(t) {
+  return Wt(t) && Ee(t) && typeof t.encodeStream == "function" && typeof t.decodeStream == "function" && (t.size === void 0 || ot(t.size));
+}
+function rs() {
+  return {
+    encode: (t) => {
+      if (!Array.isArray(t))
+        throw new Error("array expected");
+      const e = {};
+      for (const n of t) {
+        if (!Array.isArray(n) || n.length !== 2)
+          throw new Error("array of two elements expected");
+        const r = n[0], o = n[1];
+        if (e[r] !== void 0)
+          throw new Error(`key(${r}) appears twice in struct`);
+        e[r] = o;
+      }
+      return e;
+    },
+    decode: (t) => {
+      if (!Wt(t))
+        throw new Error(`expected plain object, got ${t}`);
+      return Object.entries(t);
+    }
+  };
+}
+const ns = {
+  encode: (t) => {
+    if (typeof t != "bigint")
+      throw new Error(`expected bigint, got ${typeof t}`);
+    if (t > BigInt(Number.MAX_SAFE_INTEGER))
+      throw new Error(`element bigger than MAX_SAFE_INTEGER=${t}`);
+    return Number(t);
+  },
+  decode: (t) => {
+    if (!ot(t))
+      throw new Error("element is not a safe integer");
+    return BigInt(t);
+  }
+};
+function os(t) {
+  if (!Wt(t))
+    throw new Error("plain object expected");
+  return {
+    encode: (e) => {
+      if (!ot(e) || !(e in t))
+        throw new Error(`wrong value ${e}`);
+      return t[e];
+    },
+    decode: (e) => {
+      if (typeof e != "string")
+        throw new Error(`wrong value ${typeof e}`);
+      return t[e];
+    }
+  };
+}
+function ss(t, e = !1) {
+  if (!ot(t))
+    throw new Error(`decimal/precision: wrong value ${t}`);
+  if (typeof e != "boolean")
+    throw new Error(`decimal/round: expected boolean, got ${typeof e}`);
+  const n = 10n ** BigInt(t);
+  return {
+    encode: (r) => {
+      if (typeof r != "bigint")
+        throw new Error(`expected bigint, got ${typeof r}`);
+      let o = (r < 0n ? -r : r).toString(10), s = o.length - t;
+      s < 0 && (o = o.padStart(o.length - s, "0"), s = 0);
+      let i = o.length - 1;
+      for (; i >= s && o[i] === "0"; i--)
+        ;
+      let c = o.slice(0, s), a = o.slice(s, i + 1);
+      return c || (c = "0"), r < 0n && (c = "-" + c), a ? `${c}.${a}` : c;
+    },
+    decode: (r) => {
+      if (typeof r != "string")
+        throw new Error(`expected string, got ${typeof r}`);
+      if (r === "-0")
+        throw new Error("negative zero is not allowed");
+      let o = !1;
+      if (r.startsWith("-") && (o = !0, r = r.slice(1)), !/^(0|[1-9]\d*)(\.\d+)?$/.test(r))
+        throw new Error(`wrong string value=${r}`);
+      let s = r.indexOf(".");
+      s = s === -1 ? r.length : s;
+      const i = r.slice(0, s), c = r.slice(s + 1).replace(/0+$/, ""), a = BigInt(i) * n;
+      if (!e && c.length > t)
+        throw new Error(`fractional part cannot be represented with this precision (num=${r}, prec=${t})`);
+      const f = Math.min(c.length, t), d = BigInt(c.slice(0, f)) * 10n ** BigInt(t - f), u = a + d;
+      return o ? -u : u;
+    }
+  };
+}
+function is(t) {
+  if (!Array.isArray(t))
+    throw new Error(`expected array, got ${typeof t}`);
+  for (const e of t)
+    if (!Ee(e))
+      throw new Error(`wrong base coder ${e}`);
+  return {
+    encode: (e) => {
+      for (const n of t) {
+        const r = n.encode(e);
+        if (r !== void 0)
+          return r;
+      }
+      throw new Error(`match/encode: cannot find match in ${e}`);
+    },
+    decode: (e) => {
+      for (const n of t) {
+        const r = n.decode(e);
+        if (r !== void 0)
+          return r;
+      }
+      throw new Error(`match/decode: cannot find match in ${e}`);
+    }
+  };
+}
+const wn = (t) => {
+  if (!Ee(t))
+    throw new Error("BaseCoder expected");
+  return { encode: t.decode, decode: t.encode };
+}, gn = { dict: rs, numberBigint: ns, tsEnum: os, decimal: ss, match: is, reverse: wn }, Ge = (t, e = !1, n = !1, r = !0) => {
+  if (!ot(t))
+    throw new Error(`bigint/size: wrong value ${t}`);
+  if (typeof e != "boolean")
+    throw new Error(`bigint/le: expected boolean, got ${typeof e}`);
+  if (typeof n != "boolean")
+    throw new Error(`bigint/signed: expected boolean, got ${typeof n}`);
+  if (typeof r != "boolean")
+    throw new Error(`bigint/sized: expected boolean, got ${typeof r}`);
+  const o = BigInt(t), s = 2n ** (8n * o - 1n);
+  return Z({
+    size: r ? t : void 0,
+    encodeStream: (i, c) => {
+      n && c < 0 && (c = c | s);
+      const a = [];
+      for (let d = 0; d < t; d++)
+        a.push(Number(c & 255n)), c >>= 8n;
+      let f = new Uint8Array(a).reverse();
+      if (!r) {
+        let d = 0;
+        for (d = 0; d < f.length && f[d] === 0; d++)
+          ;
+        f = f.subarray(d);
+      }
+      i.bytes(e ? f.reverse() : f);
+    },
+    decodeStream: (i) => {
+      const c = i.bytes(r ? t : Math.min(t, i.leftBytes)), a = e ? c : Te(c);
+      let f = 0n;
+      for (let d = 0; d < a.length; d++)
+        f |= BigInt(a[d]) << 8n * BigInt(d);
+      return n && f & s && (f = (f ^ s) - s), f;
+    },
+    validate: (i) => {
+      if (typeof i != "bigint")
+        throw new Error(`bigint: invalid value: ${i}`);
+      return es(i, 8n * o, !!n), i;
+    }
+  });
+}, ii = /* @__PURE__ */ Ge(32, !1), cs = /* @__PURE__ */ Ge(8, !0), ci = /* @__PURE__ */ Ge(8, !0, !0), as = (t, e) => Z({
+  size: t,
+  encodeStream: (n, r) => n.writeView(t, (o) => e.write(o, r)),
+  decodeStream: (n) => n.readView(t, e.read),
+  validate: (n) => {
+    if (typeof n != "number")
+      throw new Error(`viewCoder: expected number, got ${typeof n}`);
+    return e.validate && e.validate(n), n;
+  }
+}), qt = (t, e, n) => {
+  const r = t * 8, o = 2 ** (r - 1), s = (a) => {
+    if (!ot(a))
+      throw new Error(`sintView: value is not safe integer: ${a}`);
+    if (a < -o || a >= o)
+      throw new Error(`sintView: value out of bounds. Expected ${-o} <= ${a} < ${o}`);
+  }, i = 2 ** r, c = (a) => {
+    if (!ot(a))
+      throw new Error(`uintView: value is not safe integer: ${a}`);
+    if (0 > a || a >= i)
+      throw new Error(`uintView: value out of bounds. Expected 0 <= ${a} < ${i}`);
+  };
+  return as(t, {
+    write: n.write,
+    read: n.read,
+    validate: e ? s : c
+  });
+}, xt = /* @__PURE__ */ qt(4, !1, {
+  read: (t, e) => t.getUint32(e, !0),
+  write: (t, e) => t.setUint32(0, e, !0)
+}), ai = /* @__PURE__ */ qt(4, !1, {
+  read: (t, e) => t.getUint32(e, !1),
+  write: (t, e) => t.setUint32(0, e, !1)
+}), yn = /* @__PURE__ */ qt(4, !0, {
+  read: (t, e) => t.getInt32(e, !0),
+  write: (t, e) => t.setInt32(0, e, !0)
+}), br = /* @__PURE__ */ qt(2, !1, {
+  read: (t, e) => t.getUint16(e, !0),
+  write: (t, e) => t.setUint16(0, e, !0)
+}), fs = /* @__PURE__ */ qt(1, !1, {
+  read: (t, e) => t.getUint8(e),
+  write: (t, e) => t.setUint8(0, e)
+}), jt = (t, e = !1) => {
+  if (typeof e != "boolean")
+    throw new Error(`bytes/le: expected boolean, got ${typeof e}`);
+  const n = ln(t), r = Y(t);
+  return Z({
+    size: typeof t == "number" ? t : void 0,
+    encodeStream: (o, s) => {
+      r || n.encodeStream(o, s.length), o.bytes(e ? Te(s) : s), r && o.bytes(t);
+    },
+    decodeStream: (o) => {
+      let s;
+      if (r) {
+        const i = o.find(t);
+        if (!i)
+          throw o.err("bytes: cannot find terminator");
+        s = o.bytes(i - o.pos), o.bytes(t.length);
+      } else
+        s = o.bytes(t === null ? o.leftBytes : n.decodeStream(o));
+      return e ? Te(s) : s;
+    },
+    validate: (o) => {
+      if (!Y(o))
+        throw new Error(`bytes: invalid value ${o}`);
+      return o;
+    }
+  });
+};
+function fi(t, e) {
+  if (!Q(e))
+    throw new Error(`prefix: invalid inner value ${e}`);
+  return kt(jt(t), wn(e));
+}
+const ui = (t, e = !1) => be(kt(jt(t, e), no), (n) => {
+  if (typeof n != "string")
+    throw new Error(`expected string, got ${typeof n}`);
+  return n;
+}), di = (t, e = { isLE: !1, with0x: !1 }) => {
+  let n = kt(jt(t, e.isLE), rt);
+  const r = e.with0x;
+  if (typeof r != "boolean")
+    throw new Error(`hex/with0x: expected boolean, got ${typeof r}`);
+  return r && (n = kt(n, {
+    encode: (o) => `0x${o}`,
+    decode: (o) => {
+      if (!o.startsWith("0x"))
+        throw new Error("hex(with0x=true).encode input should start with 0x");
+      return o.slice(2);
+    }
+  })), n;
+};
+function kt(t, e) {
+  if (!Q(t))
+    throw new Error(`apply: invalid inner value ${t}`);
+  if (!Ee(e))
+    throw new Error(`apply: invalid base value ${t}`);
+  return Z({
+    size: t.size,
+    encodeStream: (n, r) => {
+      let o;
+      try {
+        o = e.decode(r);
+      } catch (s) {
+        throw n.err("" + s);
+      }
+      return t.encodeStream(n, o);
+    },
+    decodeStream: (n) => {
+      const r = t.decodeStream(n);
+      try {
+        return e.encode(r);
+      } catch (o) {
+        throw n.err("" + o);
+      }
+    }
+  });
+}
+const us = (t, e = !1) => {
+  if (!Y(t))
+    throw new Error(`flag/flagValue: expected Uint8Array, got ${typeof t}`);
+  if (typeof e != "boolean")
+    throw new Error(`flag/xor: expected boolean, got ${typeof e}`);
+  return Z({
+    size: t.length,
+    encodeStream: (n, r) => {
+      !!r !== e && n.bytes(t);
+    },
+    decodeStream: (n) => {
+      let r = n.leftBytes >= t.length;
+      return r && (r = Ut(n.bytes(t.length, !0), t), r && n.bytes(t.length)), r !== e;
+    },
+    validate: (n) => {
+      if (n !== void 0 && typeof n != "boolean")
+        throw new Error(`flag: expected boolean value or undefined, got ${typeof n}`);
+      return n;
+    }
+  });
+};
+function ds(t, e, n) {
+  if (!Q(e))
+    throw new Error(`flagged: invalid inner value ${e}`);
+  return Z({
+    encodeStream: (r, o) => {
+      ft.resolve(r.stack, t) && e.encodeStream(r, o);
+    },
+    decodeStream: (r) => {
+      let o = !1;
+      if (o = !!ft.resolve(r.stack, t), o)
+        return e.decodeStream(r);
+    }
+  });
+}
+function hi(t, e, n = !0) {
+  if (!Q(t))
+    throw new Error(`magic: invalid inner value ${t}`);
+  if (typeof n != "boolean")
+    throw new Error(`magic: expected boolean, got ${typeof n}`);
+  return Z({
+    size: t.size,
+    encodeStream: (r, o) => t.encodeStream(r, e),
+    decodeStream: (r) => {
+      const o = t.decodeStream(r);
+      if (n && typeof o != "object" && o !== e || Y(e) && !Ut(e, o))
+        throw r.err(`magic: invalid value: ${o} !== ${e}`);
+    },
+    validate: (r) => {
+      if (r !== void 0)
+        throw new Error(`magic: wrong value=${typeof r}`);
+      return r;
+    }
+  });
+}
+function bn(t) {
+  let e = 0;
+  for (const n of t) {
+    if (n.size === void 0)
+      return;
+    if (!ot(n.size))
+      throw new Error(`sizeof: wrong element size=${e}`);
+    e += n.size;
+  }
+  return e;
+}
+function me(t) {
+  if (!Wt(t))
+    throw new Error(`struct: expected plain object, got ${t}`);
+  for (const e in t)
+    if (!Q(t[e]))
+      throw new Error(`struct: field ${e} is not CoderType`);
+  return Z({
+    size: bn(Object.values(t)),
+    encodeStream: (e, n) => {
+      e.pushObj(n, (r) => {
+        for (const o in t)
+          r(o, () => t[o].encodeStream(e, n[o]));
+      });
+    },
+    decodeStream: (e) => {
+      const n = {};
+      return e.pushObj(n, (r) => {
+        for (const o in t)
+          r(o, () => n[o] = t[o].decodeStream(e));
+      }), n;
+    },
+    validate: (e) => {
+      if (typeof e != "object" || e === null)
+        throw new Error(`struct: invalid value ${e}`);
+      return e;
+    }
+  });
+}
+function li(t) {
+  if (!Array.isArray(t))
+    throw new Error(`Packed.Tuple: got ${typeof t} instead of array`);
+  for (let e = 0; e < t.length; e++)
+    if (!Q(t[e]))
+      throw new Error(`tuple: field ${e} is not CoderType`);
+  return Z({
+    size: bn(t),
+    encodeStream: (e, n) => {
+      if (!Array.isArray(n))
+        throw e.err(`tuple: invalid value ${n}`);
+      e.pushObj(n, (r) => {
+        for (let o = 0; o < t.length; o++)
+          r(`${o}`, () => t[o].encodeStream(e, n[o]));
+      });
+    },
+    decodeStream: (e) => {
+      const n = [];
+      return e.pushObj(n, (r) => {
+        for (let o = 0; o < t.length; o++)
+          r(`${o}`, () => n.push(t[o].decodeStream(e)));
+      }), n;
+    },
+    validate: (e) => {
+      if (!Array.isArray(e))
+        throw new Error(`tuple: invalid value ${e}`);
+      if (e.length !== t.length)
+        throw new Error(`tuple: wrong length=${e.length}, expected ${t.length}`);
+      return e;
+    }
+  });
+}
+function Ye(t, e) {
+  if (!Q(e))
+    throw new Error(`array: invalid inner value ${e}`);
+  const n = ln(typeof t == "string" ? `../${t}` : t);
+  return Z({
+    size: typeof t == "number" && e.size ? t * e.size : void 0,
+    encodeStream: (r, o) => {
+      const s = r;
+      s.pushObj(o, (i) => {
+        Y(t) || n.encodeStream(r, o.length);
+        for (let c = 0; c < o.length; c++)
+          i(`${c}`, () => {
+            const a = o[c], f = r.pos;
+            if (e.encodeStream(r, a), Y(t)) {
+              if (t.length > s.pos - f)
+                return;
+              const d = s.finish(!1).subarray(f, s.pos);
+              if (Ut(d.subarray(0, t.length), t))
+                throw s.err(`array: inner element encoding same as separator. elm=${a} data=${d}`);
+            }
+          });
+      }), Y(t) && r.bytes(t);
+    },
+    decodeStream: (r) => {
+      const o = [];
+      return r.pushObj(o, (s) => {
+        if (t === null)
+          for (let i = 0; !r.isEnd() && (s(`${i}`, () => o.push(e.decodeStream(r))), !(e.size && r.leftBytes < e.size)); i++)
+            ;
+        else if (Y(t))
+          for (let i = 0; ; i++) {
+            if (Ut(r.bytes(t.length, !0), t)) {
+              r.bytes(t.length);
+              break;
+            }
+            s(`${i}`, () => o.push(e.decodeStream(r)));
+          }
+        else {
+          let i;
+          s("arrayLen", () => i = n.decodeStream(r));
+          for (let c = 0; c < i; c++)
+            s(`${c}`, () => o.push(e.decodeStream(r)));
+        }
+      }), o;
+    },
+    validate: (r) => {
+      if (!Array.isArray(r))
+        throw new Error(`array: invalid value ${r}`);
+      return r;
+    }
+  });
+}
+const Ht = vt.Point, Er = Ht.Fn, En = Ht.Fn.ORDER, mn = (t) => t % 2n === 0n, N = Ze.isBytes, xn = Ze.concatBytes, An = Ze.equalBytes, Xe = (t) => Xo(at(t)), pi = (...t) => at(at(xn(...t))), wi = St.getPublicKey, gi = vt.getPublicKey, mr = (t) => t.r < En / 2n;
+function yi(t, e, n = !1) {
+  let r = vt.Signature.fromBytes(vt.sign(t, e, { prehash: !1 }));
+  if (n && !mr(r)) {
+    const o = new Uint8Array(32);
+    let s = 0;
+    for (; !mr(r); )
+      if (o.set(xt.encode(s++)), r = vt.Signature.fromBytes(vt.sign(t, e, { prehash: !1, extraEntropy: o })), s > 4294967295)
+        throw new Error("lowR counter overflow: report the error");
+  }
+  return r.toBytes("der");
+}
+const bi = St.sign, hs = St.utils.taggedHash, ct = {
+  ecdsa: 0,
+  schnorr: 1
+};
+function ls(t, e) {
+  const n = t.length;
+  if (e === ct.ecdsa) {
+    if (n === 32)
+      throw new Error("Expected non-Schnorr key");
+    return Ht.fromBytes(t), t;
+  } else if (e === ct.schnorr) {
+    if (n !== 32)
+      throw new Error("Expected 32-byte Schnorr key");
+    return St.utils.lift_x(ut(t)), t;
+  } else
+    throw new Error("Unknown key type");
+}
+function Bn(t, e) {
+  const r = St.utils.taggedHash("TapTweak", t, e), o = ut(r);
+  if (o >= En)
+    throw new Error("tweak higher than curve order");
+  return o;
+}
+function Ei(t, e = Uint8Array.of()) {
+  const n = St.utils, r = ut(t), o = Ht.BASE.multiply(r), s = mn(o.y) ? r : Er.neg(r), i = n.pointToBytes(o), c = Bn(i, e);
+  return we(Er.add(s, c), 32);
+}
+function ps(t, e) {
+  const n = St.utils, r = Bn(t, e), s = n.lift_x(ut(t)).add(Ht.BASE.multiply(r)), i = mn(s.y) ? 0 : 1;
+  return [n.pointToBytes(s), i];
+}
+const ws = at(Ht.BASE.toBytes(!1)), At = {
+  bech32: "bc",
+  pubKeyHash: 0,
+  scriptHash: 5,
+  wif: 128
+}, gs = {
+  bech32: "tb",
+  pubKeyHash: 111,
+  scriptHash: 196,
+  wif: 239
+};
+function mi(t, e) {
+  if (!N(t) || !N(e))
+    throw new Error(`cmp: wrong type a=${typeof t} b=${typeof e}`);
+  const n = Math.min(t.length, e.length);
+  for (let r = 0; r < n; r++)
+    if (t[r] != e[r])
+      return Math.sign(t[r] - e[r]);
+  return Math.sign(t.length - e.length);
+}
+function ys(t) {
+  const e = {};
+  for (const n in t) {
+    if (e[t[n]] !== void 0)
+      throw new Error("duplicate key");
+    e[t[n]] = n;
+  }
+  return e;
+}
+const K = {
+  OP_0: 0,
+  PUSHDATA1: 76,
+  PUSHDATA2: 77,
+  PUSHDATA4: 78,
+  "1NEGATE": 79,
+  RESERVED: 80,
+  OP_1: 81,
+  OP_2: 82,
+  OP_3: 83,
+  OP_4: 84,
+  OP_5: 85,
+  OP_6: 86,
+  OP_7: 87,
+  OP_8: 88,
+  OP_9: 89,
+  OP_10: 90,
+  OP_11: 91,
+  OP_12: 92,
+  OP_13: 93,
+  OP_14: 94,
+  OP_15: 95,
+  OP_16: 96,
+  // Control
+  NOP: 97,
+  VER: 98,
+  IF: 99,
+  NOTIF: 100,
+  VERIF: 101,
+  VERNOTIF: 102,
+  ELSE: 103,
+  ENDIF: 104,
+  VERIFY: 105,
+  RETURN: 106,
+  // Stack
+  TOALTSTACK: 107,
+  FROMALTSTACK: 108,
+  "2DROP": 109,
+  "2DUP": 110,
+  "3DUP": 111,
+  "2OVER": 112,
+  "2ROT": 113,
+  "2SWAP": 114,
+  IFDUP: 115,
+  DEPTH: 116,
+  DROP: 117,
+  DUP: 118,
+  NIP: 119,
+  OVER: 120,
+  PICK: 121,
+  ROLL: 122,
+  ROT: 123,
+  SWAP: 124,
+  TUCK: 125,
+  // Splice
+  CAT: 126,
+  SUBSTR: 127,
+  LEFT: 128,
+  RIGHT: 129,
+  SIZE: 130,
+  // Boolean logic
+  INVERT: 131,
+  AND: 132,
+  OR: 133,
+  XOR: 134,
+  EQUAL: 135,
+  EQUALVERIFY: 136,
+  RESERVED1: 137,
+  RESERVED2: 138,
+  // Numbers
+  "1ADD": 139,
+  "1SUB": 140,
+  "2MUL": 141,
+  "2DIV": 142,
+  NEGATE: 143,
+  ABS: 144,
+  NOT: 145,
+  "0NOTEQUAL": 146,
+  ADD: 147,
+  SUB: 148,
+  MUL: 149,
+  DIV: 150,
+  MOD: 151,
+  LSHIFT: 152,
+  RSHIFT: 153,
+  BOOLAND: 154,
+  BOOLOR: 155,
+  NUMEQUAL: 156,
+  NUMEQUALVERIFY: 157,
+  NUMNOTEQUAL: 158,
+  LESSTHAN: 159,
+  GREATERTHAN: 160,
+  LESSTHANOREQUAL: 161,
+  GREATERTHANOREQUAL: 162,
+  MIN: 163,
+  MAX: 164,
+  WITHIN: 165,
+  // Crypto
+  RIPEMD160: 166,
+  SHA1: 167,
+  SHA256: 168,
+  HASH160: 169,
+  HASH256: 170,
+  CODESEPARATOR: 171,
+  CHECKSIG: 172,
+  CHECKSIGVERIFY: 173,
+  CHECKMULTISIG: 174,
+  CHECKMULTISIGVERIFY: 175,
+  // Expansion
+  NOP1: 176,
+  CHECKLOCKTIMEVERIFY: 177,
+  CHECKSEQUENCEVERIFY: 178,
+  NOP4: 179,
+  NOP5: 180,
+  NOP6: 181,
+  NOP7: 182,
+  NOP8: 183,
+  NOP9: 184,
+  NOP10: 185,
+  // BIP 342
+  CHECKSIGADD: 186,
+  // Invalid
+  INVALID: 255
+}, bs = ys(K);
+function Sn(t = 6, e = !1) {
+  return Z({
+    encodeStream: (n, r) => {
+      if (r === 0n)
+        return;
+      const o = r < 0, s = BigInt(r), i = [];
+      for (let c = o ? -s : s; c; c >>= 8n)
+        i.push(Number(c & 0xffn));
+      i[i.length - 1] >= 128 ? i.push(o ? 128 : 0) : o && (i[i.length - 1] |= 128), n.bytes(new Uint8Array(i));
+    },
+    decodeStream: (n) => {
+      const r = n.leftBytes;
+      if (r > t)
+        throw new Error(`ScriptNum: number (${r}) bigger than limit=${t}`);
+      if (r === 0)
+        return 0n;
+      if (e) {
+        const i = n.bytes(r, !0);
+        if ((i[i.length - 1] & 127) === 0 && (r <= 1 || (i[i.length - 2] & 128) === 0))
+          throw new Error("Non-minimally encoded ScriptNum");
+      }
+      let o = 0, s = 0n;
+      for (let i = 0; i < r; ++i)
+        o = n.byte(), s |= BigInt(o) << 8n * BigInt(i);
+      return o >= 128 && (s &= 2n ** BigInt(r * 8) - 1n >> 1n, s = -s), s;
+    }
+  });
+}
+function Es(t, e = 4, n = !0) {
+  if (typeof t == "number")
+    return t;
+  if (N(t))
+    try {
+      const r = Sn(e, n).decode(t);
+      return r > Number.MAX_SAFE_INTEGER ? void 0 : Number(r);
+    } catch {
+      return;
+    }
+}
+const Kt = Z({
+  encodeStream: (t, e) => {
+    for (let n of e) {
+      if (typeof n == "string") {
+        if (K[n] === void 0)
+          throw new Error(`Unknown opcode=${n}`);
+        t.byte(K[n]);
+        continue;
+      } else if (typeof n == "number") {
+        if (n === 0) {
+          t.byte(0);
+          continue;
+        } else if (1 <= n && n <= 16) {
+          t.byte(K.OP_1 - 1 + n);
+          continue;
+        }
+      }
+      if (typeof n == "number" && (n = Sn().encode(BigInt(n))), !N(n))
+        throw new Error(`Wrong Script OP=${n} (${typeof n})`);
+      const r = n.length;
+      r < K.PUSHDATA1 ? t.byte(r) : r <= 255 ? (t.byte(K.PUSHDATA1), t.byte(r)) : r <= 65535 ? (t.byte(K.PUSHDATA2), t.bytes(br.encode(r))) : (t.byte(K.PUSHDATA4), t.bytes(xt.encode(r))), t.bytes(n);
+    }
+  },
+  decodeStream: (t) => {
+    const e = [];
+    for (; !t.isEnd(); ) {
+      const n = t.byte();
+      if (K.OP_0 < n && n <= K.PUSHDATA4) {
+        let r;
+        if (n < K.PUSHDATA1)
+          r = n;
+        else if (n === K.PUSHDATA1)
+          r = fs.decodeStream(t);
+        else if (n === K.PUSHDATA2)
+          r = br.decodeStream(t);
+        else if (n === K.PUSHDATA4)
+          r = xt.decodeStream(t);
+        else
+          throw new Error("Should be not possible");
+        e.push(t.bytes(r));
+      } else if (n === 0)
+        e.push(0);
+      else if (K.OP_1 <= n && n <= K.OP_16)
+        e.push(n - (K.OP_1 - 1));
+      else {
+        const r = bs[n];
+        if (r === void 0)
+          throw new Error(`Unknown opcode=${n.toString(16)}`);
+        e.push(r);
+      }
+    }
+    return e;
+  }
+}), xr = {
+  253: [253, 2, 253n, 65535n],
+  254: [254, 4, 65536n, 4294967295n],
+  255: [255, 8, 4294967296n, 18446744073709551615n]
+}, Qe = Z({
+  encodeStream: (t, e) => {
+    if (typeof e == "number" && (e = BigInt(e)), 0n <= e && e <= 252n)
+      return t.byte(Number(e));
+    for (const [n, r, o, s] of Object.values(xr))
+      if (!(o > e || e > s)) {
+        t.byte(n);
+        for (let i = 0; i < r; i++)
+          t.byte(Number(e >> 8n * BigInt(i) & 0xffn));
+        return;
+      }
+    throw t.err(`VarInt too big: ${e}`);
+  },
+  decodeStream: (t) => {
+    const e = t.byte();
+    if (e <= 252)
+      return BigInt(e);
+    const [n, r, o] = xr[e];
+    let s = 0n;
+    for (let i = 0; i < r; i++)
+      s |= BigInt(t.byte()) << 8n * BigInt(i);
+    if (s < o)
+      throw t.err(`Wrong CompactSize(${8 * r})`);
+    return s;
+  }
+}), ms = kt(Qe, gn.numberBigint), xe = jt(Qe), xs = Ye(ms, xe), ue = (t) => Ye(Qe, t), vn = me({
+  txid: jt(32, !0),
+  // hash(prev_tx),
+  index: xt,
+  // output number of previous tx
+  finalScriptSig: xe,
+  // btc merges input and output script, executes it. If ok = tx passes
+  sequence: xt
+  // ?
+}), In = me({ amount: cs, script: xe }), As = me({
+  version: yn,
+  segwitFlag: us(new Uint8Array([0, 1])),
+  inputs: ue(vn),
+  outputs: ue(In),
+  witnesses: ds("segwitFlag", Ye("inputs/length", xs)),
+  // < 500000000	Block number at which this transaction is unlocked
+  // >= 500000000	UNIX timestamp at which this transaction is unlocked
+  // Handled as part of PSBTv2
+  lockTime: xt
+});
+function Bs(t) {
+  if (t.segwitFlag && t.witnesses && !t.witnesses.length)
+    throw new Error("Segwit flag with empty witnesses array");
+  return t;
+}
+const xi = be(As, Bs), Ai = me({
+  version: yn,
+  inputs: ue(vn),
+  outputs: ue(In),
+  lockTime: xt
+}), Ss = {
+  encode(t) {
+    if (!(t.length !== 2 || t[0] !== 1 || !N(t[1]) || rt.encode(t[1]) !== "4e73"))
+      return { type: "p2a", script: Kt.encode(t) };
+  },
+  decode: (t) => {
+    if (t.type === "p2a")
+      return [1, rt.decode("4e73")];
+  }
+};
+function Et(t, e) {
+  try {
+    return ls(t, e), !0;
+  } catch {
+    return !1;
+  }
+}
+const vs = {
+  encode(t) {
+    if (!(t.length !== 2 || !N(t[0]) || !Et(t[0], ct.ecdsa) || t[1] !== "CHECKSIG"))
+      return { type: "pk", pubkey: t[0] };
+  },
+  decode: (t) => t.type === "pk" ? [t.pubkey, "CHECKSIG"] : void 0
+}, Is = {
+  encode(t) {
+    if (!(t.length !== 5 || t[0] !== "DUP" || t[1] !== "HASH160" || !N(t[2])) && !(t[3] !== "EQUALVERIFY" || t[4] !== "CHECKSIG"))
+      return { type: "pkh", hash: t[2] };
+  },
+  decode: (t) => t.type === "pkh" ? ["DUP", "HASH160", t.hash, "EQUALVERIFY", "CHECKSIG"] : void 0
+}, $s = {
+  encode(t) {
+    if (!(t.length !== 3 || t[0] !== "HASH160" || !N(t[1]) || t[2] !== "EQUAL"))
+      return { type: "sh", hash: t[1] };
+  },
+  decode: (t) => t.type === "sh" ? ["HASH160", t.hash, "EQUAL"] : void 0
+}, Os = {
+  encode(t) {
+    if (!(t.length !== 2 || t[0] !== 0 || !N(t[1])) && t[1].length === 32)
+      return { type: "wsh", hash: t[1] };
+  },
+  decode: (t) => t.type === "wsh" ? [0, t.hash] : void 0
+}, Rs = {
+  encode(t) {
+    if (!(t.length !== 2 || t[0] !== 0 || !N(t[1])) && t[1].length === 20)
+      return { type: "wpkh", hash: t[1] };
+  },
+  decode: (t) => t.type === "wpkh" ? [0, t.hash] : void 0
+}, Us = {
+  encode(t) {
+    const e = t.length - 1;
+    if (t[e] !== "CHECKMULTISIG")
+      return;
+    const n = t[0], r = t[e - 1];
+    if (typeof n != "number" || typeof r != "number")
+      return;
+    const o = t.slice(1, -2);
+    if (r === o.length) {
+      for (const s of o)
+        if (!N(s))
+          return;
+      return { type: "ms", m: n, pubkeys: o };
+    }
+  },
+  // checkmultisig(n, ..pubkeys, m)
+  decode: (t) => t.type === "ms" ? [t.m, ...t.pubkeys, t.pubkeys.length, "CHECKMULTISIG"] : void 0
+}, ks = {
+  encode(t) {
+    if (!(t.length !== 2 || t[0] !== 1 || !N(t[1])))
+      return { type: "tr", pubkey: t[1] };
+  },
+  decode: (t) => t.type === "tr" ? [1, t.pubkey] : void 0
+}, Ps = {
+  encode(t) {
+    const e = t.length - 1;
+    if (t[e] !== "CHECKSIG")
+      return;
+    const n = [];
+    for (let r = 0; r < e; r++) {
+      const o = t[r];
+      if (r & 1) {
+        if (o !== "CHECKSIGVERIFY" || r === e - 1)
+          return;
+        continue;
+      }
+      if (!N(o))
+        return;
+      n.push(o);
+    }
+    return { type: "tr_ns", pubkeys: n };
+  },
+  decode: (t) => {
+    if (t.type !== "tr_ns")
+      return;
+    const e = [];
+    for (let n = 0; n < t.pubkeys.length - 1; n++)
+      e.push(t.pubkeys[n], "CHECKSIGVERIFY");
+    return e.push(t.pubkeys[t.pubkeys.length - 1], "CHECKSIG"), e;
+  }
+}, _s = {
+  encode(t) {
+    const e = t.length - 1;
+    if (t[e] !== "NUMEQUAL" || t[1] !== "CHECKSIG")
+      return;
+    const n = [], r = Es(t[e - 1]);
+    if (typeof r == "number") {
+      for (let o = 0; o < e - 1; o++) {
+        const s = t[o];
+        if (o & 1) {
+          if (s !== (o === 1 ? "CHECKSIG" : "CHECKSIGADD"))
+            throw new Error("OutScript.encode/tr_ms: wrong element");
+          continue;
+        }
+        if (!N(s))
+          throw new Error("OutScript.encode/tr_ms: wrong key element");
+        n.push(s);
+      }
+      return { type: "tr_ms", pubkeys: n, m: r };
+    }
+  },
+  decode: (t) => {
+    if (t.type !== "tr_ms")
+      return;
+    const e = [t.pubkeys[0], "CHECKSIG"];
+    for (let n = 1; n < t.pubkeys.length; n++)
+      e.push(t.pubkeys[n], "CHECKSIGADD");
+    return e.push(t.m, "NUMEQUAL"), e;
+  }
+}, Hs = {
+  encode(t) {
+    return { type: "unknown", script: Kt.encode(t) };
+  },
+  decode: (t) => t.type === "unknown" ? Kt.decode(t.script) : void 0
+}, Ls = [
+  Ss,
+  vs,
+  Is,
+  $s,
+  Os,
+  Rs,
+  Us,
+  ks,
+  Ps,
+  _s,
+  Hs
+], Ts = kt(Kt, gn.match(Ls)), nt = be(Ts, (t) => {
+  if (t.type === "pk" && !Et(t.pubkey, ct.ecdsa))
+    throw new Error("OutScript/pk: wrong key");
+  if ((t.type === "pkh" || t.type === "sh" || t.type === "wpkh") && (!N(t.hash) || t.hash.length !== 20))
+    throw new Error(`OutScript/${t.type}: wrong hash`);
+  if (t.type === "wsh" && (!N(t.hash) || t.hash.length !== 32))
+    throw new Error("OutScript/wsh: wrong hash");
+  if (t.type === "tr" && (!N(t.pubkey) || !Et(t.pubkey, ct.schnorr)))
+    throw new Error("OutScript/tr: wrong taproot public key");
+  if ((t.type === "ms" || t.type === "tr_ns" || t.type === "tr_ms") && !Array.isArray(t.pubkeys))
+    throw new Error("OutScript/multisig: wrong pubkeys array");
+  if (t.type === "ms") {
+    const e = t.pubkeys.length;
+    for (const n of t.pubkeys)
+      if (!Et(n, ct.ecdsa))
+        throw new Error("OutScript/multisig: wrong pubkey");
+    if (t.m <= 0 || e > 16 || t.m > e)
+      throw new Error("OutScript/multisig: invalid params");
+  }
+  if (t.type === "tr_ns" || t.type === "tr_ms") {
+    for (const e of t.pubkeys)
+      if (!Et(e, ct.schnorr))
+        throw new Error(`OutScript/${t.type}: wrong pubkey`);
+  }
+  if (t.type === "tr_ms") {
+    const e = t.pubkeys.length;
+    if (t.m <= 0 || e > 999 || t.m > e)
+      throw new Error("OutScript/tr_ms: invalid params");
+  }
+  return t;
+});
+function Ar(t, e) {
+  if (!An(t.hash, at(e)))
+    throw new Error("checkScript: wsh wrong witnessScript hash");
+  const n = nt.decode(e);
+  if (n.type === "tr" || n.type === "tr_ns" || n.type === "tr_ms")
+    throw new Error(`checkScript: P2${n.type} cannot be wrapped in P2SH`);
+  if (n.type === "wpkh" || n.type === "sh")
+    throw new Error(`checkScript: P2${n.type} cannot be wrapped in P2WSH`);
+}
+function Ns(t, e, n) {
+  if (t) {
+    const r = nt.decode(t);
+    if (r.type === "tr_ns" || r.type === "tr_ms" || r.type === "ms" || r.type == "pk")
+      throw new Error(`checkScript: non-wrapped ${r.type}`);
+    if (r.type === "sh" && e) {
+      if (!An(r.hash, Xe(e)))
+        throw new Error("checkScript: sh wrong redeemScript hash");
+      const o = nt.decode(e);
+      if (o.type === "tr" || o.type === "tr_ns" || o.type === "tr_ms")
+        throw new Error(`checkScript: P2${o.type} cannot be wrapped in P2SH`);
+      if (o.type === "sh")
+        throw new Error("checkScript: P2SH cannot be wrapped in P2SH");
+    }
+    r.type === "wsh" && n && Ar(r, n);
+  }
+  if (e) {
+    const r = nt.decode(e);
+    r.type === "wsh" && n && Ar(r, n);
+  }
+}
+const Cs = (t, e = At) => {
+  const n = t.script;
+  if (!N(n))
+    throw new Error(`Wrong script: ${typeof t.script}, expected Uint8Array`);
+  const r = Xe(n), o = nt.encode({ type: "sh", hash: r });
+  return Ns(o, n, t.witnessScript), t.witnessScript ? {
+    type: "sh",
+    redeemScript: n,
+    script: nt.encode({ type: "sh", hash: r }),
+    address: Vt(e).encode({ type: "sh", hash: r }),
+    hash: r,
+    witnessScript: t.witnessScript
+  } : {
+    type: "sh",
+    redeemScript: n,
+    script: nt.encode({ type: "sh", hash: r }),
+    address: Vt(e).encode({ type: "sh", hash: r }),
+    hash: r
+  };
+}, Ds = (t, e = At) => {
+  if (!Et(t, ct.ecdsa))
+    throw new Error("P2WPKH: invalid publicKey");
+  if (t.length === 65)
+    throw new Error("P2WPKH: uncompressed public key");
+  const n = Xe(t);
+  return {
+    type: "wpkh",
+    script: nt.encode({ type: "wpkh", hash: n }),
+    address: Vt(e).encode({ type: "wpkh", hash: n }),
+    hash: n
+  };
+}, Ks = 192, Bi = (t, e = Ks) => hs("TapLeaf", new Uint8Array([e]), xe.encode(t));
+function Vs(t, e, n = At, r = !1, o) {
+  if (!t)
+    throw new Error("p2tr: should have pubKey or scriptTree (or both)");
+  const s = typeof t == "string" ? rt.decode(t) : t || ws;
+  if (!Et(s, ct.schnorr))
+    throw new Error("p2tr: non-schnorr pubkey");
+  {
+    const i = ps(s, Qo)[0];
+    return {
+      type: "tr",
+      script: nt.encode({ type: "tr", pubkey: i }),
+      address: Vt(n).encode({ type: "tr", pubkey: i }),
+      // For tests
+      tweakedPubkey: i,
+      // PSBT stuff
+      tapInternalKey: s
+    };
+  }
+}
+const $n = ro(at);
+function On(t, e) {
+  if (e.length < 2 || e.length > 40)
+    throw new Error("Witness: invalid length");
+  if (t > 16)
+    throw new Error("Witness: invalid version");
+  if (t === 0 && !(e.length === 20 || e.length === 32))
+    throw new Error("Witness: invalid length for version");
+}
+function Oe(t, e, n = At) {
+  On(t, e);
+  const r = t === 0 ? ke : Rr;
+  return r.encode(n.bech32, [t].concat(r.toWords(e)));
+}
+function Br(t, e) {
+  return $n.encode(xn(Uint8Array.from(e), t));
+}
+function Vt(t = At) {
+  return {
+    encode(e) {
+      const { type: n } = e;
+      if (n === "wpkh")
+        return Oe(0, e.hash, t);
+      if (n === "wsh")
+        return Oe(0, e.hash, t);
+      if (n === "tr")
+        return Oe(1, e.pubkey, t);
+      if (n === "pkh")
+        return Br(e.hash, [t.pubKeyHash]);
+      if (n === "sh")
+        return Br(e.hash, [t.scriptHash]);
+      throw new Error(`Unknown address type=${n}`);
+    },
+    decode(e) {
+      if (e.length < 14 || e.length > 74)
+        throw new Error("Invalid address length");
+      if (t.bech32 && e.toLowerCase().startsWith(`${t.bech32}1`)) {
+        let r;
+        try {
+          if (r = ke.decode(e), r.words[0] !== 0)
+            throw new Error(`bech32: wrong version=${r.words[0]}`);
+        } catch {
+          if (r = Rr.decode(e), r.words[0] === 0)
+            throw new Error(`bech32m: wrong version=${r.words[0]}`);
+        }
+        if (r.prefix !== t.bech32)
+          throw new Error(`wrong bech32 prefix=${r.prefix}`);
+        const [o, ...s] = r.words, i = ke.fromWords(s);
+        if (On(o, i), o === 0 && i.length === 32)
+          return { type: "wsh", hash: i };
+        if (o === 0 && i.length === 20)
+          return { type: "wpkh", hash: i };
+        if (o === 1 && i.length === 32)
+          return { type: "tr", pubkey: i };
+        throw new Error("Unknown witness program");
+      }
+      const n = $n.decode(e);
+      if (n.length !== 21)
+        throw new Error("Invalid base58 address");
+      if (n[0] === t.pubKeyHash)
+        return { type: "pkh", hash: n.slice(1) };
+      if (n[0] === t.scriptHash)
+        return {
+          type: "sh",
+          hash: n.slice(1)
+        };
+      throw new Error(`Invalid address prefix=${n[0]}`);
+    }
+  };
+}
+function Si(t) {
+  return t === "mainnet" ? At : t === "testnet" ? gs : At;
+}
+function Lt(t) {
+  return t.bech32 === "bc";
+}
+function Ms(t, e) {
+  return Ws(t, e) ? "p2pkh" : qs(t, e) ? "p2sh" : Rn(t, e) ? "p2wpkh" : js(t, e) ? "p2wsh" : Un(t, e) ? "p2tr" : "unknown";
+}
+function Ws(t, e) {
+  return Lt(t) ? e.startsWith("1") : e.startsWith("m") || e.startsWith("n");
+}
+function qs(t, e) {
+  return Lt(t) ? e.startsWith("3") : e.startsWith("2");
+}
+function Rn(t, e) {
+  return Lt(t) ? e.startsWith("bc1q") : e.startsWith("tb1q");
+}
+function Un(t, e) {
+  return Lt(t) ? e.startsWith("bc1p") : e.startsWith("tb1p");
+}
+function js(t, e) {
+  return Un(t, e) || Rn(t, e) ? !1 : Lt(t) ? e.startsWith("bc1") : e.startsWith("tb1");
+}
+function Fs(t, e) {
+  if (e.byteLength !== 33)
+    throw new Error("Invalid public key length");
+  return e.slice(1);
+}
+function vi(t, e) {
+  return Vs(
+    Fs(t, e),
+    void 0,
+    t
+  ).tapInternalKey;
+}
+function Ii(t, e) {
+  return Cs(Ds(e, t), t).redeemScript;
+}
+function Zs(t, e) {
+  const n = Vt(t).decode(e);
+  return nt.encode(n);
+}
+function zs(t, e) {
+  return rt.encode(Zs(t, e));
+}
+const Gs = "0000000000000000000000000000000000000000000000000000000000000000", kn = "0000000000000000000000000000000000000000000000000000000000000000", Ys = rt.encode(
+  Kt.encode(["OP_1", rt.decode(kn), "OP_1", "CHECKMULTISIG"])
+);
+class $i {
+  constructor(e, n, r) {
+    this.network = e, this.inner = n, this.addresses = r;
+  }
+  async connect() {
+    await this.inner.connect();
+  }
+  async disconnect() {
+    await this.inner.disconnect();
+  }
+  async getAddresses() {
+    const e = await this.inner.getAddresses(), n = (s, i) => {
+      const c = Ms(this.network, i.address), a = c === "p2tr" ? zt.P2TR : c === "p2sh" ? zt.P2SH_P2WPKH : c === "p2wpkh" ? zt.P2WPKH : c === "p2pkh" ? zt.P2PKH : void 0;
+      if (a == null)
+        throw new Nt(
+          `[MockAddressWalletAdapter] Please provide a supported ${s} address`
+        );
+      return {
+        network: Lt(this.network) ? er.MAINNET : er.TESTNET,
+        purposes: i.purposes,
+        addressType: a,
+        address: i.address,
+        scriptPubKey: zs(this.network, i.address),
+        publicKey: kn,
+        redeemScript: Ys,
+        tapInternalKey: Gs
+      };
+    };
+    let r, o;
+    return this.addresses.bitcoin != null && (r = n("bitcoin", {
+      ...this.addresses.bitcoin,
+      purposes: [dt.Bitcoin]
+    })), this.addresses.ordinals != null && (o = n("ordinals", {
+      ...this.addresses.ordinals,
+      purposes: [
+        dt.Ordinals,
+        dt.BRC20,
+        dt.Runes
+      ]
+    })), e.flatMap((s) => {
+      const i = [];
+      let c = s.purposes;
+      return r != null && c.includes(dt.Bitcoin) && (i.push(r), c = c.filter(
+        (a) => a !== dt.Bitcoin
+      )), o != null && c.includes(dt.Ordinals) && (i.push(o), c = c.filter(
+        (a) => a !== dt.Ordinals
+      )), c.length > 0 && i.push({ ...s, purposes: c }), i;
+    });
+  }
+  async signMessage(e, n) {
+    throw new Nt(
+      "[MockAddressWalletAdapter] it's a mock adapter, can't send inscription"
+    );
+  }
+  get sendBitcoinFeeRateCapability() {
+    return this.inner.sendBitcoinFeeRateCapability;
+  }
+  get sendInscriptionFeeRateCapability() {
+    return this.inner.sendInscriptionFeeRateCapability;
+  }
+  sendBitcoin(e, n, r) {
+    throw new Nt(
+      "[MockAddressWalletAdapter] it's a mock adapter, can't send bitcoin"
+    );
+  }
+  sendInscription(e, n, r) {
+    throw new Nt(
+      "[MockAddressWalletAdapter] it's a mock adapter, can't send inscription"
+    );
+  }
+  signAndFinalizePsbt(e) {
+    throw new Nt(
+      "[MockAddressWalletAdapter] it's a mock adapter, can't sign transaction"
+    );
+  }
+  onAddressesChanged(e) {
+    return {
+      unsubscribe: () => {
+      }
+    };
+  }
+}
+export {
+  cs as $,
+  mi as A,
+  Qs as B,
+  ms as C,
+  kt as D,
+  Qo as E,
+  gn as F,
+  li as G,
+  di as H,
+  ci as I,
+  Qe as J,
+  pi as K,
+  Js as L,
+  ti as M,
+  si as N,
+  ei as O,
+  ct as P,
+  At as Q,
+  xs as R,
+  Vt as S,
+  nt as T,
+  ri as U,
+  xe as V,
+  Ns as W,
+  ni as X,
+  ii as Y,
+  Kt as Z,
+  yn as _,
+  $i as a,
+  at as a0,
+  xn as a1,
+  Bi as a2,
+  hs as a3,
+  N as a4,
+  wi as a5,
+  ps as a6,
+  bi as a7,
+  gi as a8,
+  Xe as a9,
+  yi as aa,
+  ys as ab,
+  Ei as ac,
+  Si as b,
+  Zs as c,
+  Ms as d,
+  Ii as e,
+  Sr as f,
+  vi as g,
+  rt as h,
+  oi as i,
+  Cn as j,
+  jt as k,
+  xt as l,
+  In as m,
+  xi as n,
+  Ye as o,
+  An as p,
+  ls as q,
+  hi as r,
+  me as s,
+  ui as t,
+  ai as u,
+  be as v,
+  fs as w,
+  Z as x,
+  Ai as y,
+  fi as z
+};
+//# sourceMappingURL=index-D7YwhNAG.mjs.map