@bsv/wallet-toolbox 1.7.14 → 1.7.16

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

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

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

@@ -0,0 +1,155 @@
+import Point from './Point.js';
+import PrivateKey from './PrivateKey.js';
+import BigNumber from './BigNumber.js';
+import Signature from './Signature.js';
+/**
+ * The PublicKey class extends the Point class. It is used in public-key cryptography to derive shared secret, verify message signatures, and encode the public key in the DER format.
+ * The class comes with static methods to generate PublicKey instances from private keys or from strings.
+ *
+ * @extends {Point}
+ * @see {@link Point} for more information on Point.
+ */
+export default class PublicKey extends Point {
+    /**
+     * Static factory method to derive a public key from a private key.
+     * It multiplies the generator point 'g' on the elliptic curve by the private key.
+     *
+     * @static
+     * @method fromPrivateKey
+     *
+     * @param key - The private key from which to derive the public key.
+     *
+     * @returns Returns the PublicKey derived from the given PrivateKey.
+     *
+     * @example
+     * const myPrivKey = new PrivateKey(...)
+     * const myPubKey = PublicKey.fromPrivateKey(myPrivKey)
+     */
+    static fromPrivateKey(key: PrivateKey): PublicKey;
+    /**
+     * Static factory method to create a PublicKey instance from a string.
+     *
+     * @param str - A string representing a public key.
+     *
+     * @returns Returns the PublicKey created from the string.
+     *
+     * @example
+     * const myPubKey = PublicKey.fromString("03....")
+     */
+    static fromString(str: string): PublicKey;
+    /**
+     * Static factory method to create a PublicKey instance from a number array.
+     *
+     * @param bytes - A number array representing a public key.
+     *
+     * @returns Returns the PublicKey created from the number array.
+     *
+     * @example
+     * const myPubKey = PublicKey.fromString("03....")
+     */
+    static fromDER(bytes: number[]): PublicKey;
+    /**
+     * @constructor
+     * @param 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.
+     * @param y - If x is not a point, 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 PublicKey(point1);
+     * new PublicKey('abc123', 'def456');
+     */
+    constructor(x: Point | BigNumber | number | number[] | string | null, y?: BigNumber | number | number[] | string | null, isRed?: boolean);
+    /**
+     * Derive a shared secret from a public key and a private key for use in symmetric encryption.
+     * This method multiplies the public key (an instance of Point) with a private key.
+     *
+     * @param priv - The private key to use in deriving the shared secret.
+     *
+     * @returns Returns the Point representing the shared secret.
+     *
+     * @throws Will throw an error if the public key is not valid for ECDH secret derivation.
+     *
+     * @example
+     * const myPrivKey = new PrivateKey(...)
+     * const sharedSecret = myPubKey.deriveSharedSecret(myPrivKey)
+     */
+    deriveSharedSecret(priv: PrivateKey): Point;
+    /**
+     * Verify a signature of a message using this public key.
+     *
+     * @param msg - The message to verify. It can be a string or an array of numbers.
+     * @param sig - The Signature of the message that needs verification.
+     * @param enc - The encoding of the message. It defaults to 'utf8'.
+     *
+     * @returns Returns true if the signature is verified successfully, otherwise false.
+     *
+     * @example
+     * const myMessage = "Hello, world!"
+     * const mySignature = new Signature(...)
+     * const isVerified = myPubKey.verify(myMessage, mySignature)
+     */
+    verify(msg: number[] | string, sig: Signature, enc?: 'hex' | 'utf8'): boolean;
+    /**
+     * Encode the public key to DER (Distinguished Encoding Rules) format.
+     *
+     * @returns Returns the DER-encoded public key in number array or string.
+     *
+     * @param enc - The encoding of the DER string. undefined = number array, 'hex' = hex string.
+     *
+     * @example
+     * const derPublicKey = myPubKey.toDER()
+     */
+    toDER(enc?: 'hex' | undefined): number[] | string;
+    /**
+     * Hash sha256 and ripemd160 of the public key.
+     *
+     * @returns Returns the hash of the public key.
+     *
+     * @example
+     * const publicKeyHash = pubkey.toHash()
+     */
+    toHash(enc?: 'hex'): number[] | string;
+    /**
+     * Base58Check encodes the hash of the public 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 'mainnet' or 'testnet'
+     *
+     * @returns Returns the address encoding associated with the hash of the public key.
+     *
+     * @example
+     * const address = pubkey.toAddress()
+     * const address = pubkey.toAddress('mainnet')
+     * const testnetAddress = pubkey.toAddress([0x6f])
+     * const testnetAddress = pubkey.toAddress('testnet')
+     */
+    toAddress(prefix?: number[] | string): string;
+    /**
+     * Derives a child key with BRC-42.
+     * @param privateKey The private 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(privateKey: PrivateKey, invoiceNumber: string, cacheSharedSecret?: ((priv: PrivateKey, pub: Point, point: Point) => void), retrieveCachedSharedSecret?: ((priv: PrivateKey, pub: Point) => (Point | undefined))): PublicKey;
+    /**
+     * Takes an array of numbers or a string and returns a new PublicKey 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.
+     *
+     * @static
+     * @method fromMsgHashAndCompactSignature
+     * @param msgHash - The message hash which was signed.
+     * @param signature - The signature in compact format.
+     * @param enc - The encoding of the signature string.
+     * @returns A PublicKey instance derived from the message hash and compact signature.
+     * @example
+     * const publicKey = Signature.fromMsgHashAndCompactSignature(msgHash, 'IMOl2mVKfDgsSsHT4uIYBNN4e...', 'base64');
+     */
+    static fromMsgHashAndCompactSignature(msgHash: BigNumber, signature: number[] | string, enc?: 'hex' | 'base64'): PublicKey;
+}
+//# sourceMappingURL=PublicKey.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PublicKey.d.ts","sourceRoot":"","sources":["../../../../src/primitives/PublicKey.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,YAAY,CAAA;AAC9B,OAAO,UAAU,MAAM,iBAAiB,CAAA;AAGxC,OAAO,SAAS,MAAM,gBAAgB,CAAA;AAEtC,OAAO,SAAS,MAAM,gBAAgB,CAAA;AAGtC;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,SAAU,SAAQ,KAAK;IAC1C;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,cAAc,CAAE,GAAG,EAAE,UAAU,GAAG,SAAS;IAMlD;;;;;;;;;OASG;IACH,MAAM,CAAC,UAAU,CAAE,GAAG,EAAE,MAAM,GAAG,SAAS;IAK1C;;;;;;;;;OASG;IACH,MAAM,CAAC,OAAO,CAAE,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS;IAK3C;;;;;;;;;OASG;gBAED,CAAC,EAAE,KAAK,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,EACxD,CAAC,GAAE,SAAS,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,GAAG,IAAW,EACvD,KAAK,GAAE,OAAc;IAiBvB;;;;;;;;;;;;;OAaG;IACH,kBAAkB,CAAE,IAAI,EAAE,UAAU,GAAG,KAAK;IAO5C;;;;;;;;;;;;;OAaG;IACH,MAAM,CACJ,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,EACtB,GAAG,EAAE,SAAS,EACd,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,GACnB,OAAO;IAKV;;;;;;;;;OASG;IACH,KAAK,CAAE,GAAG,CAAC,EAAE,KAAK,GAAG,SAAS,GAAG,MAAM,EAAE,GAAG,MAAM;IAKlD;;;;;;;OAOG;IACH,MAAM,CAAE,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,EAAE,GAAG,MAAM;IAQvC;;;;;;;;;;;;;OAaG;IACH,SAAS,CAAE,MAAM,GAAE,MAAM,EAAE,GAAG,MAAe,GAAG,MAAM;IAatD;;;;;;;OAOG;IACH,WAAW,CACT,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,MAAM,EACrB,iBAAiB,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,EAC1E,0BAA0B,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,KAAK,KAAK,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC,GACnF,SAAS;IAuBZ;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,8BAA8B,CACnC,OAAO,EAAE,SAAS,EAClB,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,EAC5B,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,GACrB,SAAS;CAwBb"}

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

@@ -0,0 +1,14 @@
+/**
+ * Generates a sequence of pseudo-random bytes with the given length.
+ *
+ * @param len - The number of bytes to generate
+ *
+ * @returns The generated bytes
+ *
+ * @example
+ * import Random from '@bsv/sdk/primitives/Random'
+ * const bytes = Random(32) // Produces 32 random bytes
+ */
+declare const _default: (len: number) => number[];
+export default _default;
+//# sourceMappingURL=Random.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Random.d.ts","sourceRoot":"","sources":["../../../../src/primitives/Random.ts"],"names":[],"mappings":"AAoFA;;;;;;;;;;GAUG;yBACa,KAAK,MAAM,KAAG,MAAM,EAAE;AAAtC,wBAKC"}

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

@@ -0,0 +1,308 @@
+import BigNumber from './BigNumber.js';
+import Mersenne from './Mersenne.js';
+/**
+ * A base reduction engine that provides several arithmetic operations over
+ * big numbers under a modulus context. It's particularly suitable for
+ * calculations required in cryptography algorithms and encoding schemas.
+ *
+ * @class ReductionContext
+ *
+ * @property prime - The prime number utilised in the reduction context, typically an instance of Mersenne class.
+ * @property m - The modulus used for reduction operations.
+ */
+export default class ReductionContext {
+    prime: Mersenne | null;
+    m: BigNumber;
+    /**
+     * Constructs a new ReductionContext.
+     *
+     * @constructor
+     * @param m - A BigNumber representing the modulus, or 'k256' to create a context for Koblitz curve.
+     *
+     * @example
+     * new ReductionContext(new BigNumber(11));
+     * new ReductionContext('k256');
+     */
+    constructor(m: BigNumber | 'k256');
+    /**
+     * Asserts that given value is truthy. Throws an Error with a provided message
+     * if the value is falsy.
+     *
+     * @private
+     * @param val - The value to be checked.
+     * @param msg - The error message to be thrown if the value is falsy.
+     *
+     * @example
+     * this.assert(1 < 2, '1 is not less than 2');
+     * this.assert(2 < 1, '2 is less than 1'); // throws an Error with message '2 is less than 1'
+     */
+    private assert;
+    /**
+     * Verifies that a BigNumber is positive and red. Throws an error if these
+     * conditions are not met.
+     *
+     * @param a - The BigNumber to be verified.
+     *
+     * @example
+     * this.verify1(new BigNumber(10).toRed());
+     * this.verify1(new BigNumber(-10).toRed()); //throws an Error
+     * this.verify1(new BigNumber(10)); //throws an Error
+     */
+    verify1(a: BigNumber): void;
+    /**
+     * Verifies that two BigNumbers are both positive and red. Also checks
+     * that they have the same reduction context. Throws an error if these
+     * conditions are not met.
+     *
+     * @param a - The first BigNumber to be verified.
+     * @param b - The second BigNumber to be verified.
+     *
+     * @example
+     * this.verify2(new BigNumber(10).toRed(this), new BigNumber(20).toRed(this));
+     * this.verify2(new BigNumber(-10).toRed(this), new BigNumber(20).toRed(this)); //throws an Error
+     * this.verify2(new BigNumber(10).toRed(this), new BigNumber(20)); //throws an Error
+     */
+    verify2(a: BigNumber, b: BigNumber): void;
+    /**
+     * Performs an in-place reduction of the given BigNumber by the modulus of the reduction context, 'm'.
+     *
+     * @method imod
+     *
+     * @param a - BigNumber to be reduced.
+     *
+     * @returns Returns the reduced result.
+     *
+     * @example
+     * const context = new ReductionContext(new BigNumber(7));
+     * context.imod(new BigNumber(19)); // Returns 5
+     */
+    imod(a: BigNumber): BigNumber;
+    /**
+     * Negates a BigNumber in the context of the modulus.
+     *
+     * @method neg
+     *
+     * @param a - BigNumber to negate.
+     *
+     * @returns Returns the negation of 'a' in the reduction context.
+     *
+     * @example
+     * const context = new ReductionContext(new BigNumber(7));
+     * context.neg(new BigNumber(3)); // Returns 4
+     */
+    neg(a: BigNumber): BigNumber;
+    /**
+     * Performs the addition operation on two BigNumbers in the reduction context.
+     *
+     * @method add
+     *
+     * @param a - First BigNumber to add.
+     * @param b - Second BigNumber to add.
+     *
+     * @returns Returns the result of 'a + b' in the reduction context.
+     *
+     * @example
+     * const context = new ReductionContext(new BigNumber(5));
+     * context.add(new BigNumber(2), new BigNumber(4)); // Returns 1
+     */
+    add(a: BigNumber, b: BigNumber): BigNumber;
+    /**
+     * Performs an in-place addition operation on two BigNumbers in the reduction context
+     * in order to avoid creating a new BigNumber, it modifies the first one with the result.
+     *
+     * @method iadd
+     *
+     * @param a - First BigNumber to add.
+     * @param b - Second BigNumber to add.
+     *
+     * @returns Returns the modified 'a' after addition with 'b' in the reduction context.
+     *
+     * @example
+     * const context = new ReductionContext(new BigNumber(5));
+     * const a = new BigNumber(2);
+     * context.iadd(a, new BigNumber(4)); // Modifies 'a' to be 1
+     */
+    iadd(a: BigNumber, b: BigNumber): BigNumber;
+    /**
+     * Subtracts one BigNumber from another BigNumber in the reduction context.
+     *
+     * @method sub
+     *
+     * @param a - BigNumber to be subtracted from.
+     * @param b - BigNumber to subtract.
+     *
+     * @returns Returns the result of 'a - b' in the reduction context.
+     *
+     * @example
+     * const context = new ReductionContext(new BigNumber(7));
+     * context.sub(new BigNumber(3), new BigNumber(2)); // Returns 1
+     */
+    sub(a: BigNumber, b: BigNumber): BigNumber;
+    /**
+     * Performs in-place subtraction of one BigNumber from another in the reduction context,
+     * it modifies the first BigNumber with the result.
+     *
+     * @method isub
+     *
+     * @param a - BigNumber to be subtracted from.
+     * @param b - BigNumber to subtract.
+     *
+     * @returns Returns the modified 'a' after subtraction of 'b' in the reduction context.
+     *
+     * @example
+     * const context = new ReductionContext(new BigNumber(5));
+     * const a = new BigNumber(4);
+     * context.isub(a, new BigNumber(2)); // Modifies 'a' to be 2
+     */
+    isub(a: BigNumber, b: BigNumber): BigNumber;
+    /**
+     * Performs bitwise shift left operation on a BigNumber in the reduction context.
+     *
+     * @method shl
+     *
+     * @param a - BigNumber to perform shift on.
+     * @param num - The number of positions to shift.
+     *
+     * @returns Returns the result of shifting 'a' left by 'num' positions in the reduction context.
+     *
+     * @example
+     * const context = new ReductionContext(new BigNumber(32));
+     * context.shl(new BigNumber(4), 2); // Returns 16
+     */
+    shl(a: BigNumber, num: number): BigNumber;
+    /**
+     * Performs in-place multiplication of two BigNumbers in the reduction context,
+     * modifying the first BigNumber with the result.
+     *
+     * @method imul
+     *
+     * @param a - First BigNumber to multiply.
+     * @param b - Second BigNumber to multiply.
+     *
+     * @returns Returns the modified 'a' after multiplication with 'b' in the reduction context.
+     *
+     * @example
+     * const context = new ReductionContext(new BigNumber(7));
+     * const a = new BigNumber(3);
+     * context.imul(a, new BigNumber(2)); // Modifies 'a' to be 6
+     */
+    imul(a: BigNumber, b: BigNumber): BigNumber;
+    /**
+     * Multiplies two BigNumbers in the reduction context.
+     *
+     * @method mul
+     *
+     * @param a - First BigNumber to multiply.
+     * @param b - Second BigNumber to multiply.
+     *
+     * @returns Returns the result of 'a * b' in the reduction context.
+     *
+     * @example
+     * const context = new ReductionContext(new BigNumber(7));
+     * context.mul(new BigNumber(3), new BigNumber(2)); // Returns 6
+     */
+    mul(a: BigNumber, b: BigNumber): BigNumber;
+    /**
+     * Calculates the square of a BigNumber in the reduction context,
+     * modifying the original BigNumber with the result.
+     *
+     * @method isqr
+     *
+     * @param a - BigNumber to be squared.
+     *
+     * @returns Returns the squared 'a' in the reduction context.
+     *
+     * @example
+     * const context = new ReductionContext(new BigNumber(7));
+     * const a = new BigNumber(3);
+     * context.isqr(a); // Modifies 'a' to be 2 (9 % 7 = 2)
+     */
+    isqr(a: BigNumber): BigNumber;
+    /**
+     * Calculates the square of a BigNumber in the reduction context.
+     *
+     * @method sqr
+     *
+     * @param a - BigNumber to be squared.
+     *
+     * @returns Returns the result of 'a^2' in the reduction context.
+     *
+     * @example
+     * const context = new ReductionContext(new BigNumber(7));
+     * context.sqr(new BigNumber(3)); // Returns 2 (9 % 7 = 2)
+     */
+    sqr(a: BigNumber): BigNumber;
+    /**
+     * Calculates the square root of a BigNumber in the reduction context.
+     *
+     * @method sqrt
+     *
+     * @param a - The BigNumber to calculate the square root of.
+     *
+     * @returns Returns the square root of 'a' in the reduction context.
+     *
+     * @example
+     * const context = new ReductionContext(new BigNumber(9));
+     * context.sqrt(new BigNumber(4)); // Returns 2
+     */
+    sqrt(a: BigNumber): BigNumber;
+    /**
+     * Calculates the multiplicative inverse of a BigNumber in the reduction context.
+     *
+     * @method invm
+     *
+     * @param a - The BigNumber to find the multiplicative inverse of.
+     *
+     * @returns Returns the multiplicative inverse of 'a' in the reduction context.
+     *
+     * @example
+     * const context = new ReductionContext(new BigNumber(11));
+     * context.invm(new BigNumber(3)); // Returns 4 (3*4 mod 11 = 1)
+     */
+    invm(a: BigNumber): BigNumber;
+    /**
+     * Raises a BigNumber to a power in the reduction context.
+     *
+     * @method pow
+     *
+     * @param a - The BigNumber to be raised to a power.
+     * @param num - The power to raise the BigNumber to.
+     *
+     * @returns Returns the result of 'a' raised to the power of 'num' in the reduction context.
+     *
+     * @example
+     * const context = new ReductionContext(new BigNumber(7));
+     * context.pow(new BigNumber(3), new BigNumber(2)); // Returns 2 (3^2 % 7)
+     */
+    pow(a: BigNumber, num: BigNumber): BigNumber;
+    /**
+     * Converts a BigNumber to its equivalent in the reduction context.
+     *
+     * @method convertTo
+     *
+     * @param num - The BigNumber to convert to the reduction context.
+     *
+     * @returns Returns the converted BigNumber compatible with the reduction context.
+     *
+     * @example
+     * const context = new ReductionContext(new BigNumber(7));
+     * context.convertTo(new BigNumber(8)); // Returns 1 (8 % 7)
+     */
+    convertTo(num: BigNumber): BigNumber;
+    /**
+     * Converts a BigNumber from reduction context to its regular form.
+     *
+     * @method convertFrom
+     *
+     * @param num - The BigNumber to convert from the reduction context.
+     *
+     * @returns Returns the converted BigNumber in its regular form.
+     *
+     * @example
+     * const context = new ReductionContext(new BigNumber(7));
+     * const a = context.convertTo(new BigNumber(8)); // 'a' is now 1 in the reduction context
+     * context.convertFrom(a); // Returns 1
+     */
+    convertFrom(num: BigNumber): BigNumber;
+}
+//# sourceMappingURL=ReductionContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ReductionContext.d.ts","sourceRoot":"","sources":["../../../../src/primitives/ReductionContext.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,gBAAgB,CAAA;AAEtC,OAAO,QAAQ,MAAM,eAAe,CAAA;AAEpC;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACnC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAA;IACtB,CAAC,EAAE,SAAS,CAAA;IAEZ;;;;;;;;;OASG;gBACU,CAAC,EAAE,SAAS,GAAG,MAAM;IAYlC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,MAAM;IAId;;;;;;;;;;OAUG;IACH,OAAO,CAAE,CAAC,EAAE,SAAS,GAAG,IAAI;IAK5B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,IAAI;IAW1C;;;;;;;;;;;;OAYG;IACH,IAAI,CAAE,CAAC,EAAE,SAAS,GAAG,SAAS;IAO9B;;;;;;;;;;;;OAYG;IACH,GAAG,CAAE,CAAC,EAAE,SAAS,GAAG,SAAS;IAQ7B;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,SAAS;IAU3C;;;;;;;;;;;;;;;OAeG;IACH,IAAI,CAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,SAAS;IAU5C;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,SAAS;IAU3C;;;;;;;;;;;;;;;OAeG;IACH,IAAI,CAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,SAAS;IAU5C;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAE,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS;IAK1C;;;;;;;;;;;;;;;OAeG;IACH,IAAI,CAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,SAAS;IAK5C;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,SAAS;IAK3C;;;;;;;;;;;;;;OAcG;IACH,IAAI,CAAE,CAAC,EAAE,SAAS,GAAG,SAAS;IAI9B;;;;;;;;;;;;OAYG;IACH,GAAG,CAAE,CAAC,EAAE,SAAS,GAAG,SAAS;IAI7B;;;;;;;;;;;;OAYG;IACH,IAAI,CAAE,CAAC,EAAE,SAAS,GAAG,SAAS;IA0D9B;;;;;;;;;;;;OAYG;IACH,IAAI,CAAE,CAAC,EAAE,SAAS,GAAG,SAAS;IAU9B;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAE,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,SAAS,GAAG,SAAS;IAiD7C;;;;;;;;;;;;OAYG;IACH,SAAS,CAAE,GAAG,EAAE,SAAS,GAAG,SAAS;IAMrC;;;;;;;;;;;;;OAaG;IACH,WAAW,CAAE,GAAG,EAAE,SAAS,GAAG,SAAS;CAKxC"}

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

@@ -0,0 +1,65 @@
+import BigNumber from './BigNumber.js';
+import Point from './Point.js';
+import { PrivateKey, PublicKey } from './index.js';
+/**
+ * Class representing the Schnorr Zero-Knowledge Proof (ZKP) protocol.
+ *
+ * This class provides methods to generate and verify proofs that demonstrate knowledge of a secret without revealing it.
+ * Specifically, it allows one party to prove to another that they know the private key corresponding to a public key
+ * and have correctly computed a shared secret, without disclosing the private key itself.
+ *
+ * The protocol involves two main methods:
+ * - `generateProof`: Generates a proof linking a public key `A` and a shared secret `S`, proving knowledge of the corresponding private key `a`.
+ * - `verifyProof`: Verifies the provided proof, ensuring its validity without revealing any secret information.
+ *
+ * The class utilizes elliptic curve cryptography (ECC) and the SHA-256 hash function to compute challenges within the proof.
+ *
+ * @example
+ * ```typescript
+ * const schnorr = new Schnorr();
+ * const a = PrivateKey.fromRandom(); // Prover's private key
+ * const A = a.toPublicKey();         // Prover's public key
+ * const b = PrivateKey.fromRandom(); // Other party's private key
+ * const B = b.toPublicKey();         // Other party's public key
+ * const S = B.mul(a);                // Shared secret
+ *
+ * // Prover generates the proof
+ * const proof = schnorr.generateProof(a, A, B, S);
+ *
+ * // Verifier verifies the proof
+ * const isValid = schnorr.verifyProof(A.point, B.point, S.point, proof);
+ * console.log(`Proof is valid: ${isValid}`);
+ * ```
+ */
+export default class Schnorr {
+    private readonly curve;
+    constructor();
+    /**
+     * Generates a proof that demonstrates the link between public key A and shared secret S
+     * @param a Private key corresponding to public key A
+     * @param A Public key
+     * @param B Other party's public key
+     * @param S Shared secret
+     * @returns Proof (R, S', z)
+     */
+    generateProof(aArg: PrivateKey, AArg: PublicKey, BArg: PublicKey, S: Point): {
+        R: Point;
+        SPrime: Point;
+        z: BigNumber;
+    };
+    /**
+     * Verifies the proof of the link between public key A and shared secret S
+     * @param A Public key
+     * @param B Other party's public key
+     * @param S Shared secret
+     * @param proof Proof (R, S', z)
+     * @returns True if the proof is valid, false otherwise
+     */
+    verifyProof(A: Point, B: Point, S: Point, proof: {
+        R: Point;
+        SPrime: Point;
+        z: BigNumber;
+    }): boolean;
+    private computeChallenge;
+}
+//# sourceMappingURL=Schnorr.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Schnorr.d.ts","sourceRoot":"","sources":["../../../../src/primitives/Schnorr.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,gBAAgB,CAAA;AAEtC,OAAO,KAAK,MAAM,YAAY,CAAA;AAE9B,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,OAAO,OAAO,OAAO;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAO;;IAM7B;;;;;;;OAOG;IACH,aAAa,CACX,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,SAAS,EACf,CAAC,EAAE,KAAK,GACP;QAAE,CAAC,EAAE,KAAK,CAAC;QAAC,MAAM,EAAE,KAAK,CAAC;QAAC,CAAC,EAAE,SAAS,CAAA;KAAE;IAS5C;;;;;;;OAOG;IACH,WAAW,CACT,CAAC,EAAE,KAAK,EACR,CAAC,EAAE,KAAK,EACR,CAAC,EAAE,KAAK,EACR,KAAK,EAAE;QAAE,CAAC,EAAE,KAAK,CAAC;QAAC,MAAM,EAAE,KAAK,CAAC;QAAC,CAAC,EAAE,SAAS,CAAA;KAAE,GAC/C,OAAO;IAqBV,OAAO,CAAC,gBAAgB;CAiBzB"}

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

@@ -0,0 +1,91 @@
+export type P256Point = {
+    x: bigint;
+    y: bigint;
+} | null;
+type ByteSource = string | Uint8Array | ArrayBufferView;
+/**
+ * Pure BigInt implementation of the NIST P-256 (secp256r1) curve with ECDSA sign/verify.
+ *
+ * This class is standalone (no dependency on the existing secp256k1 primitives) and exposes
+ * key generation, point encoding/decoding, scalar multiplication, and SHA-256 based ECDSA.
+ */
+export default class Secp256r1 {
+    readonly p: bigint;
+    readonly n: bigint;
+    readonly a: bigint;
+    readonly b: bigint;
+    readonly g: {
+        x: bigint;
+        y: bigint;
+    };
+    private mod;
+    private modInv;
+    private modPow;
+    private isInfinity;
+    private assertOnCurve;
+    pointFromAffine(x: bigint, y: bigint): P256Point;
+    /**
+     * Decode a point from compressed or uncompressed hex.
+     */
+    pointFromHex(hex: string): P256Point;
+    /**
+     * Encode a point to compressed or uncompressed hex. Infinity is encoded as `00`.
+     */
+    pointToHex(p: P256Point, compressed?: boolean): string;
+    /**
+     * Add two affine points (handles infinity).
+     */
+    private addPoints;
+    private doublePoint;
+    /**
+     * Add two points (handles infinity).
+     */
+    add(p1: P256Point, p2: P256Point): P256Point;
+    /**
+     * Scalar multiply an arbitrary point using double-and-add.
+     */
+    multiply(point: P256Point, scalar: bigint): P256Point;
+    /**
+     * Scalar multiply the base point.
+     */
+    multiplyBase(scalar: bigint): P256Point;
+    /**
+     * Check if a point lies on the curve (including infinity).
+     */
+    isOnCurve(p: P256Point): boolean;
+    /**
+     * Generate a new random private key as 32-byte hex.
+     */
+    generatePrivateKeyHex(): string;
+    private randomScalar;
+    private normalizePrivateKey;
+    private toScalar;
+    publicKeyFromPrivate(privateKey: string | bigint): P256Point;
+    /**
+     * Create an ECDSA signature over a message. Uses SHA-256 unless `prehashed` is true.
+     * Returns low-s normalized signature hex parts.
+     */
+    sign(message: ByteSource, privateKey: string | bigint, opts?: {
+        prehashed?: boolean;
+        nonce?: bigint;
+    }): {
+        r: string;
+        s: string;
+    };
+    /**
+     * Verify an ECDSA signature against a message and public key.
+     */
+    verify(message: ByteSource, signature: {
+        r: string | bigint;
+        s: string | bigint;
+    }, publicKey: P256Point | string, opts?: {
+        prehashed?: boolean;
+    }): boolean;
+    private normalizeMessage;
+    private bytesToScalar;
+    private deterministicNonce;
+    private toBytes;
+    private to32BytesHex;
+}
+export {};
+//# sourceMappingURL=Secp256r1.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Secp256r1.d.ts","sourceRoot":"","sources":["../../../../src/primitives/Secp256r1.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,SAAS,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAA;AAEvD,KAAK,UAAU,GAAG,MAAM,GAAG,UAAU,GAAG,eAAe,CAAA;AAiBvD;;;;;GAKG;AACH,MAAM,CAAC,OAAO,OAAO,SAAS;IAC5B,QAAQ,CAAC,CAAC,SAAI;IACd,QAAQ,CAAC,CAAC,SAAI;IACd,QAAQ,CAAC,CAAC,SAAI;IACd,QAAQ,CAAC,CAAC,SAAI;IACd,QAAQ,CAAC,CAAC;WA9BiB,MAAM;WAAK,MAAM;MA8B9B;IAEd,OAAO,CAAC,GAAG;IAKX,OAAO,CAAC,MAAM;IAad,OAAO,CAAC,MAAM;IAad,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,aAAa;IAUrB,eAAe,CAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS;IAMjD;;OAEG;IACH,YAAY,CAAE,GAAG,EAAE,MAAM,GAAG,SAAS;IAkBrC;;OAEG;IACH,UAAU,CAAE,CAAC,EAAE,SAAS,EAAE,UAAU,UAAQ,GAAG,MAAM;IASrD;;OAEG;IACH,OAAO,CAAC,SAAS;IAoBjB,OAAO,CAAC,WAAW;IASnB;;OAEG;IACH,GAAG,CAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,GAAG,SAAS;IAI7C;;OAEG;IACH,QAAQ,CAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS;IAetD;;OAEG;IACH,YAAY,CAAE,MAAM,EAAE,MAAM,GAAG,SAAS;IAIxC;;OAEG;IACH,SAAS,CAAE,CAAC,EAAE,SAAS,GAAG,OAAO;IASjC;;OAEG;IACH,qBAAqB,IAAK,MAAM;IAIhC,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,mBAAmB;IAM3B,OAAO,CAAC,QAAQ;IAUhB,oBAAoB,CAAE,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAK7D;;;OAGG;IACH,IAAI,CAAE,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,GAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE;IA6BrI;;OAEG;IACH,MAAM,CAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE;QAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,EAAE,SAAS,EAAE,SAAS,GAAG,MAAM,EAAE,IAAI,GAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO;IAwB/J,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,kBAAkB;IAe1B,OAAO,CAAC,OAAO;IAYf,OAAO,CAAC,YAAY;CAGrB"}