@bsv/wallet-toolbox 1.7.13 → 1.7.15

package/mobile/node_modules/@bsv/sdk/dist/types/src/primitives/Point.d.ts

@@ -0,0 +1,362 @@
+import BasePoint from './BasePoint.js';
+import JPoint from './JacobianPoint.js';
+import BigNumber from './BigNumber.js';
+export declare const BI_ZERO = 0n;
+export declare const BI_ONE = 1n;
+export declare const BI_TWO = 2n;
+export declare const BI_THREE = 3n;
+export declare const BI_FOUR = 4n;
+export declare const BI_EIGHT = 8n;
+export declare const P_BIGINT = 115792089237316195423570985008687907853269984665640564039457584007908834671663n;
+export declare const N_BIGINT = 115792089237316195423570985008687907852837564279074904382605163141518161494337n;
+export declare const MASK_256: bigint;
+export declare function red(x: bigint): bigint;
+export declare const biMod: (a: bigint) => bigint;
+export declare const biModSub: (a: bigint, b: bigint) => bigint;
+export declare const biModMul: (a: bigint, b: bigint) => bigint;
+export declare const biModAdd: (a: bigint, b: bigint) => bigint;
+export declare const biModInv: (a: bigint) => bigint;
+export declare const biModSqr: (a: bigint) => bigint;
+export declare const biModPow: (base: bigint, exp: bigint) => bigint;
+export declare const P_PLUS1_DIV4: bigint;
+export declare const biModSqrt: (a: bigint) => bigint | null;
+export declare const GX_BIGINT: bigint;
+export declare const GY_BIGINT: bigint;
+export interface JacobianPointBI {
+    X: bigint;
+    Y: bigint;
+    Z: bigint;
+}
+export declare const jpDouble: (P: JacobianPointBI) => JacobianPointBI;
+export declare const jpAdd: (P: JacobianPointBI, Q: JacobianPointBI) => JacobianPointBI;
+export declare const jpNeg: (P: JacobianPointBI) => JacobianPointBI;
+export declare const scalarMultiplyWNAF: (k: bigint, P0: {
+    x: bigint;
+    y: bigint;
+}, window?: number) => JacobianPointBI;
+export declare const modN: (a: bigint) => bigint;
+export declare const modMulN: (a: bigint, b: bigint) => bigint;
+/** modular inverse modulo n with plain extended‑gcd (not constant‑time) */
+export declare const modInvN: (a: bigint) => bigint;
+/**
+ * `Point` class is a representation of an elliptic curve point with affine coordinates.
+ * It extends the functionality of BasePoint and carries x, y coordinates of point on the curve.
+ * It also introduces new methods for handling Point operations in elliptic curve.
+ *
+ * @class Point
+ * @extends {BasePoint}
+ *
+ * @property x - The x-coordinate of the point.
+ * @property y - The y-coordinate of the point.
+ * @property inf - Flag to record if the point is at infinity in the Elliptic Curve.
+ */
+export default class Point extends BasePoint {
+    x: BigNumber | null;
+    y: BigNumber | null;
+    inf: boolean;
+    /**
+     * Creates a point object from a given Array. These numbers can represent coordinates in hex format, or points
+     * in multiple established formats.
+     * The function verifies the integrity of the provided data and throws errors if inconsistencies are found.
+     *
+     * @method fromDER
+     * @static
+     * @param bytes - The point representation number array.
+     * @returns Returns a new point representing the given string.
+     * @throws `Error` If the point number[] value has a wrong length.
+     * @throws `Error` If the point format is unknown.
+     *
+     * @example
+     * const derPoint = [ 2, 18, 123, 108, 125, 83, 1, 251, 164, 214, 16, 119, 200, 216, 210, 193, 251, 193, 129, 67, 97, 146, 210, 216, 77, 254, 18, 6, 150, 190, 99, 198, 128 ];
+     * const point = Point.fromDER(derPoint);
+     */
+    static fromDER(bytes: number[]): Point;
+    /**
+     * Creates a point object from a given string. This string can represent coordinates in hex format, or points
+     * in multiple established formats.
+     * The function verifies the integrity of the provided data and throws errors if inconsistencies are found.
+     *
+     * @method fromString
+     * @static
+     *
+     * @param str The point representation string.
+     * @returns Returns a new point representing the given string.
+     * @throws `Error` If the point string value has a wrong length.
+     * @throws `Error` If the point format is unknown.
+     *
+     * @example
+     * const pointStr = 'abcdef';
+     * const point = Point.fromString(pointStr);
+     */
+    static fromString(str: string): Point;
+    /**
+     * Generates a point from an x coordinate and a boolean indicating whether the corresponding
+     * y coordinate is odd.
+     *
+     * @method fromX
+     * @static
+     * @param x - The x coordinate of the point.
+     * @param odd - Boolean indicating whether the corresponding y coordinate is odd or not.
+     * @returns Returns the new point.
+     * @throws `Error` If the point is invalid.
+     *
+     * @example
+     * const xCoordinate = new BigNumber('10');
+     * const point = Point.fromX(xCoordinate, true);
+     */
+    static fromX(x: BigNumber | number | number[] | string, odd: boolean): Point;
+    /**
+     * Generates a point from a serialized JSON object. The function accounts for different options in the JSON object,
+     * including precomputed values for optimization of EC operations, and calls another helper function to turn nested
+     * JSON points into proper Point objects.
+     *
+     * @method fromJSON
+     * @static
+     * @param obj - An object or array that holds the data for the point.
+     * @param isRed - A boolean to direct how the Point is constructed from the JSON object.
+     * @returns Returns a new point based on the deserialized JSON object.
+     *
+     * @example
+     * const serializedPoint = '{"x":52,"y":15}';
+     * const point = Point.fromJSON(serializedPoint, true);
+     */
+    static fromJSON(obj: string | any[], isRed: boolean): Point;
+    /**
+     * @constructor
+     * @param x - The x-coordinate of the point. May be a number, a BigNumber, a string (which will be interpreted as hex), a number array, or null. If null, an "Infinity" point is constructed.
+     * @param y - The y-coordinate of the point, similar to x.
+     * @param isRed - A boolean indicating if the point is a member of the field of integers modulo the k256 prime. Default is true.
+     *
+     * @example
+     * new Point('abc123', 'def456');
+     * new Point(null, null); // Generates Infinity point.
+     */
+    constructor(x: BigNumber | number | number[] | string | null, y: BigNumber | number | number[] | string | null, isRed?: boolean);
+    /**
+     * Validates if a point belongs to the curve. Follows the short Weierstrass
+     * equation for elliptic curves: y^2 = x^3 + ax + b.
+     *
+     * @method validate
+     * @returns {boolean} true if the point is on the curve, false otherwise.
+     *
+     * @example
+     * const aPoint = new Point(x, y);
+     * const isValid = aPoint.validate();
+     */
+    validate(): boolean;
+    /**
+     * Encodes the coordinates of a point into an array or a hexadecimal string.
+     * The details of encoding are determined by the optional compact and enc parameters.
+     *
+     * @method encode
+     * @param compact - If true, an additional prefix byte 0x02 or 0x03 based on the 'y' coordinate being even or odd respectively is used. If false, byte 0x04 is used.
+     * @param enc - Expects the string 'hex' if hexadecimal string encoding is required instead of an array of numbers.
+     * @throws Will throw an error if the specified encoding method is not recognized. Expects 'hex'.
+     * @returns If enc is undefined, a byte array representation of the point will be returned. if enc is 'hex', a hexadecimal string representation of the point will be returned.
+     *
+     * @example
+     * const aPoint = new Point(x, y);
+     * const encodedPointArray = aPoint.encode();
+     * const encodedPointHex = aPoint.encode(true, 'hex');
+     */
+    encode(compact?: boolean, enc?: 'hex'): number[] | string;
+    /**
+     * Converts the point coordinates to a hexadecimal string. A wrapper method
+     * for encode. Byte 0x02 or 0x03 is used as prefix based on the 'y' coordinate being even or odd respectively.
+     *
+     * @method toString
+     * @returns {string} A hexadecimal string representation of the point coordinates.
+     *
+     * @example
+     * const aPoint = new Point(x, y);
+     * const stringPoint = aPoint.toString();
+     */
+    toString(): string;
+    /**
+     * Exports the x and y coordinates of the point, and the precomputed doubles and non-adjacent form (NAF) for optimization. The output is an array.
+     *
+     * @method toJSON
+     * @returns An Array where first two elements are the coordinates of the point and optional third element is an object with doubles and NAF points.
+     *
+     * @example
+     * const aPoint = new Point(x, y);
+     * const jsonPoint = aPoint.toJSON();
+     */
+    toJSON(): [
+        BigNumber | null,
+        BigNumber | null,
+        {
+            doubles: {
+                step: any;
+                points: any[];
+            } | undefined;
+            naf: {
+                wnd: any;
+                points: any[];
+            } | undefined;
+        }?
+    ];
+    /**
+     * Provides the point coordinates in a human-readable string format for debugging purposes.
+     *
+     * @method inspect
+     * @returns String of the format '<EC Point x: x-coordinate y: y-coordinate>', or '<EC Point Infinity>' if the point is at infinity.
+     *
+     * @example
+     * const aPoint = new Point(x, y);
+     * console.log(aPoint.inspect());
+     */
+    inspect(): string;
+    /**
+     * Checks if the point is at infinity.
+     * @method isInfinity
+     * @returns Returns whether or not the point is at infinity.
+     *
+     * @example
+     * const p = new Point(null, null);
+     * console.log(p.isInfinity()); // outputs: true
+     */
+    isInfinity(): boolean;
+    /**
+     * Adds another Point to this Point, returning a new Point.
+     *
+     * @method add
+     * @param p - The Point to add to this one.
+     * @returns A new Point that results from the addition.
+     *
+     * @example
+     * const p1 = new Point(1, 2);
+     * const p2 = new Point(2, 3);
+     * const result = p1.add(p2);
+     */
+    add(p: Point): Point;
+    /**
+     * Doubles the current point.
+     *
+     * @method dbl
+     *
+     * @example
+     * const P = new Point('123', '456');
+     * const result = P.dbl();
+     * */
+    dbl(): Point;
+    /**
+     * Returns X coordinate of point
+     *
+     * @example
+     * const P = new Point('123', '456');
+     * const x = P.getX();
+     */
+    getX(): BigNumber;
+    /**
+     * Returns X coordinate of point
+     *
+     * @example
+     * const P = new Point('123', '456');
+     * const x = P.getX();
+     */
+    getY(): BigNumber;
+    /**
+     * Multiplies this Point by a scalar value, returning a new Point.
+     *
+     * @method mul
+     * @param k - The scalar value to multiply this Point by.
+     * @returns  A new Point that results from the multiplication.
+     *
+     * @example
+     * const p = new Point(1, 2);
+     * const result = p.mul(2); // this doubles the Point
+     */
+    mul(k: BigNumber | number | number[] | string): Point;
+    /**
+     * Performs a multiplication and addition operation in a single step.
+     * Multiplies this Point by k1, adds the resulting Point to the result of p2 multiplied by k2.
+     *
+     * @method mulAdd
+     * @param k1 - The scalar value to multiply this Point by.
+     * @param p2 - The other Point to be involved in the operation.
+     * @param k2 - The scalar value to multiply the Point p2 by.
+     * @returns A Point that results from the combined multiplication and addition operations.
+     *
+     * @example
+     * const p1 = new Point(1, 2);
+     * const p2 = new Point(2, 3);
+     * const result = p1.mulAdd(2, p2, 3);
+     */
+    mulAdd(k1: BigNumber, p2: Point, k2: BigNumber): Point;
+    /**
+     * Performs the Jacobian multiplication and addition operation in a single
+     * step. Instead of returning a regular Point, the result is a JacobianPoint.
+     *
+     * @method jmulAdd
+     * @param k1 - The scalar value to multiply this Point by.
+     * @param p2 - The other Point to be involved in the operation
+     * @param k2 - The scalar value to multiply the Point p2 by.
+     * @returns A JacobianPoint that results from the combined multiplication and addition operation.
+     *
+     * @example
+     * const p1 = new Point(1, 2);
+     * const p2 = new Point(2, 3);
+     * const result = p1.jmulAdd(2, p2, 3);
+     */
+    jmulAdd(k1: BigNumber, p2: Point, k2: BigNumber): JPoint;
+    /**
+     * Checks if the Point instance is equal to another given Point.
+     *
+     * @method eq
+     * @param p - The Point to be checked if equal to the current instance.
+     *
+     * @returns Whether the two Point instances are equal. Both the 'x' and 'y' coordinates have to match, and both points have to either be valid or at infinity for equality. If both conditions are true, it returns true, else it returns false.
+     *
+     * @example
+     * const p1 = new Point(5, 20);
+     * const p2 = new Point(5, 20);
+     * const areEqual = p1.eq(p2); // returns true
+     */
+    eq(p: Point): boolean;
+    /**
+     * Negate a point. The negation of a point P is the mirror of P about x-axis.
+     *
+     * @method neg
+     *
+     * @example
+     * const P = new Point('123', '456');
+     * const result = P.neg();
+     */
+    neg(_precompute?: boolean): Point;
+    /**
+     * Performs the "doubling" operation on the Point a given number of times.
+     * This is used in elliptic curve operations to perform multiplication by 2, multiple times.
+     * If the point is at infinity, it simply returns the point because doubling
+     * a point at infinity is still infinity.
+     *
+     * @method dblp
+     * @param k - The number of times the "doubling" operation is to be performed on the Point.
+     * @returns The Point after 'k' "doubling" operations have been performed.
+     *
+     * @example
+     * const p = new Point(5, 20);
+     * const doubledPoint = p.dblp(10); // returns the point after "doubled" 10 times
+     */
+    dblp(k: number): Point;
+    /**
+     * Converts the point to a Jacobian point. If the point is at infinity, the corresponding Jacobian point
+     * will also be at infinity.
+     *
+     * @method toJ
+     * @returns Returns a new Jacobian point based on the current point.
+     *
+     * @example
+     * const point = new Point(xCoordinate, yCoordinate);
+     * const jacobianPoint = point.toJ();
+     */
+    toJ(): JPoint;
+    private _getBeta;
+    private _fixedNafMul;
+    private _wnafMulAdd;
+    private _endoWnafMulAdd;
+    private _hasDoubles;
+    private _getDoubles;
+    private _getNAFPoints;
+}
+//# sourceMappingURL=Point.d.ts.map

package/mobile/node_modules/@bsv/sdk/dist/types/src/primitives/Point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Point.d.ts","sourceRoot":"","sources":["../../../../src/primitives/Point.ts"],"names":[],"mappings":"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"}

package/mobile/node_modules/@bsv/sdk/dist/types/src/primitives/Polynomial.d.ts

@@ -0,0 +1,32 @@
+import PrivateKey from './PrivateKey.js';
+import BigNumber from './BigNumber.js';
+export declare class PointInFiniteField {
+    x: BigNumber;
+    y: BigNumber;
+    constructor(x: BigNumber, y: BigNumber);
+    toString(): string;
+    static fromString(str: string): PointInFiniteField;
+}
+/**
+ * Polynomial class
+ *
+ * This class is used to create a polynomial with a given threshold and a private key.
+ * The polynomial is used to create shares of the private key.
+ *
+ * @param key - The private key to split
+ * @param threshold - The number of shares required to recombine the private key
+ *
+ * @example
+ * const key = new PrivateKey()
+ * const threshold = 2
+ * const polynomial = new Polynomial(key, threshold)
+ *
+ */
+export default class Polynomial {
+    readonly points: PointInFiniteField[];
+    readonly threshold: number;
+    constructor(points: PointInFiniteField[], threshold?: number);
+    static fromPrivateKey(key: PrivateKey, threshold: number): Polynomial;
+    valueAt(x: BigNumber): BigNumber;
+}
+//# sourceMappingURL=Polynomial.d.ts.map

package/mobile/node_modules/@bsv/sdk/dist/types/src/primitives/Polynomial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Polynomial.d.ts","sourceRoot":"","sources":["../../../../src/primitives/Polynomial.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,iBAAiB,CAAA;AACxC,OAAO,SAAS,MAAM,gBAAgB,CAAA;AAKtC,qBAAa,kBAAkB;IAC7B,CAAC,EAAE,SAAS,CAAA;IACZ,CAAC,EAAE,SAAS,CAAA;gBAEC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS;IAMvC,QAAQ,IAAK,MAAM;IAInB,MAAM,CAAC,UAAU,CAAE,GAAG,EAAE,MAAM,GAAG,kBAAkB;CAOpD;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,OAAO,OAAO,UAAU;IAC7B,QAAQ,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAA;IACrC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;gBAEb,MAAM,EAAE,kBAAkB,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM;IAK7D,MAAM,CAAC,cAAc,CAAE,GAAG,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU;IAkBtE,OAAO,CAAE,CAAC,EAAE,SAAS,GAAG,SAAS;CAsBlC"}

package/mobile/node_modules/@bsv/sdk/dist/types/src/primitives/PrivateKey.d.ts

@@ -0,0 +1,284 @@
+import BigNumber from './BigNumber.js';
+import Signature from './Signature.js';
+import PublicKey from './PublicKey.js';
+import Point from './Point.js';
+import { PointInFiniteField } from './Polynomial.js';
+/**
+ * @class KeyShares
+ *
+ * This class is used to store the shares of a private key.
+ *
+ * @param shares - An array of shares
+ * @param threshold - The number of shares required to recombine the private key
+ *
+ * @returns KeyShares
+ *
+ * @example
+ * const key = PrivateKey.fromShares(shares)
+ *
+ */
+export declare class KeyShares {
+    points: PointInFiniteField[];
+    threshold: number;
+    integrity: string;
+    constructor(points: PointInFiniteField[], threshold: number, integrity: string);
+    static fromBackupFormat(shares: string[]): KeyShares;
+    toBackupFormat(): string[];
+}
+/**
+ * Represents a Private Key, which is a secret that can be used to generate signatures in a cryptographic system.
+ *
+ * The `PrivateKey` class extends from the `BigNumber` class. It offers methods to create signatures, verify them,
+ * create a corresponding public key and derive a shared secret from a public key.
+ *
+ * @extends {BigNumber}
+ * @see {@link BigNumber} for more information on BigNumber.
+ */
+export default class PrivateKey extends BigNumber {
+    /**
+     * Generates a private key randomly.
+     *
+     * @method fromRandom
+     * @static
+     * @returns The newly generated Private Key.
+     *
+     * @example
+     * const privateKey = PrivateKey.fromRandom();
+     */
+    static fromRandom(): PrivateKey;
+    /**
+     * Generates a private key from a string.
+     *
+     * @method fromString
+     * @static
+     * @param str - The string to generate the private key from.
+     * @param base - The base of the string.
+     * @returns The generated Private Key.
+     * @throws Will throw an error if the string is not valid.
+     **/
+    static fromString(str: string, base?: number | 'hex'): PrivateKey;
+    /**
+     * Generates a private key from a hexadecimal string.
+     *
+     * @method fromHex
+     * @static
+     * @param {string} str - The hexadecimal string representing the private key. The string must represent a valid private key in big-endian format.
+     * @returns {PrivateKey} The generated Private Key instance.
+     * @throws {Error} If the string is not a valid hexadecimal or represents an invalid private key.
+     **/
+    static fromHex(str: string): PrivateKey;
+    /**
+     * Generates a private key from a WIF (Wallet Import Format) string.
+     *
+     * @method fromWif
+     * @static
+     * @param wif - The WIF string to generate the private key from.
+     * @param base - The base of the string.
+     * @returns The generated Private Key.
+     * @throws Will throw an error if the string is not a valid WIF.
+     **/
+    static fromWif(wif: string, prefixLength?: number): PrivateKey;
+    /**
+     * @constructor
+     *
+     * @param number - The number (various types accepted) to construct a BigNumber from. Default is 0.
+     *
+     * @param base - The base of number provided. By default is 10. Ignored if number is BigNumber.
+     *
+     * @param endian - The endianness provided. By default is 'big endian'. Ignored if number is BigNumber.
+     *
+     * @param modN - Optional. Default 'apply. If 'apply', apply modN to input to guarantee a valid PrivateKey. If 'error', if input is out of field throw new Error('Input is out of field'). If 'nocheck', assumes input is in field.
+     *
+     * @example
+     * import PrivateKey from './PrivateKey';
+     * import BigNumber from './BigNumber';
+     * const privKey = new PrivateKey(new BigNumber('123456', 10, 'be'));
+     */
+    constructor(number?: BigNumber | number | string | number[], base?: number | 'be' | 'le' | 'hex', endian?: 'be' | 'le', modN?: 'apply' | 'nocheck' | 'error');
+    /**
+     * A utility function to check that the value of this PrivateKey lies in the field limited by curve.n
+     * @returns { inField, modN } where modN is this PrivateKey's current BigNumber value mod curve.n, and inField is true only if modN equals current BigNumber value.
+     */
+    checkInField(): {
+        inField: boolean;
+        modN: BigNumber;
+    };
+    /**
+     * @returns true if the PrivateKey's current BigNumber value lies in the field limited by curve.n
+     */
+    isValid(): boolean;
+    /**
+     * Signs a message using the private key.
+     *
+     * @method sign
+     * @param msg - The message (array of numbers or string) to be signed.
+     * @param enc - If 'hex' the string will be treated as hex, utf8 otherwise.
+     * @param forceLowS - If true (the default), the signature will be forced to have a low S value.
+     * @param customK — If provided, uses a custom K-value for the signature. Provie a function that returns a BigNumber, or the BigNumber itself.
+     * @returns A digital signature generated from the hash of the message and the private key.
+     *
+     * @example
+     * const privateKey = PrivateKey.fromRandom();
+     * const signature = privateKey.sign('Hello, World!');
+     */
+    sign(msg: number[] | string, enc?: 'hex' | 'utf8', forceLowS?: boolean, customK?: ((iter: number) => BigNumber) | BigNumber): Signature;
+    /**
+     * Verifies a message's signature using the public key associated with this private key.
+     *
+     * @method verify
+     * @param msg - The original message which has been signed.
+     * @param sig - The signature to be verified.
+     * @param enc - The data encoding method.
+     * @returns Whether or not the signature is valid.
+     *
+     * @example
+     * const privateKey = PrivateKey.fromRandom();
+     * const signature = privateKey.sign('Hello, World!');
+     * const isSignatureValid = privateKey.verify('Hello, World!', signature);
+     */
+    verify(msg: number[] | string, sig: Signature, enc?: 'hex'): boolean;
+    /**
+     * Converts the private key to its corresponding public key.
+     *
+     * The public key is generated by multiplying the base point G of the curve and the private key.
+     *
+     * @method toPublicKey
+     * @returns The generated PublicKey.
+     *
+     * @example
+     * const privateKey = PrivateKey.fromRandom();
+     * const publicKey = privateKey.toPublicKey();
+     */
+    toPublicKey(): PublicKey;
+    /**
+     * Converts the private key to a Wallet Import Format (WIF) string.
+     *
+     * Base58Check encoding is used for encoding the private key.
+     * The prefix
+     *
+     * @method toWif
+     * @returns The WIF string.
+     *
+     * @param prefix defaults to [0x80] for mainnet, set it to [0xef] for testnet.
+     *
+     * @throws Error('Value is out of field') if current BigNumber value is out of field limited by curve.n
+     *
+     * @example
+     * const privateKey = PrivateKey.fromRandom();
+     * const wif = privateKey.toWif();
+     * const testnetWif = privateKey.toWif([0xef]);
+     */
+    toWif(prefix?: number[]): string;
+    /**
+     * Base58Check encodes the hash of the public key associated with this private key with a prefix to indicate locking script type.
+     * Defaults to P2PKH for mainnet, otherwise known as a "Bitcoin Address".
+     *
+     * @param prefix defaults to [0x00] for mainnet, set to [0x6f] for testnet or use the strings 'testnet' or 'mainnet'
+     *
+     * @returns Returns the address encoding associated with the hash of the public key associated with this private key.
+     *
+     * @example
+     * const address = privkey.toAddress()
+     * const address = privkey.toAddress('mainnet')
+     * const testnetAddress = privkey.toAddress([0x6f])
+     * const testnetAddress = privkey.toAddress('testnet')
+     */
+    toAddress(prefix?: number[] | string): string;
+    /**
+     * Converts this PrivateKey to a hexadecimal string.
+     *
+     * @method toHex
+     * @param length - The minimum length of the hex string
+     * @returns Returns a string representing the hexadecimal value of this BigNumber.
+     *
+     * @example
+     * const bigNumber = new BigNumber(255);
+     * const hex = bigNumber.toHex();
+     */
+    toHex(): string;
+    /**
+     * Converts this PrivateKey to a string representation.
+     *
+     * @method toString
+     * @param {number | 'hex'} [base='hex'] - The base for representing the number. Default is hexadecimal ('hex').
+     * @param {number} [padding=64] - The minimum number of digits for the output string. Default is 64, ensuring a 256-bit representation in hexadecimal.
+     * @returns {string} A string representation of the PrivateKey in the specified base, padded to the specified length.
+     *
+     **/
+    toString(base?: number | 'hex', padding?: number): string;
+    /**
+     * Derives a shared secret from the public key.
+     *
+     * @method deriveSharedSecret
+     * @param key - The public key to derive the shared secret from.
+     * @returns The derived shared secret (a point on the curve).
+     * @throws Will throw an error if the public key is not valid.
+     *
+     * @example
+     * const privateKey = PrivateKey.fromRandom();
+     * const publicKey = privateKey.toPublicKey();
+     * const sharedSecret = privateKey.deriveSharedSecret(publicKey);
+     */
+    deriveSharedSecret(key: PublicKey): Point;
+    /**
+     * Derives a child key with BRC-42.
+     * @param publicKey The public key of the other party
+     * @param invoiceNumber The invoice number used to derive the child key
+     * @param cacheSharedSecret Optional function to cache shared secrets
+     * @param retrieveCachedSharedSecret Optional function to retrieve shared secrets from the cache
+     * @returns The derived child key.
+     */
+    deriveChild(publicKey: PublicKey, invoiceNumber: string, cacheSharedSecret?: ((priv: PrivateKey, pub: Point, point: Point) => void), retrieveCachedSharedSecret?: ((priv: PrivateKey, pub: Point) => (Point | undefined))): PrivateKey;
+    /**
+     * Splits the private key into shares using Shamir's Secret Sharing Scheme.
+     *
+     * @param threshold The minimum number of shares required to reconstruct the private key.
+     * @param totalShares The total number of shares to generate.
+     * @param prime The prime number to be used in Shamir's Secret Sharing Scheme.
+     * @returns An array of shares.
+     *
+     * @example
+     * const key = PrivateKey.fromRandom()
+     * const shares = key.toKeyShares(2, 5)
+     */
+    toKeyShares(threshold: number, totalShares: number): KeyShares;
+    /**
+     * @method toBackupShares
+     *
+     * Creates a backup of the private key by splitting it into shares.
+     *
+     *
+     * @param threshold The number of shares which will be required to reconstruct the private key.
+     * @param totalShares The number of shares to generate for distribution.
+     * @returns
+     */
+    toBackupShares(threshold: number, totalShares: number): string[];
+    /**
+     *
+     * @method fromBackupShares
+     *
+     * Creates a private key from backup shares.
+     *
+     * @param shares
+     * @returns PrivateKey
+     *
+     * @example
+     *
+     * const share1 = '3znuzt7DZp8HzZTfTh5MF9YQKNX3oSxTbSYmSRGrH2ev.2Nm17qoocmoAhBTCs8TEBxNXCskV9N41rB2PckcgYeqV.2.35449bb9'
+     * const share2 = 'Cm5fuUc39X5xgdedao8Pr1kvCSm8Gk7Cfenc7xUKcfLX.2juyK9BxCWn2DiY5JUAgj9NsQ77cc9bWksFyW45haXZm.2.35449bb9'
+     *
+     * const recoveredKey = PrivateKey.fromBackupShares([share1, share2])
+     */
+    static fromBackupShares(shares: string[]): PrivateKey;
+    /**
+     * Combines shares to reconstruct the private key.
+     *
+     * @param shares An array of points (shares) to be used to reconstruct the private key.
+     * @param threshold The minimum number of shares required to reconstruct the private key.
+     *
+     * @returns The reconstructed private key.
+     *
+     **/
+    static fromKeyShares(keyShares: KeyShares): PrivateKey;
+}
+//# sourceMappingURL=PrivateKey.d.ts.map