@bsv/sdk 1.0.4 → 1.0.5

package/docs/primitives.md

@@ -3586,7 +3586,7 @@ Returns
 Example
 
 ```ts
-const bn = new BigNumber('000000", 2, "be");
+const bn = new BigNumber("000000", 2, "be");
 bn.strip();
 // bn now represents 0
 ```
@@ -4392,343 +4392,353 @@ const product = montMethod.mul(a, b);
 Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
 
 ---
-### Class: RIPEMD160
+### Class: BasePoint
 
-An implementation of RIPEMD160 cryptographic hash function. Extends the BaseHash class.
-It provides a way to compute a 'digest' for any kind of input data; transforming the data
-into a unique output of fixed size. The output is deterministic; it will always be
-the same for the same input.
+Base class for Point (affine coordinates) and JacobianPoint classes,
+defining their curve and type.
+
+```ts
+export default abstract class BasePoint {
+    curve: Curve;
+    type: "affine" | "jacobian";
+    precomputed: {
+        doubles: {
+            step: number;
+            points: any[];
+        } | undefined;
+        naf: {
+            wnd: any;
+            points: any[];
+        } | undefined;
+        beta: BasePoint | null | undefined;
+    } | null;
+    constructor(type: "affine" | "jacobian") 
+}
+```
+
+Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#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
 
 ```ts
-const ripemd160 = new RIPEMD160();
+const pointJ = new JacobianPoint('3', '4', '1');
 ```
 
 ```ts
-export class RIPEMD160 extends BaseHash {
-    h: number[];
-    constructor() 
-    _update(msg: number[], start: number): void 
-    _digest(enc?: "hex"): string | number[] 
+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 
 }
 ```
 
 <details>
 
-<summary>Class RIPEMD160 Details</summary>
+<summary>Class JacobianPoint Details</summary>
 
-#### Property h
+#### Constructor
 
-Array that is updated iteratively as part of hashing computation.
+Constructs a new `JacobianPoint` instance.
 
 ```ts
-h: number[]
+constructor(x: string | BigNumber | null, y: string | BigNumber | null, z: string | BigNumber | null) 
 ```
 
-</details>
-
-Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
-
----
-### Class: SHA256
+Argument Details
 
-An implementation of SHA256 cryptographic hash function. Extends the BaseHash class.
-It provides a way to compute a 'digest' for any kind of input data; transforming the data
-into a unique output of fixed size. The output is deterministic; it will always be
-the same for the same input.
++ **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
 
 ```ts
-const sha256 = new SHA256();
+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.
+
 ```ts
-export class SHA256 extends BaseHash {
-    h: number[];
-    W: number[];
-    k: number[];
-    constructor() 
-    _update(msg: number[], start?: number): void 
-    ;
-    _digest(enc?: "hex"): number[] | string 
-}
+x: BigNumber
 ```
 
-<details>
+#### Property y
 
-<summary>Class SHA256 Details</summary>
+The `y` coordinate of the point in the Jacobian form.
 
-#### Property W
+```ts
+y: BigNumber
+```
 
-Provides a way to recycle usage of the array memory.
+#### Property z
+
+The `z` coordinate of the point in the Jacobian form.
 
 ```ts
-W: number[]
+z: BigNumber
 ```
 
-#### Property h
+#### Property zOne
 
-The initial hash constants
+Flag that indicates if the `z` coordinate is one.
 
 ```ts
-h: number[]
+zOne: boolean
 ```
 
-#### Property k
+#### Method add
 
-The round constants used for each round of SHA-256
+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.
 
 ```ts
-k: number[]
+add(p: JacobianPoint): JacobianPoint 
 ```
 
-</details>
+Returns
 
-Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+Returns a new Jacobian point as the result of the addition.
 
----
-### Class: SHA1
+Argument Details
 
-An implementation of SHA1 cryptographic hash function. Extends the BaseHash class.
-It provides a way to compute a 'digest' for any kind of input data; transforming the data
-into a unique output of fixed size. The output is deterministic; it will always be
-the same for the same input.
++ **p**
+  + The Jacobian point to be added.
 
 Example
 
 ```ts
-const sha1 = new SHA1();
-```
-
-```ts
-export class SHA1 extends BaseHash {
-    h: number[];
-    W: number[];
-    k: number[];
-    constructor() 
-    _update(msg: number[], start?: number): void 
-    _digest(enc?: "hex"): number[] | string 
-}
+const p1 = new JacobianPoint(x1, y1, z1)
+const p2 = new JacobianPoint(x2, y2, z2)
+const result = p1.add(p2)
 ```
 
-<details>
-
-<summary>Class SHA1 Details</summary>
-
-#### Property W
+#### Method dbl
 
-Provides a way to recycle usage of the array memory.
+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.
 
 ```ts
-W: number[]
+dbl(): JacobianPoint 
 ```
 
-#### Property h
+Returns
 
-The initial hash constants.
+Returns a new Jacobian point as the result of the doubling.
+
+Example
 
 ```ts
-h: number[]
+const jp = new JacobianPoint(x, y, z)
+const result = jp.dbl()
 ```
 
-#### Property k
+#### Method dblp
 
-The round constants used for each round of SHA-1.
+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.
 
 ```ts
-k: number[]
+dblp(pow: number): JacobianPoint 
 ```
 
-</details>
+Returns
 
-Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+Returns a new Jacobian point as the result of multiple doublings.
 
----
-### Class: SHA512
+Argument Details
 
-An implementation of SHA512 cryptographic hash function. Extends the BaseHash class.
-It provides a way to compute a 'digest' for any kind of input data; transforming the data
-into a unique output of fixed size. The output is deterministic; it will always be
-the same for the same input.
++ **pow**
+  + The number of times the point should be doubled.
 
 Example
 
 ```ts
-const sha512 = new SHA512();
+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.
+
 ```ts
-export class SHA512 extends BaseHash {
-    h: number[];
-    W: number[];
-    k: number[];
-    constructor() 
-    _prepareBlock(msg, start) 
-    _update(msg, start) 
-    _digest(enc) 
-}
+eq(p: Point | JacobianPoint): boolean 
 ```
 
-<details>
+Returns
 
-<summary>Class SHA512 Details</summary>
+Returns true if the points are equal, otherwise returns false.
 
-#### Property W
+Argument Details
 
-Provides a way to recycle usage of the array memory.
++ **p**
+  + The affine or Jacobian point to compare with.
+
+Example
 
 ```ts
-W: number[]
+const jp1 = new JacobianPoint(x1, y1, z1)
+const jp2 = new JacobianPoint(x2, y2, z2)
+const areEqual = jp1.eq(jp2)
 ```
 
-#### Property h
+#### Method eqXToP
 
-The initial hash constants.
+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.
 
 ```ts
-h: number[]
+eqXToP(x: BigNumber): boolean 
 ```
 
-#### Property k
+Returns
 
-The round constants used for each round of SHA-512.
+Returns true if the x coordinates are equal, otherwise returns false.
+
+Argument Details
+
++ **x**
+  + The x coordinate of a point in projective coordinates.
+
+Example
 
 ```ts
-k: number[]
+const jp = new JacobianPoint(x1, y1, z1)
+const isXEqual = jp.eqXToP(x2)
 ```
 
-</details>
+#### Method inspect
 
-Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
-
----
-### Class: SHA256HMAC
-
-The `SHA256HMAC` class is used to create Hash-based Message Authentication Code (HMAC) using the SHA-256 cryptographic hash function.
-
-HMAC is a specific type of MAC involving a cryptographic hash function and a secret cryptographic key. It may be used to simultaneously verify both the data integrity and the authenticity of a message.
-
-This class also uses the SHA-256 cryptographic hash algorithm that produces a 256-bit (32-byte) hash value.
+Returns the string representation of the JacobianPoint instance.
 
 ```ts
-export class SHA256HMAC {
-    inner: SHA256;
-    outer: SHA256;
-    blockSize = 64;
-    outSize = 32;
-    constructor(key: number[] | string) 
-    update(msg: number[] | string, enc?: "hex"): SHA256HMAC 
-    digest(enc?: "hex"): number[] | string 
-}
+inspect(): string 
 ```
 
-<details>
-
-<summary>Class SHA256HMAC Details</summary>
-
-#### Constructor
+Returns
 
-The constructor for the `SHA256HMAC` class.
+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>'.
 
-It initializes the `SHA256HMAC` object and sets up the inner and outer padded keys.
-If the key size is larger than the blockSize, it is digested using SHA-256.
-If the key size is less than the blockSize, it is padded with zeroes.
+Example
 
 ```ts
-constructor(key: number[] | string) 
+const point = new JacobianPoint('5', '6', '1');
+console.log(point.inspect()); // Output: '<EC JPoint x: 5 y: 6 z: 1>'
 ```
 
-Argument Details
-
-+ **key**
-  + The key to use to create the HMAC. Can be a number array or a string in hexadecimal format.
+#### Method isInfinity
 
-Example
+Checks whether the JacobianPoint instance represents a point at infinity.
 
 ```ts
-const myHMAC = new SHA256HMAC('deadbeef');
+isInfinity(): boolean 
 ```
 
-#### Property blockSize
+Returns
 
-The block size for the SHA-256 hash function, in bytes. It's set to 64 bytes.
+Returns true if the JacobianPoint's z-coordinate equals to zero (which represents the point at infinity in Jacobian coordinates). Returns false otherwise.
+
+Example
 
 ```ts
-blockSize = 64
+const point = new JacobianPoint('5', '6', '0');
+console.log(point.isInfinity()); // Output: true
 ```
 
-#### Property inner
+#### Method mixedAdd
 
-Represents the inner hash of SHA-256.
+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.
 
 ```ts
-inner: SHA256
+mixedAdd(p: Point): JacobianPoint 
 ```
 
-#### Property outSize
+Returns
 
-The output size of the SHA-256 hash function, in bytes. It's set to 32 bytes.
+Returns the result of the mixed addition as a new Jacobian point.
 
-```ts
-outSize = 32
-```
+Argument Details
 
-#### Property outer
++ **p**
+  + The affine point to be added.
 
-Represents the outer hash of SHA-256.
+Example
 
 ```ts
-outer: SHA256
+const jp = new JacobianPoint(x1, y1, z1)
+const ap = new Point(x2, y2)
+const result = jp.mixedAdd(ap)
 ```
 
-#### Method digest
+#### Method neg
 
-Finalizes the HMAC computation and returns the resultant hash.
+Negation operation. It returns the additive inverse of the Jacobian point.
 
 ```ts
-digest(enc?: "hex"): number[] | string 
+neg(): JacobianPoint 
 ```
 
 Returns
 
-Returns the digest of the hashed data. Can be a number array or a string.
-
-Argument Details
-
-+ **enc**
-  + If 'hex', then the output is encoded as hexadecimal. If undefined or not 'hex', then no encoding is performed.
+Returns a new Jacobian point as the result of the negation.
 
 Example
 
 ```ts
-let hashedMessage = myHMAC.digest('hex');
+const jp = new JacobianPoint(x, y, z)
+const result = jp.neg()
 ```
 
-#### Method update
+#### Method toP
 
-Updates the `SHA256HMAC` object with part of the message to be hashed.
+Converts the `JacobianPoint` object instance to standard affine `Point` format and returns `Point` type.
 
 ```ts
-update(msg: number[] | string, enc?: "hex"): SHA256HMAC 
+toP(): Point 
 ```
 
 Returns
 
-Returns the instance of `SHA256HMAC` for chaining calls.
-
-Argument Details
+The `Point`(affine) object representing the same point as the original `JacobianPoint`.
 
-+ **msg**
-  + Part of the message to hash. Can be a number array or a string.
-+ **enc**
-  + If 'hex', then the input is encoded as hexadecimal. If undefined or not 'hex', then no encoding is performed.
+If the initial `JacobianPoint` represents point at infinity, an instance of `Point` at infinity is returned.
 
 Example
 
 ```ts
-myHMAC.update('deadbeef', 'hex');
+const pointJ = new JacobianPoint('3', '4', '1');
+const pointP = pointJ.toP();  // The point in affine coordinates.
 ```
 
 </details>
@@ -4736,131 +4746,96 @@ myHMAC.update('deadbeef', 'hex');
 Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
 
 ---
-### Class: SHA512HMAC
-
-The `SHA512HMAC` class is used to create Hash-based Message Authentication Code (HMAC) using the SHA-512 cryptographic hash function.
-
-HMAC is a specific type of MAC involving a cryptographic hash function and a secret cryptographic key. It may be used to simultaneously verify both the data integrity and the authenticity of a message.
-
-This class also uses the SHA-512 cryptographic hash algorithm that produces a 512-bit (64-byte) hash value.
-
-```ts
-export class SHA512HMAC {
-    inner: SHA512;
-    outer: SHA512;
-    blockSize = 128;
-    outSize = 32;
-    constructor(key: number[] | string) 
-    update(msg: number[] | string, enc?: "hex"): SHA512HMAC 
-    digest(enc?: "hex"): number[] | string 
-}
-```
-
-<details>
-
-<summary>Class SHA512HMAC Details</summary>
-
-#### Constructor
+### Class: RIPEMD160
 
-The constructor for the `SHA512HMAC` class.
+An implementation of RIPEMD160 cryptographic hash function. Extends the BaseHash class.
+It provides a way to compute a 'digest' for any kind of input data; transforming the data
+into a unique output of fixed size. The output is deterministic; it will always be
+the same for the same input.
 
-It initializes the `SHA512HMAC` object and sets up the inner and outer padded keys.
-If the key size is larger than the blockSize, it is digested using SHA-512.
-If the key size is less than the blockSize, it is padded with zeroes.
+Example
 
 ```ts
-constructor(key: number[] | string) 
+const ripemd160 = new RIPEMD160();
 ```
 
-Argument Details
-
-+ **key**
-  + The key to use to create the HMAC. Can be a number array or a string in hexadecimal format.
-
-Example
-
 ```ts
-const myHMAC = new SHA512HMAC('deadbeef');
+export class RIPEMD160 extends BaseHash {
+    h: number[];
+    constructor() 
+    _update(msg: number[], start: number): void 
+    _digest(enc?: "hex"): string | number[] 
+}
 ```
 
-#### Property blockSize
-
-The block size for the SHA-512 hash function, in bytes. It's set to 128 bytes.
+<details>
 
-```ts
-blockSize = 128
-```
+<summary>Class RIPEMD160 Details</summary>
 
-#### Property inner
+#### Property h
 
-Represents the inner hash of SHA-512.
+Array that is updated iteratively as part of hashing computation.
 
 ```ts
-inner: SHA512
+h: number[]
 ```
 
-#### Property outSize
+</details>
 
-The output size of the SHA-512 hash function, in bytes. It's set to 64 bytes.
+Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
 
-```ts
-outSize = 32
-```
+---
+### Class: SHA256
 
-#### Property outer
+An implementation of SHA256 cryptographic hash function. Extends the BaseHash class.
+It provides a way to compute a 'digest' for any kind of input data; transforming the data
+into a unique output of fixed size. The output is deterministic; it will always be
+the same for the same input.
 
-Represents the outer hash of SHA-512.
+Example
 
 ```ts
-outer: SHA512
+const sha256 = new SHA256();
 ```
 
-#### Method digest
-
-Finalizes the HMAC computation and returns the resultant hash.
-
 ```ts
-digest(enc?: "hex"): number[] | string 
+export class SHA256 extends BaseHash {
+    h: number[];
+    W: number[];
+    k: number[];
+    constructor() 
+    _update(msg: number[], start?: number): void 
+    ;
+    _digest(enc?: "hex"): number[] | string 
+}
 ```
 
-Returns
-
-Returns the digest of the hashed data. Can be a number array or a string.
+<details>
 
-Argument Details
+<summary>Class SHA256 Details</summary>
 
-+ **enc**
-  + If 'hex', then the output is encoded as hexadecimal. If undefined or not 'hex', then no encoding is performed.
+#### Property W
 
-Example
+Provides a way to recycle usage of the array memory.
 
 ```ts
-let hashedMessage = myHMAC.digest('hex');
+W: number[]
 ```
 
-#### Method update
+#### Property h
 
-Updates the `SHA512HMAC` object with part of the message to be hashed.
+The initial hash constants
 
 ```ts
-update(msg: number[] | string, enc?: "hex"): SHA512HMAC 
+h: number[]
 ```
 
-Returns
-
-Returns the instance of `SHA512HMAC` for chaining calls.
-
-Argument Details
-
-+ **msg**
-  + Part of the message to hash. Can be a number array or a string.
-+ **enc**
-  + If 'hex', then the input is encoded as hexadecimal. If undefined or not 'hex', then no encoding is performed.
+#### Property k
 
-Example
+The round constants used for each round of SHA-256
 
 ```ts
-myHMAC.update('deadbeef', 'hex');
+k: number[]
 ```
 
 </details>
@@ -4868,489 +4843,446 @@ myHMAC.update('deadbeef', 'hex');
 Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
 
 ---
-### Class: Writer
-
-```ts
-export class Writer {
-    public bufs: number[][];
-    constructor(bufs?: number[][]) 
-    getLength(): number 
-    toArray(): number[] 
-    write(buf: number[]): Writer 
-    writeReverse(buf: number[]): Writer 
-    writeUInt8(n: number): Writer 
-    writeInt8(n: number): Writer 
-    writeUInt16BE(n: number): Writer 
-    writeInt16BE(n: number): Writer 
-    writeUInt16LE(n: number): Writer 
-    writeInt16LE(n: number): Writer 
-    writeUInt32BE(n: number): Writer 
-    writeInt32BE(n: number): Writer 
-    writeUInt32LE(n: number): Writer 
-    writeInt32LE(n: number): Writer 
-    writeUInt64BEBn(bn: BigNumber): Writer 
-    writeUInt64LEBn(bn: BigNumber): Writer 
-    writeUInt64LE(n: number): Writer 
-    writeVarIntNum(n: number): Writer 
-    writeVarIntBn(bn: BigNumber): Writer 
-    static varIntNum(n: number): number[] 
-    static varIntBn(bn: BigNumber): number[] 
-}
-```
+### Class: SHA1
 
-Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+An implementation of SHA1 cryptographic hash function. Extends the BaseHash class.
+It provides a way to compute a 'digest' for any kind of input data; transforming the data
+into a unique output of fixed size. The output is deterministic; it will always be
+the same for the same input.
 
----
-### Class: Reader
+Example
 
 ```ts
-export class Reader {
-    public bin: number[];
-    public pos: number;
-    constructor(bin: number[] = [], pos: number = 0) 
-    public eof(): boolean 
-    public read(len = this.bin.length): number[] 
-    public readReverse(len = this.bin.length): number[] 
-    public readUInt8(): number 
-    public readInt8(): number 
-    public readUInt16BE(): number 
-    public readInt16BE(): number 
-    public readUInt16LE(): number 
-    public readInt16LE(): number 
-    public readUInt32BE(): number 
-    public readInt32BE(): number 
-    public readUInt32LE(): number 
-    public readInt32LE(): number 
-    public readUInt64BEBn(): BigNumber 
-    public readUInt64LEBn(): BigNumber 
-    public readVarIntNum(): number 
-    public readVarInt(): number[] 
-    public readVarIntBn(): BigNumber 
-}
+const sha1 = new SHA1();
 ```
-
-Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
-
----
-### Class: Curve
-
-```ts
-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: any;
-    _endoWnafT1: any[];
-    _endoWnafT2: any[];
-    _wnafT1: any[];
-    _wnafT2: any[];
-    _wnafT3: any[];
-    _wnafT4: any[];
-    _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 
-    ;
+
+```ts
+export class SHA1 extends BaseHash {
+    h: number[];
+    W: number[];
+    k: number[];
+    constructor() 
+    _update(msg: number[], start?: number): void 
+    _digest(enc?: "hex"): number[] | string 
 }
 ```
 
-Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+<details>
 
----
-### Class: BasePoint
+<summary>Class SHA1 Details</summary>
 
-Base class for Point (affine coordinates) and JacobianPoint classes,
-defining their curve and type.
+#### Property W
+
+Provides a way to recycle usage of the array memory.
 
 ```ts
-export default abstract class BasePoint {
-    curve: Curve;
-    type: "affine" | "jacobian";
-    precomputed: {
-        doubles: {
-            step: number;
-            points: any[];
-        } | undefined;
-        naf: {
-            wnd: any;
-            points: any[];
-        } | undefined;
-        beta: BasePoint | null | undefined;
-    } | null;
-    constructor(type: "affine" | "jacobian") 
-}
+W: number[]
+```
+
+#### Property h
+
+The initial hash constants.
+
+```ts
+h: number[]
+```
+
+#### Property k
+
+The round constants used for each round of SHA-1.
+
+```ts
+k: number[]
 ```
 
+</details>
+
 Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#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.
+### Class: SHA512
 
-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).
+An implementation of SHA512 cryptographic hash function. Extends the BaseHash class.
+It provides a way to compute a 'digest' for any kind of input data; transforming the data
+into a unique output of fixed size. The output is deterministic; it will always be
+the same for the same input.
 
 Example
 
 ```ts
-const pointJ = new JacobianPoint('3', '4', '1');
+const sha512 = new SHA512();
 ```
 
 ```ts
-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 
+export class SHA512 extends BaseHash {
+    h: number[];
+    W: number[];
+    k: number[];
+    constructor() 
+    _prepareBlock(msg, start) 
+    _update(msg, start) 
+    _digest(enc) 
 }
 ```
 
 <details>
 
-<summary>Class JacobianPoint Details</summary>
+<summary>Class SHA512 Details</summary>
 
-#### Constructor
+#### Property W
 
-Constructs a new `JacobianPoint` instance.
+Provides a way to recycle usage of the array memory.
 
 ```ts
-constructor(x: string | BigNumber | null, y: string | BigNumber | null, z: string | BigNumber | null) 
+W: number[]
 ```
 
-Argument Details
+#### Property h
 
-+ **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.
+The initial hash constants.
 
-Example
+```ts
+h: number[]
+```
+
+#### Property k
+
+The round constants used for each round of SHA-512.
 
 ```ts
-const pointJ1 = new JacobianPoint(null, null, null); // creates point at infinity
-const pointJ2 = new JacobianPoint('3', '4', '1'); // creates point (3, 4, 1)
+k: number[]
 ```
 
-#### Property x
+</details>
 
-The `x` coordinate of the point in the Jacobian form.
+Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+
+---
+### Class: SHA256HMAC
+
+The `SHA256HMAC` class is used to create Hash-based Message Authentication Code (HMAC) using the SHA-256 cryptographic hash function.
+
+HMAC is a specific type of MAC involving a cryptographic hash function and a secret cryptographic key. It may be used to simultaneously verify both the data integrity and the authenticity of a message.
+
+This class also uses the SHA-256 cryptographic hash algorithm that produces a 256-bit (32-byte) hash value.
 
 ```ts
-x: BigNumber
+export class SHA256HMAC {
+    inner: SHA256;
+    outer: SHA256;
+    blockSize = 64;
+    outSize = 32;
+    constructor(key: number[] | string) 
+    update(msg: number[] | string, enc?: "hex"): SHA256HMAC 
+    digest(enc?: "hex"): number[] | string 
+}
 ```
 
-#### Property y
+<details>
 
-The `y` coordinate of the point in the Jacobian form.
+<summary>Class SHA256HMAC Details</summary>
+
+#### Constructor
+
+The constructor for the `SHA256HMAC` class.
+
+It initializes the `SHA256HMAC` object and sets up the inner and outer padded keys.
+If the key size is larger than the blockSize, it is digested using SHA-256.
+If the key size is less than the blockSize, it is padded with zeroes.
 
 ```ts
-y: BigNumber
+constructor(key: number[] | string) 
 ```
 
-#### Property z
+Argument Details
 
-The `z` coordinate of the point in the Jacobian form.
++ **key**
+  + The key to use to create the HMAC. Can be a number array or a string in hexadecimal format.
+
+Example
 
 ```ts
-z: BigNumber
+const myHMAC = new SHA256HMAC('deadbeef');
 ```
 
-#### Property zOne
+#### Property blockSize
 
-Flag that indicates if the `z` coordinate is one.
+The block size for the SHA-256 hash function, in bytes. It's set to 64 bytes.
 
 ```ts
-zOne: boolean
+blockSize = 64
 ```
 
-#### Method add
+#### Property inner
 
-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.
+Represents the inner hash of SHA-256.
 
 ```ts
-add(p: JacobianPoint): JacobianPoint 
+inner: SHA256
 ```
 
-Returns
+#### Property outSize
 
-Returns a new Jacobian point as the result of the addition.
+The output size of the SHA-256 hash function, in bytes. It's set to 32 bytes.
 
-Argument Details
+```ts
+outSize = 32
+```
 
-+ **p**
-  + The Jacobian point to be added.
+#### Property outer
 
-Example
+Represents the outer hash of SHA-256.
 
 ```ts
-const p1 = new JacobianPoint(x1, y1, z1)
-const p2 = new JacobianPoint(x2, y2, z2)
-const result = p1.add(p2)
+outer: SHA256
 ```
 
-#### Method dbl
+#### Method digest
 
-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.
+Finalizes the HMAC computation and returns the resultant hash.
 
 ```ts
-dbl(): JacobianPoint 
+digest(enc?: "hex"): number[] | string 
 ```
 
 Returns
 
-Returns a new Jacobian point as the result of the doubling.
+Returns the digest of the hashed data. Can be a number array or a string.
+
+Argument Details
+
++ **enc**
+  + If 'hex', then the output is encoded as hexadecimal. If undefined or not 'hex', then no encoding is performed.
 
 Example
 
 ```ts
-const jp = new JacobianPoint(x, y, z)
-const result = jp.dbl()
+let hashedMessage = myHMAC.digest('hex');
 ```
 
-#### Method dblp
+#### Method update
 
-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.
+Updates the `SHA256HMAC` object with part of the message to be hashed.
 
 ```ts
-dblp(pow: number): JacobianPoint 
+update(msg: number[] | string, enc?: "hex"): SHA256HMAC 
 ```
 
 Returns
 
-Returns a new Jacobian point as the result of multiple doublings.
+Returns the instance of `SHA256HMAC` for chaining calls.
 
 Argument Details
 
-+ **pow**
-  + The number of times the point should be doubled.
++ **msg**
+  + Part of the message to hash. Can be a number array or a string.
++ **enc**
+  + If 'hex', then the input is encoded as hexadecimal. If undefined or not 'hex', then no encoding is performed.
 
 Example
 
 ```ts
-const jp = new JacobianPoint(x, y, z)
-const result = jp.dblp(3)
+myHMAC.update('deadbeef', 'hex');
 ```
 
-#### Method eq
+</details>
 
-Equality check operation. It checks whether the affine or Jacobian point is equal to this Jacobian point.
+Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
 
-```ts
-eq(p: Point | JacobianPoint): boolean 
-```
+---
+### Class: SHA512HMAC
 
-Returns
+The `SHA512HMAC` class is used to create Hash-based Message Authentication Code (HMAC) using the SHA-512 cryptographic hash function.
 
-Returns true if the points are equal, otherwise returns false.
+HMAC is a specific type of MAC involving a cryptographic hash function and a secret cryptographic key. It may be used to simultaneously verify both the data integrity and the authenticity of a message.
 
-Argument Details
+This class also uses the SHA-512 cryptographic hash algorithm that produces a 512-bit (64-byte) hash value.
+
+```ts
+export class SHA512HMAC {
+    inner: SHA512;
+    outer: SHA512;
+    blockSize = 128;
+    outSize = 32;
+    constructor(key: number[] | string) 
+    update(msg: number[] | string, enc?: "hex"): SHA512HMAC 
+    digest(enc?: "hex"): number[] | string 
+}
+```
 
-+ **p**
-  + The affine or Jacobian point to compare with.
+<details>
 
-Example
+<summary>Class SHA512HMAC Details</summary>
 
-```ts
-const jp1 = new JacobianPoint(x1, y1, z1)
-const jp2 = new JacobianPoint(x2, y2, z2)
-const areEqual = jp1.eq(jp2)
-```
+#### Constructor
 
-#### Method eqXToP
+The constructor for the `SHA512HMAC` class.
 
-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.
+It initializes the `SHA512HMAC` object and sets up the inner and outer padded keys.
+If the key size is larger than the blockSize, it is digested using SHA-512.
+If the key size is less than the blockSize, it is padded with zeroes.
 
 ```ts
-eqXToP(x: BigNumber): boolean 
+constructor(key: number[] | string) 
 ```
 
-Returns
-
-Returns true if the x coordinates are equal, otherwise returns false.
-
 Argument Details
 
-+ **x**
-  + The x coordinate of a point in projective coordinates.
++ **key**
+  + The key to use to create the HMAC. Can be a number array or a string in hexadecimal format.
 
 Example
 
 ```ts
-const jp = new JacobianPoint(x1, y1, z1)
-const isXEqual = jp.eqXToP(x2)
+const myHMAC = new SHA512HMAC('deadbeef');
 ```
 
-#### Method inspect
+#### Property blockSize
 
-Returns the string representation of the JacobianPoint instance.
+The block size for the SHA-512 hash function, in bytes. It's set to 128 bytes.
 
 ```ts
-inspect(): string 
+blockSize = 128
 ```
 
-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>'.
+#### Property inner
 
-Example
+Represents the inner hash of SHA-512.
 
 ```ts
-const point = new JacobianPoint('5', '6', '1');
-console.log(point.inspect()); // Output: '<EC JPoint x: 5 y: 6 z: 1>'
+inner: SHA512
 ```
 
-#### Method isInfinity
+#### Property outSize
 
-Checks whether the JacobianPoint instance represents a point at infinity.
+The output size of the SHA-512 hash function, in bytes. It's set to 64 bytes.
 
 ```ts
-isInfinity(): boolean 
+outSize = 32
 ```
 
-Returns
-
-Returns true if the JacobianPoint's z-coordinate equals to zero (which represents the point at infinity in Jacobian coordinates). Returns false otherwise.
+#### Property outer
 
-Example
+Represents the outer hash of SHA-512.
 
 ```ts
-const point = new JacobianPoint('5', '6', '0');
-console.log(point.isInfinity()); // Output: true
+outer: SHA512
 ```
 
-#### Method mixedAdd
+#### Method digest
 
-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.
+Finalizes the HMAC computation and returns the resultant hash.
 
 ```ts
-mixedAdd(p: Point): JacobianPoint 
+digest(enc?: "hex"): number[] | string 
 ```
 
 Returns
 
-Returns the result of the mixed addition as a new Jacobian point.
+Returns the digest of the hashed data. Can be a number array or a string.
 
 Argument Details
 
-+ **p**
-  + The affine point to be added.
++ **enc**
+  + If 'hex', then the output is encoded as hexadecimal. If undefined or not 'hex', then no encoding is performed.
 
 Example
 
 ```ts
-const jp = new JacobianPoint(x1, y1, z1)
-const ap = new Point(x2, y2)
-const result = jp.mixedAdd(ap)
+let hashedMessage = myHMAC.digest('hex');
 ```
 
-#### Method neg
+#### Method update
 
-Negation operation. It returns the additive inverse of the Jacobian point.
+Updates the `SHA512HMAC` object with part of the message to be hashed.
 
 ```ts
-neg(): JacobianPoint 
+update(msg: number[] | string, enc?: "hex"): SHA512HMAC 
 ```
 
 Returns
 
-Returns a new Jacobian point as the result of the negation.
+Returns the instance of `SHA512HMAC` for chaining calls.
+
+Argument Details
+
++ **msg**
+  + Part of the message to hash. Can be a number array or a string.
++ **enc**
+  + If 'hex', then the input is encoded as hexadecimal. If undefined or not 'hex', then no encoding is performed.
 
 Example
 
 ```ts
-const jp = new JacobianPoint(x, y, z)
-const result = jp.neg()
+myHMAC.update('deadbeef', 'hex');
 ```
 
-#### Method toP
+</details>
 
-Converts the `JacobianPoint` object instance to standard affine `Point` format and returns `Point` type.
+Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+
+---
+### Class: Writer
 
 ```ts
-toP(): Point 
+export class Writer {
+    public bufs: number[][];
+    constructor(bufs?: number[][]) 
+    getLength(): number 
+    toArray(): number[] 
+    write(buf: number[]): Writer 
+    writeReverse(buf: number[]): Writer 
+    writeUInt8(n: number): Writer 
+    writeInt8(n: number): Writer 
+    writeUInt16BE(n: number): Writer 
+    writeInt16BE(n: number): Writer 
+    writeUInt16LE(n: number): Writer 
+    writeInt16LE(n: number): Writer 
+    writeUInt32BE(n: number): Writer 
+    writeInt32BE(n: number): Writer 
+    writeUInt32LE(n: number): Writer 
+    writeInt32LE(n: number): Writer 
+    writeUInt64BEBn(bn: BigNumber): Writer 
+    writeUInt64LEBn(bn: BigNumber): Writer 
+    writeUInt64LE(n: number): Writer 
+    writeVarIntNum(n: number): Writer 
+    writeVarIntBn(bn: BigNumber): Writer 
+    static varIntNum(n: number): number[] 
+    static varIntBn(bn: BigNumber): number[] 
+}
 ```
 
-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.
+Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
 
-Example
+---
+### Class: Reader
 
 ```ts
-const pointJ = new JacobianPoint('3', '4', '1');
-const pointP = pointJ.toP();  // The point in affine coordinates.
+export class Reader {
+    public bin: number[];
+    public pos: number;
+    constructor(bin: number[] = [], pos: number = 0) 
+    public eof(): boolean 
+    public read(len = this.bin.length): number[] 
+    public readReverse(len = this.bin.length): number[] 
+    public readUInt8(): number 
+    public readInt8(): number 
+    public readUInt16BE(): number 
+    public readInt16BE(): number 
+    public readUInt16LE(): number 
+    public readInt16LE(): number 
+    public readUInt32BE(): number 
+    public readInt32BE(): number 
+    public readUInt32LE(): number 
+    public readInt32LE(): number 
+    public readUInt64BEBn(): BigNumber 
+    public readUInt64LEBn(): BigNumber 
+    public readVarIntNum(): number 
+    public readVarInt(): number[] 
+    public readVarIntBn(): BigNumber 
+}
 ```
 
-</details>
-
 Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
 
 ---
@@ -5934,6 +5866,74 @@ const isValid = aPoint.validate();
 
 Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
 
+---
+### Class: Curve
+
+```ts
+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: any;
+    _endoWnafT1: any[];
+    _endoWnafT2: any[];
+    _wnafT1: any[];
+    _wnafT2: any[];
+    _wnafT3: any[];
+    _wnafT4: any[];
+    _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 
+    ;
+}
+```
+
+Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+
 ---
 ### Class: DRBG
 
@@ -6212,6 +6212,7 @@ export default class PrivateKey extends BigNumber {
     static fromRandom(): PrivateKey 
     static fromString(str: string, base: number | "hex"): PrivateKey 
     static fromWif(wif: string, prefixLength: number = 1): PrivateKey 
+    constructor(number: BigNumber | number | string | number[] = 0, base: number | "be" | "le" | "hex" = 10, endian: "be" | "le" = "be") 
     sign(msg: number[] | string, enc?: "hex", forceLowS: boolean = true, customK?: Function | BigNumber): Signature 
     verify(msg: number[] | string, sig: Signature, enc?: "hex"): boolean 
     toPublicKey(): PublicKey 
@@ -6226,6 +6227,28 @@ export default class PrivateKey extends BigNumber {
 
 <summary>Class PrivateKey Details</summary>
 
+#### Constructor
+
+```ts
+constructor(number: BigNumber | number | string | number[] = 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. Ignored if number is BigNumber.
++ **endian**
+  + The endianness provided. By default is 'big endian'. Ignored if number is BigNumber.
+
+Example
+
+```ts
+import BigNumber from './BigNumber';
+const bn = new BigNumber('123456', 10, 'be');
+```
+
 #### Method deriveChild
 
 Derives a child key with BRC-42.
@@ -7014,7 +7037,7 @@ Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#v
 
 ```ts
 zero2 = (word: string): string => {
-    if (word.length === 1) {
+    if (word.length % 2 === 1) {
         return "0" + word;
     }
     else {