@ozdao/prometheus-framework 0.1.66 → 0.1.68

package/dist/node_modules/@noble/curves/esm/abstract/weierstrass.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const _=require("./modular.cjs"),m=require("./utils.cjs"),et=require("./curve.cjs");/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */function at(v){const n=et.validateBasic(v);m.validateObject(n,{a:"field",b:"field"},{allowedPrivateKeyLengths:"array",wrapPrivateKey:"boolean",isTorsionFree:"function",clearCofactor:"function",allowInfinityPoint:"boolean",fromBytes:"function",toBytes:"function"});const{endo:t,Fp:x,a:O}=n;if(t){if(!x.eql(O,x.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:ct,hexToBytes:ut}=m,$={Err:class extends Error{constructor(n=""){super(n)}},_parseInt(v){const{Err:n}=$;if(v.length<2||v[0]!==2)throw new n("Invalid signature integer tag");const t=v[1],x=v.subarray(2,t+2);if(!t||x.length!==t)throw new n("Invalid signature integer: wrong length");if(x[0]&128)throw new n("Invalid signature integer: negative");if(x[0]===0&&!(x[1]&128))throw new n("Invalid signature integer: unnecessary leading zero");return{d:ct(x),l:v.subarray(t+2)}},toSig(v){const{Err:n}=$,t=typeof v=="string"?ut(v):v;if(!(t instanceof Uint8Array))throw new Error("ui8a expected");let x=t.length;if(x<2||t[0]!=48)throw new n("Invalid signature tag");if(t[1]!==x-2)throw new n("Invalid signature: incorrect length");const{d:O,l:T}=$._parseInt(t.subarray(2)),{d:F,l:R}=$._parseInt(T);if(R.length)throw new n("Invalid signature: left bytes after parsing");return{r:O,s:F}},hexFromSig(v){const n=S=>Number.parseInt(S[0],16)&8?"00"+S:S,t=S=>{const V=S.toString(16);return V.length&1?`0${V}`:V},x=n(t(v.s)),O=n(t(v.r)),T=x.length/2,F=O.length/2,R=t(T),C=t(F);return`30${t(F+T+4)}02${C}${O}02${R}${x}`}},P=BigInt(0),U=BigInt(1);BigInt(2);const ot=BigInt(3);BigInt(4);function it(v){const n=at(v),{Fp:t}=n,x=n.toBytes||((y,r,i)=>{const o=r.toAffine();return m.concatBytes(Uint8Array.from([4]),t.toBytes(o.x),t.toBytes(o.y))}),O=n.fromBytes||(y=>{const r=y.subarray(1),i=t.fromBytes(r.subarray(0,t.BYTES)),o=t.fromBytes(r.subarray(t.BYTES,2*t.BYTES));return{x:i,y:o}});function T(y){const{a:r,b:i}=n,o=t.sqr(y),u=t.mul(o,y);return t.add(t.add(u,t.mul(y,r)),i)}if(!t.eql(t.sqr(n.Gy),T(n.Gx)))throw new Error("bad generator point: equation left != right");function F(y){return typeof y=="bigint"&&P<y&&y<n.n}function R(y){if(!F(y))throw new Error("Expected valid bigint: 0 < bigint < curve.n")}function C(y){const{allowedPrivateKeyLengths:r,nByteLength:i,wrapPrivateKey:o,n:u}=n;if(r&&typeof y!="bigint"){if(y instanceof Uint8Array&&(y=m.bytesToHex(y)),typeof y!="string"||!r.includes(y.length))throw new Error("Invalid key");y=y.padStart(i*2,"0")}let f;try{f=typeof y=="bigint"?y:m.bytesToNumberBE(m.ensureBytes("private key",y,i))}catch{throw new Error(`private key must be ${i} bytes, hex or bigint, not ${typeof y}`)}return o&&(f=_.mod(f,u)),R(f),f}const S=new Map;function V(y){if(!(y instanceof w))throw new Error("ProjectivePoint expected")}class w{constructor(r,i,o){if(this.px=r,this.py=i,this.pz=o,r==null||!t.isValid(r))throw new Error("x required");if(i==null||!t.isValid(i))throw new Error("y required");if(o==null||!t.isValid(o))throw new Error("z required")}static fromAffine(r){const{x:i,y:o}=r||{};if(!r||!t.isValid(i)||!t.isValid(o))throw new Error("invalid affine point");if(r instanceof w)throw new Error("projective point not allowed");const u=f=>t.eql(f,t.ZERO);return u(i)&&u(o)?w.ZERO:new w(i,o,t.ONE)}get x(){return this.toAffine().x}get y(){return this.toAffine().y}static normalizeZ(r){const i=t.invertBatch(r.map(o=>o.pz));return r.map((o,u)=>o.toAffine(i[u])).map(w.fromAffine)}static fromHex(r){const i=w.fromAffine(O(m.ensureBytes("pointHex",r)));return i.assertValidity(),i}static fromPrivateKey(r){return w.BASE.multiply(C(r))}_setWindowSize(r){this._WINDOW_SIZE=r,S.delete(this)}assertValidity(){if(this.is0()){if(n.allowInfinityPoint)return;throw new Error("bad point: ZERO")}const{x:r,y:i}=this.toAffine();if(!t.isValid(r)||!t.isValid(i))throw new Error("bad point: x or y not FE");const o=t.sqr(i),u=T(r);if(!t.eql(o,u))throw new Error("bad point: equation left != right");if(!this.isTorsionFree())throw new Error("bad point: not in prime-order subgroup")}hasEvenY(){const{y:r}=this.toAffine();if(t.isOdd)return!t.isOdd(r);throw new Error("Field doesn't support isOdd")}equals(r){V(r);const{px:i,py:o,pz:u}=this,{px:f,py:g,pz:h}=r,a=t.eql(t.mul(i,h),t.mul(f,u)),c=t.eql(t.mul(o,h),t.mul(g,u));return a&&c}negate(){return new w(this.px,t.neg(this.py),this.pz)}double(){const{a:r,b:i}=n,o=t.mul(i,ot),{px:u,py:f,pz:g}=this;let h=t.ZERO,a=t.ZERO,c=t.ZERO,d=t.mul(u,u),z=t.mul(f,f),B=t.mul(g,g),p=t.mul(u,f);return p=t.add(p,p),c=t.mul(u,g),c=t.add(c,c),h=t.mul(r,c),a=t.mul(o,B),a=t.add(h,a),h=t.sub(z,a),a=t.add(z,a),a=t.mul(h,a),h=t.mul(p,h),c=t.mul(o,c),B=t.mul(r,B),p=t.sub(d,B),p=t.mul(r,p),p=t.add(p,c),c=t.add(d,d),d=t.add(c,d),d=t.add(d,B),d=t.mul(d,p),a=t.add(a,d),B=t.mul(f,g),B=t.add(B,B),d=t.mul(B,p),h=t.sub(h,d),c=t.mul(B,z),c=t.add(c,c),c=t.add(c,c),new w(h,a,c)}add(r){V(r);const{px:i,py:o,pz:u}=this,{px:f,py:g,pz:h}=r;let a=t.ZERO,c=t.ZERO,d=t.ZERO;const z=n.a,B=t.mul(n.b,ot);let p=t.mul(i,f),N=t.mul(o,g),Z=t.mul(u,h),H=t.add(i,o),e=t.add(f,g);H=t.mul(H,e),e=t.add(p,N),H=t.sub(H,e),e=t.add(i,u);let s=t.add(f,h);return e=t.mul(e,s),s=t.add(p,Z),e=t.sub(e,s),s=t.add(o,u),a=t.add(g,h),s=t.mul(s,a),a=t.add(N,Z),s=t.sub(s,a),d=t.mul(z,e),a=t.mul(B,Z),d=t.add(a,d),a=t.sub(N,d),d=t.add(N,d),c=t.mul(a,d),N=t.add(p,p),N=t.add(N,p),Z=t.mul(z,Z),e=t.mul(B,e),N=t.add(N,Z),Z=t.sub(p,Z),Z=t.mul(z,Z),e=t.add(e,Z),p=t.mul(N,e),c=t.add(c,p),p=t.mul(s,e),a=t.mul(H,a),a=t.sub(a,p),p=t.mul(H,N),d=t.mul(s,d),d=t.add(d,p),new w(a,c,d)}subtract(r){return this.add(r.negate())}is0(){return this.equals(w.ZERO)}wNAF(r){return L.wNAFCached(this,S,r,i=>{const o=t.invertBatch(i.map(u=>u.pz));return i.map((u,f)=>u.toAffine(o[f])).map(w.fromAffine)})}multiplyUnsafe(r){const i=w.ZERO;if(r===P)return i;if(R(r),r===U)return this;const{endo:o}=n;if(!o)return L.unsafeLadder(this,r);let{k1neg:u,k1:f,k2neg:g,k2:h}=o.splitScalar(r),a=i,c=i,d=this;for(;f>P||h>P;)f&U&&(a=a.add(d)),h&U&&(c=c.add(d)),d=d.double(),f>>=U,h>>=U;return u&&(a=a.negate()),g&&(c=c.negate()),c=new w(t.mul(c.px,o.beta),c.py,c.pz),a.add(c)}multiply(r){R(r);let i=r,o,u;const{endo:f}=n;if(f){const{k1neg:g,k1:h,k2neg:a,k2:c}=f.splitScalar(i);let{p:d,f:z}=this.wNAF(h),{p:B,f:p}=this.wNAF(c);d=L.constTimeNegate(g,d),B=L.constTimeNegate(a,B),B=new w(t.mul(B.px,f.beta),B.py,B.pz),o=d.add(B),u=z.add(p)}else{const{p:g,f:h}=this.wNAF(i);o=g,u=h}return w.normalizeZ([o,u])[0]}multiplyAndAddUnsafe(r,i,o){const u=w.BASE,f=(h,a)=>a===P||a===U||!h.equals(u)?h.multiplyUnsafe(a):h.multiply(a),g=f(this,i).add(f(r,o));return g.is0()?void 0:g}toAffine(r){const{px:i,py:o,pz:u}=this,f=this.is0();r==null&&(r=f?t.ONE:t.inv(u));const g=t.mul(i,r),h=t.mul(o,r),a=t.mul(u,r);if(f)return{x:t.ZERO,y:t.ZERO};if(!t.eql(a,t.ONE))throw new Error("invZ was invalid");return{x:g,y:h}}isTorsionFree(){const{h:r,isTorsionFree:i}=n;if(r===U)return!0;if(i)return i(w,this);throw new Error("isTorsionFree() has not been declared for the elliptic curve")}clearCofactor(){const{h:r,clearCofactor:i}=n;return r===U?this:i?i(w,this):this.multiplyUnsafe(n.h)}toRawBytes(r=!0){return this.assertValidity(),x(w,this,r)}toHex(r=!0){return m.bytesToHex(this.toRawBytes(r))}}w.BASE=new w(n.Gx,n.Gy,t.ONE),w.ZERO=new w(t.ZERO,t.ONE,t.ZERO);const W=n.nBitLength,L=et.wNAF(w,n.endo?Math.ceil(W/2):W);return{CURVE:n,ProjectivePoint:w,normPrivateKeyToScalar:C,weierstrassEquation:T,isWithinCurveOrder:F}}function lt(v){const n=et.validateBasic(v);return m.validateObject(n,{hash:"hash",hmac:"function",randomBytes:"function"},{bits2int:"function",bits2int_modN:"function",lowS:"boolean"}),Object.freeze({lowS:!0,...n})}function ft(v){const n=lt(v),{Fp:t,n:x}=n,O=t.BYTES+1,T=2*t.BYTES+1;function F(e){return P<e&&e<t.ORDER}function R(e){return _.mod(e,x)}function C(e){return _.invert(e,x)}const{ProjectivePoint:S,normPrivateKeyToScalar:V,weierstrassEquation:w,isWithinCurveOrder:W}=it({...n,toBytes(e,s,l){const b=s.toAffine(),E=t.toBytes(b.x),A=m.concatBytes;return l?A(Uint8Array.from([s.hasEvenY()?2:3]),E):A(Uint8Array.from([4]),E,t.toBytes(b.y))},fromBytes(e){const s=e.length,l=e[0],b=e.subarray(1);if(s===O&&(l===2||l===3)){const E=m.bytesToNumberBE(b);if(!F(E))throw new Error("Point is not on curve");const A=w(E);let I=t.sqrt(A);const q=(I&U)===U;return(l&1)===1!==q&&(I=t.neg(I)),{x:E,y:I}}else if(s===T&&l===4){const E=t.fromBytes(b.subarray(0,t.BYTES)),A=t.fromBytes(b.subarray(t.BYTES,2*t.BYTES));return{x:E,y:A}}else throw new Error(`Point of length ${s} was invalid. Expected ${O} compressed bytes or ${T} uncompressed bytes`)}}),L=e=>m.bytesToHex(m.numberToBytesBE(e,n.nByteLength));function y(e){const s=x>>U;return e>s}function r(e){return y(e)?R(-e):e}const i=(e,s,l)=>m.bytesToNumberBE(e.slice(s,l));class o{constructor(s,l,b){this.r=s,this.s=l,this.recovery=b,this.assertValidity()}static fromCompact(s){const l=n.nByteLength;return s=m.ensureBytes("compactSignature",s,l*2),new o(i(s,0,l),i(s,l,2*l))}static fromDER(s){const{r:l,s:b}=$.toSig(m.ensureBytes("DER",s));return new o(l,b)}assertValidity(){if(!W(this.r))throw new Error("r must be 0 < r < CURVE.n");if(!W(this.s))throw new Error("s must be 0 < s < CURVE.n")}addRecoveryBit(s){return new o(this.r,this.s,s)}recoverPublicKey(s){const{r:l,s:b,recovery:E}=this,A=c(m.ensureBytes("msgHash",s));if(E==null||![0,1,2,3].includes(E))throw new Error("recovery id invalid");const I=E===2||E===3?l+n.n:l;if(I>=t.ORDER)throw new Error("recovery id 2 or 3 invalid");const q=E&1?"03":"02",D=S.fromHex(q+L(I)),j=C(I),X=R(-A*j),J=R(b*j),K=S.BASE.multiplyAndAddUnsafe(D,X,J);if(!K)throw new Error("point at infinify");return K.assertValidity(),K}hasHighS(){return y(this.s)}normalizeS(){return this.hasHighS()?new o(this.r,R(-this.s),this.recovery):this}toDERRawBytes(){return m.hexToBytes(this.toDERHex())}toDERHex(){return $.hexFromSig({r:this.r,s:this.s})}toCompactRawBytes(){return m.hexToBytes(this.toCompactHex())}toCompactHex(){return L(this.r)+L(this.s)}}const u={isValidPrivateKey(e){try{return V(e),!0}catch{return!1}},normPrivateKeyToScalar:V,randomPrivateKey:()=>{const e=n.randomBytes(t.BYTES+8),s=_.hashToPrivateScalar(e,x);return m.numberToBytesBE(s,n.nByteLength)},precompute(e=8,s=S.BASE){return s._setWindowSize(e),s.multiply(BigInt(3)),s}};function f(e,s=!0){return S.fromPrivateKey(e).toRawBytes(s)}function g(e){const s=e instanceof Uint8Array,l=typeof e=="string",b=(s||l)&&e.length;return s?b===O||b===T:l?b===2*O||b===2*T:e instanceof S}function h(e,s,l=!0){if(g(e))throw new Error("first arg must be private key");if(!g(s))throw new Error("second arg must be public key");return S.fromHex(s).multiply(V(e)).toRawBytes(l)}const a=n.bits2int||function(e){const s=m.bytesToNumberBE(e),l=e.length*8-n.nBitLength;return l>0?s>>BigInt(l):s},c=n.bits2int_modN||function(e){return R(a(e))},d=m.bitMask(n.nBitLength);function z(e){if(typeof e!="bigint")throw new Error("bigint expected");if(!(P<=e&&e<d))throw new Error(`bigint expected < 2^${n.nBitLength}`);return m.numberToBytesBE(e,n.nByteLength)}function B(e,s,l=p){if(["recovered","canonical"].some(k=>k in l))throw new Error("sign() legacy options not supported");const{hash:b,randomBytes:E}=n;let{lowS:A,prehash:I,extraEntropy:q}=l;A==null&&(A=!0),e=m.ensureBytes("msgHash",e),I&&(e=m.ensureBytes("prehashed msgHash",b(e)));const D=c(e),j=V(s),X=[z(j),z(D)];if(q!=null){const k=q===!0?E(t.BYTES):q;X.push(m.ensureBytes("extraEntropy",k,t.BYTES))}const J=m.concatBytes(...X),K=D;function tt(k){const G=a(k);if(!W(G))return;const rt=C(G),M=S.BASE.multiply(G).toAffine(),Y=R(M.x);if(Y===P)return;const Q=R(rt*R(K+Y*j));if(Q===P)return;let nt=(M.x===Y?0:2)|Number(M.y&U),st=Q;return A&&y(Q)&&(st=r(Q),nt^=1),new o(Y,st,nt)}return{seed:J,k2sig:tt}}const p={lowS:n.lowS,prehash:!1},N={lowS:n.lowS,prehash:!1};function Z(e,s,l=p){const{seed:b,k2sig:E}=B(e,s,l),A=n;return m.createHmacDrbg(A.hash.outputLen,A.nByteLength,A.hmac)(b,E)}S.BASE._setWindowSize(8);function H(e,s,l,b=N){var M;const E=e;if(s=m.ensureBytes("msgHash",s),l=m.ensureBytes("publicKey",l),"strict"in b)throw new Error("options.strict was renamed to lowS");const{lowS:A,prehash:I}=b;let q,D;try{if(typeof E=="string"||E instanceof Uint8Array)try{q=o.fromDER(E)}catch(Y){if(!(Y instanceof $.Err))throw Y;q=o.fromCompact(E)}else if(typeof E=="object"&&typeof E.r=="bigint"&&typeof E.s=="bigint"){const{r:Y,s:Q}=E;q=new o(Y,Q)}else throw new Error("PARSE");D=S.fromHex(l)}catch(Y){if(Y.message==="PARSE")throw new Error("signature must be Signature instance, Uint8Array or hex string");return!1}if(A&&q.hasHighS())return!1;I&&(s=n.hash(s));const{r:j,s:X}=q,J=c(s),K=C(X),tt=R(J*K),k=R(j*K),G=(M=S.BASE.multiplyAndAddUnsafe(D,tt,k))==null?void 0:M.toAffine();return G?R(G.x)===j:!1}return{CURVE:n,getPublicKey:f,getSharedSecret:h,sign:Z,verify:H,ProjectivePoint:S,Signature:o,utils:u}}exports.DER=$;exports.weierstrass=ft;exports.weierstrassPoints=it;

package/dist/node_modules/@noble/curves/esm/abstract/weierstrass.js

@@ -0,0 +1,581 @@
+import { mod as ut, hashToPrivateScalar as dt, invert as ht } from "./modular.js";
+import * as mt from "./utils.js";
+import { bytesToNumberBE as _, bitMask as yt, concatBytes as et, validateObject as lt, ensureBytes as Y, hexToBytes as at, numberToBytesBE as rt, createHmacDrbg as pt, bytesToHex as nt } from "./utils.js";
+import { wNAF as wt, validateBasic as ft } from "./curve.js";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function Et(B) {
+  const n = ft(B);
+  lt(n, {
+    a: "field",
+    b: "field"
+  }, {
+    allowedPrivateKeyLengths: "array",
+    wrapPrivateKey: "boolean",
+    isTorsionFree: "function",
+    clearCofactor: "function",
+    allowInfinityPoint: "boolean",
+    fromBytes: "function",
+    toBytes: "function"
+  });
+  const { endo: t, Fp: v, a: A } = n;
+  if (t) {
+    if (!v.eql(A, v.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: gt, hexToBytes: bt } = mt, k = {
+  // asn.1 DER encoding utils
+  Err: class extends Error {
+    constructor(n = "") {
+      super(n);
+    }
+  },
+  _parseInt(B) {
+    const { Err: n } = k;
+    if (B.length < 2 || B[0] !== 2)
+      throw new n("Invalid signature integer tag");
+    const t = B[1], v = B.subarray(2, t + 2);
+    if (!t || v.length !== t)
+      throw new n("Invalid signature integer: wrong length");
+    if (v[0] & 128)
+      throw new n("Invalid signature integer: negative");
+    if (v[0] === 0 && !(v[1] & 128))
+      throw new n("Invalid signature integer: unnecessary leading zero");
+    return { d: gt(v), l: B.subarray(t + 2) };
+  },
+  toSig(B) {
+    const { Err: n } = k, t = typeof B == "string" ? bt(B) : B;
+    if (!(t instanceof Uint8Array))
+      throw new Error("ui8a expected");
+    let v = t.length;
+    if (v < 2 || t[0] != 48)
+      throw new n("Invalid signature tag");
+    if (t[1] !== v - 2)
+      throw new n("Invalid signature: incorrect length");
+    const { d: A, l: O } = k._parseInt(t.subarray(2)), { d: F, l: S } = k._parseInt(O);
+    if (S.length)
+      throw new n("Invalid signature: left bytes after parsing");
+    return { r: A, s: F };
+  },
+  hexFromSig(B) {
+    const n = (x) => Number.parseInt(x[0], 16) & 8 ? "00" + x : x, t = (x) => {
+      const U = x.toString(16);
+      return U.length & 1 ? `0${U}` : U;
+    }, v = n(t(B.s)), A = n(t(B.r)), O = v.length / 2, F = A.length / 2, S = t(O), L = t(F);
+    return `30${t(F + O + 4)}02${L}${A}02${S}${v}`;
+  }
+}, C = BigInt(0), z = BigInt(1);
+BigInt(2);
+const ct = BigInt(3);
+BigInt(4);
+function Bt(B) {
+  const n = Et(B), { Fp: t } = n, v = n.toBytes || ((m, e, i) => {
+    const s = e.toAffine();
+    return et(Uint8Array.from([4]), t.toBytes(s.x), t.toBytes(s.y));
+  }), A = n.fromBytes || ((m) => {
+    const e = m.subarray(1), i = t.fromBytes(e.subarray(0, t.BYTES)), s = t.fromBytes(e.subarray(t.BYTES, 2 * t.BYTES));
+    return { x: i, y: s };
+  });
+  function O(m) {
+    const { a: e, b: i } = n, s = t.sqr(m), u = t.mul(s, m);
+    return t.add(t.add(u, t.mul(m, e)), i);
+  }
+  if (!t.eql(t.sqr(n.Gy), O(n.Gx)))
+    throw new Error("bad generator point: equation left != right");
+  function F(m) {
+    return typeof m == "bigint" && C < m && m < n.n;
+  }
+  function S(m) {
+    if (!F(m))
+      throw new Error("Expected valid bigint: 0 < bigint < curve.n");
+  }
+  function L(m) {
+    const { allowedPrivateKeyLengths: e, nByteLength: i, wrapPrivateKey: s, n: u } = n;
+    if (e && typeof m != "bigint") {
+      if (m instanceof Uint8Array && (m = nt(m)), typeof m != "string" || !e.includes(m.length))
+        throw new Error("Invalid key");
+      m = m.padStart(i * 2, "0");
+    }
+    let f;
+    try {
+      f = typeof m == "bigint" ? m : _(Y("private key", m, i));
+    } catch {
+      throw new Error(`private key must be ${i} bytes, hex or bigint, not ${typeof m}`);
+    }
+    return s && (f = ut(f, u)), S(f), f;
+  }
+  const x = /* @__PURE__ */ new Map();
+  function U(m) {
+    if (!(m instanceof y))
+      throw new Error("ProjectivePoint expected");
+  }
+  class y {
+    constructor(e, i, s) {
+      if (this.px = e, this.py = i, this.pz = s, e == null || !t.isValid(e))
+        throw new Error("x required");
+      if (i == null || !t.isValid(i))
+        throw new Error("y required");
+      if (s == null || !t.isValid(s))
+        throw new Error("z required");
+    }
+    // Does not validate if the point is on-curve.
+    // Use fromHex instead, or call assertValidity() later.
+    static fromAffine(e) {
+      const { x: i, y: s } = e || {};
+      if (!e || !t.isValid(i) || !t.isValid(s))
+        throw new Error("invalid affine point");
+      if (e instanceof y)
+        throw new Error("projective point not allowed");
+      const u = (f) => t.eql(f, t.ZERO);
+      return u(i) && u(s) ? y.ZERO : new y(i, s, 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(e) {
+      const i = t.invertBatch(e.map((s) => s.pz));
+      return e.map((s, u) => s.toAffine(i[u])).map(y.fromAffine);
+    }
+    /**
+     * Converts hash string or Uint8Array to Point.
+     * @param hex short/long ECDSA hex
+     */
+    static fromHex(e) {
+      const i = y.fromAffine(A(Y("pointHex", e)));
+      return i.assertValidity(), i;
+    }
+    // Multiplies generator point by privateKey.
+    static fromPrivateKey(e) {
+      return y.BASE.multiply(L(e));
+    }
+    // "Private method", don't use it directly
+    _setWindowSize(e) {
+      this._WINDOW_SIZE = e, x.delete(this);
+    }
+    // A point on curve is valid if it conforms to equation.
+    assertValidity() {
+      if (this.is0()) {
+        if (n.allowInfinityPoint)
+          return;
+        throw new Error("bad point: ZERO");
+      }
+      const { x: e, y: i } = this.toAffine();
+      if (!t.isValid(e) || !t.isValid(i))
+        throw new Error("bad point: x or y not FE");
+      const s = t.sqr(i), u = O(e);
+      if (!t.eql(s, u))
+        throw new Error("bad point: equation left != right");
+      if (!this.isTorsionFree())
+        throw new Error("bad point: not in prime-order subgroup");
+    }
+    hasEvenY() {
+      const { y: e } = this.toAffine();
+      if (t.isOdd)
+        return !t.isOdd(e);
+      throw new Error("Field doesn't support isOdd");
+    }
+    /**
+     * Compare one point to another.
+     */
+    equals(e) {
+      U(e);
+      const { px: i, py: s, pz: u } = this, { px: f, py: E, pz: h } = e, a = t.eql(t.mul(i, h), t.mul(f, u)), c = t.eql(t.mul(s, h), t.mul(E, u));
+      return a && c;
+    }
+    /**
+     * Flips point to one corresponding to (x, -y) in Affine coordinates.
+     */
+    negate() {
+      return new y(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: e, b: i } = n, s = t.mul(i, ct), { px: u, py: f, pz: E } = this;
+      let h = t.ZERO, a = t.ZERO, c = t.ZERO, d = t.mul(u, u), q = t.mul(f, f), b = t.mul(E, E), p = t.mul(u, f);
+      return p = t.add(p, p), c = t.mul(u, E), c = t.add(c, c), h = t.mul(e, c), a = t.mul(s, b), a = t.add(h, a), h = t.sub(q, a), a = t.add(q, a), a = t.mul(h, a), h = t.mul(p, h), c = t.mul(s, c), b = t.mul(e, b), p = t.sub(d, b), p = t.mul(e, p), p = t.add(p, c), c = t.add(d, d), d = t.add(c, d), d = t.add(d, b), d = t.mul(d, p), a = t.add(a, d), b = t.mul(f, E), b = t.add(b, b), d = t.mul(b, p), h = t.sub(h, d), c = t.mul(b, q), c = t.add(c, c), c = t.add(c, c), new y(h, a, c);
+    }
+    // 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(e) {
+      U(e);
+      const { px: i, py: s, pz: u } = this, { px: f, py: E, pz: h } = e;
+      let a = t.ZERO, c = t.ZERO, d = t.ZERO;
+      const q = n.a, b = t.mul(n.b, ct);
+      let p = t.mul(i, f), T = t.mul(s, E), Z = t.mul(u, h), H = t.add(i, s), r = t.add(f, E);
+      H = t.mul(H, r), r = t.add(p, T), H = t.sub(H, r), r = t.add(i, u);
+      let o = t.add(f, h);
+      return r = t.mul(r, o), o = t.add(p, Z), r = t.sub(r, o), o = t.add(s, u), a = t.add(E, h), o = t.mul(o, a), a = t.add(T, Z), o = t.sub(o, a), d = t.mul(q, r), a = t.mul(b, Z), d = t.add(a, d), a = t.sub(T, d), d = t.add(T, d), c = t.mul(a, d), T = t.add(p, p), T = t.add(T, p), Z = t.mul(q, Z), r = t.mul(b, r), T = t.add(T, Z), Z = t.sub(p, Z), Z = t.mul(q, Z), r = t.add(r, Z), p = t.mul(T, r), c = t.add(c, p), p = t.mul(o, r), a = t.mul(H, a), a = t.sub(a, p), p = t.mul(H, T), d = t.mul(o, d), d = t.add(d, p), new y(a, c, d);
+    }
+    subtract(e) {
+      return this.add(e.negate());
+    }
+    is0() {
+      return this.equals(y.ZERO);
+    }
+    wNAF(e) {
+      return P.wNAFCached(this, x, e, (i) => {
+        const s = t.invertBatch(i.map((u) => u.pz));
+        return i.map((u, f) => u.toAffine(s[f])).map(y.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(e) {
+      const i = y.ZERO;
+      if (e === C)
+        return i;
+      if (S(e), e === z)
+        return this;
+      const { endo: s } = n;
+      if (!s)
+        return P.unsafeLadder(this, e);
+      let { k1neg: u, k1: f, k2neg: E, k2: h } = s.splitScalar(e), a = i, c = i, d = this;
+      for (; f > C || h > C; )
+        f & z && (a = a.add(d)), h & z && (c = c.add(d)), d = d.double(), f >>= z, h >>= z;
+      return u && (a = a.negate()), E && (c = c.negate()), c = new y(t.mul(c.px, s.beta), c.py, c.pz), a.add(c);
+    }
+    /**
+     * 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(e) {
+      S(e);
+      let i = e, s, u;
+      const { endo: f } = n;
+      if (f) {
+        const { k1neg: E, k1: h, k2neg: a, k2: c } = f.splitScalar(i);
+        let { p: d, f: q } = this.wNAF(h), { p: b, f: p } = this.wNAF(c);
+        d = P.constTimeNegate(E, d), b = P.constTimeNegate(a, b), b = new y(t.mul(b.px, f.beta), b.py, b.pz), s = d.add(b), u = q.add(p);
+      } else {
+        const { p: E, f: h } = this.wNAF(i);
+        s = E, u = h;
+      }
+      return y.normalizeZ([s, u])[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(e, i, s) {
+      const u = y.BASE, f = (h, a) => a === C || a === z || !h.equals(u) ? h.multiplyUnsafe(a) : h.multiply(a), E = f(this, i).add(f(e, s));
+      return E.is0() ? void 0 : E;
+    }
+    // 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(e) {
+      const { px: i, py: s, pz: u } = this, f = this.is0();
+      e == null && (e = f ? t.ONE : t.inv(u));
+      const E = t.mul(i, e), h = t.mul(s, e), a = t.mul(u, e);
+      if (f)
+        return { x: t.ZERO, y: t.ZERO };
+      if (!t.eql(a, t.ONE))
+        throw new Error("invZ was invalid");
+      return { x: E, y: h };
+    }
+    isTorsionFree() {
+      const { h: e, isTorsionFree: i } = n;
+      if (e === z)
+        return !0;
+      if (i)
+        return i(y, this);
+      throw new Error("isTorsionFree() has not been declared for the elliptic curve");
+    }
+    clearCofactor() {
+      const { h: e, clearCofactor: i } = n;
+      return e === z ? this : i ? i(y, this) : this.multiplyUnsafe(n.h);
+    }
+    toRawBytes(e = !0) {
+      return this.assertValidity(), v(y, this, e);
+    }
+    toHex(e = !0) {
+      return nt(this.toRawBytes(e));
+    }
+  }
+  y.BASE = new y(n.Gx, n.Gy, t.ONE), y.ZERO = new y(t.ZERO, t.ONE, t.ZERO);
+  const W = n.nBitLength, P = wt(y, n.endo ? Math.ceil(W / 2) : W);
+  return {
+    CURVE: n,
+    ProjectivePoint: y,
+    normPrivateKeyToScalar: L,
+    weierstrassEquation: O,
+    isWithinCurveOrder: F
+  };
+}
+function vt(B) {
+  const n = ft(B);
+  return lt(n, {
+    hash: "hash",
+    hmac: "function",
+    randomBytes: "function"
+  }, {
+    bits2int: "function",
+    bits2int_modN: "function",
+    lowS: "boolean"
+  }), Object.freeze({ lowS: !0, ...n });
+}
+function Ot(B) {
+  const n = vt(B), { Fp: t, n: v } = n, A = t.BYTES + 1, O = 2 * t.BYTES + 1;
+  function F(r) {
+    return C < r && r < t.ORDER;
+  }
+  function S(r) {
+    return ut(r, v);
+  }
+  function L(r) {
+    return ht(r, v);
+  }
+  const { ProjectivePoint: x, normPrivateKeyToScalar: U, weierstrassEquation: y, isWithinCurveOrder: W } = Bt({
+    ...n,
+    toBytes(r, o, l) {
+      const g = o.toAffine(), w = t.toBytes(g.x), R = et;
+      return l ? R(Uint8Array.from([o.hasEvenY() ? 2 : 3]), w) : R(Uint8Array.from([4]), w, t.toBytes(g.y));
+    },
+    fromBytes(r) {
+      const o = r.length, l = r[0], g = r.subarray(1);
+      if (o === A && (l === 2 || l === 3)) {
+        const w = _(g);
+        if (!F(w))
+          throw new Error("Point is not on curve");
+        const R = y(w);
+        let I = t.sqrt(R);
+        const N = (I & z) === z;
+        return (l & 1) === 1 !== N && (I = t.neg(I)), { x: w, y: I };
+      } else if (o === O && l === 4) {
+        const w = t.fromBytes(g.subarray(0, t.BYTES)), R = t.fromBytes(g.subarray(t.BYTES, 2 * t.BYTES));
+        return { x: w, y: R };
+      } else
+        throw new Error(`Point of length ${o} was invalid. Expected ${A} compressed bytes or ${O} uncompressed bytes`);
+    }
+  }), P = (r) => nt(rt(r, n.nByteLength));
+  function m(r) {
+    const o = v >> z;
+    return r > o;
+  }
+  function e(r) {
+    return m(r) ? S(-r) : r;
+  }
+  const i = (r, o, l) => _(r.slice(o, l));
+  class s {
+    constructor(o, l, g) {
+      this.r = o, this.s = l, this.recovery = g, this.assertValidity();
+    }
+    // pair (bytes of r, bytes of s)
+    static fromCompact(o) {
+      const l = n.nByteLength;
+      return o = Y("compactSignature", o, l * 2), new s(i(o, 0, l), i(o, l, 2 * l));
+    }
+    // DER encoded ECDSA signature
+    // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
+    static fromDER(o) {
+      const { r: l, s: g } = k.toSig(Y("DER", o));
+      return new s(l, g);
+    }
+    assertValidity() {
+      if (!W(this.r))
+        throw new Error("r must be 0 < r < CURVE.n");
+      if (!W(this.s))
+        throw new Error("s must be 0 < s < CURVE.n");
+    }
+    addRecoveryBit(o) {
+      return new s(this.r, this.s, o);
+    }
+    recoverPublicKey(o) {
+      const { r: l, s: g, recovery: w } = this, R = c(Y("msgHash", o));
+      if (w == null || ![0, 1, 2, 3].includes(w))
+        throw new Error("recovery id invalid");
+      const I = w === 2 || w === 3 ? l + n.n : l;
+      if (I >= t.ORDER)
+        throw new Error("recovery id 2 or 3 invalid");
+      const N = w & 1 ? "03" : "02", D = x.fromHex(N + P(I)), K = L(I), X = S(-R * K), J = S(g * K), $ = x.BASE.multiplyAndAddUnsafe(D, X, J);
+      if (!$)
+        throw new Error("point at infinify");
+      return $.assertValidity(), $;
+    }
+    // Signatures should be low-s, to prevent malleability.
+    hasHighS() {
+      return m(this.s);
+    }
+    normalizeS() {
+      return this.hasHighS() ? new s(this.r, S(-this.s), this.recovery) : this;
+    }
+    // DER-encoded
+    toDERRawBytes() {
+      return at(this.toDERHex());
+    }
+    toDERHex() {
+      return k.hexFromSig({ r: this.r, s: this.s });
+    }
+    // padded bytes of r, then padded bytes of s
+    toCompactRawBytes() {
+      return at(this.toCompactHex());
+    }
+    toCompactHex() {
+      return P(this.r) + P(this.s);
+    }
+  }
+  const u = {
+    isValidPrivateKey(r) {
+      try {
+        return U(r), !0;
+      } catch {
+        return !1;
+      }
+    },
+    normPrivateKeyToScalar: U,
+    /**
+     * Produces cryptographically secure private key from random of size (nBitLength+64)
+     * as per FIPS 186 B.4.1 with modulo bias being neglible.
+     */
+    randomPrivateKey: () => {
+      const r = n.randomBytes(t.BYTES + 8), o = dt(r, v);
+      return rt(o, n.nByteLength);
+    },
+    /**
+     * 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(r = 8, o = x.BASE) {
+      return o._setWindowSize(r), o.multiply(BigInt(3)), o;
+    }
+  };
+  function f(r, o = !0) {
+    return x.fromPrivateKey(r).toRawBytes(o);
+  }
+  function E(r) {
+    const o = r instanceof Uint8Array, l = typeof r == "string", g = (o || l) && r.length;
+    return o ? g === A || g === O : l ? g === 2 * A || g === 2 * O : r instanceof x;
+  }
+  function h(r, o, l = !0) {
+    if (E(r))
+      throw new Error("first arg must be private key");
+    if (!E(o))
+      throw new Error("second arg must be public key");
+    return x.fromHex(o).multiply(U(r)).toRawBytes(l);
+  }
+  const a = n.bits2int || function(r) {
+    const o = _(r), l = r.length * 8 - n.nBitLength;
+    return l > 0 ? o >> BigInt(l) : o;
+  }, c = n.bits2int_modN || function(r) {
+    return S(a(r));
+  }, d = yt(n.nBitLength);
+  function q(r) {
+    if (typeof r != "bigint")
+      throw new Error("bigint expected");
+    if (!(C <= r && r < d))
+      throw new Error(`bigint expected < 2^${n.nBitLength}`);
+    return rt(r, n.nByteLength);
+  }
+  function b(r, o, l = p) {
+    if (["recovered", "canonical"].some((j) => j in l))
+      throw new Error("sign() legacy options not supported");
+    const { hash: g, randomBytes: w } = n;
+    let { lowS: R, prehash: I, extraEntropy: N } = l;
+    R == null && (R = !0), r = Y("msgHash", r), I && (r = Y("prehashed msgHash", g(r)));
+    const D = c(r), K = U(o), X = [q(K), q(D)];
+    if (N != null) {
+      const j = N === !0 ? w(t.BYTES) : N;
+      X.push(Y("extraEntropy", j, t.BYTES));
+    }
+    const J = et(...X), $ = D;
+    function tt(j) {
+      const G = a(j);
+      if (!W(G))
+        return;
+      const ot = L(G), M = x.BASE.multiply(G).toAffine(), V = S(M.x);
+      if (V === C)
+        return;
+      const Q = S(ot * S($ + V * K));
+      if (Q === C)
+        return;
+      let st = (M.x === V ? 0 : 2) | Number(M.y & z), it = Q;
+      return R && m(Q) && (it = e(Q), st ^= 1), new s(V, it, st);
+    }
+    return { seed: J, k2sig: tt };
+  }
+  const p = { lowS: n.lowS, prehash: !1 }, T = { lowS: n.lowS, prehash: !1 };
+  function Z(r, o, l = p) {
+    const { seed: g, k2sig: w } = b(r, o, l), R = n;
+    return pt(R.hash.outputLen, R.nByteLength, R.hmac)(g, w);
+  }
+  x.BASE._setWindowSize(8);
+  function H(r, o, l, g = T) {
+    var M;
+    const w = r;
+    if (o = Y("msgHash", o), l = Y("publicKey", l), "strict" in g)
+      throw new Error("options.strict was renamed to lowS");
+    const { lowS: R, prehash: I } = g;
+    let N, D;
+    try {
+      if (typeof w == "string" || w instanceof Uint8Array)
+        try {
+          N = s.fromDER(w);
+        } catch (V) {
+          if (!(V instanceof k.Err))
+            throw V;
+          N = s.fromCompact(w);
+        }
+      else if (typeof w == "object" && typeof w.r == "bigint" && typeof w.s == "bigint") {
+        const { r: V, s: Q } = w;
+        N = new s(V, Q);
+      } else
+        throw new Error("PARSE");
+      D = x.fromHex(l);
+    } catch (V) {
+      if (V.message === "PARSE")
+        throw new Error("signature must be Signature instance, Uint8Array or hex string");
+      return !1;
+    }
+    if (R && N.hasHighS())
+      return !1;
+    I && (o = n.hash(o));
+    const { r: K, s: X } = N, J = c(o), $ = L(X), tt = S(J * $), j = S(K * $), G = (M = x.BASE.multiplyAndAddUnsafe(D, tt, j)) == null ? void 0 : M.toAffine();
+    return G ? S(G.x) === K : !1;
+  }
+  return {
+    CURVE: n,
+    getPublicKey: f,
+    getSharedSecret: h,
+    sign: Z,
+    verify: H,
+    ProjectivePoint: x,
+    Signature: s,
+    utils: u
+  };
+}
+export {
+  k as DER,
+  Ot as weierstrass,
+  Bt as weierstrassPoints
+};

package/dist/node_modules/@noble/curves/esm/secp256k1.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const C=require("../../hashes/esm/sha256.cjs");require("../../hashes/esm/utils.cjs");const n=require("./abstract/modular.cjs");require("./abstract/weierstrass.cjs");require("./abstract/utils.cjs");const F=require("./_shortw_utils.cjs");/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */const k=BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),x=BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),G=BigInt(1),u=BigInt(2),h=(t,f)=>(t+f/u)/f;function M(t){const f=k,c=BigInt(3),r=BigInt(6),B=BigInt(11),a=BigInt(22),s=BigInt(23),i=BigInt(44),d=BigInt(88),o=t*t*t%f,e=o*o*t%f,g=n.pow2(e,c,f)*e%f,b=n.pow2(g,c,f)*e%f,l=n.pow2(b,u,f)*o%f,I=n.pow2(l,B,f)*l%f,p=n.pow2(I,a,f)*I%f,_=n.pow2(p,i,f)*p%f,P=n.pow2(_,d,f)*_%f,S=n.pow2(P,i,f)*p%f,v=n.pow2(S,c,f)*e%f,E=n.pow2(v,s,f)*I%f,j=n.pow2(E,r,f)*o%f,q=n.pow2(j,u,f);if(!w.eql(w.sqr(q),t))throw new Error("Cannot find square root");return q}const w=n.Field(k,void 0,void 0,{sqrt:M}),m=F.createCurve({a:BigInt(0),b:BigInt(7),Fp:w,n:x,Gx:BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),Gy:BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),h:BigInt(1),lowS:!0,endo:{beta:BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),splitScalar:t=>{const f=x,c=BigInt("0x3086d221a7d46bcde86c90e49284eb15"),r=-G*BigInt("0xe4437ed6010e88286f547fa90abfe4c3"),B=BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"),a=c,s=BigInt("0x100000000000000000000000000000000"),i=h(a*t,f),d=h(-r*t,f);let o=n.mod(t-i*c-d*B,f),e=n.mod(-i*r-d*a,f);const g=o>s,b=e>s;if(g&&(o=f-o),b&&(e=f-e),o>s||e>s)throw new Error("splitScalar: Endomorphism failed, k="+t);return{k1neg:g,k1:o,k2neg:b,k2:e}}}},C.sha256);BigInt(0);m.ProjectivePoint;exports.secp256k1=m;

package/dist/node_modules/@noble/curves/esm/secp256k1.js

@@ -0,0 +1,47 @@
+import { sha256 as F } from "../../hashes/esm/sha256.js";
+import "../../hashes/esm/utils.js";
+import { Field as G, mod as w, pow2 as t } from "./abstract/modular.js";
+import "./abstract/weierstrass.js";
+import "./abstract/utils.js";
+import { createCurve as N } from "./_shortw_utils.js";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const q = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"), h = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"), j = BigInt(1), m = BigInt(2), k = (n, f) => (n + f / m) / f;
+function M(n) {
+  const f = q, e = BigInt(3), r = BigInt(6), I = BigInt(11), a = BigInt(22), s = BigInt(23), i = BigInt(44), g = BigInt(88), o = n * n * n % f, c = o * o * n % f, d = t(c, e, f) * c % f, B = t(d, e, f) * c % f, l = t(B, m, f) * o % f, b = t(l, I, f) * l % f, p = t(b, a, f) * b % f, x = t(p, i, f) * p % f, P = t(x, g, f) * x % f, v = t(P, i, f) * p % f, E = t(v, e, f) * c % f, S = t(E, s, f) * b % f, C = t(S, r, f) * o % f, u = t(C, m, f);
+  if (!_.eql(_.sqr(u), n))
+    throw new Error("Cannot find square root");
+  return u;
+}
+const _ = G(q, void 0, void 0, { sqrt: M }), O = N({
+  a: BigInt(0),
+  b: BigInt(7),
+  Fp: _,
+  n: h,
+  // Base point (x, y) aka generator point
+  Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
+  Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
+  h: BigInt(1),
+  lowS: !0,
+  /**
+   * 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: (n) => {
+      const f = h, e = BigInt("0x3086d221a7d46bcde86c90e49284eb15"), r = -j * BigInt("0xe4437ed6010e88286f547fa90abfe4c3"), I = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), a = e, s = BigInt("0x100000000000000000000000000000000"), i = k(a * n, f), g = k(-r * n, f);
+      let o = w(n - i * e - g * I, f), c = w(-i * r - g * a, f);
+      const d = o > s, B = c > s;
+      if (d && (o = f - o), B && (c = f - c), o > s || c > s)
+        throw new Error("splitScalar: Endomorphism failed, k=" + n);
+      return { k1neg: d, k1: o, k2neg: B, k2: c };
+    }
+  }
+}, F);
+BigInt(0);
+O.ProjectivePoint;
+export {
+  O as secp256k1
+};

package/dist/node_modules/@noble/hashes/esm/_assert.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});function o(e){if(!Number.isSafeInteger(e)||e<0)throw new Error(`Wrong positive integer: ${e}`)}function i(e){if(typeof e!="boolean")throw new Error(`Expected boolean, not ${e}`)}function r(e,...t){if(!(e instanceof Uint8Array))throw new Error("Expected Uint8Array");if(t.length>0&&!t.includes(e.length))throw new Error(`Expected Uint8Array of length ${t}, not of length=${e.length}`)}function u(e){if(typeof e!="function"||typeof e.create!="function")throw new Error("Hash should be wrapped by utils.wrapConstructor");o(e.outputLen),o(e.blockLen)}function s(e,t=!0){if(e.destroyed)throw new Error("Hash instance has been destroyed");if(t&&e.finished)throw new Error("Hash#digest() has already been called")}function f(e,t){r(e);const n=t.outputLen;if(e.length<n)throw new Error(`digestInto() expects output buffer of length at least ${n}`)}const a={number:o,bool:i,bytes:r,hash:u,exists:s,output:f};exports.bool=i;exports.bytes=r;exports.default=a;exports.exists=s;exports.hash=u;exports.number=o;exports.output=f;