API

Links: API, Interfaces, Classes, Functions, Types, Enums, Variables

Interfaces

Interface: JacobianPointBI

export interface JacobianPointBI {
    X: bigint;
    Y: bigint;
    Z: bigint;
}

Links: API, Interfaces, Classes, Functions, Types, Enums, Variables

Classes

Links: API, Interfaces, Classes, Functions, Types, Enums, Variables

Class: BasePoint

Base class for Point (affine coordinates) and JacobianPoint classes, defining their curve and type.

export default abstract class BasePoint {
    curve: Curve;
    type: "affine" | "jacobian";
    precomputed: {
        doubles?: {
            step: number;
            points: BasePoint[];
        };
        naf?: {
            wnd: number;
            points: BasePoint[];
        };
        beta?: BasePoint | null;
    } | null;
    constructor(type: "affine" | "jacobian") 
}

See also: Curve

Links: API, Interfaces, Classes, Functions, Types, Enums, Variables

Class: BigNumber

JavaScript numbers are only precise up to 53 bits. Since Bitcoin relies on 256-bit cryptography, this BigNumber class enables operations on larger numbers.

export default class BigNumber {
    public static readonly zeros: string[] 
    static readonly groupSizes: number[] 
    static readonly groupBases: number[] 
    static readonly wordSize: number = 26;
    public red: ReductionContext | null;
    public get negative(): number 
    public set negative(val: number) 
    public get words(): number[] 
    public set words(newWords: number[]) 
    public get length(): number 
    static isBN(num: any): boolean 
    static max(left: BigNumber, right: BigNumber): BigNumber 
    static min(left: BigNumber, right: BigNumber): BigNumber 
    constructor(number: number | string | number[] | bigint | undefined = 0, base: number | "be" | "le" | "hex" = 10, endian: "be" | "le" = "be") 
    copy(dest: BigNumber): void 
    static move(dest: BigNumber, src: BigNumber): void 
    clone(): BigNumber 
    expand(size: number): this 
    strip(): this 
    normSign(): this { if (this._magnitude === 0n)
        this._sign = 0; return this; }
    inspect(): string 
    toString(base: number | "hex" = 10, padding: number = 1): string 
    toNumber(): number 
    toJSON(): string 
    toArray(endian: "le" | "be" = "be", length?: number): number[] 
    bitLength(): number { if (this._magnitude === 0n)
        return 0; return this._magnitude.toString(2).length; }
    static toBitArray(num: BigNumber): Array<0 | 1> 
    toBitArray(): Array<0 | 1> 
    zeroBits(): number 
    byteLength(): number { if (this._magnitude === 0n)
        return 0; return Math.ceil(this.bitLength() / 8); }
    toTwos(width: number): BigNumber 
    fromTwos(width: number): BigNumber 
    isNeg(): boolean 
    neg(): BigNumber 
    ineg(): this { if (this._magnitude !== 0n)
        this._sign = this._sign === 1 ? 0 : 1; return this; }
    iuor(num: BigNumber): this 
    iuand(num: BigNumber): this 
    iuxor(num: BigNumber): this 
    ior(num: BigNumber): this 
    iand(num: BigNumber): this 
    ixor(num: BigNumber): this 
    or(num: BigNumber): BigNumber 
    uor(num: BigNumber): BigNumber 
    and(num: BigNumber): BigNumber 
    uand(num: BigNumber): BigNumber 
    xor(num: BigNumber): BigNumber 
    uxor(num: BigNumber): BigNumber 
    inotn(width: number): this 
    notn(width: number): BigNumber 
    setn(bit: number, val: any): this { this.assert(typeof bit === "number" && bit >= 0); const Bb = BigInt(bit); if (val === 1 || val === true)
        this._magnitude |= (1n << Bb);
    else
        this._magnitude &= ~(1n << Bb); const wnb = Math.floor(bit / BigNumber.wordSize) + 1; this._nominalWordLength = Math.max(this._nominalWordLength, wnb); this._finishInitialization(); return this.strip(); }
    iadd(num: BigNumber): this 
    add(num: BigNumber): BigNumber 
    isub(num: BigNumber): this 
    sub(num: BigNumber): BigNumber 
    mul(num: BigNumber): BigNumber 
    imul(num: BigNumber): this 
    imuln(num: number): this 
    muln(num: number): BigNumber 
    sqr(): BigNumber 
    isqr(): this 
    pow(num: BigNumber): BigNumber 
    iushln(bits: number): this { this.assert(typeof bits === "number" && bits >= 0); if (bits === 0)
        return this; this._magnitude <<= BigInt(bits); this._finishInitialization(); return this.strip(); }
    ishln(bits: number): this 
    iushrn(bits: number, hint?: number, extended?: BigNumber): this 
    ishrn(bits: number, hint?: number, extended?: BigNumber): this 
    shln(bits: number): BigNumber 
    ushln(bits: number): BigNumber 
    shrn(bits: number): BigNumber 
    ushrn(bits: number): BigNumber 
    testn(bit: number): boolean 
    imaskn(bits: number): this 
    maskn(bits: number): BigNumber 
    iaddn(num: number): this 
    _iaddn(num: number): this 
    isubn(num: number): this 
    addn(num: number): BigNumber 
    subn(num: number): BigNumber 
    iabs(): this 
    abs(): BigNumber 
    divmod(num: BigNumber, mode?: "div" | "mod", positive?: boolean): any 
    div(num: BigNumber): BigNumber 
    mod(num: BigNumber): BigNumber 
    umod(num: BigNumber): BigNumber 
    divRound(num: BigNumber): BigNumber 
    modrn(numArg: number): number 
    idivn(num: number): this 
    divn(num: number): BigNumber 
    egcd(p: BigNumber): {
        a: BigNumber;
        b: BigNumber;
        gcd: BigNumber;
    } 
    gcd(num: BigNumber): BigNumber 
    invm(num: BigNumber): BigNumber 
    isEven(): boolean 
    isOdd(): boolean 
    andln(num: number): number 
    bincn(bit: number): this 
    isZero(): boolean 
    cmpn(num: number): 1 | 0 | -1 { this.assert(Math.abs(num) <= BigNumber.MAX_IMULN_ARG, "Number is too big"); const tV = this._getSignedValue(); const nV = BigInt(num); if (tV < nV)
        return -1; if (tV > nV)
        return 1; return 0; }
    cmp(num: BigNumber): 1 | 0 | -1 { const tV = this._getSignedValue(); const nV = num._getSignedValue(); if (tV < nV)
        return -1; if (tV > nV)
        return 1; return 0; }
    ucmp(num: BigNumber): 1 | 0 | -1 { if (this._magnitude < num._magnitude)
        return -1; if (this._magnitude > num._magnitude)
        return 1; return 0; }
    gtn(num: number): boolean 
    gt(num: BigNumber): boolean 
    gten(num: number): boolean 
    gte(num: BigNumber): boolean 
    ltn(num: number): boolean 
    lt(num: BigNumber): boolean 
    lten(num: number): boolean 
    lte(num: BigNumber): boolean 
    eqn(num: number): boolean 
    eq(num: BigNumber): boolean 
    toRed(ctx: ReductionContext): BigNumber 
    fromRed(): BigNumber 
    forceRed(ctx: ReductionContext): this 
    redAdd(num: BigNumber): BigNumber 
    redIAdd(num: BigNumber): BigNumber 
    redSub(num: BigNumber): BigNumber 
    redISub(num: BigNumber): BigNumber 
    redShl(num: number): BigNumber 
    redMul(num: BigNumber): BigNumber 
    redIMul(num: BigNumber): BigNumber 
    redSqr(): BigNumber 
    redISqr(): BigNumber 
    redSqrt(): BigNumber 
    redInvm(): BigNumber 
    redNeg(): BigNumber 
    redPow(num: BigNumber): BigNumber 
    static fromHex(hex: string, endian?: "le" | "be" | "little" | "big"): BigNumber 
    toHex(byteLength: number = 0): string 
    static fromJSON(str: string): BigNumber 
    static fromNumber(n: number): BigNumber 
    static fromString(str: string, base?: number | "hex"): BigNumber 
    static fromSm(bytes: number[], endian: "big" | "little" = "big"): BigNumber 
    toSm(endian: "big" | "little" = "big"): number[] 
    static fromBits(bits: number, strict: boolean = false): BigNumber 
    toBits(): number 
    static fromScriptNum(num: number[], requireMinimal: boolean = false, maxNumSize?: number): BigNumber 
    toScriptNum(): number[] 
    _invmp(p: BigNumber): BigNumber 
    mulTo(num: BigNumber, out: BigNumber): BigNumber 
}

See also: ReductionContext, red, toArray, toHex

Constructor

constructor(number: number | string | number[] | bigint | undefined = 0, base: number | "be" | "le" | "hex" = 10, endian: "be" | "le" = "be") 

Argument Details

• number
• The number (various types accepted) to construct a BigNumber from. Default is 0.
• base
• The base of number provided. By default is 10.
• endian
• The endianness provided. By default is 'big endian'.

Property red

Reduction context of the big number.

public red: ReductionContext | null

Property wordSize

The word size of big number chunks.

static readonly wordSize: number = 26

Example

console.log(BigNumber.wordSize);  // output: 26

Method _invmp

Compute the multiplicative inverse of the current BigNumber in the modulus field specified by p. The multiplicative inverse is a number which when multiplied with the current BigNumber gives '1' in the modulus field.

_invmp(p: BigNumber): BigNumber 

Returns

The multiplicative inverse BigNumber in the modulus field specified by p.

Argument Details

• p
• The BigNumber specifying the modulus field.

Method bitLength

Calculates the number of bits required to represent the BigNumber.

bitLength(): number { if (this._magnitude === 0n)
    return 0; return this._magnitude.toString(2).length; }

Returns

The bit length of the BigNumber.

Method byteLength

Calculates the number of bytes required to represent the BigNumber.

byteLength(): number { if (this._magnitude === 0n)
    return 0; return Math.ceil(this.bitLength() / 8); }

Returns

The byte length of the BigNumber.

Method fromBits

Creates a BigNumber from a number representing the "bits" value in a block header.

static fromBits(bits: number, strict: boolean = false): BigNumber 

Returns

Returns a BigNumber equivalent to the "bits" value in a block header.

Argument Details

• bits
• The number representing the bits value in a block header.
• strict
• If true, an error is thrown if the number has negative bit set.

Throws

Will throw an error if strict is true and the number has negative bit set.

Method fromHex

Creates a BigNumber from a hexadecimal string.

static fromHex(hex: string, endian?: "le" | "be" | "little" | "big"): BigNumber 

Returns

Returns a BigNumber created from the hexadecimal input string.

Argument Details

• hex
• The hexadecimal string to create a BigNumber from.
• endian
• Optional endianness for parsing the hex string.

Example

const exampleHex = 'a1b2c3';
const bigNumber = BigNumber.fromHex(exampleHex);

Method fromJSON

Creates a BigNumber from a JSON-serialized string.

static fromJSON(str: string): BigNumber 

Returns

Returns a BigNumber created from the JSON input string.

Argument Details

• str
• The JSON-serialized string to create a BigNumber from.

Method fromNumber

Creates a BigNumber from a number.

static fromNumber(n: number): BigNumber 

Returns

Returns a BigNumber equivalent to the input number.

Argument Details

• n
• The number to create a BigNumber from.

Method fromScriptNum

Creates a BigNumber from the format used in Bitcoin scripts.

static fromScriptNum(num: number[], requireMinimal: boolean = false, maxNumSize?: number): BigNumber 

Returns

Returns a BigNumber equivalent to the number used in a Bitcoin script.

Argument Details

• num
• The number in the format used in Bitcoin scripts.
• requireMinimal
• If true, non-minimally encoded values will throw an error.
• maxNumSize
• The maximum allowed size for the number.

Method fromSm

Creates a BigNumber from a signed magnitude number.

static fromSm(bytes: number[], endian: "big" | "little" = "big"): BigNumber 

Returns

Returns a BigNumber equivalent to the signed magnitude number interpreted with specified endianess.

Argument Details

• bytes
• The signed magnitude number to convert to a BigNumber.
• endian
• Defines endianess. If not provided, big endian is assumed.

Method fromString

Creates a BigNumber from a string, considering an optional base.

static fromString(str: string, base?: number | "hex"): BigNumber 

Returns

Returns a BigNumber equivalent to the string after conversion from the specified base.

Argument Details

• str
• The string to create a BigNumber from.
• base
• The base used for conversion. If not provided, base 10 is assumed.

Method isBN

Checks whether a value is an instance of BigNumber. Regular JS numbers fail this check.

static isBN(num: any): boolean 

Returns

• Returns a boolean value determining whether or not the checked num parameter is a BigNumber.

Argument Details

• num
• The value to be checked.

Method max

Returns the bigger value between two BigNumbers

static max(left: BigNumber, right: BigNumber): BigNumber 

Returns

• Returns the bigger BigNumber between left and right.

Argument Details

• left
• The first BigNumber to be compared.
• right
• The second BigNumber to be compared.

Method min

Returns the smaller value between two BigNumbers

static min(left: BigNumber, right: BigNumber): BigNumber 

Returns

• Returns the smaller value between left and right.

Argument Details

• left
• The first BigNumber to be compared.
• right
• The second BigNumber to be compared.

Method mulTo

Performs multiplication between the BigNumber instance and a given BigNumber. It chooses the multiplication method based on the lengths of the numbers to optimize execution time.

mulTo(num: BigNumber, out: BigNumber): BigNumber 

Returns

The BigNumber resulting from the multiplication operation.

Argument Details

• num
• The BigNumber multiply with.
• out
• The BigNumber where to store the result.

Method toArray

Converts the BigNumber instance to an array of bytes.

toArray(endian: "le" | "be" = "be", length?: number): number[] 

Returns

Array of bytes representing the BigNumber.

Argument Details

• endian
• Endianness of the output array, defaults to 'be'.
• length
• Optional length of the output array.

Method toBitArray

Converts a BigNumber to an array of bits.

static toBitArray(num: BigNumber): Array<0 | 1> 

Returns

An array of bits.

Argument Details

• num
• The BigNumber to convert.

Method toBits

Converts this BigNumber to a number representing the "bits" value in a block header.

toBits(): number 

Returns

Returns a number equivalent to the "bits" value in a block header.

Method toHex

Converts this BigNumber to a hexadecimal string.

toHex(byteLength: number = 0): string 

Returns

Returns a string representing the hexadecimal value of this BigNumber.

Argument Details

• length
• The minimum length of the hex string

Example

const bigNumber = new BigNumber(255)
const hex = bigNumber.toHex()

Method toJSON

Converts the BigNumber instance to a JSON-formatted string.

toJSON(): string 

Returns

The JSON string representation of the BigNumber instance.

Method toNumber

Converts the BigNumber instance to a JavaScript number. Please note that JavaScript numbers are only precise up to 53 bits.

toNumber(): number 

Returns

The JavaScript number representation of the BigNumber instance.

Throws

If the BigNumber instance cannot be safely stored in a JavaScript number

Method toScriptNum

Converts this BigNumber to a number in the format used in Bitcoin scripts.

toScriptNum(): number[] 

Returns

Returns the equivalent to this BigNumber as a Bitcoin script number.

Method toSm

Converts this BigNumber to a signed magnitude number.

toSm(endian: "big" | "little" = "big"): number[] 

Returns

Returns an array equivalent to this BigNumber interpreted as a signed magnitude with specified endianess.

Argument Details

• endian
• Defines endianess. If not provided, big endian is assumed.

Method toString

function toString() { [native code] }

Converts the BigNumber instance to a string representation.

toString(base: number | "hex" = 10, padding: number = 1): string 

Returns

The string representation of the BigNumber instance

Argument Details

• base
• The base for representing number. Default is 10. Other accepted values are 16 and 'hex'.
• padding
• Represents the minimum number of digits to represent the BigNumber as a string. Default is 1.

Method zeroBits

Returns the number of trailing zero bits in the big number.

zeroBits(): number 

Returns

Returns the number of trailing zero bits in the binary representation of the big number.

Example

const bn = new BigNumber('8'); // binary: 1000
const zeroBits = bn.zeroBits(); // 3

Links: API, Interfaces, Classes, Functions, Types, Enums, Variables

Class: Curve

export default class Curve {
    p: BigNumber;
    red: ReductionContext;
    redN: BigNumber | null;
    zero: BigNumber;
    one: BigNumber;
    two: BigNumber;
    g: Point;
    n: BigNumber;
    a: BigNumber;
    b: BigNumber;
    tinv: BigNumber;
    zeroA: boolean;
    threeA: boolean;
    endo: {
        beta: BigNumber;
        lambda: BigNumber;
        basis: Array<{
            a: BigNumber;
            b: BigNumber;
        }>;
    } | undefined;
    _endoWnafT1: BigNumber[];
    _endoWnafT2: BigNumber[];
    _wnafT1: BigNumber[];
    _wnafT2: BigNumber[];
    _wnafT3: BigNumber[];
    _wnafT4: BigNumber[];
    _bitLength: number;
    static assert(expression: unknown, message: string = "Elliptic curve assertion failed"): void 
    getNAF(num: BigNumber, w: number, bits: number): number[] 
    getJSF(k1: BigNumber, k2: BigNumber): number[][] 
    static cachedProperty(obj, name: string, computer): void 
    static parseBytes(bytes: string | number[]): number[] 
    static intFromLE(bytes: number[]): BigNumber 
    constructor() 
    _getEndomorphism(conf): {
        beta: BigNumber;
        lambda: BigNumber;
        basis: Array<{
            a: BigNumber;
            b: BigNumber;
        }>;
    } | undefined 
    _getEndoRoots(num: BigNumber): [
        BigNumber,
        BigNumber
    ] 
    _getEndoBasis(lambda: BigNumber): [
        {
            a: BigNumber;
            b: BigNumber;
        },
        {
            a: BigNumber;
            b: BigNumber;
        }
    ] 
    _endoSplit(k: BigNumber): {
        k1: BigNumber;
        k2: BigNumber;
    } 
    validate(point: Point): boolean 
}

See also: BigNumber, Point, ReductionContext, red

Links: API, Interfaces, Classes, Functions, Types, Enums, Variables

Class: DRBG

This class behaves as a HMAC-based deterministic random bit generator (DRBG). It implements a deterministic random number generator using SHA256HMAC HASH function. It takes an initial entropy and nonce when instantiated for seeding purpose.

Example

const drbg = new DRBG('af12de...', '123ef...');

export default class DRBG {
    K: number[];
    V: number[];
    constructor(entropy: number[] | string, nonce: number[] | string) 
    hmac(): SHA256HMAC 
    update(seed?): void 
    generate(len: number): string 
}

See also: SHA256HMAC

Method generate

Generates deterministic random hexadecimal string of given length. In every generation process, it also updates the internal state K and V.

generate(len: number): string 

Returns

The required deterministic random hexadecimal string.

Argument Details

• len
• The length of required random number.

Example

const randomHex = drbg.generate(256);

Method hmac

Generates HMAC using the K value of the instance. This method is used internally for operations.

hmac(): SHA256HMAC 

Returns

The SHA256HMAC object created with K value.

Example

const hmac = drbg.hmac();

Method update

Updates the K and V values of the instance based on the seed. The seed if not provided uses V as seed.

update(seed?): void 

Returns

Nothing, but updates the internal state K and V value.

Argument Details

• seed
• an optional value that used to update K and V. Default is undefined.

Example

drbg.update('e13af...');

Links: API, Interfaces, Classes, Functions, Types, Enums, Variables

Class: JacobianPoint

The JacobianPoint class extends the BasePoint class for handling Jacobian coordinates on an Elliptic Curve. This class defines the properties and the methods needed to work with points in Jacobian coordinates.

The Jacobian coordinates represent a point (x, y, z) on an Elliptic Curve such that the usual (x, y) coordinates are given by (x/z^2, y/z^3).

Example

const pointJ = new JacobianPoint('3', '4', '1');

export default class JacobianPoint extends BasePoint {
    x: BigNumber;
    y: BigNumber;
    z: BigNumber;
    zOne: boolean;
    constructor(x: string | BigNumber | null, y: string | BigNumber | null, z: string | BigNumber | null) 
    toP(): Point 
    neg(): JacobianPoint 
    add(p: JacobianPoint): JacobianPoint 
    mixedAdd(p: Point): JacobianPoint 
    dblp(pow: number): JacobianPoint 
    dbl(): JacobianPoint 
    eq(p: Point | JacobianPoint): boolean 
    eqXToP(x: BigNumber): boolean 
    inspect(): string 
    isInfinity(): boolean 
}

See also: BasePoint, BigNumber, Point

Constructor

Constructs a new JacobianPoint instance.

constructor(x: string | BigNumber | null, y: string | BigNumber | null, z: string | BigNumber | null) 

Argument Details

• x
• If null, the x-coordinate will default to the curve's defined 'one' constant. If x is not a BigNumber, x will be converted to a BigNumber assuming it is a hex string.
• y
• If null, the y-coordinate will default to the curve's defined 'one' constant. If y is not a BigNumber, y will be converted to a BigNumber assuming it is a hex string.
• z
• If null, the z-coordinate will default to 0. If z is not a BigNumber, z will be converted to a BigNumber assuming it is a hex string.

Example

const pointJ1 = new JacobianPoint(null, null, null); // creates point at infinity
const pointJ2 = new JacobianPoint('3', '4', '1'); // creates point (3, 4, 1)

Property x

The x coordinate of the point in the Jacobian form.

x: BigNumber

Property y

The y coordinate of the point in the Jacobian form.

y: BigNumber

Property z

The z coordinate of the point in the Jacobian form.

z: BigNumber

Property zOne

Flag that indicates if the z coordinate is one.

zOne: boolean

Method add

Addition operation in the Jacobian coordinates. It takes a Jacobian point as an argument and returns a new Jacobian point as a result of the addition. In the special cases, when either one of the points is the point at infinity, it will return the other point.

add(p: JacobianPoint): JacobianPoint 

Returns

Returns a new Jacobian point as the result of the addition.

Argument Details

• p
• The Jacobian point to be added.

Example

const p1 = new JacobianPoint(x1, y1, z1)
const p2 = new JacobianPoint(x2, y2, z2)
const result = p1.add(p2)

Method dbl

Point doubling operation in the Jacobian coordinates. A special case is when the point is the point at infinity, in this case, this function will return the point itself.

dbl(): JacobianPoint 

Returns

Returns a new Jacobian point as the result of the doubling.

Example

const jp = new JacobianPoint(x, y, z)
const result = jp.dbl()

Method dblp

Multiple doubling operation. It doubles the Jacobian point as many times as the pow parameter specifies. If pow is 0 or the point is the point at infinity, it will return the point itself.

dblp(pow: number): JacobianPoint 

Returns

Returns a new Jacobian point as the result of multiple doublings.

Argument Details

• pow
• The number of times the point should be doubled.

Example

const jp = new JacobianPoint(x, y, z)
const result = jp.dblp(3)

Method eq

Equality check operation. It checks whether the affine or Jacobian point is equal to this Jacobian point.

eq(p: Point | JacobianPoint): boolean 

Returns

Returns true if the points are equal, otherwise returns false.

Argument Details

• p
• The affine or Jacobian point to compare with.

Example

const jp1 = new JacobianPoint(x1, y1, z1)
const jp2 = new JacobianPoint(x2, y2, z2)
const areEqual = jp1.eq(jp2)

Method eqXToP

Equality check operation in relation to an x coordinate of a point in projective coordinates. It checks whether the x coordinate of the Jacobian point is equal to the provided x coordinate of a point in projective coordinates.

eqXToP(x: BigNumber): boolean 

Returns

Returns true if the x coordinates are equal, otherwise returns false.

Argument Details

• x
• The x coordinate of a point in projective coordinates.

Example

const jp = new JacobianPoint(x1, y1, z1)
const isXEqual = jp.eqXToP(x2)

Method inspect

Returns the string representation of the JacobianPoint instance.

inspect(): string 

Returns

Returns the string description of the JacobianPoint. If the JacobianPoint represents a point at infinity, the return value of this function is ''. For a normal point, it returns the string description format as ''.

Example

const point = new JacobianPoint('5', '6', '1');
console.log(point.inspect()); // Output: '<EC JPoint x: 5 y: 6 z: 1>'

Method isInfinity

Checks whether the JacobianPoint instance represents a point at infinity.

isInfinity(): boolean 

Returns

Returns true if the JacobianPoint's z-coordinate equals to zero (which represents the point at infinity in Jacobian coordinates). Returns false otherwise.

Example

const point = new JacobianPoint('5', '6', '0');
console.log(point.isInfinity()); // Output: true

Method mixedAdd

Mixed addition operation. This function combines the standard point addition with the transformation from the affine to Jacobian coordinates. It first converts the affine point to Jacobian, and then preforms the addition.

mixedAdd(p: Point): JacobianPoint 

Returns

Returns the result of the mixed addition as a new Jacobian point.

Argument Details

• p
• The affine point to be added.

Example

const jp = new JacobianPoint(x1, y1, z1)
const ap = new Point(x2, y2)
const result = jp.mixedAdd(ap)

Method neg

Negation operation. It returns the additive inverse of the Jacobian point.

neg(): JacobianPoint 

Returns

Returns a new Jacobian point as the result of the negation.

Example

const jp = new JacobianPoint(x, y, z)
const result = jp.neg()

Method toP

Converts the JacobianPoint object instance to standard affine Point format and returns Point type.

toP(): Point 

Returns

The Point(affine) object representing the same point as the original JacobianPoint.

If the initial JacobianPoint represents point at infinity, an instance of Point at infinity is returned.

Example

const pointJ = new JacobianPoint('3', '4', '1');
const pointP = pointJ.toP();  // The point in affine coordinates.

Links: API, Interfaces, Classes, Functions, Types, Enums, Variables

Class: K256

A class representing K-256, a prime number with optimizations, specifically used in the secp256k1 curve. It extends the functionalities of the Mersenne class. K-256 prime is represented as 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f'

Example

const k256 = new K256();

export default class K256 extends Mersenne {
    constructor() 
    split(input: BigNumber, output: BigNumber): void 
    imulK(num: BigNumber): BigNumber 
}

See also: BigNumber, Mersenne

Constructor

Constructor for the K256 class. Creates an instance of K256 using the super constructor from Mersenne.

constructor() 

Example

const k256 = new K256();

Method imulK

Multiplies a BigNumber ('num') with the constant 'K' in-place and returns the result. 'K' is equal to 0x1000003d1 or in decimal representation: [ 64, 977 ].

imulK(num: BigNumber): BigNumber 

Returns

Returns the mutated BigNumber after multiplication.

Argument Details

• num
• The BigNumber to multiply with K.

Example

const number = new BigNumber(12345);
const result = k256.imulK(number);

Method split

Splits a BigNumber into a new BigNumber based on specific computation rules. This method modifies the input and output big numbers.

split(input: BigNumber, output: BigNumber): void 

Argument Details

• input
• The BigNumber to be split.
• output
• The BigNumber that results from the split.

Example

const input = new BigNumber(3456);
const output = new BigNumber(0);
k256.split(input, output);

Links: API, Interfaces, Classes, Functions, Types, Enums, Variables

Class: KeyShares

Example

const key = PrivateKey.fromShares(shares)

export class KeyShares {
    points: PointInFiniteField[];
    threshold: number;
    integrity: string;
    constructor(points: PointInFiniteField[], threshold: number, integrity: string) 
    static fromBackupFormat(shares: string[]): KeyShares 
    toBackupFormat(): string[] 
}

See also: PointInFiniteField

Links: API, Interfaces, Classes, Functions, Types, Enums, Variables

Class: Mersenne

A representation of a pseudo-Mersenne prime. A pseudo-Mersenne prime has the general form 2^n - k, where n and k are integers.

export default class Mersenne {
    name: string;
    p: BigNumber;
    k: BigNumber;
    n: number;
    constructor(name: string, p: string) 
    ireduce(num: BigNumber): BigNumber 
    split(input: BigNumber, out: BigNumber): void 
    imulK(num: BigNumber): BigNumber 
}

See also: BigNumber

Constructor

constructor(name: string, p: string) 

Argument Details

• name
• An identifier for the Mersenne instance.
• p
• A string representation of the pseudo-Mersenne prime, expressed in hexadecimal.

Example

const mersenne = new Mersenne('M31', '7FFFFFFF');

Property k

The constant subtracted from 2^n to derive a pseudo-Mersenne prime.

k: BigNumber

Property n

The exponent which determines the magnitude of the prime.

n: number

Property name

The identifier for the Mersenne instance.

name: string

Property p

BigNumber equivalent to 2^n - k.

p: BigNumber

Method imulK

Performs an in-place multiplication of the parameter by constant k.

imulK(num: BigNumber): BigNumber 

Returns

The result of the multiplication, in BigNumber format.

Argument Details

• num
• The BigNumber to multiply with k.

Example

const multiplied = mersenne.imulK(new BigNumber('2345', 16));

Method ireduce

Reduces an input BigNumber in place, under the assumption that it is less than the square of the pseudo-Mersenne prime.

ireduce(num: BigNumber): BigNumber 

Returns

The reduced BigNumber.

Argument Details

• num
• The BigNumber to be reduced.

Example

const reduced = mersenne.ireduce(new BigNumber('2345', 16));

Method split

Shifts bits of the input BigNumber to the right, in place, to meet the magnitude of the pseudo-Mersenne prime.

split(input: BigNumber, out: BigNumber): void 

Argument Details

• input
• The BigNumber to be shifted (will contain HI part).
• out
• The BigNumber to hold the shifted result (LO part).

Example

mersenne.split(new BigNumber('2345', 16), new BigNumber());

Links: API, Interfaces, Classes, Functions, Types, Enums, Variables

Class: MontgomoryMethod

Represents a Montgomery reduction context, which is a mathematical method for performing modular multiplication without division.

Montgomery reduction is an algorithm used mainly in cryptography which can help to speed up calculations in contexts where there are many repeated computations.

This class extends the ReductionContext class.

export default class MontgomoryMethod extends ReductionContext {
    shift: number;
    r: BigNumber;
    r2: BigNumber;
    rinv: BigNumber;
    minv: BigNumber;
    constructor(m: BigNumber | "k256") 
    convertTo(num: BigNumber): BigNumber 
    convertFrom(num: BigNumber): BigNumber 
    imul(a: BigNumber, b: BigNumber): BigNumber 
    mul(a: BigNumber, b: BigNumber): BigNumber 
    invm(a: BigNumber): BigNumber 
}

See also: BigNumber, ReductionContext

Constructor

constructor(m: BigNumber | "k256") 

Argument Details

• m
• The modulus to be used for the Montgomery method reductions.

Property minv

The modular multiplicative inverse of m mod r.

minv: BigNumber

Property r

The 2^shift, shifted left by the bit length of modulus m.

r: BigNumber

Property r2

The square of r modulo m.

r2: BigNumber

Property rinv

The modular multiplicative inverse of r mod m.

rinv: BigNumber

Property shift

The number of bits in the modulus.

shift: number

Method convertFrom

Converts a number from the Montgomery domain back to the original domain.

convertFrom(num: BigNumber): BigNumber 

Returns

The result of the conversion from the Montgomery domain.

Argument Details

• num
• The number to be converted from the Montgomery domain.

Example

const montMethod = new MontgomoryMethod(m);
const convertedNum = montMethod.convertFrom(num);

Method convertTo

Converts a number into the Montgomery domain.

convertTo(num: BigNumber): BigNumber 

Returns

The result of the conversion into the Montgomery domain.

Argument Details

• num
• The number to be converted into the Montgomery domain.

Example

const montMethod = new MontgomoryMethod(m);
const convertedNum = montMethod.convertTo(num);

Method imul

Performs an in-place multiplication of two numbers in the Montgomery domain.

imul(a: BigNumber, b: BigNumber): BigNumber 

Returns

The result of the in-place multiplication.

Argument Details

• a
• The first number to multiply.
• b
• The second number to multiply.

Example

const montMethod = new MontgomoryMethod(m);
const product = montMethod.imul(a, b);

Method invm

Calculates the modular multiplicative inverse of a number in the Montgomery domain.

invm(a: BigNumber): BigNumber 

Returns

The modular multiplicative inverse of 'a'.

Argument Details

• a
• The number to compute the modular multiplicative inverse of.

Example

const montMethod = new MontgomoryMethod(m);
const inverse = montMethod.invm(a);

Method mul

Performs the multiplication of two numbers in the Montgomery domain.

mul(a: BigNumber, b: BigNumber): BigNumber 

Returns

The result of the multiplication.

Argument Details

• a
• The first number to multiply.
• b
• The second number to multiply.

Example

const montMethod = new MontgomoryMethod(m);
const product = montMethod.mul(a, b);

Links: API, Interfaces, Classes, Functions, Types, Enums, Variables

Class: Point

Point class is a representation of an elliptic curve point with affine coordinates. It extends the functionality of BasePoint and carries x, y coordinates of point on the curve. It also introduces new methods for handling Point operations in elliptic curve.

export default class Point extends BasePoint {
    x: BigNumber | null;
    y: BigNumber | null;
    inf: boolean;
    static fromDER(bytes: number[]): Point 
    static fromString(str: string): Point 
    static fromX(x: BigNumber | number | number[] | string, odd: boolean): Point 
    static fromJSON(obj: string | any[], isRed: boolean): Point 
    constructor(x: BigNumber | number | number[] | string | null, y: BigNumber | number | number[] | string | null, isRed: boolean = true) 
    validate(): boolean 
    encode(compact: boolean = true, enc?: "hex"): number[] | string 
    toString(): string 
    toJSON(): [
        BigNumber | null,
        BigNumber | null,
        {
            doubles: {
                step: any;
                points: any[];
            } | undefined;
            naf: {
                wnd: any;
                points: any[];
            } | undefined;
        }?
    ] 
    inspect(): string 
    isInfinity(): boolean 
    add(p: Point): Point 
    dbl(): Point 
    getX(): BigNumber 
    getY(): BigNumber 
    mul(k: BigNumber | number | number[] | string): Point 
    mulAdd(k1: BigNumber, p2: Point, k2: BigNumber): Point 
    jmulAdd(k1: BigNumber, p2: Point, k2: BigNumber): JPoint 
    eq(p: Point): boolean 
    neg(_precompute?: boolean): Point 
    dblp(k: number): Point 
    toJ(): JPoint 
}

See also: BasePoint, BigNumber, encode

Constructor

constructor(x: BigNumber | number | number[] | string | null, y: BigNumber | number | number[] | string | null, isRed: boolean = true) 

Argument Details

• x
• The x-coordinate of the point. May be a number, a BigNumber, a string (which will be interpreted as hex), a number array, or null. If null, an "Infinity" point is constructed.
• y
• The y-coordinate of the point, similar to x.
• isRed
• A boolean indicating if the point is a member of the field of integers modulo the k256 prime. Default is true.

Example

new Point('abc123', 'def456');
new Point(null, null); // Generates Infinity point.

Property inf

Flag to record if the point is at infinity in the Elliptic Curve.

inf: boolean

Property x

The x-coordinate of the point.

x: BigNumber | null

Property y

The y-coordinate of the point.

y: BigNumber | null

Method add

Adds another Point to this Point, returning a new Point.

add(p: Point): Point 

Returns

A new Point that results from the addition.

Argument Details

• p
• The Point to add to this one.

Example

const p1 = new Point(1, 2);
const p2 = new Point(2, 3);
const result = p1.add(p2);

Method dbl

Doubles the current point.

dbl(): Point 

Example

const P = new Point('123', '456');
const result = P.dbl();

Method dblp

Performs the "doubling" operation on the Point a given number of times. This is used in elliptic curve operations to perform multiplication by 2, multiple times. If the point is at infinity, it simply returns the point because doubling a point at infinity is still infinity.

dblp(k: number): Point 

Returns

The Point after 'k' "doubling" operations have been performed.

Argument Details

• k
• The number of times the "doubling" operation is to be performed on the Point.

Example

const p = new Point(5, 20);
const doubledPoint = p.dblp(10); // returns the point after "doubled" 10 times

Method encode

Encodes the coordinates of a point into an array or a hexadecimal string. The details of encoding are determined by the optional compact and enc parameters.

encode(compact: boolean = true, enc?: "hex"): number[] | string 

Returns

If enc is undefined, a byte array representation of the point will be returned. if enc is 'hex', a hexadecimal string representation of the point will be returned.

Argument Details

• compact
• If true, an additional prefix byte 0x02 or 0x03 based on the 'y' coordinate being even or odd respectively is used. If false, byte 0x04 is used.
• enc
• Expects the string 'hex' if hexadecimal string encoding is required instead of an array of numbers.

Throws

Will throw an error if the specified encoding method is not recognized. Expects 'hex'.

Example

const aPoint = new Point(x, y);
const encodedPointArray = aPoint.encode();
const encodedPointHex = aPoint.encode(true, 'hex');