@noble/curves 1.8.0 → 1.8.1

package/src/abstract/weierstrass.ts

@@ -26,17 +26,25 @@
  */
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 import {
-  AffinePoint,
-  BasicCurve,
-  Group,
-  GroupConstructor,
+  type AffinePoint,
+  type BasicCurve,
+  type Group,
+  type GroupConstructor,
+  pippenger,
   validateBasic,
   wNAF,
-  pippenger,
 } from './curve.js';
-import * as mod from './modular.js';
+import {
+  Field,
+  type IField,
+  getMinHashLength,
+  invert,
+  mapHashToField,
+  mod,
+  validateField,
+} from './modular.js';
 import * as ut from './utils.js';
-import { CHash, Hex, PrivKey, ensureBytes, memoized, abool } from './utils.js';
+import { type CHash, type Hex, type PrivKey, abool, ensureBytes, memoized } from './utils.js';
 
 export type { AffinePoint };
 type HmacFnSync = (key: Uint8Array, ...messages: Uint8Array[]) => Uint8Array;
@@ -279,7 +287,7 @@ const _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3), _4n =
 export function weierstrassPoints<T>(opts: CurvePointsType<T>): CurvePointsRes<T> {
   const CURVE = validatePointOpts(opts);
   const { Fp } = CURVE; // All curves has same field / group length as for now, but they can differ
-  const Fn = mod.Field(CURVE.n, CURVE.nBitLength);
+  const Fn = Field(CURVE.n, CURVE.nBitLength);
 
   const toBytes =
     CURVE.toBytes ||
@@ -341,7 +349,7 @@ export function weierstrassPoints<T>(opts: CurvePointsType<T>): CurvePointsRes<T
         'invalid private key, expected hex or ' + nByteLength + ' bytes, got ' + typeof key
       );
     }
-    if (wrapPrivateKey) num = mod.mod(num, N); // disabled by default, enabled for BLS
+    if (wrapPrivateKey) num = mod(num, N); // disabled by default, enabled for BLS
     ut.aInRange('private key', num, _1n, N); // num in range [1..N-1]
     return num;
   }
@@ -815,10 +823,10 @@ export function weierstrass(curveDef: CurveType): CurveFn {
   const uncompressedLen = 2 * Fp.BYTES + 1; // e.g. 65 for 32
 
   function modN(a: bigint) {
-    return mod.mod(a, CURVE_ORDER);
+    return mod(a, CURVE_ORDER);
   }
   function invN(a: bigint) {
-    return mod.invert(a, CURVE_ORDER);
+    return invert(a, CURVE_ORDER);
   }
 
   const {
@@ -982,8 +990,8 @@ export function weierstrass(curveDef: CurveType): CurveFn {
      * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
      */
     randomPrivateKey: (): Uint8Array => {
-      const length = mod.getMinHashLength(CURVE.n);
-      return mod.mapHashToField(CURVE.randomBytes(length), CURVE.n);
+      const length = getMinHashLength(CURVE.n);
+      return mapHashToField(CURVE.randomBytes(length), CURVE.n);
     },
 
     /**
@@ -1245,7 +1253,7 @@ export function weierstrass(curveDef: CurveType): CurveFn {
  * @returns
  */
 export function SWUFpSqrtRatio<T>(
-  Fp: mod.IField<T>,
+  Fp: IField<T>,
   Z: T
 ): (u: T, v: T) => { isValid: boolean; value: T } {
   // Generic implementation
@@ -1320,14 +1328,14 @@ export function SWUFpSqrtRatio<T>(
  * https://www.rfc-editor.org/rfc/rfc9380#section-6.6.2
  */
 export function mapToCurveSimpleSWU<T>(
-  Fp: mod.IField<T>,
+  Fp: IField<T>,
   opts: {
     A: T;
     B: T;
     Z: T;
   }
 ): (u: T) => { x: T; y: T } {
-  mod.validateField(Fp);
+  validateField(Fp);
   if (!Fp.isValid(opts.A) || !Fp.isValid(opts.B) || !Fp.isValid(opts.Z))
     throw new Error('mapToCurveSimpleSWU: invalid opts');
   const sqrtRatio = SWUFpSqrtRatio(Fp, opts.Z);

package/src/bls12-381.ts

@@ -1,24 +1,3 @@
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import { sha256 } from '@noble/hashes/sha256';
-import { randomBytes } from '@noble/hashes/utils';
-import { bls, CurveFn } from './abstract/bls.js';
-import * as mod from './abstract/modular.js';
-import {
-  bitGet,
-  bitLen,
-  bytesToHex,
-  bytesToNumberBE,
-  concatBytes as concatB,
-  ensureBytes,
-  Hex,
-  numberToBytesBE,
-} from './abstract/utils.js';
-// Types
-import { isogenyMap } from './abstract/hash-to-curve.js';
-import { AffinePoint, mapToCurveSimpleSWU, ProjPointType } from './abstract/weierstrass.js';
-import { tower12, psiFrobenius } from './abstract/tower.js';
-import type { Fp, Fp2, Fp6, Fp12 } from './abstract/tower.js';
-
 /**
  * bls12-381 is pairing-friendly Barreto-Lynn-Scott elliptic curve construction allowing to:
  * * Construct zk-SNARKs at the ~120-bit security
@@ -58,11 +37,6 @@ import type { Fp, Fp2, Fp6, Fp12 } from './abstract/tower.js';
  * Basic math is done over finite fields over p.
  * More complicated math is done over polynominal extension fields.
  * To simplify calculations in Fp12, we construct extension tower:
- * - Fp₁₂ = Fp₆² => Fp₂³
- * - Fp(u) / (u² - β) where β = -1
- * - Fp₂(v) / (v³ - ξ) where ξ = u + 1
- * - Fp₆(w) / (w² - γ) where γ = v
- * Here goes constants && point encoding format
  *
  * Embedding degree (k): 12
  * Seed (X): -15132376222941642752
@@ -73,6 +47,10 @@ import type { Fp, Fp2, Fp6, Fp12 } from './abstract/tower.js';
  * Ate loop size: X
  *
  * ### Towers
+ * - Fp₁₂ = Fp₆² => Fp₂³
+ * - Fp(u) / (u² - β) where β = -1
+ * - Fp₂(v) / (v³ - ξ) where ξ = u + 1
+ * - Fp₆(w) / (w² - γ) where γ = v
  * - Fp²[u] = Fp/u²+1
  * - Fp⁶[v] = Fp²/v³-1-u
  * - Fp¹²[w] = Fp⁶/w²-v
@@ -80,6 +58,30 @@ import type { Fp, Fp2, Fp6, Fp12 } from './abstract/tower.js';
  * @todo construct bls & bn fp/fr from seed.
  * @module
  */
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+import { sha256 } from '@noble/hashes/sha256';
+import { randomBytes } from '@noble/hashes/utils';
+import { bls, type CurveFn } from './abstract/bls.js';
+import * as mod from './abstract/modular.js';
+import {
+  bitGet,
+  bitLen,
+  bytesToHex,
+  bytesToNumberBE,
+  concatBytes as concatB,
+  ensureBytes,
+  type Hex,
+  numberToBytesBE,
+} from './abstract/utils.js';
+// Types
+import { isogenyMap } from './abstract/hash-to-curve.js';
+import type { Fp, Fp12, Fp2, Fp6 } from './abstract/tower.js';
+import { psiFrobenius, tower12 } from './abstract/tower.js';
+import {
+  type AffinePoint,
+  mapToCurveSimpleSWU,
+  type ProjPointType,
+} from './abstract/weierstrass.js';
 
 // Be friendly to bad ECMAScript parsers by not using bigint literals
 // prettier-ignore

package/src/bn254.ts

@@ -46,23 +46,21 @@ Ate loop size: 6x+2
  */
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 import { sha256 } from '@noble/hashes/sha256';
-import { getHash } from './_shortw_utils.js';
-import { CurveFn, weierstrass } from './abstract/weierstrass.js';
 import { randomBytes } from '@noble/hashes/utils';
+import { getHash } from './_shortw_utils.js';
 import {
   bls,
-  CurveFn as BLSCurveFn,
-  PostPrecomputeFn,
-  PostPrecomputePointAddFn,
+  type CurveFn as BLSCurveFn,
+  type PostPrecomputeFn,
+  type PostPrecomputePointAddFn,
 } from './abstract/bls.js';
 import { Field } from './abstract/modular.js';
+import type { Fp, Fp12, Fp2, Fp6 } from './abstract/tower.js';
+import { psiFrobenius, tower12 } from './abstract/tower.js';
 import { bitGet, bitLen, notImplemented } from './abstract/utils.js';
-import { tower12, psiFrobenius } from './abstract/tower.js';
-// Types
-import type { Fp, Fp2, Fp6, Fp12 } from './abstract/tower.js';
+import { type CurveFn, weierstrass } from './abstract/weierstrass.js';
 // prettier-ignore
 const _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3);
-// prettier-ignore
 const _6n = BigInt(6);
 
 const BN_X = BigInt('4965661367192848881');

package/src/ed25519.ts

@@ -8,23 +8,22 @@
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 import { sha512 } from '@noble/hashes/sha512';
 import { concatBytes, randomBytes, utf8ToBytes } from '@noble/hashes/utils';
-import { AffinePoint, Group } from './abstract/curve.js';
-import { CurveFn, ExtPointType, twistedEdwards } from './abstract/edwards.js';
+import { type AffinePoint, type Group, pippenger } from './abstract/curve.js';
+import { type CurveFn, type ExtPointType, twistedEdwards } from './abstract/edwards.js';
 import {
   createHasher,
   expand_message_xmd,
-  htfBasicOpts,
-  HTFMethod,
+  type htfBasicOpts,
+  type HTFMethod,
 } from './abstract/hash-to-curve.js';
 import { Field, FpSqrtEven, isNegativeLE, mod, pow2 } from './abstract/modular.js';
-import { CurveFn as XCurveFn, montgomery } from './abstract/montgomery.js';
-import { pippenger } from './abstract/curve.js';
+import { montgomery, type CurveFn as XCurveFn } from './abstract/montgomery.js';
 import {
   bytesToHex,
   bytesToNumberLE,
   ensureBytes,
   equalBytes,
-  Hex,
+  type Hex,
   numberToBytesLE,
 } from './abstract/utils.js';
 

package/src/ed448.ts

@@ -9,23 +9,23 @@
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 import { shake256 } from '@noble/hashes/sha3';
 import { concatBytes, randomBytes, utf8ToBytes, wrapConstructor } from '@noble/hashes/utils';
-import { AffinePoint, Group } from './abstract/curve.js';
-import { CurveFn, ExtPointType, twistedEdwards } from './abstract/edwards.js';
+import type { AffinePoint, Group } from './abstract/curve.js';
+import { pippenger } from './abstract/curve.js';
+import { type CurveFn, type ExtPointType, twistedEdwards } from './abstract/edwards.js';
 import {
   createHasher,
   expand_message_xof,
-  htfBasicOpts,
-  HTFMethod,
+  type htfBasicOpts,
+  type HTFMethod,
 } from './abstract/hash-to-curve.js';
 import { Field, isNegativeLE, mod, pow2 } from './abstract/modular.js';
-import { CurveFn as XCurveFn, montgomery } from './abstract/montgomery.js';
-import { pippenger } from './abstract/curve.js';
+import { montgomery, type CurveFn as XCurveFn } from './abstract/montgomery.js';
 import {
   bytesToHex,
   bytesToNumberLE,
   ensureBytes,
   equalBytes,
-  Hex,
+  type Hex,
   numberToBytesLE,
 } from './abstract/utils.js';
 

package/src/index.ts

@@ -1,5 +1,17 @@
 /**
- * Audited & minimal JS implementation of elliptic curve cryptography. Check out individual modules.
+ * Audited & minimal JS implementation of elliptic curve cryptography.
  * @module
+ * @example
+```js
+import { secp256k1, schnorr } from '@noble/curves/secp256k1';
+import { ed25519, ed25519ph, ed25519ctx, x25519, RistrettoPoint } from '@noble/curves/ed25519';
+import { ed448, ed448ph, ed448ctx, x448 } from '@noble/curves/ed448';
+import { p256 } from '@noble/curves/p256';
+import { p384 } from '@noble/curves/p384';
+import { p521 } from '@noble/curves/p521';
+import { bls12_381 } from '@noble/curves/bls12-381';
+import { bn254 } from '@noble/curves/bn254';
+import { bytesToHex, hexToBytes, concatBytes, utf8ToBytes } from '@noble/curves/abstract/utils';
+```
  */
 throw new Error('root module cannot be imported: import submodules instead. Check out README');

package/src/jubjub.ts

@@ -8,7 +8,7 @@
 import { blake2s } from '@noble/hashes/blake2s';
 import { sha512 } from '@noble/hashes/sha512';
 import { concatBytes, randomBytes, utf8ToBytes } from '@noble/hashes/utils';
-import { CurveFn, ExtPointType, twistedEdwards } from './abstract/edwards.js';
+import { type CurveFn, type ExtPointType, twistedEdwards } from './abstract/edwards.js';
 import { Field } from './abstract/modular.js';
 
 export const jubjub: CurveFn = /* @__PURE__ */ twistedEdwards({

package/src/p256.ts

@@ -5,8 +5,8 @@
  */
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 import { sha256 } from '@noble/hashes/sha256';
-import { createCurve, CurveFnWithCreate } from './_shortw_utils.js';
-import { createHasher, HTFMethod } from './abstract/hash-to-curve.js';
+import { createCurve, type CurveFnWithCreate } from './_shortw_utils.js';
+import { createHasher, type HTFMethod } from './abstract/hash-to-curve.js';
 import { Field } from './abstract/modular.js';
 import { mapToCurveSimpleSWU } from './abstract/weierstrass.js';
 

package/src/p384.ts

@@ -5,8 +5,8 @@
  */
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 import { sha384 } from '@noble/hashes/sha512';
-import { createCurve, CurveFnWithCreate } from './_shortw_utils.js';
-import { createHasher, HTFMethod } from './abstract/hash-to-curve.js';
+import { createCurve, type CurveFnWithCreate } from './_shortw_utils.js';
+import { createHasher, type HTFMethod } from './abstract/hash-to-curve.js';
 import { Field } from './abstract/modular.js';
 import { mapToCurveSimpleSWU } from './abstract/weierstrass.js';
 

package/src/p521.ts

@@ -6,8 +6,8 @@
  */
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 import { sha512 } from '@noble/hashes/sha512';
-import { createCurve, CurveFnWithCreate } from './_shortw_utils.js';
-import { createHasher, HTFMethod } from './abstract/hash-to-curve.js';
+import { createCurve, type CurveFnWithCreate } from './_shortw_utils.js';
+import { createHasher, type HTFMethod } from './abstract/hash-to-curve.js';
 import { Field } from './abstract/modular.js';
 import { mapToCurveSimpleSWU } from './abstract/weierstrass.js';
 

package/src/pasta.ts

@@ -6,7 +6,7 @@
 import { sha256 } from '@noble/hashes/sha256';
 import { getHash } from './_shortw_utils.js';
 import { Field, mod } from './abstract/modular.js';
-import { CurveFn, weierstrass } from './abstract/weierstrass.js';
+import { type CurveFn, weierstrass } from './abstract/weierstrass.js';
 
 export const p: bigint = BigInt(
   '0x40000000000000000000000000000000224698fc094cf91b992d30ed00000001'

package/src/secp256k1.ts

@@ -13,19 +13,19 @@
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 import { sha256 } from '@noble/hashes/sha256';
 import { randomBytes } from '@noble/hashes/utils';
-import { createCurve, CurveFnWithCreate } from './_shortw_utils.js';
-import { createHasher, HTFMethod, isogenyMap } from './abstract/hash-to-curve.js';
+import { createCurve, type CurveFnWithCreate } from './_shortw_utils.js';
+import { createHasher, type HTFMethod, isogenyMap } from './abstract/hash-to-curve.js';
 import { Field, mod, pow2 } from './abstract/modular.js';
 import type { Hex, PrivKey } from './abstract/utils.js';
 import {
-  inRange,
   aInRange,
   bytesToNumberBE,
   concatBytes,
   ensureBytes,
+  inRange,
   numberToBytesBE,
 } from './abstract/utils.js';
-import { ProjPointType as PointType, mapToCurveSimpleSWU } from './abstract/weierstrass.js';
+import { mapToCurveSimpleSWU, type ProjPointType as PointType } from './abstract/weierstrass.js';
 
 const secp256k1P = BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f');
 const secp256k1N = BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141');