@bsv/sdk 1.0.4 → 1.0.6

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();
+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.
+
 ```ts
-export class SHA1 extends BaseHash {
-    h: number[];
-    W: number[];
-    k: number[];
-    constructor() 
-    _update(msg: number[], start?: number): void 
-    _digest(enc?: "hex"): number[] | string 
-}
+dbl(): JacobianPoint 
 ```
 
-<details>
+Returns
 
-<summary>Class SHA1 Details</summary>
+Returns a new Jacobian point as the result of the doubling.
 
-#### Property W
+Example
 
-Provides a way to recycle usage of the array memory.
+```ts
+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.
 
 ```ts
-W: number[]
+dblp(pow: number): JacobianPoint 
 ```
 
-#### Property h
+Returns
 
-The initial hash constants.
+Returns a new Jacobian point as the result of multiple doublings.
+
+Argument Details
+
++ **pow**
+  + The number of times the point should be doubled.
+
+Example
 
 ```ts
-h: number[]
+const jp = new JacobianPoint(x, y, z)
+const result = jp.dblp(3)
 ```
 
-#### Property k
+#### Method eq
 
-The round constants used for each round of SHA-1.
+Equality check operation. It checks whether the affine or Jacobian point is equal to this Jacobian point.
 
 ```ts
-k: number[]
+eq(p: Point | JacobianPoint): boolean 
 ```
 
-</details>
+Returns
 
-Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+Returns true if the points are equal, otherwise returns false.
 
----
-### 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.
++ **p**
+  + The affine or Jacobian point to compare with.
 
 Example
 
 ```ts
-const sha512 = new SHA512();
+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.
+
 ```ts
-export class SHA512 extends BaseHash {
-    h: number[];
-    W: number[];
-    k: number[];
-    constructor() 
-    _prepareBlock(msg, start) 
-    _update(msg, start) 
-    _digest(enc) 
-}
+eqXToP(x: BigNumber): boolean 
 ```
 
-<details>
+Returns
 
-<summary>Class SHA512 Details</summary>
+Returns true if the x coordinates are equal, otherwise returns false.
 
-#### Property W
+Argument Details
 
-Provides a way to recycle usage of the array memory.
++ **x**
+  + The x coordinate of a point in projective coordinates.
+
+Example
 
 ```ts
-W: number[]
+const jp = new JacobianPoint(x1, y1, z1)
+const isXEqual = jp.eqXToP(x2)
 ```
 
-#### Property h
+#### Method inspect
 
-The initial hash constants.
+Returns the string representation of the JacobianPoint instance.
 
 ```ts
-h: number[]
+inspect(): string 
 ```
 
-#### Property k
+Returns
 
-The round constants used for each round of SHA-512.
+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
 
 ```ts
-k: number[]
-```
-
-</details>
-
-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
-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 
-}
+const point = new JacobianPoint('5', '6', '1');
+console.log(point.inspect()); // Output: '<EC JPoint x: 5 y: 6 z: 1>'
 ```
 
-<details>
-
-<summary>Class SHA256HMAC Details</summary>
-
-#### Constructor
-
-The constructor for the `SHA256HMAC` class.
+#### Method isInfinity
 
-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.
+Checks whether the JacobianPoint instance represents a point at infinity.
 
 ```ts
-constructor(key: number[] | string) 
+isInfinity(): boolean 
 ```
 
-Argument Details
+Returns
 
-+ **key**
-  + The key to use to create the HMAC. Can be a number array or a string in hexadecimal format.
+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
-const myHMAC = new SHA256HMAC('deadbeef');
-```
-
-#### Property blockSize
-
-The block size for the SHA-256 hash function, in bytes. It's set to 64 bytes.
-
-```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,621 +4746,575 @@ myHMAC.update('deadbeef', 'hex');
 Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
 
 ---
-### Class: SHA512HMAC
+### Class: RIPEMD160
 
-The `SHA512HMAC` class is used to create Hash-based Message Authentication Code (HMAC) using the SHA-512 cryptographic hash function.
+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.
 
-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.
+Example
 
-This class also uses the SHA-512 cryptographic hash algorithm that produces a 512-bit (64-byte) hash value.
+```ts
+const ripemd160 = new RIPEMD160();
+```
 
 ```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 
+export class RIPEMD160 extends BaseHash {
+    h: number[];
+    constructor() 
+    _update(msg: number[], start: number): void 
+    _digest(): number[] 
+    _digestHex(): string 
 }
 ```
 
 <details>
 
-<summary>Class SHA512HMAC Details</summary>
-
-#### Constructor
+<summary>Class RIPEMD160 Details</summary>
 
-The constructor for the `SHA512HMAC` class.
+#### Property h
 
-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.
+Array that is updated iteratively as part of hashing computation.
 
 ```ts
-constructor(key: number[] | string) 
+h: number[]
 ```
 
-Argument Details
+</details>
 
-+ **key**
-  + The key to use to create the HMAC. Can be a number array or a string in hexadecimal format.
+Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+
+---
+### Class: SHA256
+
+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.
 
 Example
 
 ```ts
-const myHMAC = new SHA512HMAC('deadbeef');
+const sha256 = new SHA256();
 ```
 
-#### Property blockSize
-
-The block size for the SHA-512 hash function, in bytes. It's set to 128 bytes.
-
 ```ts
-blockSize = 128
+export class SHA256 extends BaseHash {
+    h: number[];
+    W: number[];
+    k: number[];
+    constructor() 
+    _update(msg: number[], start?: number): void 
+    ;
+    _digest(): number[] 
+    _digestHex(): string 
+}
 ```
 
-#### Property inner
-
-Represents the inner hash of SHA-512.
+<details>
 
-```ts
-inner: SHA512
-```
+<summary>Class SHA256 Details</summary>
 
-#### Property outSize
+#### Property W
 
-The output size of the SHA-512 hash function, in bytes. It's set to 64 bytes.
+Provides a way to recycle usage of the array memory.
 
 ```ts
-outSize = 32
+W: number[]
 ```
 
-#### Property outer
+#### Property h
 
-Represents the outer hash of SHA-512.
+The initial hash constants
 
 ```ts
-outer: SHA512
+h: number[]
 ```
 
-#### Method digest
+#### Property k
 
-Finalizes the HMAC computation and returns the resultant hash.
+The round constants used for each round of SHA-256
 
 ```ts
-digest(enc?: "hex"): number[] | string 
+k: number[]
 ```
 
-Returns
+</details>
 
-Returns the digest of the hashed data. Can be a number array or a string.
+Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
 
-Argument Details
+---
+### Class: SHA1
 
-+ **enc**
-  + If 'hex', then the output is encoded as hexadecimal. If undefined or not 'hex', then no encoding is performed.
+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.
 
 Example
 
 ```ts
-let hashedMessage = myHMAC.digest('hex');
+const sha1 = new SHA1();
 ```
 
-#### Method update
-
-Updates the `SHA512HMAC` object with part of the message to be hashed.
-
 ```ts
-update(msg: number[] | string, enc?: "hex"): SHA512HMAC 
+export class SHA1 extends BaseHash {
+    h: number[];
+    W: number[];
+    k: number[];
+    constructor() 
+    _update(msg: number[], start?: number): void 
+    _digest(): number[] 
+    _digestHex(): string 
+}
 ```
 
-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.
-
-Example
-
-```ts
-myHMAC.update('deadbeef', 'hex');
-```
+<details>
 
-</details>
+<summary>Class SHA1 Details</summary>
 
-Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+#### Property W
 
----
-### Class: Writer
+Provides a way to recycle usage of the array memory.
 
 ```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[] 
-}
+W: number[]
 ```
 
-Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+#### Property h
 
----
-### Class: Reader
+The initial hash constants.
 
 ```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 
-}
+h: number[]
 ```
 
-Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+#### Property k
 
----
-### Class: Curve
+The round constants used for each round of SHA-1.
 
 ```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 
-    ;
-}
+k: number[]
 ```
 
+</details>
+
 Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
 
 ---
-### Class: BasePoint
+### Class: SHA512
 
-Base class for Point (affine coordinates) and JacobianPoint classes,
-defining their curve and type.
+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
-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") 
+const sha512 = new SHA512();
+```
+
+```ts
+export class SHA512 extends BaseHash {
+    h: number[];
+    W: number[];
+    k: number[];
+    constructor() 
+    _prepareBlock(msg, start) 
+    _update(msg, start) 
+    _digest() 
+    _digestHex() 
 }
 ```
 
-Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
+<details>
 
----
-### Class: JacobianPoint
+<summary>Class SHA512 Details</summary>
 
-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.
+#### Property W
 
-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).
+Provides a way to recycle usage of the array memory.
 
-Example
+```ts
+W: number[]
+```
+
+#### Property h
+
+The initial hash constants.
 
 ```ts
-const pointJ = new JacobianPoint('3', '4', '1');
+h: number[]
 ```
 
+#### Property k
+
+The round constants used for each round of SHA-512.
+
 ```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 
+k: number[]
+```
+
+</details>
+
+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
+export class SHA256HMAC {
+    inner: SHA256;
+    outer: SHA256;
+    blockSize = 64;
+    outSize = 32;
+    constructor(key: number[] | string) 
+    update(msg: number[] | string, enc?: "hex"): SHA256HMAC 
+    digest(): number[] 
+    digestHex(): string 
 }
 ```
 
 <details>
 
-<summary>Class JacobianPoint Details</summary>
+<summary>Class SHA256HMAC Details</summary>
 
 #### Constructor
 
-Constructs a new `JacobianPoint` instance.
+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
-constructor(x: string | BigNumber | null, y: string | BigNumber | null, z: string | BigNumber | null) 
+constructor(key: number[] | string) 
 ```
 
 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.
++ **key**
+  + The key to use to create the HMAC. Can be a number array or a string in hexadecimal format.
 
 Example
 
 ```ts
-const pointJ1 = new JacobianPoint(null, null, null); // creates point at infinity
-const pointJ2 = new JacobianPoint('3', '4', '1'); // creates point (3, 4, 1)
+const myHMAC = new SHA256HMAC('deadbeef');
 ```
 
-#### Property x
+#### Property blockSize
 
-The `x` coordinate of the point in the Jacobian form.
+The block size for the SHA-256 hash function, in bytes. It's set to 64 bytes.
 
 ```ts
-x: BigNumber
+blockSize = 64
 ```
 
-#### Property y
+#### Property inner
 
-The `y` coordinate of the point in the Jacobian form.
+Represents the inner hash of SHA-256.
 
 ```ts
-y: BigNumber
+inner: SHA256
 ```
 
-#### Property z
+#### Property outSize
 
-The `z` coordinate of the point in the Jacobian form.
+The output size of the SHA-256 hash function, in bytes. It's set to 32 bytes.
 
 ```ts
-z: BigNumber
+outSize = 32
 ```
 
-#### Property zOne
+#### Property outer
 
-Flag that indicates if the `z` coordinate is one.
+Represents the outer hash of SHA-256.
 
 ```ts
-zOne: boolean
+outer: SHA256
 ```
 
-#### Method add
+#### Method digest
 
-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.
+Finalizes the HMAC computation and returns the resultant hash.
 
 ```ts
-add(p: JacobianPoint): JacobianPoint 
+digest(): number[] 
 ```
 
 Returns
 
-Returns a new Jacobian point as the result of the addition.
-
-Argument Details
-
-+ **p**
-  + The Jacobian point to be added.
+Returns the digest of the hashed data. Can be a number array or a string.
 
 Example
 
 ```ts
-const p1 = new JacobianPoint(x1, y1, z1)
-const p2 = new JacobianPoint(x2, y2, z2)
-const result = p1.add(p2)
+let hashedMessage = myHMAC.digest();
 ```
 
-#### Method dbl
+#### Method digestHex
 
-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 as a hex string.
 
 ```ts
-dbl(): JacobianPoint 
+digestHex(): string 
 ```
 
 Returns
 
-Returns a new Jacobian point as the result of the doubling.
+Returns the digest of the hashed data as a hex string
 
 Example
 
 ```ts
-const jp = new JacobianPoint(x, y, z)
-const result = jp.dbl()
+let hashedMessage = myHMAC.digestHex();
 ```
 
-#### 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)
+
+---
+### 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
-eq(p: Point | JacobianPoint): boolean 
+export class SHA512HMAC {
+    inner: SHA512;
+    outer: SHA512;
+    blockSize = 128;
+    outSize = 32;
+    constructor(key: number[] | string) 
+    update(msg: number[] | string, enc?: "hex" | "utf8"): SHA512HMAC 
+    digest(): number[] 
+    digestHex(): string 
+}
 ```
 
-Returns
+<details>
 
-Returns true if the points are equal, otherwise returns false.
+<summary>Class SHA512HMAC Details</summary>
 
-Argument Details
+#### Constructor
 
-+ **p**
-  + The affine or Jacobian point to compare with.
+The constructor for the `SHA512HMAC` class.
 
-Example
+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
-const jp1 = new JacobianPoint(x1, y1, z1)
-const jp2 = new JacobianPoint(x2, y2, z2)
-const areEqual = jp1.eq(jp2)
+constructor(key: number[] | string) 
 ```
 
-#### Method eqXToP
+Argument Details
 
-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.
++ **key**
+  + The key to use to create the HMAC. Can be a number array or a string in hexadecimal format.
+
+Example
 
 ```ts
-eqXToP(x: BigNumber): boolean 
+const myHMAC = new SHA512HMAC('deadbeef');
 ```
 
-Returns
+#### Property blockSize
 
-Returns true if the x coordinates are equal, otherwise returns false.
+The block size for the SHA-512 hash function, in bytes. It's set to 128 bytes.
 
-Argument Details
+```ts
+blockSize = 128
+```
 
-+ **x**
-  + The x coordinate of a point in projective coordinates.
+#### Property inner
 
-Example
+Represents the inner hash of SHA-512.
 
-```ts
-const jp = new JacobianPoint(x1, y1, z1)
-const isXEqual = jp.eqXToP(x2)
+```ts
+inner: SHA512
 ```
 
-#### Method inspect
+#### Property outSize
 
-Returns the string representation of the JacobianPoint instance.
+The output size of the SHA-512 hash function, in bytes. It's set to 64 bytes.
 
 ```ts
-inspect(): string 
+outSize = 32
 ```
 
-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 outer
 
-Example
+Represents the outer 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>'
+outer: SHA512
 ```
 
-#### Method isInfinity
+#### Method digest
 
-Checks whether the JacobianPoint instance represents a point at infinity.
+Finalizes the HMAC computation and returns the resultant hash.
 
 ```ts
-isInfinity(): boolean 
+digest(): number[] 
 ```
 
 Returns
 
-Returns true if the JacobianPoint's z-coordinate equals to zero (which represents the point at infinity in Jacobian coordinates). Returns false otherwise.
+Returns the digest of the hashed data as a number array.
 
 Example
 
 ```ts
-const point = new JacobianPoint('5', '6', '0');
-console.log(point.isInfinity()); // Output: true
+let hashedMessage = myHMAC.digest();
 ```
 
-#### Method mixedAdd
+#### Method digestHex
 
-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 as a hex string.
 
 ```ts
-mixedAdd(p: Point): JacobianPoint 
+digestHex(): string 
 ```
 
 Returns
 
-Returns the result of the mixed addition as a new Jacobian point.
-
-Argument Details
-
-+ **p**
-  + The affine point to be added.
+Returns the digest of the hashed data as a hex string
 
 Example
 
 ```ts
-const jp = new JacobianPoint(x1, y1, z1)
-const ap = new Point(x2, y2)
-const result = jp.mixedAdd(ap)
+let hashedMessage = myHMAC.digestHex();
 ```
 
-#### 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" | "utf8"): 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 +5898,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,7 +6244,8 @@ 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 
-    sign(msg: number[] | string, enc?: "hex", forceLowS: boolean = true, customK?: Function | BigNumber): Signature 
+    constructor(number: BigNumber | number | string | number[] = 0, base: number | "be" | "le" | "hex" = 10, endian: "be" | "le" = "be") 
+    sign(msg: number[] | string, enc?: "hex" | "utf8", forceLowS: boolean = true, customK?: Function | BigNumber): Signature 
     verify(msg: number[] | string, sig: Signature, enc?: "hex"): boolean 
     toPublicKey(): PublicKey 
     toWif(prefix: number[] = [128]): string 
@@ -6226,6 +6259,29 @@ 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 PrivateKey from './PrivateKey';
+import BigNumber from './BigNumber';
+const privKey = new PrivateKey(new BigNumber('123456', 10, 'be'));
+```
+
 #### Method deriveChild
 
 Derives a child key with BRC-42.
@@ -6343,7 +6399,7 @@ Will throw an error if the string is not a valid WIF.
 Signs a message using the private key.
 
 ```ts
-sign(msg: number[] | string, enc?: "hex", forceLowS: boolean = true, customK?: Function | BigNumber): Signature 
+sign(msg: number[] | string, enc?: "hex" | "utf8", forceLowS: boolean = true, customK?: Function | BigNumber): Signature 
 ```
 
 Returns
@@ -6485,8 +6541,9 @@ The class comes with static methods to generate PublicKey instances from private
 export default class PublicKey extends Point {
     static fromPrivateKey(key: PrivateKey): PublicKey 
     static fromString(str: string): PublicKey 
+    constructor(x: Point | BigNumber | number | number[] | string | null, y: BigNumber | number | number[] | string | null = null, isRed: boolean = true) 
     deriveSharedSecret(priv: PrivateKey): Point 
-    verify(msg: number[] | string, sig: Signature, enc?: "hex"): boolean 
+    verify(msg: number[] | string, sig: Signature, enc?: "hex" | "utf8"): boolean 
     toDER(): string 
     toHash(enc?: "hex"): number[] | string 
     toAddress(prefix: number[] = [0]): string 
@@ -6498,6 +6555,28 @@ export default class PublicKey extends Point {
 
 <summary>Class PublicKey Details</summary>
 
+#### Constructor
+
+```ts
+constructor(x: Point | BigNumber | number | number[] | string | null, y: BigNumber | number | number[] | string | null = null, isRed: boolean = true) 
+```
+
+Argument Details
+
++ **x**
+  + A point or 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**
+  + If x is not a point, 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
+
+```ts
+new PublicKey(point1);
+new PublicKey('abc123', 'def456');
+```
+
 #### Method deriveChild
 
 Derives a child key with BRC-42.
@@ -6660,7 +6739,7 @@ const publicKeyHash = pubkey.toHash()
 Verify a signature of a message using this public key.
 
 ```ts
-verify(msg: number[] | string, sig: Signature, enc?: "hex"): boolean 
+verify(msg: number[] | string, sig: Signature, enc?: "hex" | "utf8"): boolean 
 ```
 
 Returns
@@ -6674,7 +6753,7 @@ Argument Details
 + **sig**
   + The Signature of the message that needs verification.
 + **enc**
-  + The encoding of the message. It defaults to 'hex'.
+  + The encoding of the message. It defaults to 'utf8'.
 
 Example
 
@@ -6697,6 +6776,7 @@ It leverages the Advanced Encryption Standard Galois/Counter Mode (AES-GCM) for
 
 ```ts
 export default class SymmetricKey extends BigNumber {
+    static fromRandom(): SymmetricKey 
     encrypt(msg: number[] | string, enc?: "hex"): string | number[] 
     decrypt(msg: number[] | string, enc?: "hex" | "utf8"): string | number[] 
 }
@@ -6766,6 +6846,24 @@ const key = new SymmetricKey(1234);
 const encryptedMessage = key.encrypt('plainText', 'utf8');
 ```
 
+#### Method fromRandom
+
+Generates a symmetric key randomly.
+
+```ts
+static fromRandom(): SymmetricKey 
+```
+
+Returns
+
+The newly generated Symmetric Key.
+
+Example
+
+```ts
+const symmetricKey = SymmetricKey.fromRandom();
+```
+
 </details>
 
 Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
@@ -6790,9 +6888,24 @@ Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#v
 ### Function: toArray
 
 ```ts
-export function toArray(msg: number[] | string, enc?: "hex"): number[] 
+export function toArray(msg: number[] | string, enc?: "hex" | "utf8"): number[] 
 ```
 
+<details>
+
+<summary>Function toArray Details</summary>
+
+Returns
+
+array of byte values from msg. If msg is an array, a copy is returned.
+
+Argument Details
+
++ **enc**
+  + Optional. Encoding to use if msg is string. Default is 'utf8'.
+
+</details>
+
 Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#variables)
 
 ---
@@ -6923,8 +7036,8 @@ Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#v
 ### Variable: ripemd160
 
 ```ts
-ripemd160 = (msg: number[] | string, enc?: "hex"): number[] | string => {
-    return new RIPEMD160().update(msg, enc).digest(enc);
+ripemd160 = (msg: number[] | string, enc?: "hex" | "utf8"): number[] => {
+    return new RIPEMD160().update(msg, enc).digest();
 }
 ```
 
@@ -6934,8 +7047,8 @@ Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#v
 ### Variable: sha1
 
 ```ts
-sha1 = (msg: number[] | string, enc?: "hex"): number[] | string => {
-    return new SHA1().update(msg, enc).digest(enc);
+sha1 = (msg: number[] | string, enc?: "hex" | "utf8"): number[] => {
+    return new SHA1().update(msg, enc).digest();
 }
 ```
 
@@ -6945,8 +7058,8 @@ Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#v
 ### Variable: sha256
 
 ```ts
-sha256 = (msg: number[] | string, enc?: "hex"): number[] | string => {
-    return new SHA256().update(msg, enc).digest(enc);
+sha256 = (msg: number[] | string, enc?: "hex" | "utf8"): number[] => {
+    return new SHA256().update(msg, enc).digest();
 }
 ```
 
@@ -6956,8 +7069,8 @@ Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#v
 ### Variable: sha512
 
 ```ts
-sha512 = (msg: number[] | string, enc?: "hex"): number[] | string => {
-    return new SHA512().update(msg, enc).digest(enc);
+sha512 = (msg: number[] | string, enc?: "hex" | "utf8"): number[] => {
+    return new SHA512().update(msg, enc).digest();
 }
 ```
 
@@ -6967,9 +7080,9 @@ Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#v
 ### Variable: hash256
 
 ```ts
-hash256 = (msg: number[] | string, enc?: "hex"): number[] | string => {
+hash256 = (msg: number[] | string, enc?: "hex" | "utf8"): number[] => {
     const first = new SHA256().update(msg, enc).digest();
-    return new SHA256().update(first).digest(enc);
+    return new SHA256().update(first).digest();
 }
 ```
 
@@ -6979,9 +7092,9 @@ Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#v
 ### Variable: hash160
 
 ```ts
-hash160 = (msg: number[] | string, enc?: "hex"): number[] | string => {
+hash160 = (msg: number[] | string, enc?: "hex" | "utf8"): number[] => {
     const first = new SHA256().update(msg, enc).digest();
-    return new RIPEMD160().update(first).digest(enc);
+    return new RIPEMD160().update(first).digest();
 }
 ```
 
@@ -6991,8 +7104,8 @@ Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#v
 ### Variable: sha256hmac
 
 ```ts
-sha256hmac = (key: number[] | string, msg: number[] | string, enc?: "hex"): number[] | string => {
-    return new SHA256HMAC(key).update(msg, enc).digest(enc);
+sha256hmac = (key: number[] | string, msg: number[] | string, enc?: "hex"): number[] => {
+    return new SHA256HMAC(key).update(msg, enc).digest();
 }
 ```
 
@@ -7002,8 +7115,8 @@ Links: [API](#api), [Classes](#classes), [Functions](#functions), [Variables](#v
 ### Variable: sha512hmac
 
 ```ts
-sha512hmac = (key: number[] | string, msg: number[] | string, enc?: "hex"): number[] | string => {
-    return new SHA512HMAC(key).update(msg, enc).digest(enc);
+sha512hmac = (key: number[] | string, msg: number[] | string, enc?: "hex"): number[] => {
+    return new SHA512HMAC(key).update(msg, enc).digest();
 }
 ```
 
@@ -7014,7 +7127,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 {