@hinkal/common 0.0.115 → 0.0.117

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/signing-key/lib.esm/elliptic.mjs

@@ -0,0 +1,1133 @@
+import b from "../../../bn.js/lib/bn.mjs";
+import z from "../../../hash.js/lib/hash.mjs";
+function j(t, e, r) {
+  return r = {
+    path: e,
+    exports: {},
+    require: function(f, i) {
+      return fe(f, i ?? r.path);
+    }
+  }, t(r, r.exports), r.exports;
+}
+function fe() {
+  throw new Error("Dynamic requires are not currently supported by @rollup/plugin-commonjs");
+}
+var U = $;
+function $(t, e) {
+  if (!t)
+    throw new Error(e || "Assertion failed");
+}
+$.equal = function(e, r, f) {
+  if (e != r)
+    throw new Error(f || "Assertion failed: " + e + " != " + r);
+};
+var q = j(function(t, e) {
+  var r = e;
+  function f(n, s) {
+    if (Array.isArray(n))
+      return n.slice();
+    if (!n)
+      return [];
+    var a = [];
+    if (typeof n != "string") {
+      for (var o = 0; o < n.length; o++)
+        a[o] = n[o] | 0;
+      return a;
+    }
+    if (s === "hex") {
+      n = n.replace(/[^a-z0-9]+/ig, ""), n.length % 2 !== 0 && (n = "0" + n);
+      for (var o = 0; o < n.length; o += 2)
+        a.push(parseInt(n[o] + n[o + 1], 16));
+    } else
+      for (var o = 0; o < n.length; o++) {
+        var u = n.charCodeAt(o), h = u >> 8, c = u & 255;
+        h ? a.push(h, c) : a.push(c);
+      }
+    return a;
+  }
+  r.toArray = f;
+  function i(n) {
+    return n.length === 1 ? "0" + n : n;
+  }
+  r.zero2 = i;
+  function d(n) {
+    for (var s = "", a = 0; a < n.length; a++)
+      s += i(n[a].toString(16));
+    return s;
+  }
+  r.toHex = d, r.encode = function(s, a) {
+    return a === "hex" ? d(s) : s;
+  };
+}), x = j(function(t, e) {
+  var r = e;
+  r.assert = U, r.toArray = q.toArray, r.zero2 = q.zero2, r.toHex = q.toHex, r.encode = q.encode;
+  function f(a, o, u) {
+    var h = new Array(Math.max(a.bitLength(), u) + 1);
+    h.fill(0);
+    for (var c = 1 << o + 1, l = a.clone(), v = 0; v < h.length; v++) {
+      var p, m = l.andln(c - 1);
+      l.isOdd() ? (m > (c >> 1) - 1 ? p = (c >> 1) - m : p = m, l.isubn(p)) : p = 0, h[v] = p, l.iushrn(1);
+    }
+    return h;
+  }
+  r.getNAF = f;
+  function i(a, o) {
+    var u = [
+      [],
+      []
+    ];
+    a = a.clone(), o = o.clone();
+    for (var h = 0, c = 0, l; a.cmpn(-h) > 0 || o.cmpn(-c) > 0; ) {
+      var v = a.andln(3) + h & 3, p = o.andln(3) + c & 3;
+      v === 3 && (v = -1), p === 3 && (p = -1);
+      var m;
+      v & 1 ? (l = a.andln(7) + h & 7, (l === 3 || l === 5) && p === 2 ? m = -v : m = v) : m = 0, u[0].push(m);
+      var y;
+      p & 1 ? (l = o.andln(7) + c & 7, (l === 3 || l === 5) && v === 2 ? y = -p : y = p) : y = 0, u[1].push(y), 2 * h === m + 1 && (h = 1 - h), 2 * c === y + 1 && (c = 1 - c), a.iushrn(1), o.iushrn(1);
+    }
+    return u;
+  }
+  r.getJSF = i;
+  function d(a, o, u) {
+    var h = "_" + o;
+    a.prototype[o] = function() {
+      return this[h] !== void 0 ? this[h] : this[h] = u.call(this);
+    };
+  }
+  r.cachedProperty = d;
+  function n(a) {
+    return typeof a == "string" ? r.toArray(a, "hex") : a;
+  }
+  r.parseBytes = n;
+  function s(a) {
+    return new b(a, "hex", "le");
+  }
+  r.intFromLE = s;
+}), D = x.getNAF, te = x.getJSF, B = x.assert;
+function E(t, e) {
+  this.type = t, this.p = new b(e.p, 16), this.red = e.prime ? b.red(e.prime) : b.mont(this.p), this.zero = new b(0).toRed(this.red), this.one = new b(1).toRed(this.red), this.two = new b(2).toRed(this.red), this.n = e.n && new b(e.n, 16), this.g = e.g && this.pointFromJSON(e.g, e.gRed), this._wnafT1 = new Array(4), this._wnafT2 = new Array(4), this._wnafT3 = new Array(4), this._wnafT4 = new Array(4), this._bitLength = this.n ? this.n.bitLength() : 0;
+  var r = this.n && this.p.div(this.n);
+  !r || r.cmpn(100) > 0 ? this.redN = null : (this._maxwellTrick = !0, this.redN = this.n.toRed(this.red));
+}
+var F = E;
+E.prototype.point = function() {
+  throw new Error("Not implemented");
+};
+E.prototype.validate = function() {
+  throw new Error("Not implemented");
+};
+E.prototype._fixedNafMul = function(e, r) {
+  B(e.precomputed);
+  var f = e._getDoubles(), i = D(r, 1, this._bitLength), d = (1 << f.step + 1) - (f.step % 2 === 0 ? 2 : 1);
+  d /= 3;
+  var n = [], s, a;
+  for (s = 0; s < i.length; s += f.step) {
+    a = 0;
+    for (var o = s + f.step - 1; o >= s; o--)
+      a = (a << 1) + i[o];
+    n.push(a);
+  }
+  for (var u = this.jpoint(null, null, null), h = this.jpoint(null, null, null), c = d; c > 0; c--) {
+    for (s = 0; s < n.length; s++)
+      a = n[s], a === c ? h = h.mixedAdd(f.points[s]) : a === -c && (h = h.mixedAdd(f.points[s].neg()));
+    u = u.add(h);
+  }
+  return u.toP();
+};
+E.prototype._wnafMul = function(e, r) {
+  var f = 4, i = e._getNAFPoints(f);
+  f = i.wnd;
+  for (var d = i.points, n = D(r, f, this._bitLength), s = this.jpoint(null, null, null), a = n.length - 1; a >= 0; a--) {
+    for (var o = 0; a >= 0 && n[a] === 0; a--)
+      o++;
+    if (a >= 0 && o++, s = s.dblp(o), a < 0)
+      break;
+    var u = n[a];
+    B(u !== 0), e.type === "affine" ? u > 0 ? s = s.mixedAdd(d[u - 1 >> 1]) : s = s.mixedAdd(d[-u - 1 >> 1].neg()) : u > 0 ? s = s.add(d[u - 1 >> 1]) : s = s.add(d[-u - 1 >> 1].neg());
+  }
+  return e.type === "affine" ? s.toP() : s;
+};
+E.prototype._wnafMulAdd = function(e, r, f, i, d) {
+  var n = this._wnafT1, s = this._wnafT2, a = this._wnafT3, o = 0, u, h, c;
+  for (u = 0; u < i; u++) {
+    c = r[u];
+    var l = c._getNAFPoints(e);
+    n[u] = l.wnd, s[u] = l.points;
+  }
+  for (u = i - 1; u >= 1; u -= 2) {
+    var v = u - 1, p = u;
+    if (n[v] !== 1 || n[p] !== 1) {
+      a[v] = D(f[v], n[v], this._bitLength), a[p] = D(f[p], n[p], this._bitLength), o = Math.max(a[v].length, o), o = Math.max(a[p].length, o);
+      continue;
+    }
+    var m = [
+      r[v],
+      /* 1 */
+      null,
+      /* 3 */
+      null,
+      /* 5 */
+      r[p]
+      /* 7 */
+    ];
+    r[v].y.cmp(r[p].y) === 0 ? (m[1] = r[v].add(r[p]), m[2] = r[v].toJ().mixedAdd(r[p].neg())) : r[v].y.cmp(r[p].y.redNeg()) === 0 ? (m[1] = r[v].toJ().mixedAdd(r[p]), m[2] = r[v].add(r[p].neg())) : (m[1] = r[v].toJ().mixedAdd(r[p]), m[2] = r[v].toJ().mixedAdd(r[p].neg()));
+    var y = [
+      -3,
+      /* -1 -1 */
+      -1,
+      /* -1 0 */
+      -5,
+      /* -1 1 */
+      -7,
+      /* 0 -1 */
+      0,
+      /* 0 0 */
+      7,
+      /* 0 1 */
+      5,
+      /* 1 -1 */
+      1,
+      /* 1 0 */
+      3
+      /* 1 1 */
+    ], I = te(f[v], f[p]);
+    for (o = Math.max(I[0].length, o), a[v] = new Array(o), a[p] = new Array(o), h = 0; h < o; h++) {
+      var N = I[0][h] | 0, V = I[1][h] | 0;
+      a[v][h] = y[(N + 1) * 3 + (V + 1)], a[p][h] = 0, s[v] = m;
+    }
+  }
+  var P = this.jpoint(null, null, null), L = this._wnafT4;
+  for (u = o; u >= 0; u--) {
+    for (var X = 0; u >= 0; ) {
+      var k = !0;
+      for (h = 0; h < i; h++)
+        L[h] = a[h][u] | 0, L[h] !== 0 && (k = !1);
+      if (!k)
+        break;
+      X++, u--;
+    }
+    if (u >= 0 && X++, P = P.dblp(X), u < 0)
+      break;
+    for (h = 0; h < i; h++) {
+      var O = L[h];
+      O !== 0 && (O > 0 ? c = s[h][O - 1 >> 1] : O < 0 && (c = s[h][-O - 1 >> 1].neg()), c.type === "affine" ? P = P.mixedAdd(c) : P = P.add(c));
+    }
+  }
+  for (u = 0; u < i; u++)
+    s[u] = null;
+  return d ? P : P.toP();
+};
+function _(t, e) {
+  this.curve = t, this.type = e, this.precomputed = null;
+}
+E.BasePoint = _;
+_.prototype.eq = function() {
+  throw new Error("Not implemented");
+};
+_.prototype.validate = function() {
+  return this.curve.validate(this);
+};
+E.prototype.decodePoint = function(e, r) {
+  e = x.toArray(e, r);
+  var f = this.p.byteLength();
+  if ((e[0] === 4 || e[0] === 6 || e[0] === 7) && e.length - 1 === 2 * f) {
+    e[0] === 6 ? B(e[e.length - 1] % 2 === 0) : e[0] === 7 && B(e[e.length - 1] % 2 === 1);
+    var i = this.point(
+      e.slice(1, 1 + f),
+      e.slice(1 + f, 1 + 2 * f)
+    );
+    return i;
+  } else if ((e[0] === 2 || e[0] === 3) && e.length - 1 === f)
+    return this.pointFromX(e.slice(1, 1 + f), e[0] === 3);
+  throw new Error("Unknown point format");
+};
+_.prototype.encodeCompressed = function(e) {
+  return this.encode(e, !0);
+};
+_.prototype._encode = function(e) {
+  var r = this.curve.p.byteLength(), f = this.getX().toArray("be", r);
+  return e ? [this.getY().isEven() ? 2 : 3].concat(f) : [4].concat(f, this.getY().toArray("be", r));
+};
+_.prototype.encode = function(e, r) {
+  return x.encode(this._encode(r), e);
+};
+_.prototype.precompute = function(e) {
+  if (this.precomputed)
+    return this;
+  var r = {
+    doubles: null,
+    naf: null,
+    beta: null
+  };
+  return r.naf = this._getNAFPoints(8), r.doubles = this._getDoubles(4, e), r.beta = this._getBeta(), this.precomputed = r, this;
+};
+_.prototype._hasDoubles = function(e) {
+  if (!this.precomputed)
+    return !1;
+  var r = this.precomputed.doubles;
+  return r ? r.points.length >= Math.ceil((e.bitLength() + 1) / r.step) : !1;
+};
+_.prototype._getDoubles = function(e, r) {
+  if (this.precomputed && this.precomputed.doubles)
+    return this.precomputed.doubles;
+  for (var f = [this], i = this, d = 0; d < r; d += e) {
+    for (var n = 0; n < e; n++)
+      i = i.dbl();
+    f.push(i);
+  }
+  return {
+    step: e,
+    points: f
+  };
+};
+_.prototype._getNAFPoints = function(e) {
+  if (this.precomputed && this.precomputed.naf)
+    return this.precomputed.naf;
+  for (var r = [this], f = (1 << e) - 1, i = f === 1 ? null : this.dbl(), d = 1; d < f; d++)
+    r[d] = r[d - 1].add(i);
+  return {
+    wnd: e,
+    points: r
+  };
+};
+_.prototype._getBeta = function() {
+  return null;
+};
+_.prototype.dblp = function(e) {
+  for (var r = this, f = 0; f < e; f++)
+    r = r.dbl();
+  return r;
+};
+var G = j(function(t) {
+  typeof Object.create == "function" ? t.exports = function(r, f) {
+    f && (r.super_ = f, r.prototype = Object.create(f.prototype, {
+      constructor: {
+        value: r,
+        enumerable: !1,
+        writable: !0,
+        configurable: !0
+      }
+    }));
+  } : t.exports = function(r, f) {
+    if (f) {
+      r.super_ = f;
+      var i = function() {
+      };
+      i.prototype = f.prototype, r.prototype = new i(), r.prototype.constructor = r;
+    }
+  };
+}), ie = x.assert;
+function M(t) {
+  F.call(this, "short", t), this.a = new b(t.a, 16).toRed(this.red), this.b = new b(t.b, 16).toRed(this.red), this.tinv = this.two.redInvm(), this.zeroA = this.a.fromRed().cmpn(0) === 0, this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0, this.endo = this._getEndomorphism(t), this._endoWnafT1 = new Array(4), this._endoWnafT2 = new Array(4);
+}
+G(M, F);
+var ne = M;
+M.prototype._getEndomorphism = function(e) {
+  if (!(!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1)) {
+    var r, f;
+    if (e.beta)
+      r = new b(e.beta, 16).toRed(this.red);
+    else {
+      var i = this._getEndoRoots(this.p);
+      r = i[0].cmp(i[1]) < 0 ? i[0] : i[1], r = r.toRed(this.red);
+    }
+    if (e.lambda)
+      f = new b(e.lambda, 16);
+    else {
+      var d = this._getEndoRoots(this.n);
+      this.g.mul(d[0]).x.cmp(this.g.x.redMul(r)) === 0 ? f = d[0] : (f = d[1], ie(this.g.mul(f).x.cmp(this.g.x.redMul(r)) === 0));
+    }
+    var n;
+    return e.basis ? n = e.basis.map(function(s) {
+      return {
+        a: new b(s.a, 16),
+        b: new b(s.b, 16)
+      };
+    }) : n = this._getEndoBasis(f), {
+      beta: r,
+      lambda: f,
+      basis: n
+    };
+  }
+};
+M.prototype._getEndoRoots = function(e) {
+  var r = e === this.p ? this.red : b.mont(e), f = new b(2).toRed(r).redInvm(), i = f.redNeg(), d = new b(3).toRed(r).redNeg().redSqrt().redMul(f), n = i.redAdd(d).fromRed(), s = i.redSub(d).fromRed();
+  return [n, s];
+};
+M.prototype._getEndoBasis = function(e) {
+  for (var r = this.n.ushrn(Math.floor(this.n.bitLength() / 2)), f = e, i = this.n.clone(), d = new b(1), n = new b(0), s = new b(0), a = new b(1), o, u, h, c, l, v, p, m = 0, y, I; f.cmpn(0) !== 0; ) {
+    var N = i.div(f);
+    y = i.sub(N.mul(f)), I = s.sub(N.mul(d));
+    var V = a.sub(N.mul(n));
+    if (!h && y.cmp(r) < 0)
+      o = p.neg(), u = d, h = y.neg(), c = I;
+    else if (h && ++m === 2)
+      break;
+    p = y, i = f, f = y, s = d, d = I, a = n, n = V;
+  }
+  l = y.neg(), v = I;
+  var P = h.sqr().add(c.sqr()), L = l.sqr().add(v.sqr());
+  return L.cmp(P) >= 0 && (l = o, v = u), h.negative && (h = h.neg(), c = c.neg()), l.negative && (l = l.neg(), v = v.neg()), [
+    { a: h, b: c },
+    { a: l, b: v }
+  ];
+};
+M.prototype._endoSplit = function(e) {
+  var r = this.endo.basis, f = r[0], i = r[1], d = i.b.mul(e).divRound(this.n), n = f.b.neg().mul(e).divRound(this.n), s = d.mul(f.a), a = n.mul(i.a), o = d.mul(f.b), u = n.mul(i.b), h = e.sub(s).sub(a), c = o.add(u).neg();
+  return { k1: h, k2: c };
+};
+M.prototype.pointFromX = function(e, r) {
+  e = new b(e, 16), e.red || (e = e.toRed(this.red));
+  var f = e.redSqr().redMul(e).redIAdd(e.redMul(this.a)).redIAdd(this.b), i = f.redSqrt();
+  if (i.redSqr().redSub(f).cmp(this.zero) !== 0)
+    throw new Error("invalid point");
+  var d = i.fromRed().isOdd();
+  return (r && !d || !r && d) && (i = i.redNeg()), this.point(e, i);
+};
+M.prototype.validate = function(e) {
+  if (e.inf)
+    return !0;
+  var r = e.x, f = e.y, i = this.a.redMul(r), d = r.redSqr().redMul(r).redIAdd(i).redIAdd(this.b);
+  return f.redSqr().redISub(d).cmpn(0) === 0;
+};
+M.prototype._endoWnafMulAdd = function(e, r, f) {
+  for (var i = this._endoWnafT1, d = this._endoWnafT2, n = 0; n < e.length; n++) {
+    var s = this._endoSplit(r[n]), a = e[n], o = a._getBeta();
+    s.k1.negative && (s.k1.ineg(), a = a.neg(!0)), s.k2.negative && (s.k2.ineg(), o = o.neg(!0)), i[n * 2] = a, i[n * 2 + 1] = o, d[n * 2] = s.k1, d[n * 2 + 1] = s.k2;
+  }
+  for (var u = this._wnafMulAdd(1, i, d, n * 2, f), h = 0; h < n * 2; h++)
+    i[h] = null, d[h] = null;
+  return u;
+};
+function g(t, e, r, f) {
+  F.BasePoint.call(this, t, "affine"), e === null && r === null ? (this.x = null, this.y = null, this.inf = !0) : (this.x = new b(e, 16), this.y = new b(r, 16), f && (this.x.forceRed(this.curve.red), this.y.forceRed(this.curve.red)), this.x.red || (this.x = this.x.toRed(this.curve.red)), this.y.red || (this.y = this.y.toRed(this.curve.red)), this.inf = !1);
+}
+G(g, F.BasePoint);
+M.prototype.point = function(e, r, f) {
+  return new g(this, e, r, f);
+};
+M.prototype.pointFromJSON = function(e, r) {
+  return g.fromJSON(this, e, r);
+};
+g.prototype._getBeta = function() {
+  if (this.curve.endo) {
+    var e = this.precomputed;
+    if (e && e.beta)
+      return e.beta;
+    var r = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y);
+    if (e) {
+      var f = this.curve, i = function(d) {
+        return f.point(d.x.redMul(f.endo.beta), d.y);
+      };
+      e.beta = r, r.precomputed = {
+        beta: null,
+        naf: e.naf && {
+          wnd: e.naf.wnd,
+          points: e.naf.points.map(i)
+        },
+        doubles: e.doubles && {
+          step: e.doubles.step,
+          points: e.doubles.points.map(i)
+        }
+      };
+    }
+    return r;
+  }
+};
+g.prototype.toJSON = function() {
+  return this.precomputed ? [this.x, this.y, this.precomputed && {
+    doubles: this.precomputed.doubles && {
+      step: this.precomputed.doubles.step,
+      points: this.precomputed.doubles.points.slice(1)
+    },
+    naf: this.precomputed.naf && {
+      wnd: this.precomputed.naf.wnd,
+      points: this.precomputed.naf.points.slice(1)
+    }
+  }] : [this.x, this.y];
+};
+g.fromJSON = function(e, r, f) {
+  typeof r == "string" && (r = JSON.parse(r));
+  var i = e.point(r[0], r[1], f);
+  if (!r[2])
+    return i;
+  function d(s) {
+    return e.point(s[0], s[1], f);
+  }
+  var n = r[2];
+  return i.precomputed = {
+    beta: null,
+    doubles: n.doubles && {
+      step: n.doubles.step,
+      points: [i].concat(n.doubles.points.map(d))
+    },
+    naf: n.naf && {
+      wnd: n.naf.wnd,
+      points: [i].concat(n.naf.points.map(d))
+    }
+  }, i;
+};
+g.prototype.inspect = function() {
+  return this.isInfinity() ? "<EC Point Infinity>" : "<EC Point x: " + this.x.fromRed().toString(16, 2) + " y: " + this.y.fromRed().toString(16, 2) + ">";
+};
+g.prototype.isInfinity = function() {
+  return this.inf;
+};
+g.prototype.add = function(e) {
+  if (this.inf)
+    return e;
+  if (e.inf)
+    return this;
+  if (this.eq(e))
+    return this.dbl();
+  if (this.neg().eq(e))
+    return this.curve.point(null, null);
+  if (this.x.cmp(e.x) === 0)
+    return this.curve.point(null, null);
+  var r = this.y.redSub(e.y);
+  r.cmpn(0) !== 0 && (r = r.redMul(this.x.redSub(e.x).redInvm()));
+  var f = r.redSqr().redISub(this.x).redISub(e.x), i = r.redMul(this.x.redSub(f)).redISub(this.y);
+  return this.curve.point(f, i);
+};
+g.prototype.dbl = function() {
+  if (this.inf)
+    return this;
+  var e = this.y.redAdd(this.y);
+  if (e.cmpn(0) === 0)
+    return this.curve.point(null, null);
+  var r = this.curve.a, f = this.x.redSqr(), i = e.redInvm(), d = f.redAdd(f).redIAdd(f).redIAdd(r).redMul(i), n = d.redSqr().redISub(this.x.redAdd(this.x)), s = d.redMul(this.x.redSub(n)).redISub(this.y);
+  return this.curve.point(n, s);
+};
+g.prototype.getX = function() {
+  return this.x.fromRed();
+};
+g.prototype.getY = function() {
+  return this.y.fromRed();
+};
+g.prototype.mul = function(e) {
+  return e = new b(e, 16), this.isInfinity() ? this : this._hasDoubles(e) ? this.curve._fixedNafMul(this, e) : this.curve.endo ? this.curve._endoWnafMulAdd([this], [e]) : this.curve._wnafMul(this, e);
+};
+g.prototype.mulAdd = function(e, r, f) {
+  var i = [this, r], d = [e, f];
+  return this.curve.endo ? this.curve._endoWnafMulAdd(i, d) : this.curve._wnafMulAdd(1, i, d, 2);
+};
+g.prototype.jmulAdd = function(e, r, f) {
+  var i = [this, r], d = [e, f];
+  return this.curve.endo ? this.curve._endoWnafMulAdd(i, d, !0) : this.curve._wnafMulAdd(1, i, d, 2, !0);
+};
+g.prototype.eq = function(e) {
+  return this === e || this.inf === e.inf && (this.inf || this.x.cmp(e.x) === 0 && this.y.cmp(e.y) === 0);
+};
+g.prototype.neg = function(e) {
+  if (this.inf)
+    return this;
+  var r = this.curve.point(this.x, this.y.redNeg());
+  if (e && this.precomputed) {
+    var f = this.precomputed, i = function(d) {
+      return d.neg();
+    };
+    r.precomputed = {
+      naf: f.naf && {
+        wnd: f.naf.wnd,
+        points: f.naf.points.map(i)
+      },
+      doubles: f.doubles && {
+        step: f.doubles.step,
+        points: f.doubles.points.map(i)
+      }
+    };
+  }
+  return r;
+};
+g.prototype.toJ = function() {
+  if (this.inf)
+    return this.curve.jpoint(null, null, null);
+  var e = this.curve.jpoint(this.x, this.y, this.curve.one);
+  return e;
+};
+function A(t, e, r, f) {
+  F.BasePoint.call(this, t, "jacobian"), e === null && r === null && f === null ? (this.x = this.curve.one, this.y = this.curve.one, this.z = new b(0)) : (this.x = new b(e, 16), this.y = new b(r, 16), this.z = new b(f, 16)), this.x.red || (this.x = this.x.toRed(this.curve.red)), this.y.red || (this.y = this.y.toRed(this.curve.red)), this.z.red || (this.z = this.z.toRed(this.curve.red)), this.zOne = this.z === this.curve.one;
+}
+G(A, F.BasePoint);
+M.prototype.jpoint = function(e, r, f) {
+  return new A(this, e, r, f);
+};
+A.prototype.toP = function() {
+  if (this.isInfinity())
+    return this.curve.point(null, null);
+  var e = this.z.redInvm(), r = e.redSqr(), f = this.x.redMul(r), i = this.y.redMul(r).redMul(e);
+  return this.curve.point(f, i);
+};
+A.prototype.neg = function() {
+  return this.curve.jpoint(this.x, this.y.redNeg(), this.z);
+};
+A.prototype.add = function(e) {
+  if (this.isInfinity())
+    return e;
+  if (e.isInfinity())
+    return this;
+  var r = e.z.redSqr(), f = this.z.redSqr(), i = this.x.redMul(r), d = e.x.redMul(f), n = this.y.redMul(r.redMul(e.z)), s = e.y.redMul(f.redMul(this.z)), a = i.redSub(d), o = n.redSub(s);
+  if (a.cmpn(0) === 0)
+    return o.cmpn(0) !== 0 ? this.curve.jpoint(null, null, null) : this.dbl();
+  var u = a.redSqr(), h = u.redMul(a), c = i.redMul(u), l = o.redSqr().redIAdd(h).redISub(c).redISub(c), v = o.redMul(c.redISub(l)).redISub(n.redMul(h)), p = this.z.redMul(e.z).redMul(a);
+  return this.curve.jpoint(l, v, p);
+};
+A.prototype.mixedAdd = function(e) {
+  if (this.isInfinity())
+    return e.toJ();
+  if (e.isInfinity())
+    return this;
+  var r = this.z.redSqr(), f = this.x, i = e.x.redMul(r), d = this.y, n = e.y.redMul(r).redMul(this.z), s = f.redSub(i), a = d.redSub(n);
+  if (s.cmpn(0) === 0)
+    return a.cmpn(0) !== 0 ? this.curve.jpoint(null, null, null) : this.dbl();
+  var o = s.redSqr(), u = o.redMul(s), h = f.redMul(o), c = a.redSqr().redIAdd(u).redISub(h).redISub(h), l = a.redMul(h.redISub(c)).redISub(d.redMul(u)), v = this.z.redMul(s);
+  return this.curve.jpoint(c, l, v);
+};
+A.prototype.dblp = function(e) {
+  if (e === 0)
+    return this;
+  if (this.isInfinity())
+    return this;
+  if (!e)
+    return this.dbl();
+  var r;
+  if (this.curve.zeroA || this.curve.threeA) {
+    var f = this;
+    for (r = 0; r < e; r++)
+      f = f.dbl();
+    return f;
+  }
+  var i = this.curve.a, d = this.curve.tinv, n = this.x, s = this.y, a = this.z, o = a.redSqr().redSqr(), u = s.redAdd(s);
+  for (r = 0; r < e; r++) {
+    var h = n.redSqr(), c = u.redSqr(), l = c.redSqr(), v = h.redAdd(h).redIAdd(h).redIAdd(i.redMul(o)), p = n.redMul(c), m = v.redSqr().redISub(p.redAdd(p)), y = p.redISub(m), I = v.redMul(y);
+    I = I.redIAdd(I).redISub(l);
+    var N = u.redMul(a);
+    r + 1 < e && (o = o.redMul(l)), n = m, a = N, u = I;
+  }
+  return this.curve.jpoint(n, u.redMul(d), a);
+};
+A.prototype.dbl = function() {
+  return this.isInfinity() ? this : this.curve.zeroA ? this._zeroDbl() : this.curve.threeA ? this._threeDbl() : this._dbl();
+};
+A.prototype._zeroDbl = function() {
+  var e, r, f;
+  if (this.zOne) {
+    var i = this.x.redSqr(), d = this.y.redSqr(), n = d.redSqr(), s = this.x.redAdd(d).redSqr().redISub(i).redISub(n);
+    s = s.redIAdd(s);
+    var a = i.redAdd(i).redIAdd(i), o = a.redSqr().redISub(s).redISub(s), u = n.redIAdd(n);
+    u = u.redIAdd(u), u = u.redIAdd(u), e = o, r = a.redMul(s.redISub(o)).redISub(u), f = this.y.redAdd(this.y);
+  } else {
+    var h = this.x.redSqr(), c = this.y.redSqr(), l = c.redSqr(), v = this.x.redAdd(c).redSqr().redISub(h).redISub(l);
+    v = v.redIAdd(v);
+    var p = h.redAdd(h).redIAdd(h), m = p.redSqr(), y = l.redIAdd(l);
+    y = y.redIAdd(y), y = y.redIAdd(y), e = m.redISub(v).redISub(v), r = p.redMul(v.redISub(e)).redISub(y), f = this.y.redMul(this.z), f = f.redIAdd(f);
+  }
+  return this.curve.jpoint(e, r, f);
+};
+A.prototype._threeDbl = function() {
+  var e, r, f;
+  if (this.zOne) {
+    var i = this.x.redSqr(), d = this.y.redSqr(), n = d.redSqr(), s = this.x.redAdd(d).redSqr().redISub(i).redISub(n);
+    s = s.redIAdd(s);
+    var a = i.redAdd(i).redIAdd(i).redIAdd(this.curve.a), o = a.redSqr().redISub(s).redISub(s);
+    e = o;
+    var u = n.redIAdd(n);
+    u = u.redIAdd(u), u = u.redIAdd(u), r = a.redMul(s.redISub(o)).redISub(u), f = this.y.redAdd(this.y);
+  } else {
+    var h = this.z.redSqr(), c = this.y.redSqr(), l = this.x.redMul(c), v = this.x.redSub(h).redMul(this.x.redAdd(h));
+    v = v.redAdd(v).redIAdd(v);
+    var p = l.redIAdd(l);
+    p = p.redIAdd(p);
+    var m = p.redAdd(p);
+    e = v.redSqr().redISub(m), f = this.y.redAdd(this.z).redSqr().redISub(c).redISub(h);
+    var y = c.redSqr();
+    y = y.redIAdd(y), y = y.redIAdd(y), y = y.redIAdd(y), r = v.redMul(p.redISub(e)).redISub(y);
+  }
+  return this.curve.jpoint(e, r, f);
+};
+A.prototype._dbl = function() {
+  var e = this.curve.a, r = this.x, f = this.y, i = this.z, d = i.redSqr().redSqr(), n = r.redSqr(), s = f.redSqr(), a = n.redAdd(n).redIAdd(n).redIAdd(e.redMul(d)), o = r.redAdd(r);
+  o = o.redIAdd(o);
+  var u = o.redMul(s), h = a.redSqr().redISub(u.redAdd(u)), c = u.redISub(h), l = s.redSqr();
+  l = l.redIAdd(l), l = l.redIAdd(l), l = l.redIAdd(l);
+  var v = a.redMul(c).redISub(l), p = f.redAdd(f).redMul(i);
+  return this.curve.jpoint(h, v, p);
+};
+A.prototype.trpl = function() {
+  if (!this.curve.zeroA)
+    return this.dbl().add(this);
+  var e = this.x.redSqr(), r = this.y.redSqr(), f = this.z.redSqr(), i = r.redSqr(), d = e.redAdd(e).redIAdd(e), n = d.redSqr(), s = this.x.redAdd(r).redSqr().redISub(e).redISub(i);
+  s = s.redIAdd(s), s = s.redAdd(s).redIAdd(s), s = s.redISub(n);
+  var a = s.redSqr(), o = i.redIAdd(i);
+  o = o.redIAdd(o), o = o.redIAdd(o), o = o.redIAdd(o);
+  var u = d.redIAdd(s).redSqr().redISub(n).redISub(a).redISub(o), h = r.redMul(u);
+  h = h.redIAdd(h), h = h.redIAdd(h);
+  var c = this.x.redMul(a).redISub(h);
+  c = c.redIAdd(c), c = c.redIAdd(c);
+  var l = this.y.redMul(u.redMul(o.redISub(u)).redISub(s.redMul(a)));
+  l = l.redIAdd(l), l = l.redIAdd(l), l = l.redIAdd(l);
+  var v = this.z.redAdd(s).redSqr().redISub(f).redISub(a);
+  return this.curve.jpoint(c, l, v);
+};
+A.prototype.mul = function(e, r) {
+  return e = new b(e, r), this.curve._wnafMul(this, e);
+};
+A.prototype.eq = function(e) {
+  if (e.type === "affine")
+    return this.eq(e.toJ());
+  if (this === e)
+    return !0;
+  var r = this.z.redSqr(), f = e.z.redSqr();
+  if (this.x.redMul(f).redISub(e.x.redMul(r)).cmpn(0) !== 0)
+    return !1;
+  var i = r.redMul(this.z), d = f.redMul(e.z);
+  return this.y.redMul(d).redISub(e.y.redMul(i)).cmpn(0) === 0;
+};
+A.prototype.eqXToP = function(e) {
+  var r = this.z.redSqr(), f = e.toRed(this.curve.red).redMul(r);
+  if (this.x.cmp(f) === 0)
+    return !0;
+  for (var i = e.clone(), d = this.curve.redN.redMul(r); ; ) {
+    if (i.iadd(this.curve.n), i.cmp(this.curve.p) >= 0)
+      return !1;
+    if (f.redIAdd(d), this.x.cmp(f) === 0)
+      return !0;
+  }
+};
+A.prototype.inspect = function() {
+  return this.isInfinity() ? "<EC JPoint Infinity>" : "<EC JPoint x: " + this.x.toString(16, 2) + " y: " + this.y.toString(16, 2) + " z: " + this.z.toString(16, 2) + ">";
+};
+A.prototype.isInfinity = function() {
+  return this.z.cmpn(0) === 0;
+};
+var J = j(function(t, e) {
+  var r = e;
+  r.base = F, r.short = ne, r.mont = /*RicMoo:ethers:require(./mont)*/
+  null, r.edwards = /*RicMoo:ethers:require(./edwards)*/
+  null;
+}), T = j(function(t, e) {
+  var r = e, f = x.assert;
+  function i(s) {
+    s.type === "short" ? this.curve = new J.short(s) : s.type === "edwards" ? this.curve = new J.edwards(s) : this.curve = new J.mont(s), this.g = this.curve.g, this.n = this.curve.n, this.hash = s.hash, f(this.g.validate(), "Invalid curve"), f(this.g.mul(this.n).isInfinity(), "Invalid curve, G*N != O");
+  }
+  r.PresetCurve = i;
+  function d(s, a) {
+    Object.defineProperty(r, s, {
+      configurable: !0,
+      enumerable: !0,
+      get: function() {
+        var o = new i(a);
+        return Object.defineProperty(r, s, {
+          configurable: !0,
+          enumerable: !0,
+          value: o
+        }), o;
+      }
+    });
+  }
+  d("p192", {
+    type: "short",
+    prime: "p192",
+    p: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff",
+    a: "ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc",
+    b: "64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1",
+    n: "ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831",
+    hash: z.sha256,
+    gRed: !1,
+    g: [
+      "188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012",
+      "07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811"
+    ]
+  }), d("p224", {
+    type: "short",
+    prime: "p224",
+    p: "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001",
+    a: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe",
+    b: "b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4",
+    n: "ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d",
+    hash: z.sha256,
+    gRed: !1,
+    g: [
+      "b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21",
+      "bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34"
+    ]
+  }), d("p256", {
+    type: "short",
+    prime: null,
+    p: "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff",
+    a: "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc",
+    b: "5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b",
+    n: "ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551",
+    hash: z.sha256,
+    gRed: !1,
+    g: [
+      "6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296",
+      "4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5"
+    ]
+  }), d("p384", {
+    type: "short",
+    prime: null,
+    p: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe ffffffff 00000000 00000000 ffffffff",
+    a: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe ffffffff 00000000 00000000 fffffffc",
+    b: "b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f 5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef",
+    n: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 f4372ddf 581a0db2 48b0a77a ecec196a ccc52973",
+    hash: z.sha384,
+    gRed: !1,
+    g: [
+      "aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 5502f25d bf55296c 3a545e38 72760ab7",
+      "3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 0a60b1ce 1d7e819d 7a431d7c 90ea0e5f"
+    ]
+  }), d("p521", {
+    type: "short",
+    prime: null,
+    p: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff",
+    a: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffc",
+    b: "00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b 99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd 3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00",
+    n: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409",
+    hash: z.sha512,
+    gRed: !1,
+    g: [
+      "000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66",
+      "00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 3fad0761 353c7086 a272c240 88be9476 9fd16650"
+    ]
+  }), d("curve25519", {
+    type: "mont",
+    prime: "p25519",
+    p: "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed",
+    a: "76d06",
+    b: "1",
+    n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed",
+    hash: z.sha256,
+    gRed: !1,
+    g: [
+      "9"
+    ]
+  }), d("ed25519", {
+    type: "edwards",
+    prime: "p25519",
+    p: "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed",
+    a: "-1",
+    c: "1",
+    // -121665 * (121666^(-1)) (mod P)
+    d: "52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3",
+    n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed",
+    hash: z.sha256,
+    gRed: !1,
+    g: [
+      "216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a",
+      // 4/5
+      "6666666666666666666666666666666666666666666666666666666666666658"
+    ]
+  });
+  var n;
+  try {
+    n = /*RicMoo:ethers:require(./precomputed/secp256k1)*/
+    null.crash();
+  } catch {
+    n = void 0;
+  }
+  d("secp256k1", {
+    type: "short",
+    prime: "k256",
+    p: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f",
+    a: "0",
+    b: "7",
+    n: "ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141",
+    h: "1",
+    hash: z.sha256,
+    // Precomputed endomorphism
+    beta: "7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee",
+    lambda: "5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72",
+    basis: [
+      {
+        a: "3086d221a7d46bcde86c90e49284eb15",
+        b: "-e4437ed6010e88286f547fa90abfe4c3"
+      },
+      {
+        a: "114ca50f7a8e2f3f657c1108d9d44cfd8",
+        b: "3086d221a7d46bcde86c90e49284eb15"
+      }
+    ],
+    gRed: !1,
+    g: [
+      "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+      "483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8",
+      n
+    ]
+  });
+});
+function R(t) {
+  if (!(this instanceof R))
+    return new R(t);
+  this.hash = t.hash, this.predResist = !!t.predResist, this.outLen = this.hash.outSize, this.minEntropy = t.minEntropy || this.hash.hmacStrength, this._reseed = null, this.reseedInterval = null, this.K = null, this.V = null;
+  var e = q.toArray(t.entropy, t.entropyEnc || "hex"), r = q.toArray(t.nonce, t.nonceEnc || "hex"), f = q.toArray(t.pers, t.persEnc || "hex");
+  U(
+    e.length >= this.minEntropy / 8,
+    "Not enough entropy. Minimum is: " + this.minEntropy + " bits"
+  ), this._init(e, r, f);
+}
+var ee = R;
+R.prototype._init = function(e, r, f) {
+  var i = e.concat(r).concat(f);
+  this.K = new Array(this.outLen / 8), this.V = new Array(this.outLen / 8);
+  for (var d = 0; d < this.V.length; d++)
+    this.K[d] = 0, this.V[d] = 1;
+  this._update(i), this._reseed = 1, this.reseedInterval = 281474976710656;
+};
+R.prototype._hmac = function() {
+  return new z.hmac(this.hash, this.K);
+};
+R.prototype._update = function(e) {
+  var r = this._hmac().update(this.V).update([0]);
+  e && (r = r.update(e)), this.K = r.digest(), this.V = this._hmac().update(this.V).digest(), e && (this.K = this._hmac().update(this.V).update([1]).update(e).digest(), this.V = this._hmac().update(this.V).digest());
+};
+R.prototype.reseed = function(e, r, f, i) {
+  typeof r != "string" && (i = f, f = r, r = null), e = q.toArray(e, r), f = q.toArray(f, i), U(
+    e.length >= this.minEntropy / 8,
+    "Not enough entropy. Minimum is: " + this.minEntropy + " bits"
+  ), this._update(e.concat(f || [])), this._reseed = 1;
+};
+R.prototype.generate = function(e, r, f, i) {
+  if (this._reseed > this.reseedInterval)
+    throw new Error("Reseed is required");
+  typeof r != "string" && (i = f, f = r, r = null), f && (f = q.toArray(f, i || "hex"), this._update(f));
+  for (var d = []; d.length < e; )
+    this.V = this._hmac().update(this.V).digest(), d = d.concat(this.V);
+  var n = d.slice(0, e);
+  return this._update(f), this._reseed++, q.encode(n, r);
+};
+var Y = x.assert;
+function S(t, e) {
+  this.ec = t, this.priv = null, this.pub = null, e.priv && this._importPrivate(e.priv, e.privEnc), e.pub && this._importPublic(e.pub, e.pubEnc);
+}
+var Z = S;
+S.fromPublic = function(e, r, f) {
+  return r instanceof S ? r : new S(e, {
+    pub: r,
+    pubEnc: f
+  });
+};
+S.fromPrivate = function(e, r, f) {
+  return r instanceof S ? r : new S(e, {
+    priv: r,
+    privEnc: f
+  });
+};
+S.prototype.validate = function() {
+  var e = this.getPublic();
+  return e.isInfinity() ? { result: !1, reason: "Invalid public key" } : e.validate() ? e.mul(this.ec.curve.n).isInfinity() ? { result: !0, reason: null } : { result: !1, reason: "Public key * N != O" } : { result: !1, reason: "Public key is not a point" };
+};
+S.prototype.getPublic = function(e, r) {
+  return typeof e == "string" && (r = e, e = null), this.pub || (this.pub = this.ec.g.mul(this.priv)), r ? this.pub.encode(r, e) : this.pub;
+};
+S.prototype.getPrivate = function(e) {
+  return e === "hex" ? this.priv.toString(16, 2) : this.priv;
+};
+S.prototype._importPrivate = function(e, r) {
+  this.priv = new b(e, r || 16), this.priv = this.priv.umod(this.ec.curve.n);
+};
+S.prototype._importPublic = function(e, r) {
+  if (e.x || e.y) {
+    this.ec.curve.type === "mont" ? Y(e.x, "Need x coordinate") : (this.ec.curve.type === "short" || this.ec.curve.type === "edwards") && Y(e.x && e.y, "Need both x and y coordinate"), this.pub = this.ec.curve.point(e.x, e.y);
+    return;
+  }
+  this.pub = this.ec.curve.decodePoint(e, r);
+};
+S.prototype.derive = function(e) {
+  return e.validate() || Y(e.validate(), "public point not validated"), e.mul(this.priv).getX();
+};
+S.prototype.sign = function(e, r, f) {
+  return this.ec.sign(e, this, r, f);
+};
+S.prototype.verify = function(e, r) {
+  return this.ec.verify(e, r, this);
+};
+S.prototype.inspect = function() {
+  return "<Key priv: " + (this.priv && this.priv.toString(16, 2)) + " pub: " + (this.pub && this.pub.inspect()) + " >";
+};
+var de = x.assert;
+function K(t, e) {
+  if (t instanceof K)
+    return t;
+  this._importDER(t, e) || (de(t.r && t.s, "Signature without r or s"), this.r = new b(t.r, 16), this.s = new b(t.s, 16), t.recoveryParam === void 0 ? this.recoveryParam = null : this.recoveryParam = t.recoveryParam);
+}
+var C = K;
+function se() {
+  this.place = 0;
+}
+function W(t, e) {
+  var r = t[e.place++];
+  if (!(r & 128))
+    return r;
+  var f = r & 15;
+  if (f === 0 || f > 4)
+    return !1;
+  for (var i = 0, d = 0, n = e.place; d < f; d++, n++)
+    i <<= 8, i |= t[n], i >>>= 0;
+  return i <= 127 ? !1 : (e.place = n, i);
+}
+function Q(t) {
+  for (var e = 0, r = t.length - 1; !t[e] && !(t[e + 1] & 128) && e < r; )
+    e++;
+  return e === 0 ? t : t.slice(e);
+}
+K.prototype._importDER = function(e, r) {
+  e = x.toArray(e, r);
+  var f = new se();
+  if (e[f.place++] !== 48)
+    return !1;
+  var i = W(e, f);
+  if (i === !1 || i + f.place !== e.length || e[f.place++] !== 2)
+    return !1;
+  var d = W(e, f);
+  if (d === !1)
+    return !1;
+  var n = e.slice(f.place, d + f.place);
+  if (f.place += d, e[f.place++] !== 2)
+    return !1;
+  var s = W(e, f);
+  if (s === !1 || e.length !== s + f.place)
+    return !1;
+  var a = e.slice(f.place, s + f.place);
+  if (n[0] === 0)
+    if (n[1] & 128)
+      n = n.slice(1);
+    else
+      return !1;
+  if (a[0] === 0)
+    if (a[1] & 128)
+      a = a.slice(1);
+    else
+      return !1;
+  return this.r = new b(n), this.s = new b(a), this.recoveryParam = null, !0;
+};
+function H(t, e) {
+  if (e < 128) {
+    t.push(e);
+    return;
+  }
+  var r = 1 + (Math.log(e) / Math.LN2 >>> 3);
+  for (t.push(r | 128); --r; )
+    t.push(e >>> (r << 3) & 255);
+  t.push(e);
+}
+K.prototype.toDER = function(e) {
+  var r = this.r.toArray(), f = this.s.toArray();
+  for (r[0] & 128 && (r = [0].concat(r)), f[0] & 128 && (f = [0].concat(f)), r = Q(r), f = Q(f); !f[0] && !(f[1] & 128); )
+    f = f.slice(1);
+  var i = [2];
+  H(i, r.length), i = i.concat(r), i.push(2), H(i, f.length);
+  var d = i.concat(f), n = [48];
+  return H(n, d.length), n = n.concat(d), x.encode(n, e);
+};
+var ae = (
+  /*RicMoo:ethers:require(brorand)*/
+  function() {
+    throw new Error("unsupported");
+  }
+), re = x.assert;
+function w(t) {
+  if (!(this instanceof w))
+    return new w(t);
+  typeof t == "string" && (re(
+    Object.prototype.hasOwnProperty.call(T, t),
+    "Unknown curve " + t
+  ), t = T[t]), t instanceof T.PresetCurve && (t = { curve: t }), this.curve = t.curve.curve, this.n = this.curve.n, this.nh = this.n.ushrn(1), this.g = this.curve.g, this.g = t.curve.g, this.g.precompute(t.curve.n.bitLength() + 1), this.hash = t.hash || t.curve.hash;
+}
+var ue = w;
+w.prototype.keyPair = function(e) {
+  return new Z(this, e);
+};
+w.prototype.keyFromPrivate = function(e, r) {
+  return Z.fromPrivate(this, e, r);
+};
+w.prototype.keyFromPublic = function(e, r) {
+  return Z.fromPublic(this, e, r);
+};
+w.prototype.genKeyPair = function(e) {
+  e || (e = {});
+  for (var r = new ee({
+    hash: this.hash,
+    pers: e.pers,
+    persEnc: e.persEnc || "utf8",
+    entropy: e.entropy || ae(this.hash.hmacStrength),
+    entropyEnc: e.entropy && e.entropyEnc || "utf8",
+    nonce: this.n.toArray()
+  }), f = this.n.byteLength(), i = this.n.sub(new b(2)); ; ) {
+    var d = new b(r.generate(f));
+    if (!(d.cmp(i) > 0))
+      return d.iaddn(1), this.keyFromPrivate(d);
+  }
+};
+w.prototype._truncateToN = function(e, r) {
+  var f = e.byteLength() * 8 - this.n.bitLength();
+  return f > 0 && (e = e.ushrn(f)), !r && e.cmp(this.n) >= 0 ? e.sub(this.n) : e;
+};
+w.prototype.sign = function(e, r, f, i) {
+  typeof f == "object" && (i = f, f = null), i || (i = {}), r = this.keyFromPrivate(r, f), e = this._truncateToN(new b(e, 16));
+  for (var d = this.n.byteLength(), n = r.getPrivate().toArray("be", d), s = e.toArray("be", d), a = new ee({
+    hash: this.hash,
+    entropy: n,
+    nonce: s,
+    pers: i.pers,
+    persEnc: i.persEnc || "utf8"
+  }), o = this.n.sub(new b(1)), u = 0; ; u++) {
+    var h = i.k ? i.k(u) : new b(a.generate(this.n.byteLength()));
+    if (h = this._truncateToN(h, !0), !(h.cmpn(1) <= 0 || h.cmp(o) >= 0)) {
+      var c = this.g.mul(h);
+      if (!c.isInfinity()) {
+        var l = c.getX(), v = l.umod(this.n);
+        if (v.cmpn(0) !== 0) {
+          var p = h.invm(this.n).mul(v.mul(r.getPrivate()).iadd(e));
+          if (p = p.umod(this.n), p.cmpn(0) !== 0) {
+            var m = (c.getY().isOdd() ? 1 : 0) | (l.cmp(v) !== 0 ? 2 : 0);
+            return i.canonical && p.cmp(this.nh) > 0 && (p = this.n.sub(p), m ^= 1), new C({ r: v, s: p, recoveryParam: m });
+          }
+        }
+      }
+    }
+  }
+};
+w.prototype.verify = function(e, r, f, i) {
+  e = this._truncateToN(new b(e, 16)), f = this.keyFromPublic(f, i), r = new C(r, "hex");
+  var d = r.r, n = r.s;
+  if (d.cmpn(1) < 0 || d.cmp(this.n) >= 0 || n.cmpn(1) < 0 || n.cmp(this.n) >= 0)
+    return !1;
+  var s = n.invm(this.n), a = s.mul(e).umod(this.n), o = s.mul(d).umod(this.n), u;
+  return this.curve._maxwellTrick ? (u = this.g.jmulAdd(a, f.getPublic(), o), u.isInfinity() ? !1 : u.eqXToP(d)) : (u = this.g.mulAdd(a, f.getPublic(), o), u.isInfinity() ? !1 : u.getX().umod(this.n).cmp(d) === 0);
+};
+w.prototype.recoverPubKey = function(t, e, r, f) {
+  re((3 & r) === r, "The recovery param is more than two bits"), e = new C(e, f);
+  var i = this.n, d = new b(t), n = e.r, s = e.s, a = r & 1, o = r >> 1;
+  if (n.cmp(this.curve.p.umod(this.curve.n)) >= 0 && o)
+    throw new Error("Unable to find sencond key candinate");
+  o ? n = this.curve.pointFromX(n.add(this.curve.n), a) : n = this.curve.pointFromX(n, a);
+  var u = e.r.invm(i), h = i.sub(d).mul(u).umod(i), c = s.mul(u).umod(i);
+  return this.g.mulAdd(h, n, c);
+};
+w.prototype.getKeyRecoveryParam = function(t, e, r, f) {
+  if (e = new C(e, f), e.recoveryParam !== null)
+    return e.recoveryParam;
+  for (var i = 0; i < 4; i++) {
+    var d;
+    try {
+      d = this.recoverPubKey(t, e, i);
+    } catch {
+      continue;
+    }
+    if (d.eq(r))
+      return i;
+  }
+  throw new Error("Unable to find valid recovery factor");
+};
+var he = j(function(t, e) {
+  var r = e;
+  r.version = "6.5.4", r.utils = x, r.rand = /*RicMoo:ethers:require(brorand)*/
+  function() {
+    throw new Error("unsupported");
+  }, r.curve = J, r.curves = T, r.ec = ue, r.eddsa = /*RicMoo:ethers:require(./elliptic/eddsa)*/
+  null;
+}), ve = he.ec;
+export {
+  ve as EC
+};