@bsv/sdk 1.0.0

package/dist/types/src/primitives/JacobianPoint.d.ts

@@ -0,0 +1,164 @@
+import BasePoint from './BasePoint.js';
+import BigNumber from './BigNumber.js';
+import Point from './Point.js';
+/**
+ * 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).
+ *
+ * @property x - The `x` coordinate of the point in the Jacobian form.
+ * @property y - The `y` coordinate of the point in the Jacobian form.
+ * @property z - The `z` coordinate of the point in the Jacobian form.
+ * @property zOne - Flag that indicates if the `z` coordinate is one.
+ *
+ * @example
+ * const pointJ = new JacobianPoint('3', '4', '1');
+ */
+export default class JacobianPoint extends BasePoint {
+    x: BigNumber;
+    y: BigNumber;
+    z: BigNumber;
+    zOne: boolean;
+    /**
+     * Constructs a new `JacobianPoint` instance.
+     *
+     * @param 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.
+     *
+     * @param 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.
+     *
+     * @param 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)
+     */
+    constructor(x: string | BigNumber | null, y: string | BigNumber | null, z: string | BigNumber | null);
+    /**
+     * Converts the `JacobianPoint` object instance to standard affine `Point` format and returns `Point` type.
+     *
+     * @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.
+     */
+    toP(): Point;
+    /**
+     * Negation operation. It returns the additive inverse of the Jacobian point.
+     *
+     * @method neg
+     * @returns Returns a new Jacobian point as the result of the negation.
+     *
+     * @example
+     * const jp = new JacobianPoint(x, y, z)
+     * const result = jp.neg()
+     */
+    neg(): JacobianPoint;
+    /**
+     * 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.
+     *
+     * @method add
+     * @param p - The Jacobian point to be added.
+     * @returns Returns a new Jacobian point as the result of the addition.
+     *
+     * @example
+     * const p1 = new JacobianPoint(x1, y1, z1)
+     * const p2 = new JacobianPoint(x2, y2, z2)
+     * const result = p1.add(p2)
+     */
+    add(p: JacobianPoint): JacobianPoint;
+    /**
+     * 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.
+     *
+     * @method mixedAdd
+     * @param p - The affine point to be added.
+     * @returns Returns the result of the mixed addition as a new Jacobian point.
+     *
+     * @example
+     * const jp = new JacobianPoint(x1, y1, z1)
+     * const ap = new Point(x2, y2)
+     * const result = jp.mixedAdd(ap)
+     */
+    mixedAdd(p: Point): JacobianPoint;
+    /**
+     * 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.
+     *
+     * @method dblp
+     * @param pow - The number of times the point should be doubled.
+     * @returns Returns a new Jacobian point as the result of multiple doublings.
+     *
+     * @example
+     * const jp = new JacobianPoint(x, y, z)
+     * const result = jp.dblp(3)
+     */
+    dblp(pow: number): JacobianPoint;
+    /**
+     * 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.
+     *
+     * @method dbl
+     * @returns Returns a new Jacobian point as the result of the doubling.
+     *
+     * @example
+     * const jp = new JacobianPoint(x, y, z)
+     * const result = jp.dbl()
+     */
+    dbl(): JacobianPoint;
+    /**
+     * Equality check operation. It checks whether the affine or Jacobian point is equal to this Jacobian point.
+     *
+     * @method eq
+     * @param p - The affine or Jacobian point to compare with.
+     * @returns Returns true if the points are equal, otherwise returns false.
+     *
+     * @example
+     * const jp1 = new JacobianPoint(x1, y1, z1)
+     * const jp2 = new JacobianPoint(x2, y2, z2)
+     * const areEqual = jp1.eq(jp2)
+     */
+    eq(p: Point | JacobianPoint): boolean;
+    /**
+     * 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.
+     *
+     * @method eqXToP
+     * @param x - The x coordinate of a point in projective coordinates.
+     * @returns Returns true if the x coordinates are equal, otherwise returns false.
+     *
+     * @example
+     * const jp = new JacobianPoint(x1, y1, z1)
+     * const isXEqual = jp.eqXToP(x2)
+     */
+    eqXToP(x: BigNumber): boolean;
+    /**
+     * Returns the string representation of the JacobianPoint instance.
+     * @method inspect
+     * @returns Returns the string description of the JacobianPoint. If the JacobianPoint represents a point at infinity, the return value of this function is '<EC JPoint Infinity>'. For a normal point, it returns the string description format as '<EC JPoint x: x-coordinate y: y-coordinate z: z-coordinate>'.
+     *
+     * @example
+     * const point = new JacobianPoint('5', '6', '1');
+     * console.log(point.inspect()); // Output: '<EC JPoint x: 5 y: 6 z: 1>'
+     */
+    inspect(): string;
+    /**
+     * Checks whether the JacobianPoint instance represents a point at infinity.
+     * @method isInfinity
+     * @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
+     */
+    isInfinity(): boolean;
+}
+//# sourceMappingURL=JacobianPoint.d.ts.map

package/dist/types/src/primitives/JacobianPoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JacobianPoint.d.ts","sourceRoot":"","sources":["../../../../src/primitives/JacobianPoint.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,gBAAgB,CAAA;AACtC,OAAO,SAAS,MAAM,gBAAgB,CAAA;AACtC,OAAO,KAAK,MAAM,YAAY,CAAA;AAE9B;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,SAAS;IAClD,CAAC,EAAE,SAAS,CAAA;IACZ,CAAC,EAAE,SAAS,CAAA;IACZ,CAAC,EAAE,SAAS,CAAA;IACZ,IAAI,EAAE,OAAO,CAAA;IAEb;;;;;;;;;;;;;;;OAeG;gBAED,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,EAC5B,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,EAC5B,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IA4B9B;;;;;;;;;;OAUG;IACH,GAAG,IAAK,KAAK;IAab;;;;;;;;;OASG;IACH,GAAG,IAAK,aAAa;IAIrB;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAE,CAAC,EAAE,aAAa,GAAG,aAAa;IAoCrC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAE,CAAC,EAAE,KAAK,GAAG,aAAa;IAmClC;;;;;;;;;;OAUG;IACH,IAAI,CAAE,GAAG,EAAE,MAAM,GAAG,aAAa;IAiBjC;;;;;;;;;OASG;IACH,GAAG,IAAK,aAAa;IA2ErB;;;;;;;;;;;OAWG;IACH,EAAE,CAAE,CAAC,EAAE,KAAK,GAAG,aAAa,GAAG,OAAO;IAmBtC;;;;;;;;;;;;OAYG;IACH,MAAM,CAAE,CAAC,EAAE,SAAS,GAAG,OAAO;IAgB9B;;;;;;;;OAQG;IACH,OAAO,IAAK,MAAM;IAOlB;;;;;;;;OAQG;IACH,UAAU,IAAK,OAAO;CAGvB"}

package/dist/types/src/primitives/K256.d.ts

@@ -0,0 +1,53 @@
+import Mersenne from './Mersenne.js';
+import BigNumber from './BigNumber.js';
+/**
+ * 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'
+ *
+ * @class K256
+ * @extends {Mersenne}
+ *
+ * @example
+ * const k256 = new K256();
+ */
+export default class K256 extends Mersenne {
+    /**
+     * Constructor for the K256 class.
+     * Creates an instance of K256 using the super constructor from Mersenne.
+     *
+     * @constructor
+     *
+     * @example
+     * const k256 = new K256();
+     */
+    constructor();
+    /**
+     * Splits a BigNumber into a new BigNumber based on specific computation
+     * rules. This method modifies the input and output big numbers.
+     *
+     * @method split
+     * @param input - The BigNumber to be split.
+     * @param output - The BigNumber that results from the split.
+     *
+     * @example
+     * const input = new BigNumber(3456);
+     * const output = new BigNumber(0);
+     * k256.split(input, output);
+     */
+    split(input: BigNumber, output: BigNumber): void;
+    /**
+     * 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 ].
+     *
+     * @method imulK
+     * @param num - The BigNumber to multiply with K.
+     * @returns Returns the mutated BigNumber after multiplication.
+     *
+     * @example
+     * const number = new BigNumber(12345);
+     * const result = k256.imulK(number);
+     */
+    imulK(num: BigNumber): BigNumber;
+}
+//# sourceMappingURL=K256.d.ts.map

package/dist/types/src/primitives/K256.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"K256.d.ts","sourceRoot":"","sources":["../../../../src/primitives/K256.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,eAAe,CAAA;AACpC,OAAO,SAAS,MAAM,gBAAgB,CAAA;AAEtC;;;;;;;;;;GAUG;AACH,MAAM,CAAC,OAAO,OAAO,IAAK,SAAQ,QAAQ;IACxC;;;;;;;;OAQG;;IAQH;;;;;;;;;;;;OAYG;IACH,KAAK,CAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI;IAmCjD;;;;;;;;;;;OAWG;IACH,KAAK,CAAE,GAAG,EAAE,SAAS,GAAG,SAAS;CAwBlC"}

package/dist/types/src/primitives/Mersenne.d.ts

@@ -0,0 +1,72 @@
+import BigNumber from './BigNumber.js';
+/**
+ * A representation of a pseudo-Mersenne prime.
+ * A pseudo-Mersenne prime has the general form 2^n - k, where n and k are integers.
+ *
+ * @class Mersenne
+ *
+ * @property name - The identifier for the Mersenne instance.
+ * @property p - BigNumber equivalent to 2^n - k.
+ * @property k - The constant subtracted from 2^n to derive a pseudo-Mersenne prime.
+ * @property n - The exponent which determines the magnitude of the prime.
+ */
+export default class Mersenne {
+    name: string;
+    p: BigNumber;
+    k: BigNumber;
+    n: number;
+    private readonly tmp;
+    /**
+     * @constructor
+     * @param name - An identifier for the Mersenne instance.
+     * @param p - A string representation of the pseudo-Mersenne prime, expressed in hexadecimal.
+     *
+     * @example
+     * const mersenne = new Mersenne('M31', '7FFFFFFF');
+     */
+    constructor(name: string, p: string);
+    /**
+     * Creates a temporary BigNumber structure for computations,
+     * ensuring the appropriate number of words are initially allocated.
+     *
+     * @method _tmp
+     * @returns A BigNumber with scaled size depending on prime magnitude.
+     */
+    private _tmp;
+    /**
+     * Reduces an input BigNumber in place, under the assumption that
+     * it is less than the square of the pseudo-Mersenne prime.
+     *
+     * @method ireduce
+     * @param num - The BigNumber to be reduced.
+     * @returns The reduced BigNumber.
+     *
+     * @example
+     * const reduced = mersenne.ireduce(new BigNumber('2345', 16));
+     */
+    ireduce(num: BigNumber): BigNumber;
+    /**
+     * Shifts bits of the input BigNumber to the right, in place,
+     * to meet the magnitude of the pseudo-Mersenne prime.
+     *
+     * @method split
+     * @param input - The BigNumber to be shifted.
+     * @param out - The BigNumber to hold the shifted result.
+     *
+     * @example
+     * mersenne.split(new BigNumber('2345', 16), new BigNumber());
+     */
+    split(input: BigNumber, out: BigNumber): void;
+    /**
+     * Performs an in-place multiplication of the parameter by constant k.
+     *
+     * @method imulK
+     * @param num - The BigNumber to multiply with k.
+     * @returns The result of the multiplication, in BigNumber format.
+     *
+     * @example
+     * const multiplied = mersenne.imulK(new BigNumber('2345', 16));
+     */
+    imulK(num: BigNumber): BigNumber;
+}
+//# sourceMappingURL=Mersenne.d.ts.map

package/dist/types/src/primitives/Mersenne.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mersenne.d.ts","sourceRoot":"","sources":["../../../../src/primitives/Mersenne.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,gBAAgB,CAAA;AAEtC;;;;;;;;;;GAUG;AACH,MAAM,CAAC,OAAO,OAAO,QAAQ;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,CAAC,EAAE,SAAS,CAAA;IACZ,CAAC,EAAE,SAAS,CAAA;IACZ,CAAC,EAAE,MAAM,CAAA;IACT,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAW;IAE/B;;;;;;;OAOG;gBACU,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAUpC;;;;;;OAMG;IACH,OAAO,CAAC,IAAI;IAMZ;;;;;;;;;;OAUG;IACH,OAAO,CAAE,GAAG,EAAE,SAAS,GAAG,SAAS;IAgCnC;;;;;;;;;;OAUG;IACH,KAAK,CAAE,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,SAAS,GAAG,IAAI;IAI9C;;;;;;;;;OASG;IACH,KAAK,CAAE,GAAG,EAAE,SAAS,GAAG,SAAS;CAGlC"}

package/dist/types/src/primitives/MontgomoryMethod.d.ts

@@ -0,0 +1,96 @@
+import ReductionContext from './ReductionContext.js';
+import BigNumber from './BigNumber.js';
+/**
+ * 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.
+ *
+ * @class MontgomoryMethod
+ * @extends {ReductionContext}
+ *
+ * @property shift - The number of bits in the modulus.
+ * @property r - The 2^shift, shifted left by the bit length of modulus `m`.
+ * @property r2 - The square of `r` modulo `m`.
+ * @property rinv - The modular multiplicative inverse of `r` mod `m`.
+ * @property minv - The modular multiplicative inverse of `m` mod `r`.
+ */
+export default class MontgomoryMethod extends ReductionContext {
+    shift: number;
+    r: BigNumber;
+    r2: BigNumber;
+    rinv: BigNumber;
+    minv: BigNumber;
+    /**
+     * @constructor
+     * @param m - The modulus to be used for the Montgomery method reductions.
+     */
+    constructor(m: BigNumber | 'k256');
+    /**
+     * Converts a number into the Montgomery domain.
+     *
+     * @method convertTo
+     * @param num - The number to be converted into the Montgomery domain.
+     * @returns The result of the conversion into the Montgomery domain.
+     *
+     * @example
+     * const montMethod = new MontgomoryMethod(m);
+     * const convertedNum = montMethod.convertTo(num);
+     */
+    convertTo(num: BigNumber): BigNumber;
+    /**
+     * Converts a number from the Montgomery domain back to the original domain.
+     *
+     * @method convertFrom
+     * @param num - The number to be converted from the Montgomery domain.
+     * @returns The result of the conversion from the Montgomery domain.
+     *
+     * @example
+     * const montMethod = new MontgomoryMethod(m);
+     * const convertedNum = montMethod.convertFrom(num);
+     */
+    convertFrom(num: BigNumber): BigNumber;
+    /**
+     * Performs an in-place multiplication of two numbers in the Montgomery domain.
+     *
+     * @method imul
+     * @param a - The first number to multiply.
+     * @param b - The second number to multiply.
+     * @returns The result of the in-place multiplication.
+     *
+     * @example
+     * const montMethod = new MontgomoryMethod(m);
+     * const product = montMethod.imul(a, b);
+     */
+    imul(a: BigNumber, b: BigNumber): BigNumber;
+    /**
+     * Performs the multiplication of two numbers in the Montgomery domain.
+     *
+     * @method mul
+     * @param a - The first number to multiply.
+     * @param b - The second number to multiply.
+     * @returns The result of the multiplication.
+     *
+     * @example
+     * const montMethod = new MontgomoryMethod(m);
+     * const product = montMethod.mul(a, b);
+     */
+    mul(a: BigNumber, b: BigNumber): BigNumber;
+    /**
+     * Calculates the modular multiplicative inverse of a number in the Montgomery domain.
+     *
+     * @method invm
+     * @param a - The number to compute the modular multiplicative inverse of.
+     * @returns The modular multiplicative inverse of 'a'.
+     *
+     * @example
+     * const montMethod = new MontgomoryMethod(m);
+     * const inverse = montMethod.invm(a);
+     */
+    invm(a: BigNumber): BigNumber;
+}
+//# sourceMappingURL=MontgomoryMethod.d.ts.map

package/dist/types/src/primitives/MontgomoryMethod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MontgomoryMethod.d.ts","sourceRoot":"","sources":["../../../../src/primitives/MontgomoryMethod.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAgB,MAAM,uBAAuB,CAAA;AACpD,OAAO,SAAS,MAAM,gBAAgB,CAAA;AAEtC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,gBAAgB;IAC5D,KAAK,EAAE,MAAM,CAAA;IACb,CAAC,EAAE,SAAS,CAAA;IACZ,EAAE,EAAE,SAAS,CAAA;IACb,IAAI,EAAE,SAAS,CAAA;IACf,IAAI,EAAE,SAAS,CAAA;IAEf;;;OAGG;gBACU,CAAC,EAAE,SAAS,GAAG,MAAM;IAiBlC;;;;;;;;;;OAUG;IACH,SAAS,CAAE,GAAG,EAAE,SAAS,GAAG,SAAS;IAIrC;;;;;;;;;;OAUG;IACH,WAAW,CAAE,GAAG,EAAE,SAAS,GAAG,SAAS;IAMvC;;;;;;;;;;;OAWG;IACH,IAAI,CAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,SAAS;IAqB5C;;;;;;;;;;;OAWG;IACH,GAAG,CAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,SAAS;IAgB3C;;;;;;;;;;OAUG;IACH,IAAI,CAAE,CAAC,EAAE,SAAS,GAAG,SAAS;CAK/B"}