@babylonlabs-io/ts-sdk 0.72.0 → 0.73.0

package/dist/pegin-registration-client-BdRiR8br.js

@@ -0,0 +1,2635 @@
+var Cn = Object.defineProperty;
+var Tn = (t, e, r) => e in t ? Cn(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var lt = (t, e, r) => Tn(t, typeof e != "symbol" ? e + "" : e, r);
+import { isAddress as $n, keccak256 as _n, encodeAbiParameters as Vn, encodeFunctionData as ye, isAddressEqual as Rn, zeroAddress as Nn } from "viem";
+import { B as F } from "./BTCVaultRegistry.abi-CJwWI2EO.js";
+import { B as be, h as Mt } from "./BTCVaultRegistryKeyEpochs.abi-D8cIbMtH.js";
+import { M as Ee, d as xe } from "./constants-CPzppOdq.js";
+import { waitForTransactionReceiptSmartAware as Hn } from "./tbv/core/utils/eth/index.js";
+import { a as xt } from "./onChainBtcPubkey-C-6UWpD8.js";
+import { c as kn, H as On, r as At, g as Be, h as Ze, i as ue, s as Jt } from "./sha2-CrlWM5S8.js";
+import { a as qn } from "./vaultCoreVersion-D_fP9P3C.js";
+const te = 25, Un = 9999;
+function ve(t) {
+  if (!Number.isInteger(t) || t < 0 || t >= Ee)
+    throw new Error(
+      `Quoted commissionBps must be an integer in [0, ${Ee}), got ${t}`
+    );
+  return Math.min(
+    t + te,
+    Un
+  );
+}
+const Kn = /* @__PURE__ */ Uint8Array.from([
+  7,
+  4,
+  13,
+  1,
+  10,
+  6,
+  15,
+  3,
+  12,
+  0,
+  9,
+  5,
+  2,
+  14,
+  11,
+  8
+]), De = Uint8Array.from(new Array(16).fill(0).map((t, e) => e)), Ln = De.map((t) => (9 * t + 5) % 16), ze = /* @__PURE__ */ (() => {
+  const r = [[De], [Ln]];
+  for (let n = 0; n < 4; n++)
+    for (let o of r)
+      o.push(o[n].map((s) => Kn[s]));
+  return r;
+})(), Xe = ze[0], Ye = ze[1], je = /* @__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)), Mn = /* @__PURE__ */ Xe.map((t, e) => t.map((r) => je[e][r])), Fn = /* @__PURE__ */ Ye.map((t, e) => t.map((r) => je[e][r])), Zn = /* @__PURE__ */ Uint32Array.from([
+  0,
+  1518500249,
+  1859775393,
+  2400959708,
+  2840853838
+]), Dn = /* @__PURE__ */ Uint32Array.from([
+  1352829926,
+  1548603684,
+  1836072691,
+  2053994217,
+  0
+]);
+function Pe(t, e, r, n) {
+  return t === 0 ? e ^ r ^ n : t === 1 ? e & r | ~e & n : t === 2 ? (e | ~r) ^ n : t === 3 ? e & n | r & ~n : e ^ (r | ~n);
+}
+const St = /* @__PURE__ */ new Uint32Array(16);
+class zn extends On {
+  constructor() {
+    super(64, 20, 8, !0);
+    lt(this, "h0", 1732584193);
+    lt(this, "h1", -271733879);
+    lt(this, "h2", -1732584194);
+    lt(this, "h3", 271733878);
+    lt(this, "h4", -1009589776);
+  }
+  get() {
+    const { h0: r, h1: n, h2: o, h3: s, h4: i } = this;
+    return [r, n, o, s, i];
+  }
+  set(r, n, o, s, i) {
+    this.h0 = r | 0, this.h1 = n | 0, this.h2 = o | 0, this.h3 = s | 0, this.h4 = i | 0;
+  }
+  process(r, n) {
+    for (let h = 0; h < 16; h++, n += 4)
+      St[h] = r.getUint32(n, !0);
+    let o = this.h0 | 0, s = o, i = this.h1 | 0, a = i, u = this.h2 | 0, l = u, m = this.h3 | 0, y = m, c = this.h4 | 0, f = c;
+    for (let h = 0; h < 5; h++) {
+      const w = 4 - h, A = Zn[h], _ = Dn[h], nt = Xe[h], V = Ye[h], j = Mn[h], z = Fn[h];
+      for (let q = 0; q < 16; q++) {
+        const J = At(o + Pe(h, i, u, m) + St[nt[q]] + A, j[q]) + c | 0;
+        o = c, c = m, m = At(u, 10) | 0, u = i, i = J;
+      }
+      for (let q = 0; q < 16; q++) {
+        const J = At(s + Pe(w, a, l, y) + St[V[q]] + _, z[q]) + f | 0;
+        s = f, f = y, y = At(l, 10) | 0, l = a, a = J;
+      }
+    }
+    this.set(this.h1 + u + y | 0, this.h2 + m + f | 0, this.h3 + c + s | 0, this.h4 + o + a | 0, this.h0 + i + l | 0);
+  }
+  roundClean() {
+    Be(St);
+  }
+  destroy() {
+    this.destroyed = !0, Be(this.buffer), this.set(0, 0, 0, 0, 0);
+  }
+}
+const Xn = /* @__PURE__ */ kn(() => new zn()), dt = typeof globalThis == "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+function qt(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function ee(t) {
+  if (!Number.isSafeInteger(t) || t < 0)
+    throw new Error("positive integer expected, got " + t);
+}
+function ut(t, ...e) {
+  if (!qt(t))
+    throw new Error("Uint8Array expected");
+  if (e.length > 0 && !e.includes(t.length))
+    throw new Error("Uint8Array expected of length " + e + ", got length=" + t.length);
+}
+function We(t) {
+  if (typeof t != "function" || typeof t.create != "function")
+    throw new Error("Hash should be wrapped by utils.createHasher");
+  ee(t.outputLen), ee(t.blockLen);
+}
+function $t(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 Yn(t, e) {
+  ut(t);
+  const r = e.outputLen;
+  if (t.length < r)
+    throw new Error("digestInto() expects output buffer of length at least " + r);
+}
+function _t(...t) {
+  for (let e = 0; e < t.length; e++)
+    t[e].fill(0);
+}
+function Ft(t) {
+  return new DataView(t.buffer, t.byteOffset, t.byteLength);
+}
+function X(t, e) {
+  return t << 32 - e | t >>> e;
+}
+const Ge = /* @ts-ignore */ typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", jn = /* @__PURE__ */ Array.from({ length: 256 }, (t, e) => e.toString(16).padStart(2, "0"));
+function ht(t) {
+  if (ut(t), Ge)
+    return t.toHex();
+  let e = "";
+  for (let r = 0; r < t.length; r++)
+    e += jn[t[r]];
+  return e;
+}
+const W = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function Ie(t) {
+  if (t >= W._0 && t <= W._9)
+    return t - W._0;
+  if (t >= W.A && t <= W.F)
+    return t - (W.A - 10);
+  if (t >= W.a && t <= W.f)
+    return t - (W.a - 10);
+}
+function Vt(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  if (Ge)
+    return Uint8Array.fromHex(t);
+  const e = t.length, r = e / 2;
+  if (e % 2)
+    throw new Error("hex string expected, got unpadded hex of length " + e);
+  const n = new Uint8Array(r);
+  for (let o = 0, s = 0; o < r; o++, s += 2) {
+    const i = Ie(t.charCodeAt(s)), a = Ie(t.charCodeAt(s + 1));
+    if (i === void 0 || a === void 0) {
+      const u = t[s] + t[s + 1];
+      throw new Error('hex string expected, got non-hex character "' + u + '" at index ' + s);
+    }
+    n[o] = i * 16 + a;
+  }
+  return n;
+}
+function Qe(t) {
+  if (typeof t != "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(t));
+}
+function fe(t) {
+  return typeof t == "string" && (t = Qe(t)), ut(t), t;
+}
+function Y(...t) {
+  let e = 0;
+  for (let n = 0; n < t.length; n++) {
+    const o = t[n];
+    ut(o), e += o.length;
+  }
+  const r = new Uint8Array(e);
+  for (let n = 0, o = 0; n < t.length; n++) {
+    const s = t[n];
+    r.set(s, o), o += s.length;
+  }
+  return r;
+}
+class Je {
+}
+function Wn(t) {
+  const e = (n) => t().update(fe(n)).digest(), r = t();
+  return e.outputLen = r.outputLen, e.blockLen = r.blockLen, e.create = () => t(), e;
+}
+function Ut(t = 32) {
+  if (dt && typeof dt.getRandomValues == "function")
+    return dt.getRandomValues(new Uint8Array(t));
+  if (dt && typeof dt.randomBytes == "function")
+    return Uint8Array.from(dt.randomBytes(t));
+  throw new Error("crypto.getRandomValues must be defined");
+}
+function Gn(t, e, r, n) {
+  if (typeof t.setBigUint64 == "function")
+    return t.setBigUint64(e, r, n);
+  const o = BigInt(32), s = BigInt(4294967295), i = Number(r >> o & s), a = Number(r & s), u = n ? 4 : 0, l = n ? 0 : 4;
+  t.setUint32(e + u, i, n), t.setUint32(e + l, a, n);
+}
+function Qn(t, e, r) {
+  return t & e ^ ~t & r;
+}
+function Jn(t, e, r) {
+  return t & e ^ t & r ^ e & r;
+}
+class tr extends Je {
+  constructor(e, r, n, o) {
+    super(), this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.blockLen = e, this.outputLen = r, this.padOffset = n, this.isLE = o, this.buffer = new Uint8Array(e), this.view = Ft(this.buffer);
+  }
+  update(e) {
+    $t(this), e = fe(e), ut(e);
+    const { view: r, buffer: n, blockLen: o } = this, s = e.length;
+    for (let i = 0; i < s; ) {
+      const a = Math.min(o - this.pos, s - i);
+      if (a === o) {
+        const u = Ft(e);
+        for (; o <= s - i; i += o)
+          this.process(u, i);
+        continue;
+      }
+      n.set(e.subarray(i, i + a), this.pos), this.pos += a, i += a, this.pos === o && (this.process(r, 0), this.pos = 0);
+    }
+    return this.length += e.length, this.roundClean(), this;
+  }
+  digestInto(e) {
+    $t(this), Yn(e, this), this.finished = !0;
+    const { buffer: r, view: n, blockLen: o, isLE: s } = this;
+    let { pos: i } = this;
+    r[i++] = 128, _t(this.buffer.subarray(i)), this.padOffset > o - i && (this.process(n, 0), i = 0);
+    for (let y = i; y < o; y++)
+      r[y] = 0;
+    Gn(n, o - 8, BigInt(this.length * 8), s), this.process(n, 0);
+    const a = Ft(e), u = this.outputLen;
+    if (u % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const l = u / 4, m = this.get();
+    if (l > m.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let y = 0; y < l; y++)
+      a.setUint32(4 * y, m[y], s);
+  }
+  digest() {
+    const { buffer: e, outputLen: r } = this;
+    this.digestInto(e);
+    const n = e.slice(0, r);
+    return this.destroy(), n;
+  }
+  _cloneInto(e) {
+    e || (e = new this.constructor()), e.set(...this.get());
+    const { blockLen: r, buffer: n, length: o, finished: s, destroyed: i, pos: a } = this;
+    return e.destroyed = i, e.finished = s, e.length = o, e.pos = a, o % r && e.buffer.set(n), e;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+const tt = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]), er = /* @__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
+]), et = /* @__PURE__ */ new Uint32Array(64);
+class nr extends tr {
+  constructor(e = 32) {
+    super(64, e, 8, !1), this.A = tt[0] | 0, this.B = tt[1] | 0, this.C = tt[2] | 0, this.D = tt[3] | 0, this.E = tt[4] | 0, this.F = tt[5] | 0, this.G = tt[6] | 0, this.H = tt[7] | 0;
+  }
+  get() {
+    const { A: e, B: r, C: n, D: o, E: s, F: i, G: a, H: u } = this;
+    return [e, r, n, o, s, i, a, u];
+  }
+  // prettier-ignore
+  set(e, r, n, o, s, i, a, u) {
+    this.A = e | 0, this.B = r | 0, this.C = n | 0, this.D = o | 0, this.E = s | 0, this.F = i | 0, this.G = a | 0, this.H = u | 0;
+  }
+  process(e, r) {
+    for (let y = 0; y < 16; y++, r += 4)
+      et[y] = e.getUint32(r, !1);
+    for (let y = 16; y < 64; y++) {
+      const c = et[y - 15], f = et[y - 2], h = X(c, 7) ^ X(c, 18) ^ c >>> 3, w = X(f, 17) ^ X(f, 19) ^ f >>> 10;
+      et[y] = w + et[y - 7] + h + et[y - 16] | 0;
+    }
+    let { A: n, B: o, C: s, D: i, E: a, F: u, G: l, H: m } = this;
+    for (let y = 0; y < 64; y++) {
+      const c = X(a, 6) ^ X(a, 11) ^ X(a, 25), f = m + c + Qn(a, u, l) + er[y] + et[y] | 0, w = (X(n, 2) ^ X(n, 13) ^ X(n, 22)) + Jn(n, o, s) | 0;
+      m = l, l = u, u = a, a = i + f | 0, i = s, s = o, o = n, n = f + w | 0;
+    }
+    n = n + this.A | 0, o = o + this.B | 0, s = s + this.C | 0, i = i + this.D | 0, a = a + this.E | 0, u = u + this.F | 0, l = l + this.G | 0, m = m + this.H | 0, this.set(n, o, s, i, a, u, l, m);
+  }
+  roundClean() {
+    _t(et);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), _t(this.buffer);
+  }
+}
+const ne = /* @__PURE__ */ Wn(() => new nr());
+class tn extends Je {
+  constructor(e, r) {
+    super(), this.finished = !1, this.destroyed = !1, We(e);
+    const n = fe(r);
+    if (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 o = this.blockLen, s = new Uint8Array(o);
+    s.set(n.length > o ? e.create().update(n).digest() : n);
+    for (let i = 0; i < s.length; i++)
+      s[i] ^= 54;
+    this.iHash.update(s), this.oHash = e.create();
+    for (let i = 0; i < s.length; i++)
+      s[i] ^= 106;
+    this.oHash.update(s), _t(s);
+  }
+  update(e) {
+    return $t(this), this.iHash.update(e), this;
+  }
+  digestInto(e) {
+    $t(this), ut(e, this.outputLen), 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 || (e = Object.create(Object.getPrototypeOf(this), {}));
+    const { oHash: r, iHash: n, finished: o, destroyed: s, blockLen: i, outputLen: a } = this;
+    return e = e, e.finished = o, e.destroyed = s, e.blockLen = i, e.outputLen = a, e.oHash = r._cloneInto(e.oHash), e.iHash = n._cloneInto(e.iHash), e;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+  }
+}
+const en = (t, e, r) => new tn(t, e).update(r).digest();
+en.create = (t, e) => new tn(t, e);
+const le = /* @__PURE__ */ BigInt(0), re = /* @__PURE__ */ BigInt(1);
+function Rt(t, e = "") {
+  if (typeof t != "boolean") {
+    const r = e && `"${e}"`;
+    throw new Error(r + "expected boolean, got type=" + typeof t);
+  }
+  return t;
+}
+function st(t, e, r = "") {
+  const n = qt(t), o = t == null ? void 0 : t.length, s = e !== void 0;
+  if (!n || s && o !== e) {
+    const i = r && `"${r}" `, a = s ? ` of length ${e}` : "", u = n ? `length=${o}` : `type=${typeof t}`;
+    throw new Error(i + "expected Uint8Array" + a + ", got " + u);
+  }
+  return t;
+}
+function Ct(t) {
+  const e = t.toString(16);
+  return e.length & 1 ? "0" + e : e;
+}
+function nn(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  return t === "" ? le : BigInt("0x" + t);
+}
+function wt(t) {
+  return nn(ht(t));
+}
+function rn(t) {
+  return ut(t), nn(ht(Uint8Array.from(t).reverse()));
+}
+function Kt(t, e) {
+  return Vt(t.toString(16).padStart(e * 2, "0"));
+}
+function on(t, e) {
+  return Kt(t, e).reverse();
+}
+function O(t, e, r) {
+  let n;
+  if (typeof e == "string")
+    try {
+      n = Vt(e);
+    } catch (s) {
+      throw new Error(t + " must be hex string or Uint8Array, cause: " + s);
+    }
+  else if (qt(e))
+    n = Uint8Array.from(e);
+  else
+    throw new Error(t + " must be hex string or Uint8Array");
+  const o = n.length;
+  if (typeof r == "number" && o !== r)
+    throw new Error(t + " of length " + r + " expected, got " + o);
+  return n;
+}
+const Zt = (t) => typeof t == "bigint" && le <= t;
+function oe(t, e, r) {
+  return Zt(t) && Zt(e) && Zt(r) && e <= t && t < r;
+}
+function rr(t, e, r, n) {
+  if (!oe(e, r, n))
+    throw new Error("expected valid " + t + ": " + r + " <= n < " + n + ", got " + e);
+}
+function sn(t) {
+  let e;
+  for (e = 0; t > le; t >>= re, e += 1)
+    ;
+  return e;
+}
+const Bt = (t) => (re << BigInt(t)) - re;
+function or(t, e, r) {
+  if (typeof t != "number" || t < 2)
+    throw new Error("hashLen must be a number");
+  if (typeof e != "number" || e < 2)
+    throw new Error("qByteLen must be a number");
+  if (typeof r != "function")
+    throw new Error("hmacFn must be a function");
+  const n = (f) => new Uint8Array(f), o = (f) => Uint8Array.of(f);
+  let s = n(t), i = n(t), a = 0;
+  const u = () => {
+    s.fill(1), i.fill(0), a = 0;
+  }, l = (...f) => r(i, s, ...f), m = (f = n(0)) => {
+    i = l(o(0), f), s = l(), f.length !== 0 && (i = l(o(1), f), s = l());
+  }, y = () => {
+    if (a++ >= 1e3)
+      throw new Error("drbg: tried 1000 values");
+    let f = 0;
+    const h = [];
+    for (; f < e; ) {
+      s = l();
+      const w = s.slice();
+      h.push(w), f += s.length;
+    }
+    return Y(...h);
+  };
+  return (f, h) => {
+    u(), m(f);
+    let w;
+    for (; !(w = h(y())); )
+      m();
+    return u(), w;
+  };
+}
+function de(t, e, r = {}) {
+  if (!t || typeof t != "object")
+    throw new Error("expected valid options object");
+  function n(o, s, i) {
+    const a = t[o];
+    if (i && a === void 0)
+      return;
+    const u = typeof a;
+    if (u !== s || a === null)
+      throw new Error(`param "${o}" is invalid: expected ${s}, got ${u}`);
+  }
+  Object.entries(e).forEach(([o, s]) => n(o, s, !1)), Object.entries(r).forEach(([o, s]) => n(o, s, !0));
+}
+function Ae(t) {
+  const e = /* @__PURE__ */ new WeakMap();
+  return (r, ...n) => {
+    const o = e.get(r);
+    if (o !== void 0)
+      return o;
+    const s = t(r, ...n);
+    return e.set(r, s), s;
+  };
+}
+const M = BigInt(0), K = BigInt(1), it = /* @__PURE__ */ BigInt(2), cn = /* @__PURE__ */ BigInt(3), an = /* @__PURE__ */ BigInt(4), un = /* @__PURE__ */ BigInt(5), sr = /* @__PURE__ */ BigInt(7), fn = /* @__PURE__ */ BigInt(8), ir = /* @__PURE__ */ BigInt(9), ln = /* @__PURE__ */ BigInt(16);
+function D(t, e) {
+  const r = t % e;
+  return r >= M ? r : e + r;
+}
+function Z(t, e, r) {
+  let n = t;
+  for (; e-- > M; )
+    n *= n, n %= r;
+  return n;
+}
+function Se(t, e) {
+  if (t === M)
+    throw new Error("invert: expected non-zero number");
+  if (e <= M)
+    throw new Error("invert: expected positive modulus, got " + e);
+  let r = D(t, e), n = e, o = M, s = K;
+  for (; r !== M; ) {
+    const a = n / r, u = n % r, l = o - s * a;
+    n = r, r = u, o = s, s = l;
+  }
+  if (n !== K)
+    throw new Error("invert: does not exist");
+  return D(o, e);
+}
+function he(t, e, r) {
+  if (!t.eql(t.sqr(e), r))
+    throw new Error("Cannot find square root");
+}
+function dn(t, e) {
+  const r = (t.ORDER + K) / an, n = t.pow(e, r);
+  return he(t, n, e), n;
+}
+function cr(t, e) {
+  const r = (t.ORDER - un) / fn, n = t.mul(e, it), o = t.pow(n, r), s = t.mul(e, o), i = t.mul(t.mul(s, it), o), a = t.mul(s, t.sub(i, t.ONE));
+  return he(t, a, e), a;
+}
+function ar(t) {
+  const e = vt(t), r = hn(t), n = r(e, e.neg(e.ONE)), o = r(e, n), s = r(e, e.neg(n)), i = (t + sr) / ln;
+  return (a, u) => {
+    let l = a.pow(u, i), m = a.mul(l, n);
+    const y = a.mul(l, o), c = a.mul(l, s), f = a.eql(a.sqr(m), u), h = a.eql(a.sqr(y), u);
+    l = a.cmov(l, m, f), m = a.cmov(c, y, h);
+    const w = a.eql(a.sqr(m), u), A = a.cmov(l, m, w);
+    return he(a, A, u), A;
+  };
+}
+function hn(t) {
+  if (t < cn)
+    throw new Error("sqrt is not defined for small field");
+  let e = t - K, r = 0;
+  for (; e % it === M; )
+    e /= it, r++;
+  let n = it;
+  const o = vt(t);
+  for (; Ce(o, n) === 1; )
+    if (n++ > 1e3)
+      throw new Error("Cannot find square root: probably non-prime P");
+  if (r === 1)
+    return dn;
+  let s = o.pow(n, e);
+  const i = (e + K) / it;
+  return function(u, l) {
+    if (u.is0(l))
+      return l;
+    if (Ce(u, l) !== 1)
+      throw new Error("Cannot find square root");
+    let m = r, y = u.mul(u.ONE, s), c = u.pow(l, e), f = u.pow(l, i);
+    for (; !u.eql(c, u.ONE); ) {
+      if (u.is0(c))
+        return u.ZERO;
+      let h = 1, w = u.sqr(c);
+      for (; !u.eql(w, u.ONE); )
+        if (h++, w = u.sqr(w), h === m)
+          throw new Error("Cannot find square root");
+      const A = K << BigInt(m - h - 1), _ = u.pow(y, A);
+      m = h, y = u.sqr(_), c = u.mul(c, y), f = u.mul(f, _);
+    }
+    return f;
+  };
+}
+function ur(t) {
+  return t % an === cn ? dn : t % fn === un ? cr : t % ln === ir ? ar(t) : hn(t);
+}
+const fr = [
+  "create",
+  "isValid",
+  "is0",
+  "neg",
+  "inv",
+  "sqrt",
+  "sqr",
+  "eql",
+  "add",
+  "sub",
+  "mul",
+  "pow",
+  "div",
+  "addN",
+  "subN",
+  "mulN",
+  "sqrN"
+];
+function lr(t) {
+  const e = {
+    ORDER: "bigint",
+    MASK: "bigint",
+    BYTES: "number",
+    BITS: "number"
+  }, r = fr.reduce((n, o) => (n[o] = "function", n), e);
+  return de(t, r), t;
+}
+function dr(t, e, r) {
+  if (r < M)
+    throw new Error("invalid exponent, negatives unsupported");
+  if (r === M)
+    return t.ONE;
+  if (r === K)
+    return e;
+  let n = t.ONE, o = e;
+  for (; r > M; )
+    r & K && (n = t.mul(n, o)), o = t.sqr(o), r >>= K;
+  return n;
+}
+function gn(t, e, r = !1) {
+  const n = new Array(e.length).fill(r ? t.ZERO : void 0), o = e.reduce((i, a, u) => t.is0(a) ? i : (n[u] = i, t.mul(i, a)), t.ONE), s = t.inv(o);
+  return e.reduceRight((i, a, u) => t.is0(a) ? i : (n[u] = t.mul(i, n[u]), t.mul(i, a)), s), n;
+}
+function Ce(t, e) {
+  const r = (t.ORDER - K) / it, n = t.pow(e, r), o = t.eql(n, t.ONE), s = t.eql(n, t.ZERO), i = t.eql(n, t.neg(t.ONE));
+  if (!o && !s && !i)
+    throw new Error("invalid Legendre symbol result");
+  return o ? 1 : s ? 0 : -1;
+}
+function pn(t, e) {
+  e !== void 0 && ee(e);
+  const r = e !== void 0 ? e : t.toString(2).length, n = Math.ceil(r / 8);
+  return { nBitLength: r, nByteLength: n };
+}
+function vt(t, e, r = !1, n = {}) {
+  if (t <= M)
+    throw new Error("invalid field: expected ORDER > 0, got " + t);
+  let o, s, i = !1, a;
+  if (typeof e == "object" && e != null) {
+    if (n.sqrt || r)
+      throw new Error("cannot specify opts in two arguments");
+    const c = e;
+    c.BITS && (o = c.BITS), c.sqrt && (s = c.sqrt), typeof c.isLE == "boolean" && (r = c.isLE), typeof c.modFromBytes == "boolean" && (i = c.modFromBytes), a = c.allowedLengths;
+  } else
+    typeof e == "number" && (o = e), n.sqrt && (s = n.sqrt);
+  const { nBitLength: u, nByteLength: l } = pn(t, o);
+  if (l > 2048)
+    throw new Error("invalid field: expected ORDER of <= 2048 bytes");
+  let m;
+  const y = Object.freeze({
+    ORDER: t,
+    isLE: r,
+    BITS: u,
+    BYTES: l,
+    MASK: Bt(u),
+    ZERO: M,
+    ONE: K,
+    allowedLengths: a,
+    create: (c) => D(c, t),
+    isValid: (c) => {
+      if (typeof c != "bigint")
+        throw new Error("invalid field element: expected bigint, got " + typeof c);
+      return M <= c && c < t;
+    },
+    is0: (c) => c === M,
+    // is valid and invertible
+    isValidNot0: (c) => !y.is0(c) && y.isValid(c),
+    isOdd: (c) => (c & K) === K,
+    neg: (c) => D(-c, t),
+    eql: (c, f) => c === f,
+    sqr: (c) => D(c * c, t),
+    add: (c, f) => D(c + f, t),
+    sub: (c, f) => D(c - f, t),
+    mul: (c, f) => D(c * f, t),
+    pow: (c, f) => dr(y, c, f),
+    div: (c, f) => D(c * Se(f, t), t),
+    // Same as above, but doesn't normalize
+    sqrN: (c) => c * c,
+    addN: (c, f) => c + f,
+    subN: (c, f) => c - f,
+    mulN: (c, f) => c * f,
+    inv: (c) => Se(c, t),
+    sqrt: s || ((c) => (m || (m = ur(t)), m(y, c))),
+    toBytes: (c) => r ? on(c, l) : Kt(c, l),
+    fromBytes: (c, f = !0) => {
+      if (a) {
+        if (!a.includes(c.length) || c.length > l)
+          throw new Error("Field.fromBytes: expected " + a + " bytes, got " + c.length);
+        const w = new Uint8Array(l);
+        w.set(c, r ? 0 : w.length - c.length), c = w;
+      }
+      if (c.length !== l)
+        throw new Error("Field.fromBytes: expected " + l + " bytes, got " + c.length);
+      let h = r ? rn(c) : wt(c);
+      if (i && (h = D(h, t)), !f && !y.isValid(h))
+        throw new Error("invalid field element: outside of range 0..ORDER");
+      return h;
+    },
+    // TODO: we don't need it here, move out to separate fn
+    invertBatch: (c) => gn(y, c),
+    // We can't move this out because Fp6, Fp12 implement it
+    // and it's unclear what to return in there.
+    cmov: (c, f, h) => h ? f : c
+  });
+  return Object.freeze(y);
+}
+function mn(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 wn(t) {
+  const e = mn(t);
+  return e + Math.ceil(e / 2);
+}
+function yn(t, e, r = !1) {
+  const n = t.length, o = mn(e), s = wn(e);
+  if (n < 16 || n < s || n > 1024)
+    throw new Error("expected " + s + "-1024 bytes of input, got " + n);
+  const i = r ? rn(t) : wt(t), a = D(i, e - K) + K;
+  return r ? on(a, o) : Kt(a, o);
+}
+const pt = BigInt(0), ct = BigInt(1);
+function Nt(t, e) {
+  const r = e.negate();
+  return t ? r : e;
+}
+function Dt(t, e) {
+  const r = gn(t.Fp, e.map((n) => n.Z));
+  return e.map((n, o) => t.fromAffine(n.toAffine(r[o])));
+}
+function bn(t, e) {
+  if (!Number.isSafeInteger(t) || t <= 0 || t > e)
+    throw new Error("invalid window size, expected [1.." + e + "], got W=" + t);
+}
+function zt(t, e) {
+  bn(t, e);
+  const r = Math.ceil(e / t) + 1, n = 2 ** (t - 1), o = 2 ** t, s = Bt(t), i = BigInt(t);
+  return { windows: r, windowSize: n, mask: s, maxNumber: o, shiftBy: i };
+}
+function Te(t, e, r) {
+  const { windowSize: n, mask: o, maxNumber: s, shiftBy: i } = r;
+  let a = Number(t & o), u = t >> i;
+  a > n && (a -= s, u += ct);
+  const l = e * n, m = l + Math.abs(a) - 1, y = a === 0, c = a < 0, f = e % 2 !== 0;
+  return { nextN: u, offset: m, isZero: y, isNeg: c, isNegF: f, offsetF: l };
+}
+function hr(t, e) {
+  if (!Array.isArray(t))
+    throw new Error("array expected");
+  t.forEach((r, n) => {
+    if (!(r instanceof e))
+      throw new Error("invalid point at index " + n);
+  });
+}
+function gr(t, e) {
+  if (!Array.isArray(t))
+    throw new Error("array of scalars expected");
+  t.forEach((r, n) => {
+    if (!e.isValid(r))
+      throw new Error("invalid scalar at index " + n);
+  });
+}
+const Xt = /* @__PURE__ */ new WeakMap(), En = /* @__PURE__ */ new WeakMap();
+function Yt(t) {
+  return En.get(t) || 1;
+}
+function $e(t) {
+  if (t !== pt)
+    throw new Error("invalid wNAF");
+}
+class pr {
+  // Parametrized with a given Point class (not individual point)
+  constructor(e, r) {
+    this.BASE = e.BASE, this.ZERO = e.ZERO, this.Fn = e.Fn, this.bits = r;
+  }
+  // non-const time multiplication ladder
+  _unsafeLadder(e, r, n = this.ZERO) {
+    let o = e;
+    for (; r > pt; )
+      r & ct && (n = n.add(o)), o = o.double(), r >>= ct;
+    return n;
+  }
+  /**
+   * 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, r) {
+    const { windows: n, windowSize: o } = zt(r, this.bits), s = [];
+    let i = e, a = i;
+    for (let u = 0; u < n; u++) {
+      a = i, s.push(a);
+      for (let l = 1; l < o; l++)
+        a = a.add(i), s.push(a);
+      i = a.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, r, n) {
+    if (!this.Fn.isValid(n))
+      throw new Error("invalid scalar");
+    let o = this.ZERO, s = this.BASE;
+    const i = zt(e, this.bits);
+    for (let a = 0; a < i.windows; a++) {
+      const { nextN: u, offset: l, isZero: m, isNeg: y, isNegF: c, offsetF: f } = Te(n, a, i);
+      n = u, m ? s = s.add(Nt(c, r[f])) : o = o.add(Nt(y, r[l]));
+    }
+    return $e(n), { 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, r, n, o = this.ZERO) {
+    const s = zt(e, this.bits);
+    for (let i = 0; i < s.windows && n !== pt; i++) {
+      const { nextN: a, offset: u, isZero: l, isNeg: m } = Te(n, i, s);
+      if (n = a, !l) {
+        const y = r[u];
+        o = o.add(m ? y.negate() : y);
+      }
+    }
+    return $e(n), o;
+  }
+  getPrecomputes(e, r, n) {
+    let o = Xt.get(r);
+    return o || (o = this.precomputeWindow(r, e), e !== 1 && (typeof n == "function" && (o = n(o)), Xt.set(r, o))), o;
+  }
+  cached(e, r, n) {
+    const o = Yt(e);
+    return this.wNAF(o, this.getPrecomputes(o, e, n), r);
+  }
+  unsafe(e, r, n, o) {
+    const s = Yt(e);
+    return s === 1 ? this._unsafeLadder(e, r, o) : this.wNAFUnsafe(s, this.getPrecomputes(s, e, n), r, 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, r) {
+    bn(r, this.bits), En.set(e, r), Xt.delete(e);
+  }
+  hasCache(e) {
+    return Yt(e) !== 1;
+  }
+}
+function mr(t, e, r, n) {
+  let o = e, s = t.ZERO, i = t.ZERO;
+  for (; r > pt || n > pt; )
+    r & ct && (s = s.add(o)), n & ct && (i = i.add(o)), o = o.double(), r >>= ct, n >>= ct;
+  return { p1: s, p2: i };
+}
+function wr(t, e, r, n) {
+  hr(r, t), gr(n, e);
+  const o = r.length, s = n.length;
+  if (o !== s)
+    throw new Error("arrays of points and scalars must have equal length");
+  const i = t.ZERO, a = sn(BigInt(o));
+  let u = 1;
+  a > 12 ? u = a - 3 : a > 4 ? u = a - 2 : a > 0 && (u = 2);
+  const l = Bt(u), m = new Array(Number(l) + 1).fill(i), y = Math.floor((e.BITS - 1) / u) * u;
+  let c = i;
+  for (let f = y; f >= 0; f -= u) {
+    m.fill(i);
+    for (let w = 0; w < s; w++) {
+      const A = n[w], _ = Number(A >> BigInt(f) & l);
+      m[_] = m[_].add(r[w]);
+    }
+    let h = i;
+    for (let w = m.length - 1, A = i; w > 0; w--)
+      A = A.add(m[w]), h = h.add(A);
+    if (c = c.add(h), f !== 0)
+      for (let w = 0; w < u; w++)
+        c = c.double();
+  }
+  return c;
+}
+function _e(t, e, r) {
+  if (e) {
+    if (e.ORDER !== t)
+      throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+    return lr(e), e;
+  } else
+    return vt(t, { isLE: r });
+}
+function yr(t, e, r = {}, n) {
+  if (n === void 0 && (n = t === "edwards"), !e || typeof e != "object")
+    throw new Error(`expected valid ${t} CURVE object`);
+  for (const u of ["p", "n", "h"]) {
+    const l = e[u];
+    if (!(typeof l == "bigint" && l > pt))
+      throw new Error(`CURVE.${u} must be positive bigint`);
+  }
+  const o = _e(e.p, r.Fp, n), s = _e(e.n, r.Fn, n), a = ["Gx", "Gy", "a", "b"];
+  for (const u of a)
+    if (!o.isValid(e[u]))
+      throw new Error(`CURVE.${u} must be valid field element of CURVE.Fp`);
+  return e = Object.freeze(Object.assign({}, e)), { CURVE: e, Fp: o, Fn: s };
+}
+const Ve = (t, e) => (t + (t >= 0 ? e : -e) / xn) / e;
+function br(t, e, r) {
+  const [[n, o], [s, i]] = e, a = Ve(i * t, r), u = Ve(-o * t, r);
+  let l = t - a * n - u * s, m = -a * o - u * i;
+  const y = l < Q, c = m < Q;
+  y && (l = -l), c && (m = -m);
+  const f = Bt(Math.ceil(sn(r) / 2)) + gt;
+  if (l < Q || l >= f || m < Q || m >= f)
+    throw new Error("splitScalar (endomorphism): failed, k=" + t);
+  return { k1neg: y, k1: l, k2neg: c, k2: m };
+}
+function se(t) {
+  if (!["compact", "recovered", "der"].includes(t))
+    throw new Error('Signature format must be "compact", "recovered", or "der"');
+  return t;
+}
+function jt(t, e) {
+  const r = {};
+  for (let n of Object.keys(e))
+    r[n] = t[n] === void 0 ? e[n] : t[n];
+  return Rt(r.lowS, "lowS"), Rt(r.prehash, "prehash"), r.format !== void 0 && se(r.format), r;
+}
+class Er extends Error {
+  constructor(e = "") {
+    super(e);
+  }
+}
+const G = {
+  // asn.1 DER encoding utils
+  Err: Er,
+  // Basic building block is TLV (Tag-Length-Value)
+  _tlv: {
+    encode: (t, e) => {
+      const { Err: r } = G;
+      if (t < 0 || t > 256)
+        throw new r("tlv.encode: wrong tag");
+      if (e.length & 1)
+        throw new r("tlv.encode: unpadded data");
+      const n = e.length / 2, o = Ct(n);
+      if (o.length / 2 & 128)
+        throw new r("tlv.encode: long form length too big");
+      const s = n > 127 ? Ct(o.length / 2 | 128) : "";
+      return Ct(t) + s + o + e;
+    },
+    // v - value, l - left bytes (unparsed)
+    decode(t, e) {
+      const { Err: r } = G;
+      let n = 0;
+      if (t < 0 || t > 256)
+        throw new r("tlv.encode: wrong tag");
+      if (e.length < 2 || e[n++] !== t)
+        throw new r("tlv.decode: wrong tlv");
+      const o = e[n++], s = !!(o & 128);
+      let i = 0;
+      if (!s)
+        i = o;
+      else {
+        const u = o & 127;
+        if (!u)
+          throw new r("tlv.decode(long): indefinite length not supported");
+        if (u > 4)
+          throw new r("tlv.decode(long): byte length is too big");
+        const l = e.subarray(n, n + u);
+        if (l.length !== u)
+          throw new r("tlv.decode: length bytes not complete");
+        if (l[0] === 0)
+          throw new r("tlv.decode(long): zero leftmost byte");
+        for (const m of l)
+          i = i << 8 | m;
+        if (n += u, i < 128)
+          throw new r("tlv.decode(long): not minimal encoding");
+      }
+      const a = e.subarray(n, n + i);
+      if (a.length !== i)
+        throw new r("tlv.decode: wrong value length");
+      return { v: a, l: e.subarray(n + 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 } = G;
+      if (t < Q)
+        throw new e("integer: negative integers are not allowed");
+      let r = Ct(t);
+      if (Number.parseInt(r[0], 16) & 8 && (r = "00" + r), r.length & 1)
+        throw new e("unexpected DER parsing assertion: unpadded hex");
+      return r;
+    },
+    decode(t) {
+      const { Err: e } = G;
+      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 wt(t);
+    }
+  },
+  toSig(t) {
+    const { Err: e, _int: r, _tlv: n } = G, o = O("signature", t), { v: s, l: i } = n.decode(48, o);
+    if (i.length)
+      throw new e("invalid signature: left bytes after parsing");
+    const { v: a, l: u } = n.decode(2, s), { v: l, l: m } = n.decode(2, u);
+    if (m.length)
+      throw new e("invalid signature: left bytes after parsing");
+    return { r: r.decode(a), s: r.decode(l) };
+  },
+  hexFromSig(t) {
+    const { _tlv: e, _int: r } = G, n = e.encode(2, r.encode(t.r)), o = e.encode(2, r.encode(t.s)), s = n + o;
+    return e.encode(48, s);
+  }
+}, Q = BigInt(0), gt = BigInt(1), xn = BigInt(2), Tt = BigInt(3), xr = BigInt(4);
+function at(t, e) {
+  const { BYTES: r } = t;
+  let n;
+  if (typeof e == "bigint")
+    n = e;
+  else {
+    let o = O("private key", e);
+    try {
+      n = t.fromBytes(o);
+    } catch {
+      throw new Error(`invalid private key: expected ui8a of size ${r}, got ${typeof e}`);
+    }
+  }
+  if (!t.isValidNot0(n))
+    throw new Error("invalid private key: out of range [1..N-1]");
+  return n;
+}
+function Br(t, e = {}) {
+  const r = yr("weierstrass", t, e), { Fp: n, Fn: o } = r;
+  let s = r.CURVE;
+  const { h: i, n: a } = s;
+  de(e, {}, {
+    allowInfinityPoint: "boolean",
+    clearCofactor: "function",
+    isTorsionFree: "function",
+    fromBytes: "function",
+    toBytes: "function",
+    endo: "object",
+    wrapPrivateKey: "boolean"
+  });
+  const { endo: u } = e;
+  if (u && (!n.is0(s.a) || typeof u.beta != "bigint" || !Array.isArray(u.basises)))
+    throw new Error('invalid endo: expected "beta": bigint and "basises": array');
+  const l = vn(n, o);
+  function m() {
+    if (!n.isOdd)
+      throw new Error("compression is not supported: Field does not have .isOdd()");
+  }
+  function y(T, p, g) {
+    const { x: d, y: b } = p.toAffine(), E = n.toBytes(d);
+    if (Rt(g, "isCompressed"), g) {
+      m();
+      const v = !n.isOdd(b);
+      return Y(Bn(v), E);
+    } else
+      return Y(Uint8Array.of(4), E, n.toBytes(b));
+  }
+  function c(T) {
+    st(T, void 0, "Point");
+    const { publicKey: p, publicKeyUncompressed: g } = l, d = T.length, b = T[0], E = T.subarray(1);
+    if (d === p && (b === 2 || b === 3)) {
+      const v = n.fromBytes(E);
+      if (!n.isValid(v))
+        throw new Error("bad point: is not on curve, wrong x");
+      const B = w(v);
+      let x;
+      try {
+        x = n.sqrt(B);
+      } catch (H) {
+        const $ = H instanceof Error ? ": " + H.message : "";
+        throw new Error("bad point: is not on curve, sqrt error" + $);
+      }
+      m();
+      const P = n.isOdd(x);
+      return (b & 1) === 1 !== P && (x = n.neg(x)), { x: v, y: x };
+    } else if (d === g && b === 4) {
+      const v = n.BYTES, B = n.fromBytes(E.subarray(0, v)), x = n.fromBytes(E.subarray(v, v * 2));
+      if (!A(B, x))
+        throw new Error("bad point: is not on curve");
+      return { x: B, y: x };
+    } else
+      throw new Error(`bad point: got length ${d}, expected compressed=${p} or uncompressed=${g}`);
+  }
+  const f = e.toBytes || y, h = e.fromBytes || c;
+  function w(T) {
+    const p = n.sqr(T), g = n.mul(p, T);
+    return n.add(n.add(g, n.mul(T, s.a)), s.b);
+  }
+  function A(T, p) {
+    const g = n.sqr(p), d = w(T);
+    return n.eql(g, d);
+  }
+  if (!A(s.Gx, s.Gy))
+    throw new Error("bad curve params: generator point");
+  const _ = n.mul(n.pow(s.a, Tt), xr), nt = n.mul(n.sqr(s.b), BigInt(27));
+  if (n.is0(n.add(_, nt)))
+    throw new Error("bad curve params: a or b");
+  function V(T, p, g = !1) {
+    if (!n.isValid(p) || g && n.is0(p))
+      throw new Error(`bad point coordinate ${T}`);
+    return p;
+  }
+  function j(T) {
+    if (!(T instanceof S))
+      throw new Error("ProjectivePoint expected");
+  }
+  function z(T) {
+    if (!u || !u.basises)
+      throw new Error("no endo");
+    return br(T, u.basises, o.ORDER);
+  }
+  const q = Ae((T, p) => {
+    const { X: g, Y: d, Z: b } = T;
+    if (n.eql(b, n.ONE))
+      return { x: g, y: d };
+    const E = T.is0();
+    p == null && (p = E ? n.ONE : n.inv(b));
+    const v = n.mul(g, p), B = n.mul(d, p), x = n.mul(b, p);
+    if (E)
+      return { x: n.ZERO, y: n.ZERO };
+    if (!n.eql(x, n.ONE))
+      throw new Error("invZ was invalid");
+    return { x: v, y: B };
+  }), J = Ae((T) => {
+    if (T.is0()) {
+      if (e.allowInfinityPoint && !n.is0(T.Y))
+        return;
+      throw new Error("bad point: ZERO");
+    }
+    const { x: p, y: g } = T.toAffine();
+    if (!n.isValid(p) || !n.isValid(g))
+      throw new Error("bad point: x or y not field elements");
+    if (!A(p, g))
+      throw new Error("bad point: equation left != right");
+    if (!T.isTorsionFree())
+      throw new Error("bad point: not in prime-order subgroup");
+    return !0;
+  });
+  function ft(T, p, g, d, b) {
+    return g = new S(n.mul(g.X, T), g.Y, g.Z), p = Nt(d, p), g = Nt(b, g), p.add(g);
+  }
+  class S {
+    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+    constructor(p, g, d) {
+      this.X = V("x", p), this.Y = V("y", g, !0), this.Z = V("z", d), Object.freeze(this);
+    }
+    static CURVE() {
+      return s;
+    }
+    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+    static fromAffine(p) {
+      const { x: g, y: d } = p || {};
+      if (!p || !n.isValid(g) || !n.isValid(d))
+        throw new Error("invalid affine point");
+      if (p instanceof S)
+        throw new Error("projective point not allowed");
+      return n.is0(g) && n.is0(d) ? S.ZERO : new S(g, d, n.ONE);
+    }
+    static fromBytes(p) {
+      const g = S.fromAffine(h(st(p, void 0, "point")));
+      return g.assertValidity(), g;
+    }
+    static fromHex(p) {
+      return S.fromBytes(O("pointHex", p));
+    }
+    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(p = 8, g = !0) {
+      return rt.createCache(this, p), g || this.multiply(Tt), this;
+    }
+    // TODO: return `this`
+    /** A point on curve is valid if it conforms to equation. */
+    assertValidity() {
+      J(this);
+    }
+    hasEvenY() {
+      const { y: p } = this.toAffine();
+      if (!n.isOdd)
+        throw new Error("Field doesn't support isOdd");
+      return !n.isOdd(p);
+    }
+    /** Compare one point to another. */
+    equals(p) {
+      j(p);
+      const { X: g, Y: d, Z: b } = this, { X: E, Y: v, Z: B } = p, x = n.eql(n.mul(g, B), n.mul(E, b)), P = n.eql(n.mul(d, B), n.mul(v, b));
+      return x && P;
+    }
+    /** Flips point to one corresponding to (x, -y) in Affine coordinates. */
+    negate() {
+      return new S(this.X, n.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: p, b: g } = s, d = n.mul(g, Tt), { X: b, Y: E, Z: v } = this;
+      let B = n.ZERO, x = n.ZERO, P = n.ZERO, I = n.mul(b, b), H = n.mul(E, E), $ = n.mul(v, v), C = n.mul(b, E);
+      return C = n.add(C, C), P = n.mul(b, v), P = n.add(P, P), B = n.mul(p, P), x = n.mul(d, $), x = n.add(B, x), B = n.sub(H, x), x = n.add(H, x), x = n.mul(B, x), B = n.mul(C, B), P = n.mul(d, P), $ = n.mul(p, $), C = n.sub(I, $), C = n.mul(p, C), C = n.add(C, P), P = n.add(I, I), I = n.add(P, I), I = n.add(I, $), I = n.mul(I, C), x = n.add(x, I), $ = n.mul(E, v), $ = n.add($, $), I = n.mul($, C), B = n.sub(B, I), P = n.mul($, H), P = n.add(P, P), P = n.add(P, P), new S(B, x, P);
+    }
+    // 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(p) {
+      j(p);
+      const { X: g, Y: d, Z: b } = this, { X: E, Y: v, Z: B } = p;
+      let x = n.ZERO, P = n.ZERO, I = n.ZERO;
+      const H = s.a, $ = n.mul(s.b, Tt);
+      let C = n.mul(g, E), R = n.mul(d, v), k = n.mul(b, B), L = n.add(g, d), N = n.add(E, v);
+      L = n.mul(L, N), N = n.add(C, R), L = n.sub(L, N), N = n.add(g, b);
+      let U = n.add(E, B);
+      return N = n.mul(N, U), U = n.add(C, k), N = n.sub(N, U), U = n.add(d, b), x = n.add(v, B), U = n.mul(U, x), x = n.add(R, k), U = n.sub(U, x), I = n.mul(H, N), x = n.mul($, k), I = n.add(x, I), x = n.sub(R, I), I = n.add(R, I), P = n.mul(x, I), R = n.add(C, C), R = n.add(R, C), k = n.mul(H, k), N = n.mul($, N), R = n.add(R, k), k = n.sub(C, k), k = n.mul(H, k), N = n.add(N, k), C = n.mul(R, N), P = n.add(P, C), C = n.mul(U, N), x = n.mul(L, x), x = n.sub(x, C), C = n.mul(L, R), I = n.mul(U, I), I = n.add(I, C), new S(x, P, I);
+    }
+    subtract(p) {
+      return this.add(p.negate());
+    }
+    is0() {
+      return this.equals(S.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(p) {
+      const { endo: g } = e;
+      if (!o.isValidNot0(p))
+        throw new Error("invalid scalar: out of range");
+      let d, b;
+      const E = (v) => rt.cached(this, v, (B) => Dt(S, B));
+      if (g) {
+        const { k1neg: v, k1: B, k2neg: x, k2: P } = z(p), { p: I, f: H } = E(B), { p: $, f: C } = E(P);
+        b = H.add(C), d = ft(g.beta, I, $, v, x);
+      } else {
+        const { p: v, f: B } = E(p);
+        d = v, b = B;
+      }
+      return Dt(S, [d, b])[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(p) {
+      const { endo: g } = e, d = this;
+      if (!o.isValid(p))
+        throw new Error("invalid scalar: out of range");
+      if (p === Q || d.is0())
+        return S.ZERO;
+      if (p === gt)
+        return d;
+      if (rt.hasCache(this))
+        return this.multiply(p);
+      if (g) {
+        const { k1neg: b, k1: E, k2neg: v, k2: B } = z(p), { p1: x, p2: P } = mr(S, d, E, B);
+        return ft(g.beta, x, P, b, v);
+      } else
+        return rt.unsafe(d, p);
+    }
+    multiplyAndAddUnsafe(p, g, d) {
+      const b = this.multiplyUnsafe(g).add(p.multiplyUnsafe(d));
+      return b.is0() ? void 0 : b;
+    }
+    /**
+     * Converts Projective point to affine (x, y) coordinates.
+     * @param invertedZ Z^-1 (inverted zero) - optional, precomputation is useful for invertBatch
+     */
+    toAffine(p) {
+      return q(this, p);
+    }
+    /**
+     * Checks whether Point is free of torsion elements (is in prime subgroup).
+     * Always torsion-free for cofactor=1 curves.
+     */
+    isTorsionFree() {
+      const { isTorsionFree: p } = e;
+      return i === gt ? !0 : p ? p(S, this) : rt.unsafe(this, a).is0();
+    }
+    clearCofactor() {
+      const { clearCofactor: p } = e;
+      return i === gt ? this : p ? p(S, this) : this.multiplyUnsafe(i);
+    }
+    isSmallOrder() {
+      return this.multiplyUnsafe(i).is0();
+    }
+    toBytes(p = !0) {
+      return Rt(p, "isCompressed"), this.assertValidity(), f(S, this, p);
+    }
+    toHex(p = !0) {
+      return ht(this.toBytes(p));
+    }
+    toString() {
+      return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+    }
+    // TODO: remove
+    get px() {
+      return this.X;
+    }
+    get py() {
+      return this.X;
+    }
+    get pz() {
+      return this.Z;
+    }
+    toRawBytes(p = !0) {
+      return this.toBytes(p);
+    }
+    _setWindowSize(p) {
+      this.precompute(p);
+    }
+    static normalizeZ(p) {
+      return Dt(S, p);
+    }
+    static msm(p, g) {
+      return wr(S, o, p, g);
+    }
+    static fromPrivateKey(p) {
+      return S.BASE.multiply(at(o, p));
+    }
+  }
+  S.BASE = new S(s.Gx, s.Gy, n.ONE), S.ZERO = new S(n.ZERO, n.ONE, n.ZERO), S.Fp = n, S.Fn = o;
+  const Pt = o.BITS, rt = new pr(S, e.endo ? Math.ceil(Pt / 2) : Pt);
+  return S.BASE.precompute(8), S;
+}
+function Bn(t) {
+  return Uint8Array.of(t ? 2 : 3);
+}
+function vn(t, e) {
+  return {
+    secretKey: e.BYTES,
+    publicKey: 1 + t.BYTES,
+    publicKeyUncompressed: 1 + 2 * t.BYTES,
+    publicKeyHasPrefix: !0,
+    signature: 2 * e.BYTES
+  };
+}
+function vr(t, e = {}) {
+  const { Fn: r } = t, n = e.randomBytes || Ut, o = Object.assign(vn(t.Fp, r), { seed: wn(r.ORDER) });
+  function s(f) {
+    try {
+      return !!at(r, f);
+    } catch {
+      return !1;
+    }
+  }
+  function i(f, h) {
+    const { publicKey: w, publicKeyUncompressed: A } = o;
+    try {
+      const _ = f.length;
+      return h === !0 && _ !== w || h === !1 && _ !== A ? !1 : !!t.fromBytes(f);
+    } catch {
+      return !1;
+    }
+  }
+  function a(f = n(o.seed)) {
+    return yn(st(f, o.seed, "seed"), r.ORDER);
+  }
+  function u(f, h = !0) {
+    return t.BASE.multiply(at(r, f)).toBytes(h);
+  }
+  function l(f) {
+    const h = a(f);
+    return { secretKey: h, publicKey: u(h) };
+  }
+  function m(f) {
+    if (typeof f == "bigint")
+      return !1;
+    if (f instanceof t)
+      return !0;
+    const { secretKey: h, publicKey: w, publicKeyUncompressed: A } = o;
+    if (r.allowedLengths || h === w)
+      return;
+    const _ = O("key", f).length;
+    return _ === w || _ === A;
+  }
+  function y(f, h, w = !0) {
+    if (m(f) === !0)
+      throw new Error("first arg must be private key");
+    if (m(h) === !1)
+      throw new Error("second arg must be public key");
+    const A = at(r, f);
+    return t.fromHex(h).multiply(A).toBytes(w);
+  }
+  return Object.freeze({ getPublicKey: u, getSharedSecret: y, keygen: l, Point: t, utils: {
+    isValidSecretKey: s,
+    isValidPublicKey: i,
+    randomSecretKey: a,
+    // TODO: remove
+    isValidPrivateKey: s,
+    randomPrivateKey: a,
+    normPrivateKeyToScalar: (f) => at(r, f),
+    precompute(f = 8, h = t.BASE) {
+      return h.precompute(f, !1);
+    }
+  }, lengths: o });
+}
+function Pr(t, e, r = {}) {
+  We(e), de(r, {}, {
+    hmac: "function",
+    lowS: "boolean",
+    randomBytes: "function",
+    bits2int: "function",
+    bits2int_modN: "function"
+  });
+  const n = r.randomBytes || Ut, o = r.hmac || ((g, ...d) => en(e, g, Y(...d))), { Fp: s, Fn: i } = t, { ORDER: a, BITS: u } = i, { keygen: l, getPublicKey: m, getSharedSecret: y, utils: c, lengths: f } = vr(t, r), h = {
+    prehash: !1,
+    lowS: typeof r.lowS == "boolean" ? r.lowS : !1,
+    format: void 0,
+    //'compact' as ECDSASigFormat,
+    extraEntropy: !1
+  }, w = "compact";
+  function A(g) {
+    const d = a >> gt;
+    return g > d;
+  }
+  function _(g, d) {
+    if (!i.isValidNot0(d))
+      throw new Error(`invalid signature ${g}: out of range 1..Point.Fn.ORDER`);
+    return d;
+  }
+  function nt(g, d) {
+    se(d);
+    const b = f.signature, E = d === "compact" ? b : d === "recovered" ? b + 1 : void 0;
+    return st(g, E, `${d} signature`);
+  }
+  class V {
+    constructor(d, b, E) {
+      this.r = _("r", d), this.s = _("s", b), E != null && (this.recovery = E), Object.freeze(this);
+    }
+    static fromBytes(d, b = w) {
+      nt(d, b);
+      let E;
+      if (b === "der") {
+        const { r: P, s: I } = G.toSig(st(d));
+        return new V(P, I);
+      }
+      b === "recovered" && (E = d[0], b = "compact", d = d.subarray(1));
+      const v = i.BYTES, B = d.subarray(0, v), x = d.subarray(v, v * 2);
+      return new V(i.fromBytes(B), i.fromBytes(x), E);
+    }
+    static fromHex(d, b) {
+      return this.fromBytes(Vt(d), b);
+    }
+    addRecoveryBit(d) {
+      return new V(this.r, this.s, d);
+    }
+    recoverPublicKey(d) {
+      const b = s.ORDER, { r: E, s: v, recovery: B } = this;
+      if (B == null || ![0, 1, 2, 3].includes(B))
+        throw new Error("recovery id invalid");
+      if (a * xn < b && B > 1)
+        throw new Error("recovery id is ambiguous for h>1 curve");
+      const P = B === 2 || B === 3 ? E + a : E;
+      if (!s.isValid(P))
+        throw new Error("recovery id 2 or 3 invalid");
+      const I = s.toBytes(P), H = t.fromBytes(Y(Bn((B & 1) === 0), I)), $ = i.inv(P), C = z(O("msgHash", d)), R = i.create(-C * $), k = i.create(v * $), L = t.BASE.multiplyUnsafe(R).add(H.multiplyUnsafe(k));
+      if (L.is0())
+        throw new Error("point at infinify");
+      return L.assertValidity(), L;
+    }
+    // Signatures should be low-s, to prevent malleability.
+    hasHighS() {
+      return A(this.s);
+    }
+    toBytes(d = w) {
+      if (se(d), d === "der")
+        return Vt(G.hexFromSig(this));
+      const b = i.toBytes(this.r), E = i.toBytes(this.s);
+      if (d === "recovered") {
+        if (this.recovery == null)
+          throw new Error("recovery bit must be present");
+        return Y(Uint8Array.of(this.recovery), b, E);
+      }
+      return Y(b, E);
+    }
+    toHex(d) {
+      return ht(this.toBytes(d));
+    }
+    // TODO: remove
+    assertValidity() {
+    }
+    static fromCompact(d) {
+      return V.fromBytes(O("sig", d), "compact");
+    }
+    static fromDER(d) {
+      return V.fromBytes(O("sig", d), "der");
+    }
+    normalizeS() {
+      return this.hasHighS() ? new V(this.r, i.neg(this.s), this.recovery) : this;
+    }
+    toDERRawBytes() {
+      return this.toBytes("der");
+    }
+    toDERHex() {
+      return ht(this.toBytes("der"));
+    }
+    toCompactRawBytes() {
+      return this.toBytes("compact");
+    }
+    toCompactHex() {
+      return ht(this.toBytes("compact"));
+    }
+  }
+  const j = r.bits2int || function(d) {
+    if (d.length > 8192)
+      throw new Error("input is too large");
+    const b = wt(d), E = d.length * 8 - u;
+    return E > 0 ? b >> BigInt(E) : b;
+  }, z = r.bits2int_modN || function(d) {
+    return i.create(j(d));
+  }, q = Bt(u);
+  function J(g) {
+    return rr("num < 2^" + u, g, Q, q), i.toBytes(g);
+  }
+  function ft(g, d) {
+    return st(g, void 0, "message"), d ? st(e(g), void 0, "prehashed message") : g;
+  }
+  function S(g, d, b) {
+    if (["recovered", "canonical"].some((R) => R in b))
+      throw new Error("sign() legacy options not supported");
+    const { lowS: E, prehash: v, extraEntropy: B } = jt(b, h);
+    g = ft(g, v);
+    const x = z(g), P = at(i, d), I = [J(P), J(x)];
+    if (B != null && B !== !1) {
+      const R = B === !0 ? n(f.secretKey) : B;
+      I.push(O("extraEntropy", R));
+    }
+    const H = Y(...I), $ = x;
+    function C(R) {
+      const k = j(R);
+      if (!i.isValidNot0(k))
+        return;
+      const L = i.inv(k), N = t.BASE.multiply(k).toAffine(), U = i.create(N.x);
+      if (U === Q)
+        return;
+      const It = i.create(L * i.create($ + U * P));
+      if (It === Q)
+        return;
+      let me = (N.x === U ? 0 : 2) | Number(N.y & gt), we = It;
+      return E && A(It) && (we = i.neg(It), me ^= 1), new V(U, we, me);
+    }
+    return { seed: H, k2sig: C };
+  }
+  function Pt(g, d, b = {}) {
+    g = O("message", g);
+    const { seed: E, k2sig: v } = S(g, d, b);
+    return or(e.outputLen, i.BYTES, o)(E, v);
+  }
+  function rt(g) {
+    let d;
+    const b = typeof g == "string" || qt(g), E = !b && g !== null && typeof g == "object" && typeof g.r == "bigint" && typeof g.s == "bigint";
+    if (!b && !E)
+      throw new Error("invalid signature, expected Uint8Array, hex string or Signature instance");
+    if (E)
+      d = new V(g.r, g.s);
+    else if (b) {
+      try {
+        d = V.fromBytes(O("sig", g), "der");
+      } catch (v) {
+        if (!(v instanceof G.Err))
+          throw v;
+      }
+      if (!d)
+        try {
+          d = V.fromBytes(O("sig", g), "compact");
+        } catch {
+          return !1;
+        }
+    }
+    return d || !1;
+  }
+  function T(g, d, b, E = {}) {
+    const { lowS: v, prehash: B, format: x } = jt(E, h);
+    if (b = O("publicKey", b), d = ft(O("message", d), B), "strict" in E)
+      throw new Error("options.strict was renamed to lowS");
+    const P = x === void 0 ? rt(g) : V.fromBytes(O("sig", g), x);
+    if (P === !1)
+      return !1;
+    try {
+      const I = t.fromBytes(b);
+      if (v && P.hasHighS())
+        return !1;
+      const { r: H, s: $ } = P, C = z(d), R = i.inv($), k = i.create(C * R), L = i.create(H * R), N = t.BASE.multiplyUnsafe(k).add(I.multiplyUnsafe(L));
+      return N.is0() ? !1 : i.create(N.x) === H;
+    } catch {
+      return !1;
+    }
+  }
+  function p(g, d, b = {}) {
+    const { prehash: E } = jt(b, h);
+    return d = ft(d, E), V.fromBytes(g, "recovered").recoverPublicKey(d).toBytes();
+  }
+  return Object.freeze({
+    keygen: l,
+    getPublicKey: m,
+    getSharedSecret: y,
+    utils: c,
+    lengths: f,
+    Point: t,
+    sign: Pt,
+    verify: T,
+    recoverPublicKey: p,
+    Signature: V,
+    hash: e
+  });
+}
+function Ir(t) {
+  const e = {
+    a: t.a,
+    b: t.b,
+    p: t.Fp.ORDER,
+    n: t.n,
+    h: t.h,
+    Gx: t.Gx,
+    Gy: t.Gy
+  }, r = t.Fp;
+  let n = t.allowedPrivateKeyLengths ? Array.from(new Set(t.allowedPrivateKeyLengths.map((i) => Math.ceil(i / 2)))) : void 0;
+  const o = vt(e.n, {
+    BITS: t.nBitLength,
+    allowedLengths: n,
+    modFromBytes: t.wrapPrivateKey
+  }), s = {
+    Fp: r,
+    Fn: o,
+    allowInfinityPoint: t.allowInfinityPoint,
+    endo: t.endo,
+    isTorsionFree: t.isTorsionFree,
+    clearCofactor: t.clearCofactor,
+    fromBytes: t.fromBytes,
+    toBytes: t.toBytes
+  };
+  return { CURVE: e, curveOpts: s };
+}
+function Ar(t) {
+  const { CURVE: e, curveOpts: r } = Ir(t), n = {
+    hmac: t.hmac,
+    randomBytes: t.randomBytes,
+    lowS: t.lowS,
+    bits2int: t.bits2int,
+    bits2int_modN: t.bits2int_modN
+  };
+  return { CURVE: e, curveOpts: r, hash: t.hash, ecdsaOpts: n };
+}
+function Sr(t, e) {
+  const r = e.Point;
+  return Object.assign({}, e, {
+    ProjectivePoint: r,
+    CURVE: Object.assign({}, t, pn(r.Fn.ORDER, r.Fn.BITS))
+  });
+}
+function Cr(t) {
+  const { CURVE: e, curveOpts: r, hash: n, ecdsaOpts: o } = Ar(t), s = Br(e, r), i = Pr(s, n, o);
+  return Sr(t, i);
+}
+function Tr(t, e) {
+  const r = (n) => Cr({ ...t, hash: n });
+  return { ...r(e), create: r };
+}
+const mt = {
+  p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),
+  n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),
+  h: BigInt(1),
+  a: BigInt(0),
+  b: BigInt(7),
+  Gx: BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
+  Gy: BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")
+}, $r = {
+  beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
+  basises: [
+    [BigInt("0x3086d221a7d46bcde86c90e49284eb15"), -BigInt("0xe4437ed6010e88286f547fa90abfe4c3")],
+    [BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), BigInt("0x3086d221a7d46bcde86c90e49284eb15")]
+  ]
+}, _r = /* @__PURE__ */ BigInt(0), Re = /* @__PURE__ */ BigInt(1), ie = /* @__PURE__ */ BigInt(2);
+function Vr(t) {
+  const e = mt.p, r = BigInt(3), n = BigInt(6), o = BigInt(11), s = BigInt(22), i = BigInt(23), a = BigInt(44), u = BigInt(88), l = t * t * t % e, m = l * l * t % e, y = Z(m, r, e) * m % e, c = Z(y, r, e) * m % e, f = Z(c, ie, e) * l % e, h = Z(f, o, e) * f % e, w = Z(h, s, e) * h % e, A = Z(w, a, e) * w % e, _ = Z(A, u, e) * A % e, nt = Z(_, a, e) * w % e, V = Z(nt, r, e) * m % e, j = Z(V, i, e) * h % e, z = Z(j, n, e) * l % e, q = Z(z, ie, e);
+  if (!Ht.eql(Ht.sqr(q), t))
+    throw new Error("Cannot find square root");
+  return q;
+}
+const Ht = vt(mt.p, { sqrt: Vr }), Lt = Tr({ ...mt, Fp: Ht, lowS: !0, endo: $r }, ne), Ne = {};
+function kt(t, ...e) {
+  let r = Ne[t];
+  if (r === void 0) {
+    const n = ne(Qe(t));
+    r = Y(n, n), Ne[t] = r;
+  }
+  return ne(Y(r, ...e));
+}
+const ge = (t) => t.toBytes(!0).slice(1), yt = Lt.Point, pe = (t) => t % ie === _r;
+function ce(t) {
+  const { Fn: e, BASE: r } = yt, n = at(e, t), o = r.multiply(n);
+  return { scalar: pe(o.y) ? n : e.neg(n), bytes: ge(o) };
+}
+function Pn(t) {
+  const e = Ht;
+  if (!e.isValidNot0(t))
+    throw new Error("invalid x: Fail if x ≥ p");
+  const r = e.create(t * t), n = e.create(r * t + BigInt(7));
+  let o = e.sqrt(n);
+  pe(o) || (o = e.neg(o));
+  const s = yt.fromAffine({ x: t, y: o });
+  return s.assertValidity(), s;
+}
+const Et = wt;
+function In(...t) {
+  return yt.Fn.create(Et(kt("BIP0340/challenge", ...t)));
+}
+function He(t) {
+  return ce(t).bytes;
+}
+function Rr(t, e, r = Ut(32)) {
+  const { Fn: n } = yt, o = O("message", t), { bytes: s, scalar: i } = ce(e), a = O("auxRand", r, 32), u = n.toBytes(i ^ Et(kt("BIP0340/aux", a))), l = kt("BIP0340/nonce", u, s, o), { bytes: m, scalar: y } = ce(l), c = In(m, s, o), f = new Uint8Array(64);
+  if (f.set(m, 0), f.set(n.toBytes(n.create(y + c * i)), 32), !An(f, o, s))
+    throw new Error("sign: Invalid signature produced");
+  return f;
+}
+function An(t, e, r) {
+  const { Fn: n, BASE: o } = yt, s = O("signature", t, 64), i = O("message", e), a = O("publicKey", r, 32);
+  try {
+    const u = Pn(Et(a)), l = Et(s.subarray(0, 32));
+    if (!oe(l, Re, mt.p))
+      return !1;
+    const m = Et(s.subarray(32, 64));
+    if (!oe(m, Re, mt.n))
+      return !1;
+    const y = In(n.toBytes(l), ge(u), i), c = o.multiplyUnsafe(m).add(u.multiplyUnsafe(n.neg(y))), { x: f, y: h } = c.toAffine();
+    return !(c.is0() || !pe(h) || f !== l);
+  } catch {
+    return !1;
+  }
+}
+const bt = /* @__PURE__ */ (() => {
+  const r = (o = Ut(48)) => yn(o, mt.n);
+  Lt.utils.randomSecretKey;
+  function n(o) {
+    const s = r(o);
+    return { secretKey: s, publicKey: He(s) };
+  }
+  return {
+    keygen: n,
+    getPublicKey: He,
+    sign: Rr,
+    verify: An,
+    Point: yt,
+    utils: {
+      randomSecretKey: r,
+      randomPrivateKey: r,
+      taggedHash: kt,
+      // TODO: remove
+      lift_x: Pn,
+      pointToBytes: ge,
+      numberToBytesBE: Kt,
+      bytesToNumberBE: wt,
+      mod: D
+    },
+    lengths: {
+      secretKey: 32,
+      publicKey: 32,
+      publicKeyHasPrefix: !1,
+      signature: 64,
+      seed: 48
+    }
+  };
+})(), Nr = "5120", ae = "0014", Hr = 20, ke = 33, kr = 65, Or = 2, qr = 3, Ur = 4;
+function Sn(t, e) {
+  const r = t.startsWith("0x") || t.startsWith("0X") ? t.slice(2) : t;
+  if (!/^(?:[0-9a-fA-F]{2})+$/.test(r))
+    throw new Error(`${e} must be non-empty, even-length hex`);
+  return `0x${r.toLowerCase()}`;
+}
+function Kr(t) {
+  const e = Ze(t), r = bt.utils.lift_x(BigInt(`0x${t}`)), n = bt.utils.bytesToNumberBE(
+    bt.utils.taggedHash("TapTweak", e)
+  );
+  if (n >= Lt.CURVE.n)
+    throw new Error("Proof of possession BTC pubkey has an invalid TapTweak");
+  const o = n === 0n ? r : r.add(bt.Point.BASE.multiply(n));
+  return `0x${Nr}${ue(
+    bt.utils.pointToBytes(o)
+  )}`;
+}
+function Lr(t) {
+  const e = Sn(t, "depositorBtcPubkeyRaw"), r = Ze(e.slice(2));
+  if (r.length === 32)
+    return {
+      xOnlyPubkey: xt(e, "Payout BTC pubkey")
+    };
+  const n = r.length === ke && (r[0] === Or || r[0] === qr), o = r.length === kr && r[0] === Ur;
+  if (!n && !o)
+    throw new Error(
+      "depositorBtcPubkeyRaw must be x-only, compressed, or uncompressed"
+    );
+  try {
+    Lt.Point.fromBytes(r);
+  } catch {
+    throw new Error("depositorBtcPubkeyRaw is not a valid BTC pubkey");
+  }
+  return {
+    xOnlyPubkey: ue(r.subarray(1, ke)),
+    compressedPubkey: n ? r : void 0
+  };
+}
+function Mr(t) {
+  return `0x${ae}${ue(Xn(Jt(t)))}`;
+}
+function Fr(t, e, r) {
+  const n = Sn(
+    t,
+    "depositorPayoutScriptPubKey"
+  );
+  if ((n.length - 2) / 2 > xe)
+    throw new Error(
+      `depositorPayoutScriptPubKey exceeds ${xe} bytes`
+    );
+  const o = e.startsWith("0x") || e.startsWith("0X") ? e.slice(2) : e, s = xt(
+    `0x${o}`,
+    "Proof of possession BTC pubkey"
+  ), i = Lr(r);
+  if (i.xOnlyPubkey !== s)
+    throw new Error(
+      "depositorBtcPubkeyRaw does not match the proof of possession BTC pubkey"
+    );
+  if (n === Kr(s))
+    return n;
+  if (n.startsWith(`0x${ae}`) && n.length === 2 + ae.length + Hr * 2) {
+    if (!i.compressedPubkey)
+      throw new Error("A P2WPKH payout requires a compressed BTC pubkey");
+    if (n === Mr(i.compressedPubkey))
+      return n;
+  }
+  throw new Error(
+    "depositorPayoutScriptPubKey does not match the proof of possession BTC pubkey"
+  );
+}
+function Zr(t, e) {
+  const r = t.startsWith("0x") ? t.slice(2) : t;
+  if (r.length === 0 || r.length % 2 !== 0)
+    throw new Error(`${e} must be non-empty, even-length hex`);
+  if (!/^[0-9a-fA-F]+$/.test(r))
+    throw new Error(`${e} contains non-hex characters`);
+  const n = new Uint8Array(r.length / 2);
+  for (let o = 0; o < n.length; o++)
+    n[o] = Number.parseInt(r.slice(o * 2, o * 2 + 2), 16);
+  return n;
+}
+function Dr(t) {
+  return Array.from(t, (e) => e.toString(16).padStart(2, "0")).join(
+    ""
+  );
+}
+function zr(t) {
+  const e = new Uint8Array(
+    t.reduce((n, o) => n + o.length, 0)
+  );
+  let r = 0;
+  for (const n of t)
+    e.set(n, r), r += n.length;
+  return e;
+}
+function Xr(t) {
+  let e = 0;
+  const r = (c, f) => {
+    if (!Number.isSafeInteger(c) || c < 0)
+      throw new Error(`Invalid ${f} length ${c}`);
+    if (e + c > t.length)
+      throw new Error(`Truncated Bitcoin transaction while reading ${f}`);
+    const h = t.slice(e, e + c);
+    return e += c, h;
+  }, n = (c, f) => {
+    const h = r(c, f);
+    let w = 0n;
+    for (let A = h.length - 1; A >= 0; A--)
+      w = w << 8n | BigInt(h[A]);
+    return w;
+  }, o = (c) => {
+    const f = e, h = r(1, c)[0];
+    let w;
+    if (h < 253)
+      w = BigInt(h);
+    else if (h === 253) {
+      if (w = n(2, c), w < 0xfdn) throw new Error(`Non-canonical ${c}`);
+    } else if (h === 254) {
+      if (w = n(4, c), w <= 0xffffn) throw new Error(`Non-canonical ${c}`);
+    } else if (w = n(8, c), w <= 0xffffffffn) throw new Error(`Non-canonical ${c}`);
+    if (w > BigInt(Number.MAX_SAFE_INTEGER))
+      throw new Error(`${c} exceeds JavaScript's safe integer range`);
+    return {
+      encoded: t.slice(f, e),
+      value: Number(w)
+    };
+  }, s = r(4, "version"), i = t[e] === 0 && t[e + 1] === 1;
+  i && (e += 2);
+  const a = o("input count"), u = [];
+  for (let c = 0; c < a.value; c++) {
+    const f = e;
+    r(32, `input ${c} previous transaction hash`), r(4, `input ${c} previous output index`);
+    const h = o(`input ${c} script length`);
+    r(h.value, `input ${c} script`), r(4, `input ${c} sequence`), u.push(t.slice(f, e));
+  }
+  const l = o("output count"), m = [];
+  for (let c = 0; c < l.value; c++) {
+    const f = e;
+    r(8, `output ${c} value`);
+    const h = o(`output ${c} script length`);
+    r(h.value, `output ${c} script`), m.push(t.slice(f, e));
+  }
+  if (i) {
+    let c = !1;
+    for (let f = 0; f < a.value; f++) {
+      const h = o(`input ${f} witness item count`);
+      c || (c = h.value > 0);
+      for (let w = 0; w < h.value; w++) {
+        const A = o(
+          `input ${f} witness item ${w} length`
+        );
+        r(A.value, `input ${f} witness item ${w}`);
+      }
+    }
+    if (!c)
+      throw new Error("Bitcoin transaction has superfluous witness marker");
+  }
+  const y = r(4, "locktime");
+  if (e !== t.length)
+    throw new Error(
+      `Bitcoin transaction has ${t.length - e} trailing byte(s)`
+    );
+  return zr([
+    s,
+    a.encoded,
+    ...u,
+    l.encoded,
+    ...m,
+    y
+  ]);
+}
+function Yr(t) {
+  const e = Xr(
+    Zr(t, "transactionHex")
+  ), r = Jt(Jt(e));
+  return r.reverse(), `0x${Dr(r)}`;
+}
+function jr(t, e) {
+  const r = t.startsWith("0x") ? t : `0x${t}`;
+  if (!/^0x[0-9a-fA-F]{64}$/.test(r))
+    throw new Error("peginTxHash must be a 32-byte hex value");
+  const n = e.startsWith("0x") ? e : `0x${e}`;
+  if (!$n(n, { strict: !0 }))
+    throw new Error(`Invalid depositor Ethereum address: ${e}`);
+  return _n(
+    Vn(
+      [{ type: "bytes32" }, { type: "address" }],
+      [r, n]
+    )
+  ).slice(2);
+}
+const Wt = 65535, Oe = 1e4, Ot = 4294967295, qe = 255;
+function Wr(t) {
+  if (!Number.isInteger(t) || t < 0 || t > Ot)
+    throw new Error(
+      `Invalid offchainParamsVersion from contract: must be a uint32, got ${t}`
+    );
+}
+function Gr(t) {
+  const e = [];
+  if (t.timelockAssert <= 0n && e.push(
+    `timelockAssert must be positive, got ${t.timelockAssert}`
+  ), t.timelockAssert > BigInt(Wt) && e.push(
+    `timelockAssert ${t.timelockAssert} exceeds uint16 max (${Wt})`
+  ), t.timelockChallengeAssert <= 0n && e.push(
+    `timelockChallengeAssert must be positive, got ${t.timelockChallengeAssert}`
+  ), t.tRefund <= 0 && e.push(`tRefund must be positive, got ${t.tRefund}`), t.tStale <= 0 && e.push(`tStale must be positive, got ${t.tStale}`), t.securityCouncilKeys.length === 0 && e.push("securityCouncilKeys must not be empty"), t.councilQuorum <= 0 && e.push(`councilQuorum must be positive, got ${t.councilQuorum}`), t.councilQuorum > t.securityCouncilKeys.length && e.push(
+    `councilQuorum (${t.councilQuorum}) exceeds securityCouncilKeys count (${t.securityCouncilKeys.length})`
+  ), t.feeRate <= 0n && e.push(`feeRate must be positive, got ${t.feeRate}`), t.minPeginFeeRate <= 0n && e.push(
+    `minPeginFeeRate must be positive, got ${t.minPeginFeeRate}`
+  ), (!Number.isInteger(t.proverCircuitVersion) || t.proverCircuitVersion < 0 || t.proverCircuitVersion > Wt) && e.push(
+    `proverCircuitVersion must be a uint16, got ${t.proverCircuitVersion}`
+  ), (!Number.isInteger(t.minPrepeginDepth) || t.minPrepeginDepth <= 0 || t.minPrepeginDepth > Ot) && e.push(
+    `minPrepeginDepth must be a uint32 in [1, ${Ot}], got ${t.minPrepeginDepth}`
+  ), t.babeTotalInstances <= 0 && e.push(
+    `babeTotalInstances must be positive, got ${t.babeTotalInstances}`
+  ), t.babeInstancesToFinalize <= 0 && e.push(
+    `babeInstancesToFinalize must be positive, got ${t.babeInstancesToFinalize}`
+  ), t.babeInstancesToFinalize > t.babeTotalInstances && e.push(
+    `babeInstancesToFinalize (${t.babeInstancesToFinalize}) exceeds babeTotalInstances (${t.babeTotalInstances})`
+  ), (t.minVpCommissionBps < 0 || t.minVpCommissionBps > Oe) && e.push(
+    `minVpCommissionBps must be in [0, ${Oe}], got ${t.minVpCommissionBps}`
+  ), e.length > 0)
+    throw new Error(
+      `Invalid offchain protocol parameters: ${e.join("; ")}`
+    );
+}
+function Qr(t) {
+  const e = [];
+  if (t.minimumPegInAmount <= 0n && e.push(
+    `minimumPegInAmount must be positive, got ${t.minimumPegInAmount}`
+  ), t.maxPegInAmount < t.minimumPegInAmount && e.push(
+    `maxPegInAmount (${t.maxPegInAmount}) must be >= minimumPegInAmount (${t.minimumPegInAmount})`
+  ), t.pegInAckTimeout <= 0n && e.push(
+    `pegInAckTimeout must be positive, got ${t.pegInAckTimeout}`
+  ), t.pegInActivationTimeout <= 0n && e.push(
+    `pegInActivationTimeout must be positive, got ${t.pegInActivationTimeout}`
+  ), (!Number.isInteger(t.maxHtlcOutputCount) || t.maxHtlcOutputCount <= 0 || t.maxHtlcOutputCount > qe) && e.push(
+    `maxHtlcOutputCount must be an integer in [1, ${qe}], got ${t.maxHtlcOutputCount}`
+  ), (typeof t.expiredPegInGraceBlocks != "bigint" || t.expiredPegInGraceBlocks <= 0n) && e.push(
+    `expiredPegInGraceBlocks must be a positive bigint, got ${t.expiredPegInGraceBlocks}`
+  ), e.length > 0)
+    throw new Error(`Invalid TBV protocol parameters: ${e.join("; ")}`);
+}
+function po(t) {
+  if (Qr(t), Gr(t.offchainParams), !Number.isInteger(t.offchainParamsVersion) || t.offchainParamsVersion < 0 || t.offchainParamsVersion > Ot)
+    throw new Error(
+      `Invalid peg-in configuration: offchainParamsVersion must be a uint32, got ${t.offchainParamsVersion}`
+    );
+  qn(
+    t.activeVaultCoreVersion,
+    "ProtocolParams.activeVaultCoreVersion()"
+  );
+}
+const Ue = 9999;
+function Ke(t) {
+  return {
+    depositor: t.depositor,
+    depositorBtcPubKey: t.depositorBtcPubKey,
+    amount: t.amount,
+    vaultProvider: t.vaultProvider,
+    status: t.status,
+    applicationEntryPoint: t.applicationEntryPoint,
+    createdAt: t.createdAt
+  };
+}
+function Gt(t) {
+  const e = Number(t.offchainParamsVersion);
+  return Wr(e), {
+    depositorSignedPeginTx: t.depositorSignedPeginTx,
+    universalChallengersVersion: t.universalChallengersVersion,
+    appVaultKeepersVersion: t.appVaultKeepersVersion,
+    offchainParamsVersion: e,
+    verifiedAt: t.verifiedAt,
+    depositorWotsPkHash: t.depositorWotsPkHash,
+    hashlock: t.hashlock,
+    htlcVout: t.htlcVout,
+    depositorPopSignature: t.depositorPopSignature,
+    prePeginTxHash: t.prePeginTxHash,
+    vaultProviderCommissionBps: t.vaultProviderCommissionBps,
+    vaultCoreVersion: t.vaultCoreVersion
+  };
+}
+const Jr = 1n << 64n, Le = 0n;
+function Qt(t, e, r) {
+  if (t < 0n || t >= Jr)
+    throw new Error(
+      `getBtcVaultProtocolInfo returned ${e}=${t} for vault ${r}, outside the uint64 range — the registry may predate RFC-006`
+    );
+  return t;
+}
+function Me(t, e) {
+  return {
+    vpKeyEpoch: Qt(t.vpKeyEpoch, "vpKeyEpoch", e),
+    appKeeperKeyEpoch: Qt(
+      t.appKeeperKeyEpoch,
+      "appKeeperKeyEpoch",
+      e
+    ),
+    ucKeyEpoch: Qt(t.ucKeyEpoch, "ucKeyEpoch", e)
+  };
+}
+class to {
+  constructor(e, r) {
+    this.publicClient = e, this.contractAddress = r;
+  }
+  /**
+   * Read the VP's **genesis** (registration) x-only BTC pubkey — the key bonded
+   * at version 0, which never moves when the operator rotates.
+   *
+   * Resolved as "the operation key at epoch 0" rather than through the
+   * dedicated `getVaultProviderBTCKey` getter, which
+   * https://github.com/babylonlabs-io/vault-contracts-aave-v4/pull/539 removes.
+   * Epoch 0 predates any rotation — appended versions are stamped at epoch 1 or
+   * later — so it resolves to the registration key, and the contracts team has
+   * confirmed that is a property we can rely on rather than an implementation
+   * detail. The devnet comparison behind that claim — both getters returning the
+   * identical key for a provider that *has* rotated, while
+   * `getCurrentOperationBtcKey` differed — is recorded in
+   * https://github.com/babylonlabs-io/babylon-toolkit/issues/2188.
+   *
+   * This makes the read RFC-006-only, where the removed getter also existed on a
+   * legacy registry. That costs nothing: every caller of this method already
+   * resolves participant keys through `OperationKeyReader`, so all of them
+   * require an RFC-006 registry regardless.
+   *
+   * Validates length, hex form, and secp256k1 curve membership before minting
+   * the brand. Returns 64-char lowercase hex without the `0x` prefix.
+   */
+  async getVaultProviderGenesisBtcPubKey(e, r) {
+    const n = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: F,
+      functionName: "getOperationBtcKeyAtEpoch",
+      args: [e, Le],
+      blockNumber: r
+    });
+    return xt(
+      n,
+      `getOperationBtcKeyAtEpoch (vp=${e}, epoch=${Le})`
+    );
+  }
+  /**
+   * Read a vault provider's *current* RFC-006 operation BTC key.
+   *
+   * Falls back on-chain to the registration key when the provider has never
+   * rotated, so this returns the same value as
+   * `getVaultProviderGenesisBtcPubKey` until the first rotation.
+   *
+   * This is the key the VP's server signs its BIP-322 auth tokens with — a
+   * live per-operator identity, not a per-vault binding, so the auth pin uses
+   * the current key rather than any vault's frozen epoch.
+   */
+  async getCurrentVaultProviderOperationBtcKey(e) {
+    const r = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: F,
+      functionName: "getCurrentOperationBtcKey",
+      args: [e]
+    });
+    return xt(
+      r,
+      `getCurrentOperationBtcKey (vp=${e})`
+    );
+  }
+  /**
+   * Read a vault's frozen RFC-006 operation-key epochs.
+   *
+   * Reads `getBtcVaultProtocolInfo` through the **extended** ABI, which is only
+   * valid against an RFC-006 registry: against one whose `BTCVaultProtocolInfo`
+   * struct is not extended this call does not fail for a populated vault, it
+   * silently returns three words of tail data as epochs. Nothing here can detect
+   * that, so the guarantee is a deployment one — every network this ships to has
+   * the RFC-006 getters, and mainnet is a fresh RFC-006 deploy.
+   *
+   * A registry missing the operation-key getters entirely is the *safer* of the
+   * two cases: `resolveParticipantKeysAtEpochs` reverts downstream and these
+   * epochs never reach key resolution. See {@link UINT64_EXCLUSIVE_UPPER_BOUND}
+   * for which state the range check actually guards, and
+   * `BTCVaultRegistryKeyEpochs.abi.ts` for the decode hazard.
+   */
+  async getVaultKeyEpochs(e) {
+    const r = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: be,
+      functionName: "getBtcVaultProtocolInfo",
+      args: [e]
+    });
+    return Me(r, e);
+  }
+  async getVaultKeyEpochsBatch(e) {
+    return e.length === 0 ? [] : (await this.publicClient.multicall({
+      contracts: e.map((n) => ({
+        address: this.contractAddress,
+        abi: be,
+        functionName: "getBtcVaultProtocolInfo",
+        args: [n]
+      })),
+      allowFailure: !1
+    })).map(
+      (n, o) => Me(n, e[o])
+    );
+  }
+  async getVaultBasicInfo(e) {
+    const r = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: F,
+      functionName: "getBtcVaultBasicInfo",
+      args: [e]
+    });
+    return Ke(r);
+  }
+  async getVaultProtocolInfo(e) {
+    const r = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: F,
+      functionName: "getBtcVaultProtocolInfo",
+      args: [e]
+    });
+    return Gt(r);
+  }
+  async getProtocolInfoBatch(e) {
+    return e.length === 0 ? [] : (await this.publicClient.multicall({
+      contracts: e.map((n) => ({
+        address: this.contractAddress,
+        abi: F,
+        functionName: "getBtcVaultProtocolInfo",
+        args: [n]
+      })),
+      allowFailure: !1
+    })).map((n, o) => {
+      const s = n;
+      if (!s.depositorSignedPeginTx || s.depositorSignedPeginTx === "0x")
+        throw new Error(
+          `Vault ${e[o]} not found on-chain or has no pegin transaction`
+        );
+      return Gt(s);
+    });
+  }
+  /**
+   * Read the protocol pegin fee (in wei) for a given vault provider.
+   * Mirrors the `getPegInFee(address)` view on BTCVaultRegistry.
+   */
+  async getPegInFee(e) {
+    return await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: F,
+      functionName: "getPegInFee",
+      args: [e]
+    });
+  }
+  /**
+   * Read a vault provider's current commission in basis points from
+   * BTCVaultRegistry. The contract enforces `commissionBps < 10000`, so the
+   * legitimate range is `[0, 9999]`; anything outside indicates a wrong
+   * contract address or ABI drift and is surfaced as an error rather than
+   * trusted.
+   */
+  async getVaultProviderCommission(e) {
+    const r = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: F,
+      functionName: "getVaultProviderCommission",
+      args: [e]
+    });
+    if (!Number.isInteger(r) || r < 0 || r > Ue)
+      throw new Error(
+        `getVaultProviderCommission returned ${r} bps for ${e}, outside the protocol range [0, ${Ue}]`
+      );
+    return r;
+  }
+  async getVaultData(e) {
+    const [r, n] = await this.publicClient.multicall({
+      contracts: [
+        {
+          address: this.contractAddress,
+          abi: F,
+          functionName: "getBtcVaultBasicInfo",
+          args: [e]
+        },
+        {
+          address: this.contractAddress,
+          abi: F,
+          functionName: "getBtcVaultProtocolInfo",
+          args: [e]
+        }
+      ],
+      allowFailure: !1
+    }), o = Ke(r), s = Gt(n);
+    if (!s.depositorSignedPeginTx || s.depositorSignedPeginTx === "0x")
+      throw new Error(
+        `Vault ${e} not found on-chain or has no pegin transaction`
+      );
+    return { basic: o, protocol: s };
+  }
+}
+const eo = 0, no = 255, ro = 12e4;
+function ot(t, e) {
+  const r = t.startsWith("0x") ? t : t.startsWith("0X") ? `0x${t.slice(2)}` : `0x${t}`;
+  if (!/^0x(?:[0-9a-fA-F]{2})+$/.test(r))
+    throw new Error(`${e} must be non-empty, even-length hex`);
+  return r;
+}
+function Fe(t, e) {
+  if (!/^0x[0-9a-fA-F]{64}$/.test(t))
+    throw new Error(`${e} must be a 32-byte hex value`);
+}
+function oo(t) {
+  if (!Number.isInteger(t) || t < 0 || t > no)
+    throw new Error(`htlcVout must be a uint8, got ${t}`);
+}
+class mo {
+  constructor(e) {
+    this.config = e;
+  }
+  async registerPeginOnChain(e) {
+    const r = {
+      ...e,
+      popSignature: { ...e.popSignature }
+    };
+    this.assertQuotedCommissionPresentWhenRequired(r.quotedCommissionBps);
+    const n = this.assertPopMatchesEthAccount(r.popSignature), o = this.normalizeBtcPubkey(r.popSignature), s = ot(
+      r.popSignature.btcPopSignature,
+      "btcPopSignature"
+    ), i = this.normalizeRequest(
+      r,
+      n,
+      o
+    );
+    await this.assertVaultDoesNotExist(
+      i.vaultId,
+      i.peginTxHash
+    );
+    const a = await this.readPeginFee(r.vaultProvider), u = await this.resolveMaxAcceptableCommissionBps(
+      r.vaultProvider,
+      r.quotedCommissionBps
+    ), l = ye({
+      abi: F,
+      functionName: "submitPeginRequest",
+      args: [
+        n,
+        o,
+        s,
+        i.unsignedPrePeginTx,
+        i.depositorSignedPeginTx,
+        r.vaultProvider,
+        u,
+        r.hashlock,
+        r.htlcVout,
+        i.payoutScript,
+        r.depositorWotsPkHash
+      ]
+    });
+    return {
+      ethTxHash: await this.sendAndWait(
+        l,
+        a,
+        !1,
+        n
+      ),
+      vaultId: i.vaultId,
+      peginTxHash: i.peginTxHash
+    };
+  }
+  async registerPeginBatchOnChain(e) {
+    const r = {
+      ...e,
+      popSignature: { ...e.popSignature },
+      requests: e.requests.map((h) => ({ ...h }))
+    };
+    if (r.requests.length === 0)
+      throw new Error("Batch pegin requires at least one request");
+    this.assertQuotedCommissionPresentWhenRequired(r.quotedCommissionBps);
+    const n = this.assertPopMatchesEthAccount(r.popSignature), o = ot(
+      r.unsignedPrePeginTx,
+      "unsignedPrePeginTx"
+    ), s = this.normalizeBtcPubkey(r.popSignature), i = ot(
+      r.popSignature.btcPopSignature,
+      "btcPopSignature"
+    ), a = [], u = [], l = /* @__PURE__ */ new Set();
+    for (const h of r.requests) {
+      const w = this.normalizeRequest(
+        {
+          ...h,
+          unsignedPrePeginTx: r.unsignedPrePeginTx,
+          vaultProvider: r.vaultProvider,
+          depositorBtcPubkeyRaw: r.depositorBtcPubkeyRaw
+        },
+        n,
+        s
+      );
+      if (l.has(w.vaultId))
+        throw new Error(`Duplicate vault in batch: ${w.vaultId}`);
+      l.add(w.vaultId), a.push({
+        vaultId: w.vaultId,
+        peginTxHash: w.peginTxHash
+      }), u.push({
+        depositorBtcPubKey: s,
+        btcPopSignature: i,
+        unsignedPrePeginTx: o,
+        depositorSignedPeginTx: w.depositorSignedPeginTx,
+        hashlock: h.hashlock,
+        htlcVout: h.htlcVout,
+        referralCode: eo,
+        depositorPayoutBtcAddress: w.payoutScript,
+        depositorWotsPkHash: h.depositorWotsPkHash
+      });
+    }
+    for (const h of a)
+      await this.assertVaultDoesNotExist(h.vaultId, h.peginTxHash);
+    const m = await this.readPeginFee(r.vaultProvider), y = await this.resolveMaxAcceptableCommissionBps(
+      r.vaultProvider,
+      r.quotedCommissionBps
+    ), c = ye({
+      abi: F,
+      functionName: "submitPeginRequestBatch",
+      args: [n, r.vaultProvider, y, u]
+    });
+    return { ethTxHash: await this.sendAndWait(
+      c,
+      m * BigInt(r.requests.length),
+      !0,
+      n
+    ), vaults: a };
+  }
+  assertQuotedCommissionPresentWhenRequired(e) {
+    if (e === void 0 && this.config.requireQuotedCommissionBps)
+      throw new Error(
+        "quotedCommissionBps is required when the wallet approved deposit terms: the registration ceiling must anchor to the approved quote."
+      );
+  }
+  assertPopMatchesEthAccount(e) {
+    return this.assertEthAccount(e.depositorEthAddress);
+  }
+  assertEthAccount(e) {
+    const r = this.config.ethWallet.account;
+    if (!r) throw new Error("Ethereum wallet account not found");
+    if (!Rn(e, r.address))
+      throw new Error(
+        `Proof of possession was signed for ${e} but the Ethereum wallet is currently connected to ${r.address}. Reconnect the original account or sign a new proof of possession.`
+      );
+    return r.address;
+  }
+  normalizeBtcPubkey(e) {
+    return `0x${xt(
+      ot(e.depositorBtcPubkey, "Proof of possession BTC pubkey"),
+      "Proof of possession BTC pubkey"
+    )}`;
+  }
+  normalizeRequest(e, r, n) {
+    Fe(e.hashlock, "hashlock"), Fe(e.depositorWotsPkHash, "depositorWotsPkHash"), oo(e.htlcVout);
+    const o = ot(
+      e.unsignedPrePeginTx,
+      "unsignedPrePeginTx"
+    ), s = ot(
+      e.depositorSignedPeginTx,
+      "depositorSignedPeginTx"
+    ), i = Yr(s);
+    return {
+      unsignedPrePeginTx: o,
+      depositorSignedPeginTx: s,
+      payoutScript: Fr(
+        e.depositorPayoutScriptPubKey,
+        n,
+        e.depositorBtcPubkeyRaw
+      ),
+      peginTxHash: i,
+      vaultId: ot(jr(i, r), "vaultId")
+    };
+  }
+  async assertVaultDoesNotExist(e, r) {
+    if ((await this.config.publicClient.readContract({
+      address: this.config.btcVaultRegistry,
+      abi: F,
+      functionName: "getBtcVaultBasicInfo",
+      args: [e]
+    })).depositor !== Nn)
+      throw new Error(
+        `Vault already exists (ID: ${e}, peginTxHash: ${r}). Vault IDs are derived from the pegin transaction hash and depositor address. To create a new vault, use different UTXOs or a different amount to generate a unique transaction.`
+      );
+  }
+  async readPeginFee(e) {
+    try {
+      return await this.config.publicClient.readContract({
+        address: this.config.btcVaultRegistry,
+        abi: F,
+        functionName: "getPegInFee",
+        args: [e]
+      });
+    } catch (r) {
+      throw new Error(
+        "Failed to query pegin fee from the contract. Please check your network connection and contract address.",
+        { cause: r }
+      );
+    }
+  }
+  async resolveMaxAcceptableCommissionBps(e, r) {
+    let n;
+    try {
+      n = await new to(
+        this.config.publicClient,
+        this.config.btcVaultRegistry
+      ).getVaultProviderCommission(e);
+    } catch (o) {
+      throw new Error(
+        "Failed to query vault provider commission from the contract. Please check your network connection and contract address.",
+        { cause: o }
+      );
+    }
+    if (r !== void 0) {
+      if (n > r + te)
+        throw new Error(
+          `Vault provider commission changed since quote: quoted ${r} bps, chain currently reports ${n} bps (allowed drift ${te} bps). Please refresh and try again.`
+        );
+      return ve(r);
+    }
+    return ve(n);
+  }
+  async sendAndWait(e, r, n, o) {
+    let s = this.assertEthAccount(o), i;
+    try {
+      i = await this.config.publicClient.estimateGas({
+        to: this.config.btcVaultRegistry,
+        data: e,
+        value: r,
+        account: s
+      });
+    } catch (l) {
+      Mt(l);
+    }
+    s = this.assertEthAccount(o);
+    let a;
+    try {
+      a = await this.config.ethWallet.sendTransaction({
+        to: this.config.btcVaultRegistry,
+        data: e,
+        value: r,
+        gas: i,
+        account: s,
+        chain: this.config.ethChain
+      });
+    } catch (l) {
+      Mt(l);
+    }
+    const u = await Hn({
+      publicClient: this.config.publicClient,
+      walletAddress: o,
+      hash: a,
+      timeout: this.config.receiptTimeoutMs ?? ro
+    });
+    return u.status === "reverted" && Mt(
+      new Error(
+        `${n ? "Batch transaction" : "Transaction"} reverted. Hash: ${u.transactionHash}. Check a block explorer for details.`
+      )
+    ), u.transactionHash;
+  }
+}
+export {
+  te as C,
+  Un as M,
+  eo as N,
+  mo as V,
+  po as a,
+  Qr as b,
+  to as c,
+  jr as d,
+  ve as e,
+  Yr as f,
+  Wr as g,
+  Xn as r,
+  Gr as v
+};
+//# sourceMappingURL=pegin-registration-client-BdRiR8br.js.map