@hinkal/common 0.0.116 → 0.0.118

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/elliptic/lib/elliptic/curve/short.mjs

@@ -0,0 +1,392 @@
+import "../utils.mjs";
+import { b as R } from "../../../node_modules/bn.js/lib/bn.mjs";
+import { i as j } from "../../../../inherits/inherits_browser.mjs";
+import { b as E } from "./base.mjs";
+import { __exports as N } from "../../../../../../../../../../_virtual/utils6.mjs";
+var J = N, S = R, z = j, x = E, P = J.assert;
+function m(u) {
+  x.call(this, "short", u), this.a = new S(u.a, 16).toRed(this.red), this.b = new S(u.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(u), this._endoWnafT1 = new Array(4), this._endoWnafT2 = new Array(4);
+}
+z(m, x);
+var X = m;
+m.prototype._getEndomorphism = function(r) {
+  if (!(!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1)) {
+    var e, t;
+    if (r.beta)
+      e = new S(r.beta, 16).toRed(this.red);
+    else {
+      var d = this._getEndoRoots(this.p);
+      e = d[0].cmp(d[1]) < 0 ? d[0] : d[1], e = e.toRed(this.red);
+    }
+    if (r.lambda)
+      t = new S(r.lambda, 16);
+    else {
+      var i = this._getEndoRoots(this.n);
+      this.g.mul(i[0]).x.cmp(this.g.x.redMul(e)) === 0 ? t = i[0] : (t = i[1], P(this.g.mul(t).x.cmp(this.g.x.redMul(e)) === 0));
+    }
+    var s;
+    return r.basis ? s = r.basis.map(function(n) {
+      return {
+        a: new S(n.a, 16),
+        b: new S(n.b, 16)
+      };
+    }) : s = this._getEndoBasis(t), {
+      beta: e,
+      lambda: t,
+      basis: s
+    };
+  }
+};
+m.prototype._getEndoRoots = function(r) {
+  var e = r === this.p ? this.red : S.mont(r), t = new S(2).toRed(e).redInvm(), d = t.redNeg(), i = new S(3).toRed(e).redNeg().redSqrt().redMul(t), s = d.redAdd(i).fromRed(), n = d.redSub(i).fromRed();
+  return [s, n];
+};
+m.prototype._getEndoBasis = function(r) {
+  for (var e = this.n.ushrn(Math.floor(this.n.bitLength() / 2)), t = r, d = this.n.clone(), i = new S(1), s = new S(0), n = new S(0), l = new S(1), a, v, o, f, h, p, b, q = 0, c, M; t.cmpn(0) !== 0; ) {
+    var y = d.div(t);
+    c = d.sub(y.mul(t)), M = n.sub(y.mul(i));
+    var _ = l.sub(y.mul(s));
+    if (!o && c.cmp(e) < 0)
+      a = b.neg(), v = i, o = c.neg(), f = M;
+    else if (o && ++q === 2)
+      break;
+    b = c, d = t, t = c, n = i, i = M, l = s, s = _;
+  }
+  h = c.neg(), p = M;
+  var w = o.sqr().add(f.sqr()), g = h.sqr().add(p.sqr());
+  return g.cmp(w) >= 0 && (h = a, p = v), o.negative && (o = o.neg(), f = f.neg()), h.negative && (h = h.neg(), p = p.neg()), [
+    { a: o, b: f },
+    { a: h, b: p }
+  ];
+};
+m.prototype._endoSplit = function(r) {
+  var e = this.endo.basis, t = e[0], d = e[1], i = d.b.mul(r).divRound(this.n), s = t.b.neg().mul(r).divRound(this.n), n = i.mul(t.a), l = s.mul(d.a), a = i.mul(t.b), v = s.mul(d.b), o = r.sub(n).sub(l), f = a.add(v).neg();
+  return { k1: o, k2: f };
+};
+m.prototype.pointFromX = function(r, e) {
+  r = new S(r, 16), r.red || (r = r.toRed(this.red));
+  var t = r.redSqr().redMul(r).redIAdd(r.redMul(this.a)).redIAdd(this.b), d = t.redSqrt();
+  if (d.redSqr().redSub(t).cmp(this.zero) !== 0)
+    throw new Error("invalid point");
+  var i = d.fromRed().isOdd();
+  return (e && !i || !e && i) && (d = d.redNeg()), this.point(r, d);
+};
+m.prototype.validate = function(r) {
+  if (r.inf)
+    return !0;
+  var e = r.x, t = r.y, d = this.a.redMul(e), i = e.redSqr().redMul(e).redIAdd(d).redIAdd(this.b);
+  return t.redSqr().redISub(i).cmpn(0) === 0;
+};
+m.prototype._endoWnafMulAdd = function(r, e, t) {
+  for (var d = this._endoWnafT1, i = this._endoWnafT2, s = 0; s < r.length; s++) {
+    var n = this._endoSplit(e[s]), l = r[s], a = l._getBeta();
+    n.k1.negative && (n.k1.ineg(), l = l.neg(!0)), n.k2.negative && (n.k2.ineg(), a = a.neg(!0)), d[s * 2] = l, d[s * 2 + 1] = a, i[s * 2] = n.k1, i[s * 2 + 1] = n.k2;
+  }
+  for (var v = this._wnafMulAdd(1, d, i, s * 2, t), o = 0; o < s * 2; o++)
+    d[o] = null, i[o] = null;
+  return v;
+};
+function I(u, r, e, t) {
+  x.BasePoint.call(this, u, "affine"), r === null && e === null ? (this.x = null, this.y = null, this.inf = !0) : (this.x = new S(r, 16), this.y = new S(e, 16), t && (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);
+}
+z(I, x.BasePoint);
+m.prototype.point = function(r, e, t) {
+  return new I(this, r, e, t);
+};
+m.prototype.pointFromJSON = function(r, e) {
+  return I.fromJSON(this, r, e);
+};
+I.prototype._getBeta = function() {
+  if (this.curve.endo) {
+    var r = this.precomputed;
+    if (r && r.beta)
+      return r.beta;
+    var e = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y);
+    if (r) {
+      var t = this.curve, d = function(i) {
+        return t.point(i.x.redMul(t.endo.beta), i.y);
+      };
+      r.beta = e, e.precomputed = {
+        beta: null,
+        naf: r.naf && {
+          wnd: r.naf.wnd,
+          points: r.naf.points.map(d)
+        },
+        doubles: r.doubles && {
+          step: r.doubles.step,
+          points: r.doubles.points.map(d)
+        }
+      };
+    }
+    return e;
+  }
+};
+I.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];
+};
+I.fromJSON = function(r, e, t) {
+  typeof e == "string" && (e = JSON.parse(e));
+  var d = r.point(e[0], e[1], t);
+  if (!e[2])
+    return d;
+  function i(n) {
+    return r.point(n[0], n[1], t);
+  }
+  var s = e[2];
+  return d.precomputed = {
+    beta: null,
+    doubles: s.doubles && {
+      step: s.doubles.step,
+      points: [d].concat(s.doubles.points.map(i))
+    },
+    naf: s.naf && {
+      wnd: s.naf.wnd,
+      points: [d].concat(s.naf.points.map(i))
+    }
+  }, d;
+};
+I.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) + ">";
+};
+I.prototype.isInfinity = function() {
+  return this.inf;
+};
+I.prototype.add = function(r) {
+  if (this.inf)
+    return r;
+  if (r.inf)
+    return this;
+  if (this.eq(r))
+    return this.dbl();
+  if (this.neg().eq(r))
+    return this.curve.point(null, null);
+  if (this.x.cmp(r.x) === 0)
+    return this.curve.point(null, null);
+  var e = this.y.redSub(r.y);
+  e.cmpn(0) !== 0 && (e = e.redMul(this.x.redSub(r.x).redInvm()));
+  var t = e.redSqr().redISub(this.x).redISub(r.x), d = e.redMul(this.x.redSub(t)).redISub(this.y);
+  return this.curve.point(t, d);
+};
+I.prototype.dbl = function() {
+  if (this.inf)
+    return this;
+  var r = this.y.redAdd(this.y);
+  if (r.cmpn(0) === 0)
+    return this.curve.point(null, null);
+  var e = this.curve.a, t = this.x.redSqr(), d = r.redInvm(), i = t.redAdd(t).redIAdd(t).redIAdd(e).redMul(d), s = i.redSqr().redISub(this.x.redAdd(this.x)), n = i.redMul(this.x.redSub(s)).redISub(this.y);
+  return this.curve.point(s, n);
+};
+I.prototype.getX = function() {
+  return this.x.fromRed();
+};
+I.prototype.getY = function() {
+  return this.y.fromRed();
+};
+I.prototype.mul = function(r) {
+  return r = new S(r, 16), this.isInfinity() ? this : this._hasDoubles(r) ? this.curve._fixedNafMul(this, r) : this.curve.endo ? this.curve._endoWnafMulAdd([this], [r]) : this.curve._wnafMul(this, r);
+};
+I.prototype.mulAdd = function(r, e, t) {
+  var d = [this, e], i = [r, t];
+  return this.curve.endo ? this.curve._endoWnafMulAdd(d, i) : this.curve._wnafMulAdd(1, d, i, 2);
+};
+I.prototype.jmulAdd = function(r, e, t) {
+  var d = [this, e], i = [r, t];
+  return this.curve.endo ? this.curve._endoWnafMulAdd(d, i, !0) : this.curve._wnafMulAdd(1, d, i, 2, !0);
+};
+I.prototype.eq = function(r) {
+  return this === r || this.inf === r.inf && (this.inf || this.x.cmp(r.x) === 0 && this.y.cmp(r.y) === 0);
+};
+I.prototype.neg = function(r) {
+  if (this.inf)
+    return this;
+  var e = this.curve.point(this.x, this.y.redNeg());
+  if (r && this.precomputed) {
+    var t = this.precomputed, d = function(i) {
+      return i.neg();
+    };
+    e.precomputed = {
+      naf: t.naf && {
+        wnd: t.naf.wnd,
+        points: t.naf.points.map(d)
+      },
+      doubles: t.doubles && {
+        step: t.doubles.step,
+        points: t.doubles.points.map(d)
+      }
+    };
+  }
+  return e;
+};
+I.prototype.toJ = function() {
+  if (this.inf)
+    return this.curve.jpoint(null, null, null);
+  var r = this.curve.jpoint(this.x, this.y, this.curve.one);
+  return r;
+};
+function A(u, r, e, t) {
+  x.BasePoint.call(this, u, "jacobian"), r === null && e === null && t === null ? (this.x = this.curve.one, this.y = this.curve.one, this.z = new S(0)) : (this.x = new S(r, 16), this.y = new S(e, 16), this.z = new S(t, 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;
+}
+z(A, x.BasePoint);
+m.prototype.jpoint = function(r, e, t) {
+  return new A(this, r, e, t);
+};
+A.prototype.toP = function() {
+  if (this.isInfinity())
+    return this.curve.point(null, null);
+  var r = this.z.redInvm(), e = r.redSqr(), t = this.x.redMul(e), d = this.y.redMul(e).redMul(r);
+  return this.curve.point(t, d);
+};
+A.prototype.neg = function() {
+  return this.curve.jpoint(this.x, this.y.redNeg(), this.z);
+};
+A.prototype.add = function(r) {
+  if (this.isInfinity())
+    return r;
+  if (r.isInfinity())
+    return this;
+  var e = r.z.redSqr(), t = this.z.redSqr(), d = this.x.redMul(e), i = r.x.redMul(t), s = this.y.redMul(e.redMul(r.z)), n = r.y.redMul(t.redMul(this.z)), l = d.redSub(i), a = s.redSub(n);
+  if (l.cmpn(0) === 0)
+    return a.cmpn(0) !== 0 ? this.curve.jpoint(null, null, null) : this.dbl();
+  var v = l.redSqr(), o = v.redMul(l), f = d.redMul(v), h = a.redSqr().redIAdd(o).redISub(f).redISub(f), p = a.redMul(f.redISub(h)).redISub(s.redMul(o)), b = this.z.redMul(r.z).redMul(l);
+  return this.curve.jpoint(h, p, b);
+};
+A.prototype.mixedAdd = function(r) {
+  if (this.isInfinity())
+    return r.toJ();
+  if (r.isInfinity())
+    return this;
+  var e = this.z.redSqr(), t = this.x, d = r.x.redMul(e), i = this.y, s = r.y.redMul(e).redMul(this.z), n = t.redSub(d), l = i.redSub(s);
+  if (n.cmpn(0) === 0)
+    return l.cmpn(0) !== 0 ? this.curve.jpoint(null, null, null) : this.dbl();
+  var a = n.redSqr(), v = a.redMul(n), o = t.redMul(a), f = l.redSqr().redIAdd(v).redISub(o).redISub(o), h = l.redMul(o.redISub(f)).redISub(i.redMul(v)), p = this.z.redMul(n);
+  return this.curve.jpoint(f, h, p);
+};
+A.prototype.dblp = function(r) {
+  if (r === 0)
+    return this;
+  if (this.isInfinity())
+    return this;
+  if (!r)
+    return this.dbl();
+  var e;
+  if (this.curve.zeroA || this.curve.threeA) {
+    var t = this;
+    for (e = 0; e < r; e++)
+      t = t.dbl();
+    return t;
+  }
+  var d = this.curve.a, i = this.curve.tinv, s = this.x, n = this.y, l = this.z, a = l.redSqr().redSqr(), v = n.redAdd(n);
+  for (e = 0; e < r; e++) {
+    var o = s.redSqr(), f = v.redSqr(), h = f.redSqr(), p = o.redAdd(o).redIAdd(o).redIAdd(d.redMul(a)), b = s.redMul(f), q = p.redSqr().redISub(b.redAdd(b)), c = b.redISub(q), M = p.redMul(c);
+    M = M.redIAdd(M).redISub(h);
+    var y = v.redMul(l);
+    e + 1 < r && (a = a.redMul(h)), s = q, l = y, v = M;
+  }
+  return this.curve.jpoint(s, v.redMul(i), l);
+};
+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 r, e, t;
+  if (this.zOne) {
+    var d = this.x.redSqr(), i = this.y.redSqr(), s = i.redSqr(), n = this.x.redAdd(i).redSqr().redISub(d).redISub(s);
+    n = n.redIAdd(n);
+    var l = d.redAdd(d).redIAdd(d), a = l.redSqr().redISub(n).redISub(n), v = s.redIAdd(s);
+    v = v.redIAdd(v), v = v.redIAdd(v), r = a, e = l.redMul(n.redISub(a)).redISub(v), t = this.y.redAdd(this.y);
+  } else {
+    var o = this.x.redSqr(), f = this.y.redSqr(), h = f.redSqr(), p = this.x.redAdd(f).redSqr().redISub(o).redISub(h);
+    p = p.redIAdd(p);
+    var b = o.redAdd(o).redIAdd(o), q = b.redSqr(), c = h.redIAdd(h);
+    c = c.redIAdd(c), c = c.redIAdd(c), r = q.redISub(p).redISub(p), e = b.redMul(p.redISub(r)).redISub(c), t = this.y.redMul(this.z), t = t.redIAdd(t);
+  }
+  return this.curve.jpoint(r, e, t);
+};
+A.prototype._threeDbl = function() {
+  var r, e, t;
+  if (this.zOne) {
+    var d = this.x.redSqr(), i = this.y.redSqr(), s = i.redSqr(), n = this.x.redAdd(i).redSqr().redISub(d).redISub(s);
+    n = n.redIAdd(n);
+    var l = d.redAdd(d).redIAdd(d).redIAdd(this.curve.a), a = l.redSqr().redISub(n).redISub(n);
+    r = a;
+    var v = s.redIAdd(s);
+    v = v.redIAdd(v), v = v.redIAdd(v), e = l.redMul(n.redISub(a)).redISub(v), t = this.y.redAdd(this.y);
+  } else {
+    var o = this.z.redSqr(), f = this.y.redSqr(), h = this.x.redMul(f), p = this.x.redSub(o).redMul(this.x.redAdd(o));
+    p = p.redAdd(p).redIAdd(p);
+    var b = h.redIAdd(h);
+    b = b.redIAdd(b);
+    var q = b.redAdd(b);
+    r = p.redSqr().redISub(q), t = this.y.redAdd(this.z).redSqr().redISub(f).redISub(o);
+    var c = f.redSqr();
+    c = c.redIAdd(c), c = c.redIAdd(c), c = c.redIAdd(c), e = p.redMul(b.redISub(r)).redISub(c);
+  }
+  return this.curve.jpoint(r, e, t);
+};
+A.prototype._dbl = function() {
+  var r = this.curve.a, e = this.x, t = this.y, d = this.z, i = d.redSqr().redSqr(), s = e.redSqr(), n = t.redSqr(), l = s.redAdd(s).redIAdd(s).redIAdd(r.redMul(i)), a = e.redAdd(e);
+  a = a.redIAdd(a);
+  var v = a.redMul(n), o = l.redSqr().redISub(v.redAdd(v)), f = v.redISub(o), h = n.redSqr();
+  h = h.redIAdd(h), h = h.redIAdd(h), h = h.redIAdd(h);
+  var p = l.redMul(f).redISub(h), b = t.redAdd(t).redMul(d);
+  return this.curve.jpoint(o, p, b);
+};
+A.prototype.trpl = function() {
+  if (!this.curve.zeroA)
+    return this.dbl().add(this);
+  var r = this.x.redSqr(), e = this.y.redSqr(), t = this.z.redSqr(), d = e.redSqr(), i = r.redAdd(r).redIAdd(r), s = i.redSqr(), n = this.x.redAdd(e).redSqr().redISub(r).redISub(d);
+  n = n.redIAdd(n), n = n.redAdd(n).redIAdd(n), n = n.redISub(s);
+  var l = n.redSqr(), a = d.redIAdd(d);
+  a = a.redIAdd(a), a = a.redIAdd(a), a = a.redIAdd(a);
+  var v = i.redIAdd(n).redSqr().redISub(s).redISub(l).redISub(a), o = e.redMul(v);
+  o = o.redIAdd(o), o = o.redIAdd(o);
+  var f = this.x.redMul(l).redISub(o);
+  f = f.redIAdd(f), f = f.redIAdd(f);
+  var h = this.y.redMul(v.redMul(a.redISub(v)).redISub(n.redMul(l)));
+  h = h.redIAdd(h), h = h.redIAdd(h), h = h.redIAdd(h);
+  var p = this.z.redAdd(n).redSqr().redISub(t).redISub(l);
+  return this.curve.jpoint(f, h, p);
+};
+A.prototype.mul = function(r, e) {
+  return r = new S(r, e), this.curve._wnafMul(this, r);
+};
+A.prototype.eq = function(r) {
+  if (r.type === "affine")
+    return this.eq(r.toJ());
+  if (this === r)
+    return !0;
+  var e = this.z.redSqr(), t = r.z.redSqr();
+  if (this.x.redMul(t).redISub(r.x.redMul(e)).cmpn(0) !== 0)
+    return !1;
+  var d = e.redMul(this.z), i = t.redMul(r.z);
+  return this.y.redMul(i).redISub(r.y.redMul(d)).cmpn(0) === 0;
+};
+A.prototype.eqXToP = function(r) {
+  var e = this.z.redSqr(), t = r.toRed(this.curve.red).redMul(e);
+  if (this.x.cmp(t) === 0)
+    return !0;
+  for (var d = r.clone(), i = this.curve.redN.redMul(e); ; ) {
+    if (d.iadd(this.curve.n), d.cmp(this.curve.p) >= 0)
+      return !1;
+    if (t.redIAdd(i), this.x.cmp(t) === 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;
+};
+export {
+  X as s
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/elliptic/lib/elliptic/curves.mjs

@@ -0,0 +1,158 @@
+import { __exports as u } from "../../../../../../../../../_virtual/curves.mjs";
+import "../../../hash.js/lib/hash.mjs";
+import "./curve/index.mjs";
+import "./utils.mjs";
+import { __require as n } from "./precomputed/secp256k1.mjs";
+import { __exports as l } from "../../../../../../../../../_virtual/hash.mjs";
+import { __exports as v } from "../../../../../../../../../_virtual/utils6.mjs";
+import { __exports as m } from "../../../../../../../../../_virtual/index80.mjs";
+(function(h) {
+  var b = h, e = l, c = m, p = v, r = p.assert;
+  function s(f) {
+    f.type === "short" ? this.curve = new c.short(f) : f.type === "edwards" ? this.curve = new c.edwards(f) : this.curve = new c.mont(f), this.g = this.curve.g, this.n = this.curve.n, this.hash = f.hash, r(this.g.validate(), "Invalid curve"), r(this.g.mul(this.n).isInfinity(), "Invalid curve, G*N != O");
+  }
+  b.PresetCurve = s;
+  function a(f, i) {
+    Object.defineProperty(b, f, {
+      configurable: !0,
+      enumerable: !0,
+      get: function() {
+        var t = new s(i);
+        return Object.defineProperty(b, f, {
+          configurable: !0,
+          enumerable: !0,
+          value: t
+        }), t;
+      }
+    });
+  }
+  a("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: e.sha256,
+    gRed: !1,
+    g: [
+      "188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012",
+      "07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811"
+    ]
+  }), a("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: e.sha256,
+    gRed: !1,
+    g: [
+      "b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21",
+      "bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34"
+    ]
+  }), a("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: e.sha256,
+    gRed: !1,
+    g: [
+      "6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296",
+      "4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5"
+    ]
+  }), a("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: e.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"
+    ]
+  }), a("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: e.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"
+    ]
+  }), a("curve25519", {
+    type: "mont",
+    prime: "p25519",
+    p: "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed",
+    a: "76d06",
+    b: "1",
+    n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed",
+    hash: e.sha256,
+    gRed: !1,
+    g: [
+      "9"
+    ]
+  }), a("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: e.sha256,
+    gRed: !1,
+    g: [
+      "216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a",
+      // 4/5
+      "6666666666666666666666666666666666666666666666666666666666666658"
+    ]
+  });
+  var d;
+  try {
+    d = n();
+  } catch {
+    d = void 0;
+  }
+  a("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: e.sha256,
+    // Precomputed endomorphism
+    beta: "7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee",
+    lambda: "5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72",
+    basis: [
+      {
+        a: "3086d221a7d46bcde86c90e49284eb15",
+        b: "-e4437ed6010e88286f547fa90abfe4c3"
+      },
+      {
+        a: "114ca50f7a8e2f3f657c1108d9d44cfd8",
+        b: "3086d221a7d46bcde86c90e49284eb15"
+      }
+    ],
+    gRed: !1,
+    g: [
+      "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+      "483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8",
+      d
+    ]
+  });
+})(u);

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/elliptic/lib/elliptic/ec/index.mjs

@@ -0,0 +1,107 @@
+import { b as F } from "../../../node_modules/bn.js/lib/bn.mjs";
+import { h as T } from "../../../../hmac-drbg/lib/hmac-drbg.mjs";
+import "../utils.mjs";
+import "../curves.mjs";
+import { b as x } from "../../../../brorand/index.mjs";
+import { k as K } from "./key.mjs";
+import { s as A } from "./signature.mjs";
+import { __exports as L } from "../../../../../../../../../../_virtual/utils6.mjs";
+import { __exports as N } from "../../../../../../../../../../_virtual/curves.mjs";
+var m = F, E = T, I = L, d = N, O = x, _ = I.assert, P = K, b = A;
+function c(e) {
+  if (!(this instanceof c))
+    return new c(e);
+  typeof e == "string" && (_(
+    Object.prototype.hasOwnProperty.call(d, e),
+    "Unknown curve " + e
+  ), e = d[e]), e instanceof d.PresetCurve && (e = { curve: e }), this.curve = e.curve.curve, this.n = this.curve.n, this.nh = this.n.ushrn(1), this.g = this.curve.g, this.g = e.curve.g, this.g.precompute(e.curve.n.bitLength() + 1), this.hash = e.hash || e.curve.hash;
+}
+var Y = c;
+c.prototype.keyPair = function(r) {
+  return new P(this, r);
+};
+c.prototype.keyFromPrivate = function(r, t) {
+  return P.fromPrivate(this, r, t);
+};
+c.prototype.keyFromPublic = function(r, t) {
+  return P.fromPublic(this, r, t);
+};
+c.prototype.genKeyPair = function(r) {
+  r || (r = {});
+  for (var t = new E({
+    hash: this.hash,
+    pers: r.pers,
+    persEnc: r.persEnc || "utf8",
+    entropy: r.entropy || O(this.hash.hmacStrength),
+    entropyEnc: r.entropy && r.entropyEnc || "utf8",
+    nonce: this.n.toArray()
+  }), i = this.n.byteLength(), n = this.n.sub(new m(2)); ; ) {
+    var a = new m(t.generate(i));
+    if (!(a.cmp(n) > 0))
+      return a.iaddn(1), this.keyFromPrivate(a);
+  }
+};
+c.prototype._truncateToN = function(r, t) {
+  var i = r.byteLength() * 8 - this.n.bitLength();
+  return i > 0 && (r = r.ushrn(i)), !t && r.cmp(this.n) >= 0 ? r.sub(this.n) : r;
+};
+c.prototype.sign = function(r, t, i, n) {
+  typeof i == "object" && (n = i, i = null), n || (n = {}), t = this.keyFromPrivate(t, i), r = this._truncateToN(new m(r, 16));
+  for (var a = this.n.byteLength(), h = t.getPrivate().toArray("be", a), y = r.toArray("be", a), s = new E({
+    hash: this.hash,
+    entropy: h,
+    nonce: y,
+    pers: n.pers,
+    persEnc: n.persEnc || "utf8"
+  }), o = this.n.sub(new m(1)), u = 0; ; u++) {
+    var v = n.k ? n.k(u) : new m(s.generate(this.n.byteLength()));
+    if (v = this._truncateToN(v, !0), !(v.cmpn(1) <= 0 || v.cmp(o) >= 0)) {
+      var p = this.g.mul(v);
+      if (!p.isInfinity()) {
+        var w = p.getX(), l = w.umod(this.n);
+        if (l.cmpn(0) !== 0) {
+          var f = v.invm(this.n).mul(l.mul(t.getPrivate()).iadd(r));
+          if (f = f.umod(this.n), f.cmpn(0) !== 0) {
+            var g = (p.getY().isOdd() ? 1 : 0) | (w.cmp(l) !== 0 ? 2 : 0);
+            return n.canonical && f.cmp(this.nh) > 0 && (f = this.n.sub(f), g ^= 1), new b({ r: l, s: f, recoveryParam: g });
+          }
+        }
+      }
+    }
+  }
+};
+c.prototype.verify = function(r, t, i, n) {
+  r = this._truncateToN(new m(r, 16)), i = this.keyFromPublic(i, n), t = new b(t, "hex");
+  var a = t.r, h = t.s;
+  if (a.cmpn(1) < 0 || a.cmp(this.n) >= 0 || h.cmpn(1) < 0 || h.cmp(this.n) >= 0)
+    return !1;
+  var y = h.invm(this.n), s = y.mul(r).umod(this.n), o = y.mul(a).umod(this.n), u;
+  return this.curve._maxwellTrick ? (u = this.g.jmulAdd(s, i.getPublic(), o), u.isInfinity() ? !1 : u.eqXToP(a)) : (u = this.g.mulAdd(s, i.getPublic(), o), u.isInfinity() ? !1 : u.getX().umod(this.n).cmp(a) === 0);
+};
+c.prototype.recoverPubKey = function(e, r, t, i) {
+  _((3 & t) === t, "The recovery param is more than two bits"), r = new b(r, i);
+  var n = this.n, a = new m(e), h = r.r, y = r.s, s = t & 1, o = t >> 1;
+  if (h.cmp(this.curve.p.umod(this.curve.n)) >= 0 && o)
+    throw new Error("Unable to find sencond key candinate");
+  o ? h = this.curve.pointFromX(h.add(this.curve.n), s) : h = this.curve.pointFromX(h, s);
+  var u = r.r.invm(n), v = n.sub(a).mul(u).umod(n), p = y.mul(u).umod(n);
+  return this.g.mulAdd(v, h, p);
+};
+c.prototype.getKeyRecoveryParam = function(e, r, t, i) {
+  if (r = new b(r, i), r.recoveryParam !== null)
+    return r.recoveryParam;
+  for (var n = 0; n < 4; n++) {
+    var a;
+    try {
+      a = this.recoverPubKey(e, r, n);
+    } catch {
+      continue;
+    }
+    if (a.eq(t))
+      return n;
+  }
+  throw new Error("Unable to find valid recovery factor");
+};
+export {
+  Y as e
+};