@bsv/wallet-toolbox 1.7.14 → 1.7.16

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

@@ -0,0 +1,39 @@
+import BigNumber from './BigNumber.js';
+import Signature from './Signature.js';
+import Point from './Point.js';
+/**
+ * Generates a digital signature for a given message.
+ *
+ * @function sign
+ * @param msg - The BigNumber message for which the signature has to be computed.
+ * @param key - Private key in BigNumber.
+ * @param forceLowS - Optional boolean flag if True forces "s" to be the lower of two possible values.
+ * @param customK - Optional specification for k value, which can be a function or BigNumber.
+ * @returns Returns the elliptic curve digital signature of the message.
+ *
+ * @example
+ * const msg = new BigNumber('2664878')
+ * const key = new BigNumber('123456')
+ * const signature = sign(msg, key)
+ */
+export declare const sign: (msg: BigNumber, key: BigNumber, forceLowS?: boolean, customK?: BigNumber | ((iter: number) => BigNumber)) => Signature;
+/**
+ * Verifies a digital signature of a given message.
+ *
+ * Message and key used during the signature generation process, and the previously computed signature
+ * are used to validate the authenticity of the digital signature.
+ *
+ * @function verify
+ * @param msg - The BigNumber message for which the signature has to be verified.
+ * @param sig - Signature object consisting of parameters 'r' and 's'.
+ * @param key - Public key in Point.
+ * @returns Returns true if the signature is valid and false otherwise.
+ *
+ * @example
+ * const msg = new BigNumber('2664878', 16)
+ * const key = new Point(new BigNumber(10), new BigNumber(20)
+ * const signature = sign(msg, new BigNumber('123456'))
+ * const isVerified = verify(msg, sig, key)
+ */
+export declare const verify: (msg: BigNumber, sig: Signature, key: Point) => boolean;
+//# sourceMappingURL=ECDSA.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ECDSA.d.ts","sourceRoot":"","sources":["../../../../src/primitives/ECDSA.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,gBAAgB,CAAA;AACtC,OAAO,SAAS,MAAM,gBAAgB,CAAA;AAEtC,OAAO,KAAyH,MAAM,YAAY,CAAA;AA2ClJ;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,IAAI,GACf,KAAK,SAAS,EACd,KAAK,SAAS,EACd,YAAW,OAAe,EAC1B,UAAU,SAAS,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,CAAC,KAClD,SA6EF,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,MAAM,GAAI,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,KAAK,KAAK,KAAG,OA4CnE,CAAA"}

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

@@ -0,0 +1,499 @@
+/**
+ * The BaseHash class is an abstract base class for cryptographic hash functions.
+ * It provides a common structure and functionality for hash function classes.
+ *
+ * @class BaseHash
+ *
+ * @property pending - Stores partially processed message segments.
+ * @property pendingTotal - The total number of characters that are being stored in `pending`
+ * @property blockSize - The size of each block to processed.
+ * @property outSize - The size of the final hash output.
+ * @property endian - The endianness used during processing, can either be 'big' or 'little'.
+ * @property _delta8 - The block size divided by 8, useful in various computations.
+ * @property _delta32 - The block size divided by 32, useful in various computations.
+ * @property padLength - The length of padding to be added to finalize the computation.
+ * @property hmacStrength - The HMAC strength value.
+ *
+ * @param blockSize - The size of the block to be hashed.
+ * @param outSize - The size of the resulting hash.
+ * @param hmacStrength - The strength of the HMAC.
+ * @param padLength - The length of the padding to be added.
+ *
+ * @example
+ * Sub-classes would extend this base BaseHash class like:
+ * class RIPEMD160 extends BaseHash {
+ *   constructor () {
+ *     super(512, 160, 192, 64);
+ *     // ...
+ *   }
+ *   // ...
+ * }
+ */
+declare abstract class BaseHash {
+    pending: number[] | null;
+    pendingTotal: number;
+    blockSize: number;
+    outSize: number;
+    endian: 'big' | 'little';
+    _delta8: number;
+    _delta32: number;
+    padLength: number;
+    hmacStrength: number;
+    constructor(blockSize: number, outSize: number, hmacStrength: number, padLength: number);
+    _update(msg: number[], start: number): void;
+    _digest(): number[];
+    _digestHex(): string;
+    /**
+     * Converts the input message into an array, pads it, and joins into 32bit blocks.
+     * If there is enough data, it tries updating the hash computation.
+     *
+     * @method update
+     * @param msg - The message segment to include in the hashing computation.
+     * @param enc - The encoding of the message. If 'hex', the string will be treated as such, 'utf8' otherwise.
+     *
+     * @returns Returns the instance of the object for chaining.
+     *
+     * @example
+     * sha256.update('Hello World', 'utf8');
+     */
+    update(msg: number[] | string, enc?: 'hex' | 'utf8'): this;
+    /**
+     * Finalizes the hash computation and returns the hash value/result.
+     *
+     * @method digest
+     *
+     * @returns Returns the final hash value.
+     *
+     * @example
+     * const hash = sha256.digest();
+     */
+    digest(): number[];
+    /**
+     * Finalizes the hash computation and returns the hash value/result as a hex string.
+     *
+     * @method digest
+     *
+     * @returns Returns the final hash value as a hex string.
+     *
+     * @example
+     * const hash = sha256.digestHex();
+     */
+    digestHex(): string;
+    /**
+     * [Private Method] Used internally to prepare the padding for the final stage of the hash computation.
+     *
+     * @method _pad
+     * @private
+     *
+     * @returns Returns an array denoting the padding.
+     */
+    private _pad;
+}
+/**
+ *
+ * @param msg
+ * @param enc Optional. Encoding to use if msg is string. Default is 'utf8'.
+ * @returns array of byte values from msg. If msg is an array, a copy is returned.
+ */
+export declare function toArray(msg: number[] | string, enc?: 'hex' | 'utf8'): number[];
+/**
+ * @deprecated
+ * This function behaves differently from the standard C `htonl()`.
+ * It always performs an unconditional 32-bit byte swap.
+ * Use `swapBytes32()` for explicit byte swapping, or `realHtonl()` for
+ * standards-compliant host-to-network conversion.
+ */
+export declare function htonl(w: number): number;
+/**
+ * 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.
+ *
+ * @class RIPEMD160
+ * @param None
+ *
+ * @constructor
+ * Use the RIPEMD160 constructor to create an instance of RIPEMD160 hash function.
+ *
+ * @example
+ * const ripemd160 = new RIPEMD160();
+ *
+ * @property h - Array that is updated iteratively as part of hashing computation.
+ */
+export declare class RIPEMD160 extends BaseHash {
+    h: number[];
+    constructor();
+    _update(msg: number[], start: number): void;
+    _digest(): number[];
+    _digestHex(): string;
+}
+/**
+ * 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.
+ *
+ * @class SHA256
+ * @param None
+ *
+ * @constructor
+ * Use the SHA256 constructor to create an instance of SHA256 hash function.
+ *
+ * @example
+ * const sha256 = new SHA256();
+ *
+ * @property h - The initial hash constants
+ * @property W - Provides a way to recycle usage of the array memory.
+ * @property k - The round constants used for each round of SHA-256
+ */
+export declare class SHA256 {
+    private readonly h;
+    constructor();
+    update(msg: Uint8Array | number[] | string, enc?: 'hex' | 'utf8'): this;
+    digest(): number[];
+    digestHex(): string;
+}
+/**
+ * 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 SHA1
+ * @param None
+ *
+ * @constructor
+ * Use the SHA1 constructor to create an instance of SHA1 hash function.
+ *
+ * @example
+ * const sha1 = new SHA1();
+ *
+ * @property h - The initial hash constants.
+ * @property W - Provides a way to recycle usage of the array memory.
+ * @property k - The round constants used for each round of SHA-1.
+ */
+export declare class SHA1 extends BaseHash {
+    h: number[];
+    W: number[];
+    k: number[];
+    constructor();
+    _update(msg: number[], start?: number): void;
+    _digest(): number[];
+    _digestHex(): string;
+}
+/**
+ * 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.
+ *
+ * @class SHA512
+ * @param None
+ *
+ * @constructor
+ * Use the SHA512 constructor to create an instance of SHA512 hash function.
+ *
+ * @example
+ * const sha512 = new SHA512();
+ *
+ * @property h - The initial hash constants.
+ * @property W - Provides a way to recycle usage of the array memory.
+ * @property k - The round constants used for each round of SHA-512.
+ */
+export declare class SHA512 {
+    private readonly h;
+    constructor();
+    update(msg: number[] | string, enc?: 'hex' | 'utf8'): this;
+    digest(): number[];
+    digestHex(): string;
+}
+/**
+ * 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.
+ *
+ * @property inner - Represents the inner hash of SHA-256.
+ * @property outer - Represents the outer hash of SHA-256.
+ * @property blockSize - The block size for the SHA-256 hash function, in bytes. It's set to 64 bytes.
+ * @property outSize - The output size of the SHA-256 hash function, in bytes. It's set to 32 bytes.
+ */
+export declare class SHA256HMAC {
+    private readonly h;
+    blockSize: number;
+    outSize: number;
+    /**
+     * 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.
+     *
+     * @constructor
+     * @param key - The key to use to create the HMAC. Can be a number array or a string in hexadecimal format.
+     *
+     * @example
+     * const myHMAC = new SHA256HMAC('deadbeef');
+     */
+    constructor(key: Uint8Array | number[] | string);
+    /**
+     * Updates the `SHA256HMAC` object with part of the message to be hashed.
+     *
+     * @method update
+     * @param msg - Part of the message to hash. Can be a number array or a string.
+     * @param enc - If 'hex', then the input is encoded as hexadecimal. If undefined or not 'hex', then no encoding is performed.
+     * @returns Returns the instance of `SHA256HMAC` for chaining calls.
+     *
+     * @example
+     * myHMAC.update('deadbeef', 'hex');
+     */
+    update(msg: Uint8Array | number[] | string, enc?: 'hex'): SHA256HMAC;
+    /**
+     * Finalizes the HMAC computation and returns the resultant hash.
+     *
+     * @method digest
+     * @returns Returns the digest of the hashed data. Can be a number array or a string.
+     *
+     * @example
+     * let hashedMessage = myHMAC.digest();
+     */
+    digest(): number[];
+    /**
+     * Finalizes the HMAC computation and returns the resultant hash as a hex string.
+     *
+     * @method digest
+     * @returns Returns the digest of the hashed data as a hex string
+     *
+     * @example
+     * let hashedMessage = myHMAC.digestHex();
+     */
+    digestHex(): string;
+}
+export declare class SHA1HMAC {
+    inner: SHA1;
+    outer: SHA1;
+    blockSize: number;
+    constructor(key: number[] | string);
+    update(msg: number[] | string, enc?: 'hex'): SHA1HMAC;
+    digest(): number[];
+    digestHex(): string;
+}
+/**
+ * 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.
+ *
+ * @property inner - Represents the inner hash of SHA-512.
+ * @property outer - Represents the outer hash of SHA-512.
+ * @property blockSize - The block size for the SHA-512 hash function, in bytes. It's set to 128 bytes.
+ * @property outSize - The output size of the SHA-512 hash function, in bytes. It's set to 64 bytes.
+ */
+export declare class SHA512HMAC {
+    private readonly h;
+    blockSize: number;
+    outSize: number;
+    /**
+     * The constructor for the `SHA512HMAC` class.
+     *
+     * 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.
+     *
+     * @constructor
+     * @param key - The key to use to create the HMAC. Can be a number array or a string in hexadecimal format.
+     *
+     * @example
+     * const myHMAC = new SHA512HMAC('deadbeef');
+     */
+    constructor(key: Uint8Array | number[] | string);
+    /**
+     * Updates the `SHA512HMAC` object with part of the message to be hashed.
+     *
+     * @method update
+     * @param msg - Part of the message to hash. Can be a number array or a string.
+     * @param enc - If 'hex', then the input is encoded as hexadecimal. If undefined or not 'hex', then no encoding is performed.
+     * @returns Returns the instance of `SHA512HMAC` for chaining calls.
+     *
+     * @example
+     * myHMAC.update('deadbeef', 'hex');
+     */
+    update(msg: Uint8Array | number[] | string, enc?: 'hex' | 'utf8'): SHA512HMAC;
+    /**
+     * Finalizes the HMAC computation and returns the resultant hash.
+     *
+     * @method digest
+     * @returns Returns the digest of the hashed data as a number array.
+     *
+     * @example
+     * let hashedMessage = myHMAC.digest();
+     */
+    digest(): number[];
+    /**
+     * Finalizes the HMAC computation and returns the resultant hash as a hex string.
+     *
+     * @method digest
+     * @returns Returns the digest of the hashed data as a hex string
+     *
+     * @example
+     * let hashedMessage = myHMAC.digestHex();
+     */
+    digestHex(): string;
+}
+/**
+ * Computes RIPEMD160 hash of a given message.
+ * @function ripemd160
+ * @param msg - The message to compute the hash for.
+ * @param enc - The encoding of msg if string. Default is 'utf8'.
+ *
+ * @returns the computed RIPEMD160 hash of the message.
+ *
+ * @example
+ * const digest = ripemd160('Hello, world!');
+ */
+export declare const ripemd160: (msg: number[] | string, enc?: "hex" | "utf8") => number[];
+/**
+ * Computes SHA1 hash of a given message.
+ * @function sha1
+ * @param msg - The message to compute the hash for.
+ * @param enc - The encoding of msg if string. Default is 'utf8'.
+ *
+ * @returns the computed SHA1 hash of the message.
+ *
+ * @example
+ * const digest = sha1('Hello, world!');
+ */
+export declare const sha1: (msg: number[] | string, enc?: "hex" | "utf8") => number[];
+/**
+ * Computes SHA256 hash of a given message.
+ * @function sha256
+ * @param msg - The message to compute the hash for.
+ * @param enc - The encoding of msg if string. Default is 'utf8'.
+ *
+ * @returns the computed SHA256 hash of the message.
+ *
+ * @example
+ * const digest = sha256('Hello, world!');
+ */
+export declare const sha256: (msg: Uint8Array | number[] | string, enc?: "hex" | "utf8") => number[];
+/**
+ * Computes SHA512 hash of a given message.
+ * @function sha512
+ * @param msg - The message to compute the hash for.
+ * @param enc - The encoding of msg if string. Default is 'utf8'.
+ *
+ * @returns the computed SHA512 hash of the message.
+ *
+ * @example
+ * const digest = sha512('Hello, world!');
+ */
+export declare const sha512: (msg: number[] | string, enc?: "hex" | "utf8") => number[];
+/**
+ * Performs a 'double hash' using SHA256. This means the data is hashed twice
+ * with SHA256. First, the SHA256 hash of the message is computed, then the
+ * SHA256 hash of the resulting hash is computed.
+ * @function hash256
+ * @param msg - The message to compute the hash for.
+ * @param enc - The encoding of msg if string. Default is 'utf8'.
+ *
+ * @returns the double hashed SHA256 output.
+ *
+ * @example
+ * const doubleHash = hash256('Hello, world!');
+ */
+export declare const hash256: (msg: Uint8Array | number[] | string, enc?: "hex" | "utf8") => number[];
+/**
+ * Computes SHA256 hash of a given message and then computes a RIPEMD160 hash of the result.
+ *
+ * @function hash160
+ * @param msg - The message to compute the hash for.
+ * @param enc - The encoding of msg if string. Default is 'utf8'.
+ *
+ * @returns the RIPEMD160 hash of the SHA256 hash of the input message.
+ *
+ * @example
+ * const hash = hash160('Hello, world!');
+ */
+export declare const hash160: (msg: Uint8Array | number[] | string, enc?: "hex" | "utf8") => number[];
+/**
+ * Computes SHA256 HMAC of a given message with a given key.
+ * @function sha256hmac
+ * @param key - The key used to compute the HMAC
+ * @param msg - The message to compute the hash for.
+ * @param enc - The encoding of msg if string. Default is 'utf8'.
+ *
+ * @returns the computed HMAC of the message.
+ *
+ * @example
+ * const digest = sha256hmac('deadbeef', 'ffff001d');
+ */
+export declare const sha256hmac: (key: Uint8Array | number[] | string, msg: Uint8Array | number[] | string, enc?: "hex") => number[];
+/**
+ * Computes SHA512 HMAC of a given message with a given key.
+ * @function sha512hmac
+ * @param key - The key used to compute the HMAC
+ * @param msg - The message to compute the hash for.
+ * @param enc - The encoding of msg if string. Default is 'utf8'.
+ *
+ * @returns the computed HMAC of the message.
+ *
+ * @example
+ * const digest = sha512hmac('deadbeef', 'ffff001d');
+ */
+export declare const sha512hmac: (key: Uint8Array | number[] | string, msg: Uint8Array | number[] | string, enc?: "hex") => number[];
+/**
+ * Limited SHA-512-only PBKDF2 function for use in deprecated BIP39 code.
+ * @function pbkdf2
+ * @param password - The PBKDF2 password
+ * @param salt - The PBKDF2 salt
+ * @param iterations - The number of of iterations to run
+ * @param keylen - The length of the key
+ * @param digest - The digest (must be sha512 for this implementation)
+ *
+ * @returns The computed key
+ */
+export declare function pbkdf2(password: number[], salt: number[], iterations: number, keylen: number, digest?: string): number[];
+/**
+ * Unconditionally swaps the byte order of a 32-bit unsigned integer.
+ *
+ * This function performs a strict 32-bit byte swap regardless of host
+ * endianness. It is equivalent to the behavior commonly referred to as
+ * `bswap32` in low-level libraries.
+ *
+ * This function is introduced as part of TOB-20 to provide a clearly-named
+ * alternative to `htonl()`, which was previously implemented as an
+ * unconditional byte swap and did not match the semantics of the traditional
+ * C `htonl()` function.
+ *
+ * @param w - A 32-bit unsigned integer.
+ * @returns The value with its byte order reversed.
+ *
+ * @example
+ * swapBytes32(0x11223344) // → 0x44332211
+ */
+export declare function swapBytes32(w: number): number;
+/**
+ * Converts a 32-bit unsigned integer from host byte order to network byte order.
+ *
+ * Unlike the legacy `htonl()` implementation (which always swapped bytes),
+ * this function behaves like the traditional C `htonl()`:
+ *
+ * - On **little-endian** machines → performs a byte swap.
+ * - On **big-endian** machines → returns the value unchanged.
+ *
+ * This function is provided to resolve TOB-20, which identified that the
+ * previous `htonl()` implementation had a misleading name and did not match
+ * platform-dependent semantics.
+ *
+ * @param w - A 32-bit unsigned integer.
+ * @returns The value converted to network byte order.
+ *
+ * @example
+ * realHtonl(0x11223344) // → 0x44332211 on little-endian systems
+ */
+export declare function realHtonl(w: number): number;
+export {};
+//# sourceMappingURL=Hash.d.ts.map

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

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