@bsv/sdk 1.0.26 → 1.0.29

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

@@ -1,164 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,53 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,72 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,96 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}