@noble/curves 0.5.2 → 0.6.0

package/lib/abstract/{group.js → curve.js}

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wNAF = void 0;
+exports.validateAbsOpts = exports.wNAF = void 0;
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 // Abelian group utilities
+const modular_js_1 = require("./modular.js");
 const _0n = BigInt(0);
 const _1n = BigInt(1);
-// Not big, but pretty complex and it is easy to break stuff. To avoid too much copy paste
+// Elliptic curve multiplication of Point by scalar. Complicated and fragile. Uses wNAF method.
+// Windowed method is 10% faster, but takes 2x longer to generate & consumes 2x memory.
 function wNAF(c, bits) {
     const constTimeNegate = (condition, item) => {
         const neg = item.negate();
@@ -107,6 +109,41 @@ function wNAF(c, bits) {
             // which makes it less const-time: around 1 bigint multiply.
             return { p, f };
         },
+        wNAFCached(P, precomputesMap, n, transform) {
+            // @ts-ignore
+            const W = P._WINDOW_SIZE || 1;
+            // Calculate precomputes on a first run, reuse them after
+            let comp = precomputesMap.get(P);
+            if (!comp) {
+                comp = this.precomputeWindow(P, W);
+                if (W !== 1) {
+                    precomputesMap.set(P, transform(comp));
+                }
+            }
+            return this.wNAF(W, comp, n);
+        },
     };
 }
 exports.wNAF = wNAF;
+function validateAbsOpts(curve) {
+    (0, modular_js_1.validateField)(curve.Fp);
+    for (const i of ['n', 'h']) {
+        const val = curve[i];
+        if (typeof val !== 'bigint')
+            throw new Error(`Invalid curve param ${i}=${val} (${typeof val})`);
+    }
+    if (!curve.Fp.isValid(curve.Gx))
+        throw new Error('Invalid generator X coordinate Fp element');
+    if (!curve.Fp.isValid(curve.Gy))
+        throw new Error('Invalid generator Y coordinate Fp element');
+    for (const i of ['nBitLength', 'nByteLength']) {
+        const val = curve[i];
+        if (val === undefined)
+            continue; // Optional
+        if (!Number.isSafeInteger(val))
+            throw new Error(`Invalid param ${i}=${val} (${typeof val})`);
+    }
+    // Set defaults
+    return Object.freeze({ ...(0, modular_js_1.nLength)(curve.n, curve.nBitLength), ...curve });
+}
+exports.validateAbsOpts = validateAbsOpts;

package/lib/abstract/edwards.d.ts

@@ -1,13 +1,9 @@
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import * as mod from './modular.js';
-import * as ut from './utils.js';
-import { Hex, PrivKey } from './utils.js';
-import { Group, GroupConstructor } from './group.js';
-import { htfOpts } from './hash-to-curve.js';
-export declare type CurveType = ut.BasicCurve<bigint> & {
+import { FHash, Hex } from './utils.js';
+import { Group, GroupConstructor, AbstractCurve, AffinePoint } from './curve.js';
+export declare type CurveType = AbstractCurve<bigint> & {
     a: bigint;
     d: bigint;
-    hash: ut.CHash;
+    hash: FHash;
     randomBytes: (bytesLength?: number) => Uint8Array;
     adjustScalarBytes?: (bytes: Uint8Array) => Uint8Array;
     domain?: (data: Uint8Array, ctx: Uint8Array, phflag: boolean) => Uint8Array;
@@ -15,17 +11,13 @@ export declare type CurveType = ut.BasicCurve<bigint> & {
         isValid: boolean;
         value: bigint;
     };
-    preHash?: ut.CHash;
-    htfDefaults?: htfOpts;
-    mapToCurve?: (scalar: bigint[]) => {
-        x: bigint;
-        y: bigint;
-    };
+    preHash?: FHash;
+    mapToCurve?: (scalar: bigint[]) => AffinePoint<bigint>;
 };
 declare function validateOpts(curve: CurveType): Readonly<{
     readonly nBitLength: number;
     readonly nByteLength: number;
-    readonly Fp: mod.Field<bigint>;
+    readonly Fp: import("./modular.js").Field<bigint>;
     readonly n: bigint;
     readonly h: bigint;
     readonly hEff?: bigint | undefined;
@@ -35,7 +27,7 @@ declare function validateOpts(curve: CurveType): Readonly<{
     readonly allowInfinityPoint?: boolean | undefined;
     readonly a: bigint;
     readonly d: bigint;
-    readonly hash: ut.CHash;
+    readonly hash: FHash;
     readonly randomBytes: (bytesLength?: number | undefined) => Uint8Array;
     readonly adjustScalarBytes?: ((bytes: Uint8Array) => Uint8Array) | undefined;
     readonly domain?: ((data: Uint8Array, ctx: Uint8Array, phflag: boolean) => Uint8Array) | undefined;
@@ -43,75 +35,41 @@ declare function validateOpts(curve: CurveType): Readonly<{
         isValid: boolean;
         value: bigint;
     }) | undefined;
-    readonly preHash?: ut.CHash | undefined;
-    readonly htfDefaults?: htfOpts | undefined;
-    readonly mapToCurve?: ((scalar: bigint[]) => {
-        x: bigint;
-        y: bigint;
-    }) | undefined;
+    readonly preHash?: FHash | undefined;
+    readonly mapToCurve?: ((scalar: bigint[]) => AffinePoint<bigint>) | undefined;
 }>;
-export interface SignatureType {
-    readonly r: PointType;
-    readonly s: bigint;
-    assertValidity(): SignatureType;
-    toRawBytes(): Uint8Array;
-    toHex(): string;
-}
-export declare type SignatureConstructor = {
-    new (r: PointType, s: bigint): SignatureType;
-    fromHex(hex: Hex): SignatureType;
-};
-export interface ExtendedPointType extends Group<ExtendedPointType> {
-    readonly x: bigint;
-    readonly y: bigint;
-    readonly z: bigint;
-    readonly t: bigint;
-    multiply(scalar: number | bigint, affinePoint?: PointType): ExtendedPointType;
-    multiplyUnsafe(scalar: number | bigint): ExtendedPointType;
+export interface ExtPointType extends Group<ExtPointType> {
+    readonly ex: bigint;
+    readonly ey: bigint;
+    readonly ez: bigint;
+    readonly et: bigint;
+    assertValidity(): void;
+    multiply(scalar: bigint): ExtPointType;
+    multiplyUnsafe(scalar: bigint): ExtPointType;
     isSmallOrder(): boolean;
     isTorsionFree(): boolean;
-    toAffine(invZ?: bigint): PointType;
-    clearCofactor(): ExtendedPointType;
-}
-export interface ExtendedPointConstructor extends GroupConstructor<ExtendedPointType> {
-    new (x: bigint, y: bigint, z: bigint, t: bigint): ExtendedPointType;
-    fromAffine(p: PointType): ExtendedPointType;
-    toAffineBatch(points: ExtendedPointType[]): PointType[];
-    normalizeZ(points: ExtendedPointType[]): ExtendedPointType[];
-}
-export interface PointType extends Group<PointType> {
-    readonly x: bigint;
-    readonly y: bigint;
-    _setWindowSize(windowSize: number): void;
-    toRawBytes(isCompressed?: boolean): Uint8Array;
-    toHex(isCompressed?: boolean): string;
-    isTorsionFree(): boolean;
-    clearCofactor(): PointType;
+    clearCofactor(): ExtPointType;
+    toAffine(iz?: bigint): AffinePoint<bigint>;
 }
-export interface PointConstructor extends GroupConstructor<PointType> {
-    new (x: bigint, y: bigint): PointType;
-    fromHex(hex: Hex): PointType;
-    fromPrivateKey(privateKey: PrivKey): PointType;
-    hashToCurve(msg: Hex, options?: Partial<htfOpts>): PointType;
-    encodeToCurve(msg: Hex, options?: Partial<htfOpts>): PointType;
+export interface ExtPointConstructor extends GroupConstructor<ExtPointType> {
+    new (x: bigint, y: bigint, z: bigint, t: bigint): ExtPointType;
+    fromAffine(p: AffinePoint<bigint>): ExtPointType;
+    fromHex(hex: Hex): ExtPointType;
+    fromPrivateKey(privateKey: Hex): ExtPointType;
 }
-export declare type PubKey = Hex | PointType;
-export declare type SigType = Hex | SignatureType;
 export declare type CurveFn = {
     CURVE: ReturnType<typeof validateOpts>;
-    getPublicKey: (privateKey: PrivKey, isCompressed?: boolean) => Uint8Array;
+    getPublicKey: (privateKey: Hex) => Uint8Array;
     sign: (message: Hex, privateKey: Hex) => Uint8Array;
-    verify: (sig: SigType, message: Hex, publicKey: PubKey) => boolean;
-    Point: PointConstructor;
-    ExtendedPoint: ExtendedPointConstructor;
-    Signature: SignatureConstructor;
+    verify: (sig: Hex, message: Hex, publicKey: Hex) => boolean;
+    ExtendedPoint: ExtPointConstructor;
     utils: {
         randomPrivateKey: () => Uint8Array;
-        getExtendedPublicKey: (key: PrivKey) => {
+        getExtendedPublicKey: (key: Hex) => {
             head: Uint8Array;
             prefix: Uint8Array;
             scalar: bigint;
-            point: PointType;
+            point: ExtPointType;
             pointBytes: Uint8Array;
         };
     };