@pufferfinance/puffer-sdk 1.4.2 → 1.5.0

package/dist/secp256k1-BLbXMlpX.js

@@ -0,0 +1,1172 @@
+import { H as Ft, h as Gt, t as Wt, e as qt, b as Xt, a as Dt, r as Qt, s as Jt } from "./constants-rWWWhxR_.js";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const Ut = BigInt(0), ht = BigInt(1), te = BigInt(2);
+function nt(e) {
+  return e instanceof Uint8Array || e != null && typeof e == "object" && e.constructor.name === "Uint8Array";
+}
+function lt(e) {
+  if (!nt(e))
+    throw new Error("Uint8Array expected");
+}
+const ee = /* @__PURE__ */ Array.from({ length: 256 }, (e, n) => n.toString(16).padStart(2, "0"));
+function st(e) {
+  lt(e);
+  let n = "";
+  for (let t = 0; t < e.length; t++)
+    n += ee[e[t]];
+  return n;
+}
+function Rt(e) {
+  const n = e.toString(16);
+  return n.length & 1 ? `0${n}` : n;
+}
+function Bt(e) {
+  if (typeof e != "string")
+    throw new Error("hex string expected, got " + typeof e);
+  return BigInt(e === "" ? "0" : `0x${e}`);
+}
+const P = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
+function Nt(e) {
+  if (e >= P._0 && e <= P._9)
+    return e - P._0;
+  if (e >= P._A && e <= P._F)
+    return e - (P._A - 10);
+  if (e >= P._a && e <= P._f)
+    return e - (P._a - 10);
+}
+function ct(e) {
+  if (typeof e != "string")
+    throw new Error("hex string expected, got " + typeof e);
+  const n = e.length, t = n / 2;
+  if (n % 2)
+    throw new Error("padded hex string expected, got unpadded hex of length " + n);
+  const r = new Uint8Array(t);
+  for (let s = 0, i = 0; s < t; s++, i += 2) {
+    const l = Nt(e.charCodeAt(i)), c = Nt(e.charCodeAt(i + 1));
+    if (l === void 0 || c === void 0) {
+      const o = e[i] + e[i + 1];
+      throw new Error('hex string expected, got non-hex character "' + o + '" at index ' + i);
+    }
+    r[s] = l * 16 + c;
+  }
+  return r;
+}
+function et(e) {
+  return Bt(st(e));
+}
+function xt(e) {
+  return lt(e), Bt(st(Uint8Array.from(e).reverse()));
+}
+function ft(e, n) {
+  return ct(e.toString(16).padStart(n * 2, "0"));
+}
+function vt(e, n) {
+  return ft(e, n).reverse();
+}
+function ne(e) {
+  return ct(Rt(e));
+}
+function M(e, n, t) {
+  let r;
+  if (typeof n == "string")
+    try {
+      r = ct(n);
+    } catch (i) {
+      throw new Error(`${e} must be valid hex string, got "${n}". Cause: ${i}`);
+    }
+  else if (nt(n))
+    r = Uint8Array.from(n);
+  else
+    throw new Error(`${e} must be hex string or Uint8Array`);
+  const s = r.length;
+  if (typeof t == "number" && s !== t)
+    throw new Error(`${e} expected ${t} bytes, got ${s}`);
+  return r;
+}
+function ut(...e) {
+  let n = 0;
+  for (let r = 0; r < e.length; r++) {
+    const s = e[r];
+    lt(s), n += s.length;
+  }
+  const t = new Uint8Array(n);
+  for (let r = 0, s = 0; r < e.length; r++) {
+    const i = e[r];
+    t.set(i, s), s += i.length;
+  }
+  return t;
+}
+function re(e, n) {
+  if (e.length !== n.length)
+    return !1;
+  let t = 0;
+  for (let r = 0; r < e.length; r++)
+    t |= e[r] ^ n[r];
+  return t === 0;
+}
+function oe(e) {
+  if (typeof e != "string")
+    throw new Error(`utf8ToBytes expected string, got ${typeof e}`);
+  return new Uint8Array(new TextEncoder().encode(e));
+}
+function ie(e) {
+  let n;
+  for (n = 0; e > Ut; e >>= ht, n += 1)
+    ;
+  return n;
+}
+function se(e, n) {
+  return e >> BigInt(n) & ht;
+}
+function ce(e, n, t) {
+  return e | (t ? ht : Ut) << BigInt(n);
+}
+const St = (e) => (te << BigInt(e - 1)) - ht, wt = (e) => new Uint8Array(e), _t = (e) => Uint8Array.from(e);
+function zt(e, n, t) {
+  if (typeof e != "number" || e < 2)
+    throw new Error("hashLen must be a number");
+  if (typeof n != "number" || n < 2)
+    throw new Error("qByteLen must be a number");
+  if (typeof t != "function")
+    throw new Error("hmacFn must be a function");
+  let r = wt(e), s = wt(e), i = 0;
+  const l = () => {
+    r.fill(1), s.fill(0), i = 0;
+  }, c = (...w) => t(s, r, ...w), o = (w = wt()) => {
+    s = c(_t([0]), w), r = c(), w.length !== 0 && (s = c(_t([1]), w), r = c());
+  }, a = () => {
+    if (i++ >= 1e3)
+      throw new Error("drbg: tried 1000 values");
+    let w = 0;
+    const O = [];
+    for (; w < n; ) {
+      r = c();
+      const T = r.slice();
+      O.push(T), w += r.length;
+    }
+    return ut(...O);
+  };
+  return (w, O) => {
+    l(), o(w);
+    let T;
+    for (; !(T = O(a())); )
+      o();
+    return l(), T;
+  };
+}
+const fe = {
+  bigint: (e) => typeof e == "bigint",
+  function: (e) => typeof e == "function",
+  boolean: (e) => typeof e == "boolean",
+  string: (e) => typeof e == "string",
+  stringOrUint8Array: (e) => typeof e == "string" || nt(e),
+  isSafeInteger: (e) => Number.isSafeInteger(e),
+  array: (e) => Array.isArray(e),
+  field: (e, n) => n.Fp.isValid(e),
+  hash: (e) => typeof e == "function" && Number.isSafeInteger(e.outputLen)
+};
+function dt(e, n, t = {}) {
+  const r = (s, i, l) => {
+    const c = fe[i];
+    if (typeof c != "function")
+      throw new Error(`Invalid validator "${i}", expected function`);
+    const o = e[s];
+    if (!(l && o === void 0) && !c(o, e))
+      throw new Error(`Invalid param ${String(s)}=${o} (${typeof o}), expected ${i}`);
+  };
+  for (const [s, i] of Object.entries(n))
+    r(s, i, !1);
+  for (const [s, i] of Object.entries(t))
+    r(s, i, !0);
+  return e;
+}
+const ae = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  abytes: lt,
+  bitGet: se,
+  bitLen: ie,
+  bitMask: St,
+  bitSet: ce,
+  bytesToHex: st,
+  bytesToNumberBE: et,
+  bytesToNumberLE: xt,
+  concatBytes: ut,
+  createHmacDrbg: zt,
+  ensureBytes: M,
+  equalBytes: re,
+  hexToBytes: ct,
+  hexToNumber: Bt,
+  isBytes: nt,
+  numberToBytesBE: ft,
+  numberToBytesLE: vt,
+  numberToHexUnpadded: Rt,
+  numberToVarBytesBE: ne,
+  utf8ToBytes: oe,
+  validateObject: dt
+}, Symbol.toStringTag, { value: "Module" }));
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const L = BigInt(0), $ = BigInt(1), J = BigInt(2), ue = BigInt(3), yt = BigInt(4), Tt = BigInt(5), $t = BigInt(8);
+BigInt(9);
+BigInt(16);
+function R(e, n) {
+  const t = e % n;
+  return t >= L ? t : n + t;
+}
+function le(e, n, t) {
+  if (t <= L || n < L)
+    throw new Error("Expected power/modulo > 0");
+  if (t === $)
+    return L;
+  let r = $;
+  for (; n > L; )
+    n & $ && (r = r * e % t), e = e * e % t, n >>= $;
+  return r;
+}
+function V(e, n, t) {
+  let r = e;
+  for (; n-- > L; )
+    r *= r, r %= t;
+  return r;
+}
+function mt(e, n) {
+  if (e === L || n <= L)
+    throw new Error(`invert: expected positive integers, got n=${e} mod=${n}`);
+  let t = R(e, n), r = n, s = L, i = $;
+  for (; t !== L; ) {
+    const c = r / t, o = r % t, a = s - i * c;
+    r = t, t = o, s = i, i = a;
+  }
+  if (r !== $)
+    throw new Error("invert: does not exist");
+  return R(s, n);
+}
+function de(e) {
+  const n = (e - $) / J;
+  let t, r, s;
+  for (t = e - $, r = 0; t % J === L; t /= J, r++)
+    ;
+  for (s = J; s < e && le(s, n, e) !== e - $; s++)
+    ;
+  if (r === 1) {
+    const l = (e + $) / yt;
+    return function(o, a) {
+      const y = o.pow(a, l);
+      if (!o.eql(o.sqr(y), a))
+        throw new Error("Cannot find square root");
+      return y;
+    };
+  }
+  const i = (t + $) / J;
+  return function(c, o) {
+    if (c.pow(o, n) === c.neg(c.ONE))
+      throw new Error("Cannot find square root");
+    let a = r, y = c.pow(c.mul(c.ONE, s), t), w = c.pow(o, i), O = c.pow(o, t);
+    for (; !c.eql(O, c.ONE); ) {
+      if (c.eql(O, c.ZERO))
+        return c.ZERO;
+      let T = 1;
+      for (let f = c.sqr(O); T < a && !c.eql(f, c.ONE); T++)
+        f = c.sqr(f);
+      const m = c.pow(y, $ << BigInt(a - T - 1));
+      y = c.sqr(m), w = c.mul(w, m), O = c.mul(O, y), a = T;
+    }
+    return w;
+  };
+}
+function he(e) {
+  if (e % yt === ue) {
+    const n = (e + $) / yt;
+    return function(r, s) {
+      const i = r.pow(s, n);
+      if (!r.eql(r.sqr(i), s))
+        throw new Error("Cannot find square root");
+      return i;
+    };
+  }
+  if (e % $t === Tt) {
+    const n = (e - Tt) / $t;
+    return function(r, s) {
+      const i = r.mul(s, J), l = r.pow(i, n), c = r.mul(s, l), o = r.mul(r.mul(c, J), l), a = r.mul(c, r.sub(o, r.ONE));
+      if (!r.eql(r.sqr(a), s))
+        throw new Error("Cannot find square root");
+      return a;
+    };
+  }
+  return de(e);
+}
+const ge = [
+  "create",
+  "isValid",
+  "is0",
+  "neg",
+  "inv",
+  "sqrt",
+  "sqr",
+  "eql",
+  "add",
+  "sub",
+  "mul",
+  "pow",
+  "div",
+  "addN",
+  "subN",
+  "mulN",
+  "sqrN"
+];
+function we(e) {
+  const n = {
+    ORDER: "bigint",
+    MASK: "bigint",
+    BYTES: "isSafeInteger",
+    BITS: "isSafeInteger"
+  }, t = ge.reduce((r, s) => (r[s] = "function", r), n);
+  return dt(e, t);
+}
+function pe(e, n, t) {
+  if (t < L)
+    throw new Error("Expected power > 0");
+  if (t === L)
+    return e.ONE;
+  if (t === $)
+    return n;
+  let r = e.ONE, s = n;
+  for (; t > L; )
+    t & $ && (r = e.mul(r, s)), s = e.sqr(s), t >>= $;
+  return r;
+}
+function ye(e, n) {
+  const t = new Array(n.length), r = n.reduce((i, l, c) => e.is0(l) ? i : (t[c] = i, e.mul(i, l)), e.ONE), s = e.inv(r);
+  return n.reduceRight((i, l, c) => e.is0(l) ? i : (t[c] = e.mul(i, t[c]), e.mul(i, l)), s), t;
+}
+function Ct(e, n) {
+  const t = n !== void 0 ? n : e.toString(2).length, r = Math.ceil(t / 8);
+  return { nBitLength: t, nByteLength: r };
+}
+function me(e, n, t = !1, r = {}) {
+  if (e <= L)
+    throw new Error(`Expected Field ORDER > 0, got ${e}`);
+  const { nBitLength: s, nByteLength: i } = Ct(e, n);
+  if (i > 2048)
+    throw new Error("Field lengths over 2048 bytes are not supported");
+  const l = he(e), c = Object.freeze({
+    ORDER: e,
+    BITS: s,
+    BYTES: i,
+    MASK: St(s),
+    ZERO: L,
+    ONE: $,
+    create: (o) => R(o, e),
+    isValid: (o) => {
+      if (typeof o != "bigint")
+        throw new Error(`Invalid field element: expected bigint, got ${typeof o}`);
+      return L <= o && o < e;
+    },
+    is0: (o) => o === L,
+    isOdd: (o) => (o & $) === $,
+    neg: (o) => R(-o, e),
+    eql: (o, a) => o === a,
+    sqr: (o) => R(o * o, e),
+    add: (o, a) => R(o + a, e),
+    sub: (o, a) => R(o - a, e),
+    mul: (o, a) => R(o * a, e),
+    pow: (o, a) => pe(c, o, a),
+    div: (o, a) => R(o * mt(a, e), e),
+    // Same as above, but doesn't normalize
+    sqrN: (o) => o * o,
+    addN: (o, a) => o + a,
+    subN: (o, a) => o - a,
+    mulN: (o, a) => o * a,
+    inv: (o) => mt(o, e),
+    sqrt: r.sqrt || ((o) => l(c, o)),
+    invertBatch: (o) => ye(c, o),
+    // TODO: do we really need constant cmov?
+    // We don't have const-time bigints anyway, so probably will be not very useful
+    cmov: (o, a, y) => y ? a : o,
+    toBytes: (o) => t ? vt(o, i) : ft(o, i),
+    fromBytes: (o) => {
+      if (o.length !== i)
+        throw new Error(`Fp.fromBytes: expected ${i}, got ${o.length}`);
+      return t ? xt(o) : et(o);
+    }
+  });
+  return Object.freeze(c);
+}
+function kt(e) {
+  if (typeof e != "bigint")
+    throw new Error("field order must be bigint");
+  const n = e.toString(2).length;
+  return Math.ceil(n / 8);
+}
+function Vt(e) {
+  const n = kt(e);
+  return n + Math.ceil(n / 2);
+}
+function be(e, n, t = !1) {
+  const r = e.length, s = kt(n), i = Vt(n);
+  if (r < 16 || r < i || r > 1024)
+    throw new Error(`expected ${i}-1024 bytes of input, got ${r}`);
+  const l = t ? et(e) : xt(e), c = R(l, n - $) + $;
+  return t ? vt(c, s) : ft(c, s);
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const Ee = BigInt(0), pt = BigInt(1);
+function Be(e, n) {
+  const t = (s, i) => {
+    const l = i.negate();
+    return s ? l : i;
+  }, r = (s) => {
+    const i = Math.ceil(n / s) + 1, l = 2 ** (s - 1);
+    return { windows: i, windowSize: l };
+  };
+  return {
+    constTimeNegate: t,
+    // non-const time multiplication ladder
+    unsafeLadder(s, i) {
+      let l = e.ZERO, c = s;
+      for (; i > Ee; )
+        i & pt && (l = l.add(c)), c = c.double(), i >>= pt;
+      return l;
+    },
+    /**
+     * 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.
+     * @returns precomputed point tables flattened to a single array
+     */
+    precomputeWindow(s, i) {
+      const { windows: l, windowSize: c } = r(i), o = [];
+      let a = s, y = a;
+      for (let w = 0; w < l; w++) {
+        y = a, o.push(y);
+        for (let O = 1; O < c; O++)
+          y = y.add(a), o.push(y);
+        a = y.double();
+      }
+      return o;
+    },
+    /**
+     * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+     * @param W window size
+     * @param precomputes precomputed tables
+     * @param n scalar (we don't check here, but should be less than curve order)
+     * @returns real and fake (for const-time) points
+     */
+    wNAF(s, i, l) {
+      const { windows: c, windowSize: o } = r(s);
+      let a = e.ZERO, y = e.BASE;
+      const w = BigInt(2 ** s - 1), O = 2 ** s, T = BigInt(s);
+      for (let m = 0; m < c; m++) {
+        const f = m * o;
+        let d = Number(l & w);
+        l >>= T, d > o && (d -= O, l += pt);
+        const h = f, b = f + Math.abs(d) - 1, B = m % 2 !== 0, I = d < 0;
+        d === 0 ? y = y.add(t(B, i[h])) : a = a.add(t(I, i[b]));
+      }
+      return { p: a, f: y };
+    },
+    wNAFCached(s, i, l, c) {
+      const o = s._WINDOW_SIZE || 1;
+      let a = i.get(s);
+      return a || (a = this.precomputeWindow(s, o), o !== 1 && i.set(s, c(a))), this.wNAF(o, a, l);
+    }
+  };
+}
+function jt(e) {
+  return we(e.Fp), dt(e, {
+    n: "bigint",
+    h: "bigint",
+    Gx: "field",
+    Gy: "field"
+  }, {
+    nBitLength: "isSafeInteger",
+    nByteLength: "isSafeInteger"
+  }), Object.freeze({
+    ...Ct(e.n, e.nBitLength),
+    ...e,
+    p: e.Fp.ORDER
+  });
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function xe(e) {
+  const n = jt(e);
+  dt(n, {
+    a: "field",
+    b: "field"
+  }, {
+    allowedPrivateKeyLengths: "array",
+    wrapPrivateKey: "boolean",
+    isTorsionFree: "function",
+    clearCofactor: "function",
+    allowInfinityPoint: "boolean",
+    fromBytes: "function",
+    toBytes: "function"
+  });
+  const { endo: t, Fp: r, a: s } = n;
+  if (t) {
+    if (!r.eql(s, r.ZERO))
+      throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");
+    if (typeof t != "object" || typeof t.beta != "bigint" || typeof t.splitScalar != "function")
+      throw new Error("Expected endomorphism with beta: bigint and splitScalar: function");
+  }
+  return Object.freeze({ ...n });
+}
+const { bytesToNumberBE: ve, hexToBytes: Se } = ae, tt = {
+  // asn.1 DER encoding utils
+  Err: class extends Error {
+    constructor(n = "") {
+      super(n);
+    }
+  },
+  _parseInt(e) {
+    const { Err: n } = tt;
+    if (e.length < 2 || e[0] !== 2)
+      throw new n("Invalid signature integer tag");
+    const t = e[1], r = e.subarray(2, t + 2);
+    if (!t || r.length !== t)
+      throw new n("Invalid signature integer: wrong length");
+    if (r[0] & 128)
+      throw new n("Invalid signature integer: negative");
+    if (r[0] === 0 && !(r[1] & 128))
+      throw new n("Invalid signature integer: unnecessary leading zero");
+    return { d: ve(r), l: e.subarray(t + 2) };
+  },
+  toSig(e) {
+    const { Err: n } = tt, t = typeof e == "string" ? Se(e) : e;
+    lt(t);
+    let r = t.length;
+    if (r < 2 || t[0] != 48)
+      throw new n("Invalid signature tag");
+    if (t[1] !== r - 2)
+      throw new n("Invalid signature: incorrect length");
+    const { d: s, l: i } = tt._parseInt(t.subarray(2)), { d: l, l: c } = tt._parseInt(i);
+    if (c.length)
+      throw new n("Invalid signature: left bytes after parsing");
+    return { r: s, s: l };
+  },
+  hexFromSig(e) {
+    const n = (a) => Number.parseInt(a[0], 16) & 8 ? "00" + a : a, t = (a) => {
+      const y = a.toString(16);
+      return y.length & 1 ? `0${y}` : y;
+    }, r = n(t(e.s)), s = n(t(e.r)), i = r.length / 2, l = s.length / 2, c = t(i), o = t(l);
+    return `30${t(l + i + 4)}02${o}${s}02${c}${r}`;
+  }
+}, F = BigInt(0), j = BigInt(1);
+BigInt(2);
+const Ht = BigInt(3);
+BigInt(4);
+function Ie(e) {
+  const n = xe(e), { Fp: t } = n, r = n.toBytes || ((m, f, d) => {
+    const h = f.toAffine();
+    return ut(Uint8Array.from([4]), t.toBytes(h.x), t.toBytes(h.y));
+  }), s = n.fromBytes || ((m) => {
+    const f = m.subarray(1), d = t.fromBytes(f.subarray(0, t.BYTES)), h = t.fromBytes(f.subarray(t.BYTES, 2 * t.BYTES));
+    return { x: d, y: h };
+  });
+  function i(m) {
+    const { a: f, b: d } = n, h = t.sqr(m), b = t.mul(h, m);
+    return t.add(t.add(b, t.mul(m, f)), d);
+  }
+  if (!t.eql(t.sqr(n.Gy), i(n.Gx)))
+    throw new Error("bad generator point: equation left != right");
+  function l(m) {
+    return typeof m == "bigint" && F < m && m < n.n;
+  }
+  function c(m) {
+    if (!l(m))
+      throw new Error("Expected valid bigint: 0 < bigint < curve.n");
+  }
+  function o(m) {
+    const { allowedPrivateKeyLengths: f, nByteLength: d, wrapPrivateKey: h, n: b } = n;
+    if (f && typeof m != "bigint") {
+      if (nt(m) && (m = st(m)), typeof m != "string" || !f.includes(m.length))
+        throw new Error("Invalid key");
+      m = m.padStart(d * 2, "0");
+    }
+    let B;
+    try {
+      B = typeof m == "bigint" ? m : et(M("private key", m, d));
+    } catch {
+      throw new Error(`private key must be ${d} bytes, hex or bigint, not ${typeof m}`);
+    }
+    return h && (B = R(B, b)), c(B), B;
+  }
+  const a = /* @__PURE__ */ new Map();
+  function y(m) {
+    if (!(m instanceof w))
+      throw new Error("ProjectivePoint expected");
+  }
+  class w {
+    constructor(f, d, h) {
+      if (this.px = f, this.py = d, this.pz = h, f == null || !t.isValid(f))
+        throw new Error("x required");
+      if (d == null || !t.isValid(d))
+        throw new Error("y required");
+      if (h == null || !t.isValid(h))
+        throw new Error("z required");
+    }
+    // Does not validate if the point is on-curve.
+    // Use fromHex instead, or call assertValidity() later.
+    static fromAffine(f) {
+      const { x: d, y: h } = f || {};
+      if (!f || !t.isValid(d) || !t.isValid(h))
+        throw new Error("invalid affine point");
+      if (f instanceof w)
+        throw new Error("projective point not allowed");
+      const b = (B) => t.eql(B, t.ZERO);
+      return b(d) && b(h) ? w.ZERO : new w(d, h, t.ONE);
+    }
+    get x() {
+      return this.toAffine().x;
+    }
+    get y() {
+      return this.toAffine().y;
+    }
+    /**
+     * Takes a bunch of Projective Points but executes only one
+     * inversion on all of them. Inversion is very slow operation,
+     * so this improves performance massively.
+     * Optimization: converts a list of projective points to a list of identical points with Z=1.
+     */
+    static normalizeZ(f) {
+      const d = t.invertBatch(f.map((h) => h.pz));
+      return f.map((h, b) => h.toAffine(d[b])).map(w.fromAffine);
+    }
+    /**
+     * Converts hash string or Uint8Array to Point.
+     * @param hex short/long ECDSA hex
+     */
+    static fromHex(f) {
+      const d = w.fromAffine(s(M("pointHex", f)));
+      return d.assertValidity(), d;
+    }
+    // Multiplies generator point by privateKey.
+    static fromPrivateKey(f) {
+      return w.BASE.multiply(o(f));
+    }
+    // "Private method", don't use it directly
+    _setWindowSize(f) {
+      this._WINDOW_SIZE = f, a.delete(this);
+    }
+    // A point on curve is valid if it conforms to equation.
+    assertValidity() {
+      if (this.is0()) {
+        if (n.allowInfinityPoint && !t.is0(this.py))
+          return;
+        throw new Error("bad point: ZERO");
+      }
+      const { x: f, y: d } = this.toAffine();
+      if (!t.isValid(f) || !t.isValid(d))
+        throw new Error("bad point: x or y not FE");
+      const h = t.sqr(d), b = i(f);
+      if (!t.eql(h, b))
+        throw new Error("bad point: equation left != right");
+      if (!this.isTorsionFree())
+        throw new Error("bad point: not in prime-order subgroup");
+    }
+    hasEvenY() {
+      const { y: f } = this.toAffine();
+      if (t.isOdd)
+        return !t.isOdd(f);
+      throw new Error("Field doesn't support isOdd");
+    }
+    /**
+     * Compare one point to another.
+     */
+    equals(f) {
+      y(f);
+      const { px: d, py: h, pz: b } = this, { px: B, py: I, pz: S } = f, p = t.eql(t.mul(d, S), t.mul(B, b)), E = t.eql(t.mul(h, S), t.mul(I, b));
+      return p && E;
+    }
+    /**
+     * Flips point to one corresponding to (x, -y) in Affine coordinates.
+     */
+    negate() {
+      return new w(this.px, t.neg(this.py), this.pz);
+    }
+    // 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: f, b: d } = n, h = t.mul(d, Ht), { px: b, py: B, pz: I } = this;
+      let S = t.ZERO, p = t.ZERO, E = t.ZERO, v = t.mul(b, b), k = t.mul(B, B), _ = t.mul(I, I), A = t.mul(b, B);
+      return A = t.add(A, A), E = t.mul(b, I), E = t.add(E, E), S = t.mul(f, E), p = t.mul(h, _), p = t.add(S, p), S = t.sub(k, p), p = t.add(k, p), p = t.mul(S, p), S = t.mul(A, S), E = t.mul(h, E), _ = t.mul(f, _), A = t.sub(v, _), A = t.mul(f, A), A = t.add(A, E), E = t.add(v, v), v = t.add(E, v), v = t.add(v, _), v = t.mul(v, A), p = t.add(p, v), _ = t.mul(B, I), _ = t.add(_, _), v = t.mul(_, A), S = t.sub(S, v), E = t.mul(_, k), E = t.add(E, E), E = t.add(E, E), new w(S, p, E);
+    }
+    // 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(f) {
+      y(f);
+      const { px: d, py: h, pz: b } = this, { px: B, py: I, pz: S } = f;
+      let p = t.ZERO, E = t.ZERO, v = t.ZERO;
+      const k = n.a, _ = t.mul(n.b, Ht);
+      let A = t.mul(d, B), z = t.mul(h, I), C = t.mul(b, S), G = t.add(d, h), u = t.add(B, I);
+      G = t.mul(G, u), u = t.add(A, z), G = t.sub(G, u), u = t.add(d, b);
+      let g = t.add(B, S);
+      return u = t.mul(u, g), g = t.add(A, C), u = t.sub(u, g), g = t.add(h, b), p = t.add(I, S), g = t.mul(g, p), p = t.add(z, C), g = t.sub(g, p), v = t.mul(k, u), p = t.mul(_, C), v = t.add(p, v), p = t.sub(z, v), v = t.add(z, v), E = t.mul(p, v), z = t.add(A, A), z = t.add(z, A), C = t.mul(k, C), u = t.mul(_, u), z = t.add(z, C), C = t.sub(A, C), C = t.mul(k, C), u = t.add(u, C), A = t.mul(z, u), E = t.add(E, A), A = t.mul(g, u), p = t.mul(G, p), p = t.sub(p, A), A = t.mul(G, z), v = t.mul(g, v), v = t.add(v, A), new w(p, E, v);
+    }
+    subtract(f) {
+      return this.add(f.negate());
+    }
+    is0() {
+      return this.equals(w.ZERO);
+    }
+    wNAF(f) {
+      return T.wNAFCached(this, a, f, (d) => {
+        const h = t.invertBatch(d.map((b) => b.pz));
+        return d.map((b, B) => b.toAffine(h[B])).map(w.fromAffine);
+      });
+    }
+    /**
+     * 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 private key e.g. sig verification, which works over *public* keys.
+     */
+    multiplyUnsafe(f) {
+      const d = w.ZERO;
+      if (f === F)
+        return d;
+      if (c(f), f === j)
+        return this;
+      const { endo: h } = n;
+      if (!h)
+        return T.unsafeLadder(this, f);
+      let { k1neg: b, k1: B, k2neg: I, k2: S } = h.splitScalar(f), p = d, E = d, v = this;
+      for (; B > F || S > F; )
+        B & j && (p = p.add(v)), S & j && (E = E.add(v)), v = v.double(), B >>= j, S >>= j;
+      return b && (p = p.negate()), I && (E = E.negate()), E = new w(t.mul(E.px, h.beta), E.py, E.pz), p.add(E);
+    }
+    /**
+     * 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(f) {
+      c(f);
+      let d = f, h, b;
+      const { endo: B } = n;
+      if (B) {
+        const { k1neg: I, k1: S, k2neg: p, k2: E } = B.splitScalar(d);
+        let { p: v, f: k } = this.wNAF(S), { p: _, f: A } = this.wNAF(E);
+        v = T.constTimeNegate(I, v), _ = T.constTimeNegate(p, _), _ = new w(t.mul(_.px, B.beta), _.py, _.pz), h = v.add(_), b = k.add(A);
+      } else {
+        const { p: I, f: S } = this.wNAF(d);
+        h = I, b = S;
+      }
+      return w.normalizeZ([h, b])[0];
+    }
+    /**
+     * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
+     * Not using Strauss-Shamir trick: precomputation tables are faster.
+     * The trick could be useful if both P and Q are not G (not in our case).
+     * @returns non-zero affine point
+     */
+    multiplyAndAddUnsafe(f, d, h) {
+      const b = w.BASE, B = (S, p) => p === F || p === j || !S.equals(b) ? S.multiplyUnsafe(p) : S.multiply(p), I = B(this, d).add(B(f, h));
+      return I.is0() ? void 0 : I;
+    }
+    // Converts Projective point to affine (x, y) coordinates.
+    // Can accept precomputed Z^-1 - for example, from invertBatch.
+    // (x, y, z) ∋ (x=x/z, y=y/z)
+    toAffine(f) {
+      const { px: d, py: h, pz: b } = this, B = this.is0();
+      f == null && (f = B ? t.ONE : t.inv(b));
+      const I = t.mul(d, f), S = t.mul(h, f), p = t.mul(b, f);
+      if (B)
+        return { x: t.ZERO, y: t.ZERO };
+      if (!t.eql(p, t.ONE))
+        throw new Error("invZ was invalid");
+      return { x: I, y: S };
+    }
+    isTorsionFree() {
+      const { h: f, isTorsionFree: d } = n;
+      if (f === j)
+        return !0;
+      if (d)
+        return d(w, this);
+      throw new Error("isTorsionFree() has not been declared for the elliptic curve");
+    }
+    clearCofactor() {
+      const { h: f, clearCofactor: d } = n;
+      return f === j ? this : d ? d(w, this) : this.multiplyUnsafe(n.h);
+    }
+    toRawBytes(f = !0) {
+      return this.assertValidity(), r(w, this, f);
+    }
+    toHex(f = !0) {
+      return st(this.toRawBytes(f));
+    }
+  }
+  w.BASE = new w(n.Gx, n.Gy, t.ONE), w.ZERO = new w(t.ZERO, t.ONE, t.ZERO);
+  const O = n.nBitLength, T = Be(w, n.endo ? Math.ceil(O / 2) : O);
+  return {
+    CURVE: n,
+    ProjectivePoint: w,
+    normPrivateKeyToScalar: o,
+    weierstrassEquation: i,
+    isWithinCurveOrder: l
+  };
+}
+function Ae(e) {
+  const n = jt(e);
+  return dt(n, {
+    hash: "hash",
+    hmac: "function",
+    randomBytes: "function"
+  }, {
+    bits2int: "function",
+    bits2int_modN: "function",
+    lowS: "boolean"
+  }), Object.freeze({ lowS: !0, ...n });
+}
+function Oe(e) {
+  const n = Ae(e), { Fp: t, n: r } = n, s = t.BYTES + 1, i = 2 * t.BYTES + 1;
+  function l(u) {
+    return F < u && u < t.ORDER;
+  }
+  function c(u) {
+    return R(u, r);
+  }
+  function o(u) {
+    return mt(u, r);
+  }
+  const { ProjectivePoint: a, normPrivateKeyToScalar: y, weierstrassEquation: w, isWithinCurveOrder: O } = Ie({
+    ...n,
+    toBytes(u, g, x) {
+      const N = g.toAffine(), q = t.toBytes(N.x), H = ut;
+      return x ? H(Uint8Array.from([g.hasEvenY() ? 2 : 3]), q) : H(Uint8Array.from([4]), q, t.toBytes(N.y));
+    },
+    fromBytes(u) {
+      const g = u.length, x = u[0], N = u.subarray(1);
+      if (g === s && (x === 2 || x === 3)) {
+        const q = et(N);
+        if (!l(q))
+          throw new Error("Point is not on curve");
+        const H = w(q);
+        let Z;
+        try {
+          Z = t.sqrt(H);
+        } catch (Y) {
+          const X = Y instanceof Error ? ": " + Y.message : "";
+          throw new Error("Point is not on curve" + X);
+        }
+        const U = (Z & j) === j;
+        return (x & 1) === 1 !== U && (Z = t.neg(Z)), { x: q, y: Z };
+      } else if (g === i && x === 4) {
+        const q = t.fromBytes(N.subarray(0, t.BYTES)), H = t.fromBytes(N.subarray(t.BYTES, 2 * t.BYTES));
+        return { x: q, y: H };
+      } else
+        throw new Error(`Point of length ${g} was invalid. Expected ${s} compressed bytes or ${i} uncompressed bytes`);
+    }
+  }), T = (u) => st(ft(u, n.nByteLength));
+  function m(u) {
+    const g = r >> j;
+    return u > g;
+  }
+  function f(u) {
+    return m(u) ? c(-u) : u;
+  }
+  const d = (u, g, x) => et(u.slice(g, x));
+  class h {
+    constructor(g, x, N) {
+      this.r = g, this.s = x, this.recovery = N, this.assertValidity();
+    }
+    // pair (bytes of r, bytes of s)
+    static fromCompact(g) {
+      const x = n.nByteLength;
+      return g = M("compactSignature", g, x * 2), new h(d(g, 0, x), d(g, x, 2 * x));
+    }
+    // DER encoded ECDSA signature
+    // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
+    static fromDER(g) {
+      const { r: x, s: N } = tt.toSig(M("DER", g));
+      return new h(x, N);
+    }
+    assertValidity() {
+      if (!O(this.r))
+        throw new Error("r must be 0 < r < CURVE.n");
+      if (!O(this.s))
+        throw new Error("s must be 0 < s < CURVE.n");
+    }
+    addRecoveryBit(g) {
+      return new h(this.r, this.s, g);
+    }
+    recoverPublicKey(g) {
+      const { r: x, s: N, recovery: q } = this, H = E(M("msgHash", g));
+      if (q == null || ![0, 1, 2, 3].includes(q))
+        throw new Error("recovery id invalid");
+      const Z = q === 2 || q === 3 ? x + n.n : x;
+      if (Z >= t.ORDER)
+        throw new Error("recovery id 2 or 3 invalid");
+      const U = q & 1 ? "03" : "02", W = a.fromHex(U + T(Z)), Y = o(Z), X = c(-H * Y), at = c(N * Y), D = a.BASE.multiplyAndAddUnsafe(W, X, at);
+      if (!D)
+        throw new Error("point at infinify");
+      return D.assertValidity(), D;
+    }
+    // Signatures should be low-s, to prevent malleability.
+    hasHighS() {
+      return m(this.s);
+    }
+    normalizeS() {
+      return this.hasHighS() ? new h(this.r, c(-this.s), this.recovery) : this;
+    }
+    // DER-encoded
+    toDERRawBytes() {
+      return ct(this.toDERHex());
+    }
+    toDERHex() {
+      return tt.hexFromSig({ r: this.r, s: this.s });
+    }
+    // padded bytes of r, then padded bytes of s
+    toCompactRawBytes() {
+      return ct(this.toCompactHex());
+    }
+    toCompactHex() {
+      return T(this.r) + T(this.s);
+    }
+  }
+  const b = {
+    isValidPrivateKey(u) {
+      try {
+        return y(u), !0;
+      } catch {
+        return !1;
+      }
+    },
+    normPrivateKeyToScalar: y,
+    /**
+     * Produces cryptographically secure private key from random of size
+     * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
+     */
+    randomPrivateKey: () => {
+      const u = Vt(n.n);
+      return be(n.randomBytes(u), n.n);
+    },
+    /**
+     * Creates precompute table for an arbitrary EC point. Makes point "cached".
+     * Allows to massively speed-up `point.multiply(scalar)`.
+     * @returns cached point
+     * @example
+     * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
+     * fast.multiply(privKey); // much faster ECDH now
+     */
+    precompute(u = 8, g = a.BASE) {
+      return g._setWindowSize(u), g.multiply(BigInt(3)), g;
+    }
+  };
+  function B(u, g = !0) {
+    return a.fromPrivateKey(u).toRawBytes(g);
+  }
+  function I(u) {
+    const g = nt(u), x = typeof u == "string", N = (g || x) && u.length;
+    return g ? N === s || N === i : x ? N === 2 * s || N === 2 * i : u instanceof a;
+  }
+  function S(u, g, x = !0) {
+    if (I(u))
+      throw new Error("first arg must be private key");
+    if (!I(g))
+      throw new Error("second arg must be public key");
+    return a.fromHex(g).multiply(y(u)).toRawBytes(x);
+  }
+  const p = n.bits2int || function(u) {
+    const g = et(u), x = u.length * 8 - n.nBitLength;
+    return x > 0 ? g >> BigInt(x) : g;
+  }, E = n.bits2int_modN || function(u) {
+    return c(p(u));
+  }, v = St(n.nBitLength);
+  function k(u) {
+    if (typeof u != "bigint")
+      throw new Error("bigint expected");
+    if (!(F <= u && u < v))
+      throw new Error(`bigint expected < 2^${n.nBitLength}`);
+    return ft(u, n.nByteLength);
+  }
+  function _(u, g, x = A) {
+    if (["recovered", "canonical"].some((Q) => Q in x))
+      throw new Error("sign() legacy options not supported");
+    const { hash: N, randomBytes: q } = n;
+    let { lowS: H, prehash: Z, extraEntropy: U } = x;
+    H == null && (H = !0), u = M("msgHash", u), Z && (u = M("prehashed msgHash", N(u)));
+    const W = E(u), Y = y(g), X = [k(Y), k(W)];
+    if (U != null && U !== !1) {
+      const Q = U === !0 ? q(t.BYTES) : U;
+      X.push(M("extraEntropy", Q));
+    }
+    const at = ut(...X), D = W;
+    function gt(Q) {
+      const rt = p(Q);
+      if (!O(rt))
+        return;
+      const It = o(rt), ot = a.BASE.multiply(rt).toAffine(), K = c(ot.x);
+      if (K === F)
+        return;
+      const it = c(It * c(D + K * Y));
+      if (it === F)
+        return;
+      let At = (ot.x === K ? 0 : 2) | Number(ot.y & j), Ot = it;
+      return H && m(it) && (Ot = f(it), At ^= 1), new h(K, Ot, At);
+    }
+    return { seed: at, k2sig: gt };
+  }
+  const A = { lowS: n.lowS, prehash: !1 }, z = { lowS: n.lowS, prehash: !1 };
+  function C(u, g, x = A) {
+    const { seed: N, k2sig: q } = _(u, g, x), H = n;
+    return zt(H.hash.outputLen, H.nByteLength, H.hmac)(N, q);
+  }
+  a.BASE._setWindowSize(8);
+  function G(u, g, x, N = z) {
+    var ot;
+    const q = u;
+    if (g = M("msgHash", g), x = M("publicKey", x), "strict" in N)
+      throw new Error("options.strict was renamed to lowS");
+    const { lowS: H, prehash: Z } = N;
+    let U, W;
+    try {
+      if (typeof q == "string" || nt(q))
+        try {
+          U = h.fromDER(q);
+        } catch (K) {
+          if (!(K instanceof tt.Err))
+            throw K;
+          U = h.fromCompact(q);
+        }
+      else if (typeof q == "object" && typeof q.r == "bigint" && typeof q.s == "bigint") {
+        const { r: K, s: it } = q;
+        U = new h(K, it);
+      } else
+        throw new Error("PARSE");
+      W = a.fromHex(x);
+    } catch (K) {
+      if (K.message === "PARSE")
+        throw new Error("signature must be Signature instance, Uint8Array or hex string");
+      return !1;
+    }
+    if (H && U.hasHighS())
+      return !1;
+    Z && (g = n.hash(g));
+    const { r: Y, s: X } = U, at = E(g), D = o(X), gt = c(at * D), Q = c(Y * D), rt = (ot = a.BASE.multiplyAndAddUnsafe(W, gt, Q)) == null ? void 0 : ot.toAffine();
+    return rt ? c(rt.x) === Y : !1;
+  }
+  return {
+    CURVE: n,
+    getPublicKey: B,
+    getSharedSecret: S,
+    sign: C,
+    verify: G,
+    ProjectivePoint: a,
+    Signature: h,
+    utils: b
+  };
+}
+class Yt extends Ft {
+  constructor(n, t) {
+    super(), this.finished = !1, this.destroyed = !1, Gt(n);
+    const r = Wt(t);
+    if (this.iHash = n.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 s = this.blockLen, i = new Uint8Array(s);
+    i.set(r.length > s ? n.create().update(r).digest() : r);
+    for (let l = 0; l < i.length; l++)
+      i[l] ^= 54;
+    this.iHash.update(i), this.oHash = n.create();
+    for (let l = 0; l < i.length; l++)
+      i[l] ^= 106;
+    this.oHash.update(i), i.fill(0);
+  }
+  update(n) {
+    return qt(this), this.iHash.update(n), this;
+  }
+  digestInto(n) {
+    qt(this), Xt(n, this.outputLen), this.finished = !0, this.iHash.digestInto(n), this.oHash.update(n), this.oHash.digestInto(n), this.destroy();
+  }
+  digest() {
+    const n = new Uint8Array(this.oHash.outputLen);
+    return this.digestInto(n), n;
+  }
+  _cloneInto(n) {
+    n || (n = Object.create(Object.getPrototypeOf(this), {}));
+    const { oHash: t, iHash: r, finished: s, destroyed: i, blockLen: l, outputLen: c } = this;
+    return n = n, n.finished = s, n.destroyed = i, n.blockLen = l, n.outputLen = c, n.oHash = t._cloneInto(n.oHash), n.iHash = r._cloneInto(n.iHash), n;
+  }
+  destroy() {
+    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+  }
+}
+const Kt = (e, n, t) => new Yt(e, n).update(t).digest();
+Kt.create = (e, n) => new Yt(e, n);
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function qe(e) {
+  return {
+    hash: e,
+    hmac: (n, ...t) => Kt(e, n, Dt(...t)),
+    randomBytes: Qt
+  };
+}
+function Ne(e, n) {
+  const t = (r) => Oe({ ...e, ...qe(r) });
+  return Object.freeze({ ...t(n), create: t });
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const Mt = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"), Lt = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"), _e = BigInt(1), bt = BigInt(2), Zt = (e, n) => (e + n / bt) / n;
+function Te(e) {
+  const n = Mt, t = BigInt(3), r = BigInt(6), s = BigInt(11), i = BigInt(22), l = BigInt(23), c = BigInt(44), o = BigInt(88), a = e * e * e % n, y = a * a * e % n, w = V(y, t, n) * y % n, O = V(w, t, n) * y % n, T = V(O, bt, n) * a % n, m = V(T, s, n) * T % n, f = V(m, i, n) * m % n, d = V(f, c, n) * f % n, h = V(d, o, n) * d % n, b = V(h, c, n) * f % n, B = V(b, t, n) * y % n, I = V(B, l, n) * m % n, S = V(I, r, n) * a % n, p = V(S, bt, n);
+  if (!Et.eql(Et.sqr(p), e))
+    throw new Error("Cannot find square root");
+  return p;
+}
+const Et = me(Mt, void 0, void 0, { sqrt: Te }), Pt = Ne({
+  a: BigInt(0),
+  // equation params: a, b
+  b: BigInt(7),
+  // Seem to be rigid: bitcointalk.org/index.php?topic=289795.msg3183975#msg3183975
+  Fp: Et,
+  // Field's prime: 2n**256n - 2n**32n - 2n**9n - 2n**8n - 2n**7n - 2n**6n - 2n**4n - 1n
+  n: Lt,
+  // Curve order, total count of valid points in the field
+  // Base point (x, y) aka generator point
+  Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
+  Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
+  h: BigInt(1),
+  // Cofactor
+  lowS: !0,
+  // Allow only low-S signatures by default in sign() and verify()
+  /**
+   * secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism.
+   * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.
+   * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.
+   * Explanation: https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066
+   */
+  endo: {
+    beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
+    splitScalar: (e) => {
+      const n = Lt, t = BigInt("0x3086d221a7d46bcde86c90e49284eb15"), r = -_e * BigInt("0xe4437ed6010e88286f547fa90abfe4c3"), s = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), i = t, l = BigInt("0x100000000000000000000000000000000"), c = Zt(i * e, n), o = Zt(-r * e, n);
+      let a = R(e - c * t - o * s, n), y = R(-c * r - o * i, n);
+      const w = a > l, O = y > l;
+      if (w && (a = n - a), O && (y = n - y), a > l || y > l)
+        throw new Error("splitScalar: Endomorphism failed, k=" + e);
+      return { k1neg: w, k1: a, k2neg: O, k2: y };
+    }
+  }
+}, Jt);
+BigInt(0);
+Pt.ProjectivePoint;
+const Le = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  secp256k1: Pt
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  Le as a,
+  re as e,
+  Pt as s
+};
+//# sourceMappingURL=secp256k1-BLbXMlpX.js.map