@noble/curves 0.3.1 → 0.4.0

package/lib/weierstrass.d.ts

@@ -1,12 +1,9 @@
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import { BasicCurve, Hex, PrivKey, randomBytes as utilRandomBytes } from './utils.js';
+import * as mod from './modular.js';
+import { Hex, PrivKey } from './utils.js';
+import * as utils from './utils.js';
+import { htfOpts } from './hashToCurve.js';
 import { Group, GroupConstructor } from './group.js';
-export declare type CHash = {
-    (message: Uint8Array | string): Uint8Array;
-    blockLen: number;
-    outputLen: number;
-    create(): any;
-};
 declare type HmacFnSync = (key: Uint8Array, ...messages: Uint8Array[]) => Uint8Array;
 declare type EndomorphismOpts = {
     beta: bigint;
@@ -17,37 +14,19 @@ declare type EndomorphismOpts = {
         k2: bigint;
     };
 };
-export declare type CurveType = BasicCurve & {
-    a: bigint;
-    b: bigint;
-    lowS?: boolean;
-    hash: CHash;
-    hmac: HmacFnSync;
-    randomBytes?: (bytesLength?: number) => Uint8Array;
-    truncateHash?: (hash: Uint8Array, truncateOnly?: boolean) => bigint;
-    sqrtMod?: (n: bigint) => bigint;
+export declare type BasicCurve<T> = utils.BasicCurve<T> & {
+    a: T;
+    b: T;
     normalizePrivateKey?: (key: PrivKey) => PrivKey;
     endo?: EndomorphismOpts;
+    isTorsionFree?: (c: JacobianConstructor<T>, point: JacobianPointType<T>) => boolean;
+    clearCofactor?: (c: JacobianConstructor<T>, point: JacobianPointType<T>) => JacobianPointType<T>;
+    htfDefaults?: htfOpts;
+    mapToCurve?: (scalar: bigint[]) => {
+        x: T;
+        y: T;
+    };
 };
-declare function validateOpts(curve: CurveType): Readonly<{
-    readonly nBitLength: number;
-    readonly nByteLength: number;
-    readonly P: bigint;
-    readonly n: bigint;
-    readonly h: bigint;
-    readonly Gx: bigint;
-    readonly Gy: bigint;
-    readonly a: bigint;
-    readonly b: bigint;
-    lowS: boolean;
-    readonly hash: CHash;
-    readonly hmac: HmacFnSync;
-    randomBytes: typeof utilRandomBytes;
-    readonly truncateHash?: ((hash: Uint8Array, truncateOnly?: boolean | undefined) => bigint) | undefined;
-    readonly sqrtMod?: ((n: bigint) => bigint) | undefined;
-    readonly normalizePrivateKey?: ((key: PrivKey) => PrivKey) | undefined;
-    readonly endo?: EndomorphismOpts | undefined;
-}>;
 declare type Entropy = Hex | true;
 declare type SignOpts = {
     lowS?: boolean;
@@ -74,6 +53,58 @@ declare type SignOpts = {
  *
  * TODO: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-7.html#unique-symbol
  */
+export interface JacobianPointType<T> extends Group<JacobianPointType<T>> {
+    readonly x: T;
+    readonly y: T;
+    readonly z: T;
+    multiply(scalar: number | bigint, affinePoint?: PointType<T>): JacobianPointType<T>;
+    multiplyUnsafe(scalar: bigint): JacobianPointType<T>;
+    toAffine(invZ?: T): PointType<T>;
+}
+export interface JacobianConstructor<T> extends GroupConstructor<JacobianPointType<T>> {
+    new (x: T, y: T, z: T): JacobianPointType<T>;
+    fromAffine(p: PointType<T>): JacobianPointType<T>;
+    toAffineBatch(points: JacobianPointType<T>[]): PointType<T>[];
+    normalizeZ(points: JacobianPointType<T>[]): JacobianPointType<T>[];
+}
+export interface PointType<T> extends Group<PointType<T>> {
+    readonly x: T;
+    readonly y: T;
+    _setWindowSize(windowSize: number): void;
+    hasEvenY(): boolean;
+    toRawBytes(isCompressed?: boolean): Uint8Array;
+    toHex(isCompressed?: boolean): string;
+    assertValidity(): void;
+    multiplyAndAddUnsafe(Q: PointType<T>, a: bigint, b: bigint): PointType<T> | undefined;
+}
+export interface PointConstructor<T> extends GroupConstructor<PointType<T>> {
+    new (x: T, y: T): PointType<T>;
+    fromHex(hex: Hex): PointType<T>;
+    fromPrivateKey(privateKey: PrivKey): PointType<T>;
+    hashToCurve(msg: Hex, options?: Partial<htfOpts>): PointType<T>;
+    encodeToCurve(msg: Hex, options?: Partial<htfOpts>): PointType<T>;
+}
+export declare type CurvePointsType<T> = BasicCurve<T> & {
+    fromBytes: (bytes: Uint8Array) => {
+        x: T;
+        y: T;
+    };
+    toBytes: (c: PointConstructor<T>, point: PointType<T>, compressed: boolean) => Uint8Array;
+};
+export declare type CurvePointsRes<T> = {
+    Point: PointConstructor<T>;
+    JacobianPoint: JacobianConstructor<T>;
+    normalizePrivateKey: (key: PrivKey) => bigint;
+    weierstrassEquation: (x: T) => T;
+    isWithinCurveOrder: (num: bigint) => boolean;
+};
+export declare function weierstrassPoints<T>(opts: CurvePointsType<T>): {
+    Point: PointConstructor<T>;
+    JacobianPoint: JacobianConstructor<T>;
+    normalizePrivateKey: (key: PrivKey) => bigint;
+    weierstrassEquation: (x: T) => T;
+    isWithinCurveOrder: (num: bigint) => boolean;
+};
 export interface SignatureType {
     readonly r: bigint;
     readonly s: bigint;
@@ -82,7 +113,7 @@ export interface SignatureType {
     copyWithRecoveryBit(recovery: number): SignatureType;
     hasHighS(): boolean;
     normalizeS(): SignatureType;
-    recoverPublicKey(msgHash: Hex): PointType;
+    recoverPublicKey(msgHash: Hex): PointType<bigint>;
     toDERRawBytes(isCompressed?: boolean): Uint8Array;
     toDERHex(isCompressed?: boolean): string;
     toCompactRawBytes(): Uint8Array;
@@ -93,36 +124,42 @@ export declare type SignatureConstructor = {
     fromCompact(hex: Hex): SignatureType;
     fromDER(hex: Hex): SignatureType;
 };
-export interface JacobianPointType extends Group<JacobianPointType> {
-    readonly x: bigint;
-    readonly y: bigint;
-    readonly z: bigint;
-    multiply(scalar: number | bigint, affinePoint?: PointType): JacobianPointType;
-    multiplyUnsafe(scalar: bigint): JacobianPointType;
-    toAffine(invZ?: bigint): PointType;
-}
-export interface JacobianPointConstructor extends GroupConstructor<JacobianPointType> {
-    new (x: bigint, y: bigint, z: bigint): JacobianPointType;
-    fromAffine(p: PointType): JacobianPointType;
-    toAffineBatch(points: JacobianPointType[]): PointType[];
-    normalizeZ(points: JacobianPointType[]): JacobianPointType[];
-}
-export interface PointType extends Group<PointType> {
-    readonly x: bigint;
-    readonly y: bigint;
-    _setWindowSize(windowSize: number): void;
-    hasEvenY(): boolean;
-    toRawBytes(isCompressed?: boolean): Uint8Array;
-    toHex(isCompressed?: boolean): string;
-    assertValidity(): void;
-    multiplyAndAddUnsafe(Q: PointType, a: bigint, b: bigint): PointType | undefined;
-}
-export interface PointConstructor extends GroupConstructor<PointType> {
-    new (x: bigint, y: bigint): PointType;
-    fromHex(hex: Hex): PointType;
-    fromPrivateKey(privateKey: PrivKey): PointType;
-}
-export declare type PubKey = Hex | PointType;
+export declare type PubKey = Hex | PointType<bigint>;
+export declare type CurveType = BasicCurve<bigint> & {
+    lowS?: boolean;
+    hash: utils.CHash;
+    hmac: HmacFnSync;
+    randomBytes: (bytesLength?: number) => Uint8Array;
+    truncateHash?: (hash: Uint8Array, truncateOnly?: boolean) => bigint;
+};
+declare function validateOpts(curve: CurveType): Readonly<{
+    readonly nBitLength: number;
+    readonly nByteLength: number;
+    readonly Fp: mod.Field<bigint>;
+    readonly n: bigint;
+    readonly h: bigint;
+    readonly hEff?: bigint | undefined;
+    readonly Gx: bigint;
+    readonly Gy: bigint;
+    readonly wrapPrivateKey?: boolean | undefined;
+    readonly allowInfinityPoint?: boolean | undefined;
+    readonly a: bigint;
+    readonly b: bigint;
+    readonly normalizePrivateKey?: ((key: PrivKey) => PrivKey) | undefined;
+    readonly endo?: EndomorphismOpts | undefined;
+    readonly isTorsionFree?: ((c: JacobianConstructor<bigint>, point: JacobianPointType<bigint>) => boolean) | undefined;
+    readonly clearCofactor?: ((c: JacobianConstructor<bigint>, point: JacobianPointType<bigint>) => JacobianPointType<bigint>) | undefined;
+    readonly htfDefaults?: htfOpts | undefined;
+    readonly mapToCurve?: ((scalar: bigint[]) => {
+        x: bigint;
+        y: bigint;
+    }) | undefined;
+    lowS: boolean;
+    readonly hash: utils.CHash;
+    readonly hmac: HmacFnSync;
+    readonly randomBytes: (bytesLength?: number | undefined) => Uint8Array;
+    readonly truncateHash?: ((hash: Uint8Array, truncateOnly?: boolean | undefined) => bigint) | undefined;
+}>;
 export declare type CurveFn = {
     CURVE: ReturnType<typeof validateOpts>;
     getPublicKey: (privateKey: PrivKey, isCompressed?: boolean) => Uint8Array;
@@ -131,8 +168,8 @@ export declare type CurveFn = {
     verify: (signature: Hex | SignatureType, msgHash: Hex, publicKey: PubKey, opts?: {
         lowS?: boolean;
     }) => boolean;
-    Point: PointConstructor;
-    JacobianPoint: JacobianPointConstructor;
+    Point: PointConstructor<bigint>;
+    JacobianPoint: JacobianConstructor<bigint>;
     Signature: SignatureConstructor;
     utils: {
         mod: (a: bigint, b?: bigint) => bigint;
@@ -140,7 +177,7 @@ export declare type CurveFn = {
         _bigintToBytes: (num: bigint) => Uint8Array;
         _bigintToString: (num: bigint) => string;
         _normalizePrivateKey: (key: PrivKey) => bigint;
-        _normalizePublicKey: (publicKey: PubKey) => PointType;
+        _normalizePublicKey: (publicKey: PubKey) => PointType<bigint>;
         _isWithinCurveOrder: (num: bigint) => boolean;
         _isValidFieldElement: (num: bigint) => boolean;
         _weierstrassEquation: (x: bigint) => bigint;