@bsv/wallet-toolbox 1.7.13 → 1.7.15

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

@@ -0,0 +1,162 @@
+import BigNumber from './BigNumber.js';
+import PublicKey from './PublicKey.js';
+/**
+ * Represents a digital signature.
+ *
+ * A digital signature is a mathematical scheme for verifying the authenticity of
+ * digital messages or documents. In many scenarios, it is equivalent to a handwritten signature or stamped seal.
+ * The signature pair (R, S) corresponds to the raw ECDSA ([Elliptic Curve Digital Signature Algorithm](https://en.wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm)) signature.
+ * Signatures are often serialized into a format known as '[DER encoding](https://en.wikipedia.org/wiki/X.690#DER_encoding)' for transmission.
+ *
+ * @class Signature
+ */
+export default class Signature {
+    /**
+     * @property Represents the "r" component of the digital signature
+     */
+    r: BigNumber;
+    /**
+     * @property Represents the "s" component of the digital signature
+     */
+    s: BigNumber;
+    /**
+     * Takes an array of numbers or a string and returns a new Signature instance.
+     * This method will throw an error if the DER encoding is invalid.
+     * If a string is provided, it is assumed to represent a hexadecimal sequence.
+     *
+     * @static
+     * @method fromDER
+     * @param data - The sequence to decode from DER encoding.
+     * @param enc - The encoding of the data string.
+     * @returns The decoded data in the form of Signature instance.
+     *
+     * @example
+     * const signature = Signature.fromDER('30440220018c1f5502f8...', 'hex');
+     */
+    static fromDER(data: number[] | string, enc?: 'hex' | 'base64'): Signature;
+    /**
+     * Takes an array of numbers or a string and returns a new Signature instance.
+     * This method will throw an error if the Compact encoding is invalid.
+     * If a string is provided, it is assumed to represent a hexadecimal sequence.
+     * compactByte value 27-30 means uncompressed public key.
+     * 31-34 means compressed public key.
+     * The range represents the recovery param which can be 0,1,2,3.
+     * We could support recovery functions in future if there's demand.
+     *
+     * @static
+     * @method fromCompact
+     * @param data - The sequence to decode from Compact encoding.
+     * @param enc - The encoding of the data string.
+     * @returns The decoded data in the form of Signature instance.
+     *
+     * @example
+     * const signature = Signature.fromCompact('1b18c1f5502f8...', 'hex');
+     */
+    static fromCompact(data: number[] | string, enc?: 'hex' | 'base64'): Signature;
+    /**
+     * Creates an instance of the Signature class.
+     *
+     * @constructor
+     * @param r - The R component of the signature.
+     * @param s - The S component of the signature.
+     *
+     * @example
+     * const r = new BigNumber('208755674028...');
+     * const s = new BigNumber('564745627577...');
+     * const signature = new Signature(r, s);
+     */
+    constructor(r: BigNumber, s: BigNumber);
+    /**
+     * Verifies a digital signature.
+     *
+     * This method will return true if the signature, key, and message hash match.
+     * If the data or key do not match the signature, the function returns false.
+     *
+     * @method verify
+     * @param msg - The message to verify.
+     * @param key - The public key used to sign the original message.
+     * @param enc - The encoding of the msg string.
+     * @returns A boolean representing whether the signature is valid.
+     *
+     * @example
+     * const msg = 'The quick brown fox jumps over the lazy dog';
+     * const publicKey = PublicKey.fromString('04188ca1050...');
+     * const isVerified = signature.verify(msg, publicKey);
+     */
+    verify(msg: number[] | string, key: PublicKey, enc?: 'hex'): boolean;
+    /**
+     * Converts an instance of Signature into DER encoding.
+     * An alias for the toDER method.
+     *
+     * If the encoding parameter is set to 'hex', the function will return a hex string.
+     * If 'base64', it will return a base64 string.
+     * Otherwise, it will return an array of numbers.
+     *
+     * @method toDER
+     * @param enc - The encoding to use for the output.
+     * @returns The current instance in DER encoding.
+     *
+     * @example
+     * const der = signature.toString('base64');
+     */
+    toString(enc?: 'hex' | 'base64'): number[] | string;
+    /**
+     * Converts an instance of Signature into DER encoding.
+     *
+     * If the encoding parameter is set to 'hex', the function will return a hex string.
+     * If 'base64', it will return a base64 string.
+     * Otherwise, it will return an array of numbers.
+     *
+     * @method toDER
+     * @param enc - The encoding to use for the output.
+     * @returns The current instance in DER encoding.
+     *
+     * @example
+     * const der = signature.toDER('hex');
+     */
+    toDER(enc?: 'hex' | 'base64'): number[] | string;
+    /**
+     * Converts an instance of Signature into Compact encoding.
+     *
+     * If the encoding parameter is set to 'hex', the function will return a hex string.
+     * If 'base64', it will return a base64 string.
+     * Otherwise, it will return an array of numbers.
+     *
+     * @method toCompact
+     * @param enc - The encoding to use for the output.
+     * @returns The current instance in DER encoding.
+     *
+     * @example
+     * const compact = signature.toCompact(3, true, 'base64');
+     */
+    toCompact(recovery: number, compressed: boolean, enc?: 'hex' | 'base64'): number[] | string;
+    /**
+     * Recovers the public key from a signature.
+     * This method will return the public key if it finds a valid public key.
+     * If it does not find a valid public key, it will throw an error.
+     * The recovery factor is a number between 0 and 3.
+     * @method RecoverPublicKey
+     * @param recovery - The recovery factor.
+     * @param e - The message hash.
+     * @returns The public key associated with the signature.
+     *
+     * @example
+     * const publicKey = signature.RecoverPublicKey(0, msgHash);
+     */
+    RecoverPublicKey(recovery: number, e: BigNumber): PublicKey;
+    /**
+     * Calculates the recovery factor which will work for a particular public key and message hash.
+     * This method will return the recovery factor if it finds a valid recovery factor.
+     * If it does not find a valid recovery factor, it will throw an error.
+     * The recovery factor is a number between 0 and 3.
+     *
+     * @method CalculateRecoveryFactor
+     * @param msgHash - The message hash.
+     * @returns the recovery factor: number
+     * /
+     * @example
+     * const recovery = signature.CalculateRecoveryFactor(publicKey, msgHash);
+     */
+    CalculateRecoveryFactor(pubkey: PublicKey, msgHash: BigNumber): number;
+}
+//# sourceMappingURL=Signature.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Signature.d.ts","sourceRoot":"","sources":["../../../../src/primitives/Signature.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,gBAAgB,CAAA;AACtC,OAAO,SAAS,MAAM,gBAAgB,CAAA;AAOtC;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,OAAO,SAAS;IAC5B;;OAEG;IACH,CAAC,EAAE,SAAS,CAAA;IAEZ;;OAEG;IACH,CAAC,EAAE,SAAS,CAAA;IAEZ;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,OAAO,CAAE,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,SAAS;IA0D3E;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,WAAW,CAChB,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,EACvB,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,GACrB,SAAS;IAeZ;;;;;;;;;;;OAWG;gBACU,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS;IAKvC;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAE,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO;IAKrE;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAE,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,EAAE,GAAG,MAAM;IAIpD;;;;;;;;;;;;;OAaG;IACH,KAAK,CAAE,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,EAAE,GAAG,MAAM;IAyDjD;;;;;;;;;;;;;OAaG;IACH,SAAS,CACP,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,OAAO,EACnB,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,GACrB,MAAM,EAAE,GAAG,MAAM;IAqBpB;;;;;;;;;;;;OAYG;IACH,gBAAgB,CAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,EAAE,SAAS,GAAG,SAAS;IA2C5D;;;;;;;;;;;;OAYG;IACH,uBAAuB,CAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,GAAG,MAAM;CAcxE"}

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

@@ -0,0 +1,55 @@
+import BigNumber from './BigNumber.js';
+/**
+ * `SymmetricKey` is a class that extends the `BigNumber` class and implements symmetric encryption and decryption methods.
+ * Symmetric-Key encryption is a form of encryption where the same key is used to encrypt and decrypt the message.
+ * It leverages the Advanced Encryption Standard Galois/Counter Mode (AES-GCM) for encryption and decryption of messages.
+ *
+ * @class SymmetricKey
+ * @extends {BigNumber}
+ */
+export default class SymmetricKey extends BigNumber {
+    /**
+     * Generates a symmetric key randomly.
+     *
+     * @method fromRandom
+     * @static
+     * @returns The newly generated Symmetric Key.
+     *
+     * @example
+     * const symmetricKey = SymmetricKey.fromRandom();
+     */
+    static fromRandom(): SymmetricKey;
+    /**
+     * Encrypts a given message using AES-GCM encryption.
+     * The generated Initialization Vector (IV) is attached to the encrypted message for decryption purposes.
+     * The OpenSSL format of |IV|encryptedContent|authTag| is used.
+     *
+     * @method encrypt
+     * @param msg - The message to be encrypted. It can be a string or an array of numbers.
+     * @param enc - optional. The encoding of the message. If hex, the string is assumed to be hex, UTF-8 otherwise.
+     * @returns Returns the encrypted message as a string or an array of numbers, depending on `enc` argument.
+     *
+     * @example
+     * const key = new SymmetricKey(1234);
+     * const encryptedMessage = key.encrypt('plainText', 'utf8');
+     */
+    encrypt(msg: number[] | string, enc?: 'hex'): string | number[];
+    /**
+     * Decrypts a given AES-GCM encrypted message using the same key that was used for encryption.
+     * The method extracts the IV and the authentication tag from the encrypted message, then attempts to decrypt it.
+     * If the decryption fails (e.g., due to message tampering), an error is thrown.
+     *
+     * @method decrypt
+     * @param msg - The encrypted message to be decrypted. It can be a string or an array of numbers.
+     * @param enc - optional. The encoding of the message (if no encoding is provided, uses utf8 for strings, unless specified as hex).
+     * @returns Returns the decrypted message as a string or an array of numbers, depending on `enc` argument. If absent, an array of numbers is returned.
+     *
+     * @example
+     * const key = new SymmetricKey(1234);
+     * const decryptedMessage = key.decrypt(encryptedMessage, 'utf8');
+     *
+     * @throws {Error} Will throw an error if the decryption fails, likely due to message tampering or incorrect decryption key.
+     */
+    decrypt(msg: number[] | string, enc?: 'hex' | 'utf8'): string | number[];
+}
+//# sourceMappingURL=SymmetricKey.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SymmetricKey.d.ts","sourceRoot":"","sources":["../../../../src/primitives/SymmetricKey.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,gBAAgB,CAAA;AAKtC;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,SAAS;IACjD;;;;;;;;;OASG;IACH,MAAM,CAAC,UAAU,IAAK,YAAY;IAIlC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAE,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,EAAE;IAgBhE;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAE,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE;CA2B1E"}

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

@@ -0,0 +1,57 @@
+import Signature from './Signature.js';
+import BigNumber from './BigNumber.js';
+import Script from '../script/Script.js';
+import TransactionInput from '../transaction/TransactionInput.js';
+import TransactionOutput from '../transaction/TransactionOutput.js';
+export interface SignatureHashCache {
+    hashPrevouts?: number[];
+    hashSequence?: number[];
+    hashOutputsAll?: number[];
+    hashOutputsSingle?: Map<number, number[]>;
+}
+interface TransactionSignatureFormatParams {
+    sourceTXID: string;
+    sourceOutputIndex: number;
+    sourceSatoshis: number;
+    transactionVersion: number;
+    otherInputs: TransactionInput[];
+    outputs: TransactionOutput[];
+    inputIndex: number;
+    subscript: Script;
+    inputSequence: number;
+    lockTime: number;
+    scope: number;
+    cache?: SignatureHashCache;
+}
+export default class TransactionSignature extends Signature {
+    static readonly SIGHASH_ALL = 1;
+    static readonly SIGHASH_NONE = 2;
+    static readonly SIGHASH_SINGLE = 3;
+    static readonly SIGHASH_FORKID = 64;
+    static readonly SIGHASH_ANYONECANPAY = 128;
+    scope: number;
+    /**
+     * Formats the SIGHASH preimage for the targeted input, optionally using a cache to skip recomputing shared hash prefixes.
+     * @param params - Context for the signing input plus transaction metadata.
+     * @param params.cache - Optional cache storing previously computed `hashPrevouts`, `hashSequence`, or `hashOutputs*` values; it will be populated if present.
+     */
+    static format(params: TransactionSignatureFormatParams): number[];
+    /**
+     * Formats the same SIGHASH preimage bytes as `format`, supporting the optional cache for hash reuse.
+     * @param params - Context for the signing operation.
+     * @param params.cache - Optional `SignatureHashCache` that may already contain hashed prefixes and is populated during formatting.
+     * @returns Bytes for signing.
+     */
+    static formatBytes(params: TransactionSignatureFormatParams): Uint8Array;
+    static fromChecksigFormat(buf: number[]): TransactionSignature;
+    constructor(r: BigNumber, s: BigNumber, scope: number);
+    /**
+     * Compares to bitcoind's IsLowDERSignature
+     * See also Ecdsa signature algorithm which enforces this.
+     * See also Bip 62, "low S values in signatures"
+     */
+    hasLowS(): boolean;
+    toChecksigFormat(): number[];
+}
+export {};
+//# sourceMappingURL=TransactionSignature.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionSignature.d.ts","sourceRoot":"","sources":["../../../../src/primitives/TransactionSignature.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,gBAAgB,CAAA;AACtC,OAAO,SAAS,MAAM,gBAAgB,CAAA;AAGtC,OAAO,MAAM,MAAM,qBAAqB,CAAA;AACxC,OAAO,gBAAgB,MAAM,oCAAoC,CAAA;AACjE,OAAO,iBAAiB,MAAM,qCAAqC,CAAA;AAEnE,MAAM,WAAW,kBAAkB;IACjC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;IACvB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;IACvB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;IACzB,iBAAiB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;CAC1C;AAED,UAAU,gCAAgC;IACxC,UAAU,EAAE,MAAM,CAAA;IAClB,iBAAiB,EAAE,MAAM,CAAA;IACzB,cAAc,EAAE,MAAM,CAAA;IACtB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,WAAW,EAAE,gBAAgB,EAAE,CAAA;IAC/B,OAAO,EAAE,iBAAiB,EAAE,CAAA;IAC5B,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;IACrB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,kBAAkB,CAAA;CAC3B;AAID,MAAM,CAAC,OAAO,OAAO,oBAAqB,SAAQ,SAAS;IACzD,gBAAuB,WAAW,KAAa;IAC/C,gBAAuB,YAAY,KAAa;IAChD,gBAAuB,cAAc,KAAa;IAClD,gBAAuB,cAAc,MAAa;IAClD,gBAAuB,oBAAoB,OAAa;IAExD,KAAK,EAAE,MAAM,CAAA;IAEb;;;;OAIG;IACH,MAAM,CAAC,MAAM,CAAE,MAAM,EAAE,gCAAgC,GAAG,MAAM,EAAE;IAIlE;;;;;OAKG;IACH,MAAM,CAAC,WAAW,CAAE,MAAM,EAAE,gCAAgC,GAAG,UAAU;IAgKzE,MAAM,CAAC,kBAAkB,CAAE,GAAG,EAAE,MAAM,EAAE,GAAG,oBAAoB;gBAclD,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM;IAKtD;;;;OAIG;IACI,OAAO,IAAK,OAAO;IAe1B,gBAAgB,IAAK,MAAM,EAAE;CAI9B"}

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

@@ -0,0 +1,3 @@
+export declare function assertValidHex(msg: string): void;
+export declare function normalizeHex(msg: string): string;
+//# sourceMappingURL=hex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hex.d.ts","sourceRoot":"","sources":["../../../../src/primitives/hex.ts"],"names":[],"mappings":"AAKA,wBAAgB,cAAc,CAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAajD;AAED,wBAAgB,YAAY,CAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAcjD"}

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

@@ -0,0 +1,16 @@
+export { default as BigNumber } from './BigNumber.js';
+export { default as Curve } from './Curve.js';
+export { default as Point } from './Point.js';
+export { default as PublicKey } from './PublicKey.js';
+export { default as Signature } from './Signature.js';
+export { default as PrivateKey, KeyShares } from './PrivateKey.js';
+export { default as SymmetricKey } from './SymmetricKey.js';
+export * as ECDSA from './ECDSA.js';
+export * as Utils from './utils.js';
+export * as Hash from './Hash.js';
+export { default as Random } from './Random.js';
+export { default as TransactionSignature } from './TransactionSignature.js';
+export { default as Polynomial, PointInFiniteField } from './Polynomial.js';
+export { default as Schnorr } from './Schnorr.js';
+export { default as Secp256r1 } from './Secp256r1.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/primitives/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,YAAY,CAAA;AAC7C,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,YAAY,CAAA;AAC7C,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAClE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAC3D,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AACnC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AACnC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAC3E,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAC3E,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,cAAc,CAAA;AACjD,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,gBAAgB,CAAA"}

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

@@ -0,0 +1,140 @@
+import BigNumber from './BigNumber.js';
+/**
+ * Prepends a '0' to an odd character length word to ensure it has an even number of characters.
+ * @param {string} word - The input word.
+ * @returns {string} - The word with a leading '0' if it's an odd character length; otherwise, the original word.
+ */
+export declare const zero2: (word: string) => string;
+export declare const toHex: (msg: number[]) => string;
+/**
+ * Converts various message formats into an array of numbers.
+ * Supports arrays, hexadecimal strings, base64 strings, and UTF-8 strings.
+ *
+ * @param {any} msg - The input message (array or string).
+ * @param {('hex' | 'utf8' | 'base64')} enc - Specifies the string encoding, if applicable.
+ * @returns {any[]} - Array representation of the input.
+ */
+export declare const toArray: (msg: any, enc?: "hex" | "utf8" | "base64") => any[];
+export declare function base64ToArray(msg: string): number[];
+/**
+ * Converts an array of numbers to a UTF-8 encoded string.
+ * @param {number[]} arr - The input array of numbers.
+ * @returns {string} - The UTF-8 encoded string.
+ */
+export declare const toUTF8: (arr: number[]) => string;
+/**
+ * Encodes an array of numbers into a specified encoding ('hex' or 'utf8'). If no encoding is provided, returns the original array.
+ * @param {number[]} arr - The input array of numbers.
+ * @param {('hex' | 'utf8')} enc - The desired encoding.
+ * @returns {string | number[]} - The encoded message as a string (for 'hex' and 'utf8') or the original array.
+ */
+export declare const encode: (arr: number[], enc?: "hex" | "utf8") => string | number[];
+/**
+ * Converts an array of bytes (each between 0 and 255) into a base64 encoded string.
+ *
+ * @param {number[]} byteArray - An array of numbers where each number is a byte (0-255).
+ * @returns {string} The base64 encoded string.
+ *
+ * @example
+ * const bytes = [72, 101, 108, 108, 111]; // Represents the string "Hello"
+ * console.log(toBase64(bytes)); // Outputs: SGVsbG8=
+ */
+export declare function toBase64(byteArray: number[]): string;
+/**
+ * Converts a string from base58 to a binary array
+ * @param str - The string representation
+ * @returns The binary representation
+ */
+export declare const fromBase58: (str: string) => number[];
+/**
+ * Converts a binary array into a base58 string
+ * @param bin - The binary array to convert to base58
+ * @returns The base58 string representation
+ */
+export declare const toBase58: (bin: number[]) => string;
+/**
+ * Converts a binary array into a base58check string with a checksum
+ * @param bin - The binary array to convert to base58check
+ * @returns The base58check string representation
+ */
+export declare const toBase58Check: (bin: number[], prefix?: number[]) => string;
+/**
+ * Converts a base58check string into a binary array after validating the checksum
+ * @param str - The base58check string to convert to binary
+ * @param enc - If hex, the return values will be hex strings, arrays of numbers otherwise
+ * @param prefixLength - The length of the prefix. Optional, defaults to 1.
+ * @returns The binary array representation
+ */
+export declare const fromBase58Check: (str: string, enc?: "hex", prefixLength?: number) => {
+    data: number[] | string;
+    prefix: number[] | string;
+};
+type WriterChunk = readonly number[] | Uint8Array;
+export declare class Writer {
+    bufs: WriterChunk[];
+    private length;
+    constructor(bufs?: WriterChunk[]);
+    getLength(): number;
+    toUint8Array(): Uint8Array;
+    toArray(): number[];
+    write(buf: WriterChunk): this;
+    writeReverse(buf: number[]): this;
+    writeUInt8(n: number): this;
+    writeInt8(n: number): this;
+    writeUInt16BE(n: number): this;
+    writeInt16BE(n: number): this;
+    writeUInt16LE(n: number): this;
+    writeInt16LE(n: number): this;
+    writeUInt32BE(n: number): this;
+    writeInt32BE(n: number): this;
+    writeUInt32LE(n: number): this;
+    writeInt32LE(n: number): this;
+    writeUInt64BEBn(bn: BigNumber): this;
+    writeUInt64LEBn(bn: BigNumber): this;
+    writeUInt64LE(n: number): this;
+    writeVarIntNum(n: number): this;
+    writeVarIntBn(bn: BigNumber): this;
+    static varIntNum(n: number): number[];
+    static varIntBn(bn: BigNumber): number[];
+}
+export declare class Reader {
+    bin: number[];
+    pos: number;
+    private readonly length;
+    constructor(bin?: number[], pos?: number);
+    eof(): boolean;
+    read(len?: number): number[];
+    readReverse(len?: number): number[];
+    readUInt8(): number;
+    readInt8(): number;
+    readUInt16BE(): number;
+    readInt16BE(): number;
+    readUInt16LE(): number;
+    readInt16LE(): number;
+    readUInt32BE(): number;
+    readInt32BE(): number;
+    readUInt32LE(): number;
+    readInt32LE(): number;
+    readUInt64BEBn(): BigNumber;
+    readUInt64LEBn(): BigNumber;
+    readInt64LEBn(): BigNumber;
+    readVarIntNum(signed?: boolean): number;
+    readVarInt(): number[];
+    readVarIntBn(): BigNumber;
+}
+export declare const minimallyEncode: (buf: number[]) => number[];
+/**
+ * Verifies that a value is not null or undefined, throwing an error if it is.
+ *
+ * @template T - The type of the value being verified
+ * @param {T | undefined | null} value - The value to verify
+ * @param {string} errorMessage - The error message to throw if the value is null or undefined
+ * @returns {T} - The verified value
+ * @throws {Error} - If the value is null or undefined
+ *
+ * @example
+ * const myValue = verifyNotNull(someValue, 'someValue must be defined')
+ */
+export declare function verifyNotNull<T>(value: T | undefined | null, errorMessage?: string): T;
+export {};
+//# sourceMappingURL=utils.d.ts.map

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

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

package/mobile/node_modules/@bsv/sdk/dist/types/src/registry/RegistryClient.d.ts

@@ -0,0 +1,121 @@
+import { WalletInterface, WalletProtocol, OriginatorDomainNameStringUnder250Bytes } from '../wallet/index.js';
+import { BroadcastResponse, BroadcastFailure } from '../transaction/index.js';
+import { LookupResolver } from '../overlay-tools/index.js';
+import { DefinitionData, DefinitionType, RegistryQueryMapping, RegistryRecord } from './types/index.js';
+/**
+ * RegistryClient manages on-chain registry definitions for three types:
+ * - basket (basket-based items)
+ * - protocol (protocol-based items)
+ * - certificate (certificate-based items)
+ *
+ * It provides methods to:
+ * - Register new definitions using pushdrop-based UTXOs.
+ * - Resolve existing definitions using a lookup service.
+ * - List registry entries associated with the operator's wallet.
+ * - Remove existing registry entries by spending their UTXOs.
+ * - Update existing registry entries.
+ *
+ * Registry operators use this client to establish and manage
+ * canonical references for baskets, protocols, and certificate types.
+ */
+export declare class RegistryClient {
+    private readonly wallet;
+    private readonly originator?;
+    private network;
+    private readonly resolver;
+    private cachedIdentityKey;
+    private readonly acceptDelayedBroadcast;
+    constructor(wallet?: WalletInterface, options?: {
+        acceptDelayedBroadcast?: boolean;
+        resolver?: LookupResolver;
+    }, originator?: OriginatorDomainNameStringUnder250Bytes);
+    /**
+     * Gets the wallet's identity key, caching it after the first call.
+     * @returns The public identity key as a hex string.
+     */
+    private getIdentityKey;
+    /**
+     * Gets the network, initializing and caching it on first call.
+     * @returns The network type ('mainnet' or 'testnet').
+     */
+    private getNetwork;
+    /**
+     * Publishes a new on-chain definition for baskets, protocols, or certificates.
+     * The definition data is encoded in a pushdrop-based UTXO.
+     *
+     * Registry operators (i.e., identity key owners) can create these definitions
+     * to establish canonical references for basket IDs, protocol specs, or certificate schemas.
+     *
+     * @param data - Structured information about a 'basket', 'protocol', or 'certificate'.
+     * @returns A promise with the broadcast result or failure.
+     */
+    registerDefinition(data: DefinitionData): Promise<BroadcastResponse | BroadcastFailure>;
+    /**
+     * Resolves registrant tokens of a particular type using a lookup service.
+     *
+     * The query object shape depends on the registry type:
+     * - For "basket", the query is of type BasketMapQuery:
+     *   { basketID?: string; name?: string; registryOperators?: string[]; }
+     * - For "protocol", the query is of type ProtoMapQuery:
+     *   { name?: string; registryOperators?: string[]; protocolID?: WalletProtocol; }
+     * - For "certificate", the query is of type CertMapQuery:
+     *   { type?: string; name?: string; registryOperators?: string[]; }
+     *
+     * @param definitionType - The registry type, which can be 'basket', 'protocol', or 'certificate'.
+     * @param query - The query object used to filter registry records, whose shape is determined by the registry type.
+     * @returns A promise that resolves to an array of matching registry records.
+     */
+    resolve<T extends DefinitionType>(definitionType: T, query: RegistryQueryMapping[T]): Promise<DefinitionData[]>;
+    /**
+     * Lists the registry operator's published definitions for the given type.
+     *
+     * Returns parsed registry records including transaction details such as txid, outputIndex, satoshis, and the locking script.
+     *
+     * @param definitionType - The type of registry definition to list ('basket', 'protocol', or 'certificate').
+     * @returns A promise that resolves to an array of RegistryRecord objects.
+     */
+    listOwnRegistryEntries(definitionType: DefinitionType): Promise<RegistryRecord[]>;
+    /**
+     * Removes a registry definition by spending its associated UTXO.
+     *
+     * @param registryRecord - The registry record to remove (must have valid txid, outputIndex, and lockingScript).
+     * @returns Broadcast success/failure.
+     */
+    removeDefinition(registryRecord: RegistryRecord): Promise<BroadcastResponse | BroadcastFailure>;
+    /**
+     * Updates an existing registry record by spending its UTXO and creating a new one with updated data.
+     *
+     * @param registryRecord - The existing registry record to update (must have valid txid, outputIndex, and lockingScript).
+     * @param updatedData - The new definition data to replace the old record.
+     * @returns Broadcast success/failure.
+     */
+    updateDefinition(registryRecord: RegistryRecord, updatedData: DefinitionData): Promise<BroadcastResponse | BroadcastFailure>;
+    /**
+     * Convert definition data into an array of pushdrop fields (strings).
+     * Each definition type has a slightly different shape.
+     */
+    private buildPushDropFields;
+    /**
+     * Decodes a pushdrop locking script for a given definition type,
+     * returning a typed record with the appropriate fields.
+     */
+    private parseLockingScript;
+    /**
+     * Convert our definitionType to the wallet protocol format ([protocolID, keyID]).
+     */
+    private mapDefinitionTypeToWalletProtocol;
+    /**
+     * Convert 'basket'|'protocol'|'certificate' to the basket name used by the wallet.
+     */
+    private mapDefinitionTypeToBasketName;
+    /**
+     * Convert 'basket'|'protocol'|'certificate' to the broadcast topic name.
+     */
+    private mapDefinitionTypeToTopic;
+    /**
+     * Convert 'basket'|'protocol'|'certificate' to the lookup service name.
+     */
+    private mapDefinitionTypeToServiceName;
+}
+export declare function deserializeWalletProtocol(str: string): WalletProtocol;
+//# sourceMappingURL=RegistryClient.d.ts.map

package/mobile/node_modules/@bsv/sdk/dist/types/src/registry/RegistryClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegistryClient.d.ts","sourceRoot":"","sources":["../../../../src/registry/RegistryClient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,cAAc,EAId,uCAAuC,EACxC,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EAEL,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,yBAAyB,CAAA;AAChC,OAAO,EACL,cAAc,EAEf,MAAM,2BAA2B,CAAA;AAElC,OAAO,EAEL,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,cAAc,EACf,MAAM,kBAAkB,CAAA;AAKzB;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,cAAc;IAOvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAEvB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC;IAR9B,OAAO,CAAC,OAAO,CAAmC;IAClD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;IACzC,OAAO,CAAC,iBAAiB,CAAuB;IAChD,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;gBAG7B,MAAM,GAAE,eAAoC,EAC7D,OAAO,GAAE;QAAE,sBAAsB,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,cAAc,CAAA;KAAO,EAC5D,UAAU,CAAC,EAAE,uCAAuC;IAMvE;;;OAGG;YACW,cAAc;IAO5B;;;OAGG;YACW,UAAU;IAOxB;;;;;;;;;OASG;IACG,kBAAkB,CAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,iBAAiB,GAAG,gBAAgB,CAAC;IA4C9F;;;;;;;;;;;;;;OAcG;IACG,OAAO,CAAC,CAAC,SAAS,cAAc,EACpC,cAAc,EAAE,CAAC,EACjB,KAAK,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAC7B,OAAO,CAAC,cAAc,EAAE,CAAC;IAuB5B;;;;;;;OAOG;IACG,sBAAsB,CAAE,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAoCxF;;;;;OAKG;IACG,gBAAgB,CACpB,cAAc,EAAE,cAAc,GAC7B,OAAO,CAAC,iBAAiB,GAAG,gBAAgB,CAAC;IAkFhD;;;;;;OAMG;IACG,gBAAgB,CACpB,cAAc,EAAE,cAAc,EAC9B,WAAW,EAAE,cAAc,GAC1B,OAAO,CAAC,iBAAiB,GAAG,gBAAgB,CAAC;IA0GhD;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IA6C3B;;;OAGG;YACW,kBAAkB;IAkGhC;;OAEG;IACH,OAAO,CAAC,iCAAiC;IAazC;;OAEG;IACH,OAAO,CAAC,6BAA6B;IAarC;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAahC;;OAEG;IACH,OAAO,CAAC,8BAA8B;CAYvC;AAED,wBAAgB,yBAAyB,CAAE,GAAG,EAAE,MAAM,GAAG,cAAc,CAsBtE"}

package/mobile/node_modules/@bsv/sdk/dist/types/src/registry/index.d.ts

@@ -0,0 +1,3 @@
+export * from './RegistryClient.js';
+export * from './types/index.js';
+//# sourceMappingURL=index.d.ts.map

package/mobile/node_modules/@bsv/sdk/dist/types/src/registry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/registry/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,kBAAkB,CAAA"}