@bsv/sdk 1.0.0

package/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/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/dist/types/src/primitives/Signature.d.ts

@@ -0,0 +1,100 @@
+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;
+    /**
+     * 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'): string | number[];
+    /**
+     * 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;
+}
+//# sourceMappingURL=Signature.d.ts.map

package/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;AAKtC;;;;;;;;;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,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,SAAS;IAqE1E;;;;;;;;;;;OAWG;gBACS,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS;IAKtC;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO;IAKpE;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ;IAI/B;;;;;;;;;;;;;OAaG;IACH,KAAK,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,EAAE,GAAG,MAAM;CAoDjD"}

package/dist/types/src/primitives/SymmetricKey.d.ts

@@ -0,0 +1,44 @@
+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 {
+    /**
+    * 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/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;;;;;;;;;;;;;MAaE;IACF,OAAO,CAAE,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,EAAE;IAYhE;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAE,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE;CAkB1E"}

package/dist/types/src/primitives/TransactionSignature.d.ts

@@ -0,0 +1,36 @@
+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 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;
+    static format(params: {
+        sourceTXID: string;
+        sourceOutputIndex: number;
+        sourceSatoshis: number;
+        transactionVersion: number;
+        otherInputs: TransactionInput[];
+        outputs: TransactionOutput[];
+        inputIndex: number;
+        subscript: Script;
+        inputSequence: number;
+        lockTime: number;
+        scope: number;
+    }): number[];
+    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[];
+}
+//# sourceMappingURL=TransactionSignature.d.ts.map

package/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,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,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE;QACpB,UAAU,EAAE,MAAM,CAAA;QAClB,iBAAiB,EAAE,MAAM,CAAA;QACzB,cAAc,EAAE,MAAM,CAAA;QACtB,kBAAkB,EAAE,MAAM,CAAA;QAC1B,WAAW,EAAE,gBAAgB,EAAE,CAAA;QAC/B,OAAO,EAAE,iBAAiB,EAAE,CAAA;QAC5B,UAAU,EAAE,MAAM,CAAA;QAClB,SAAS,EAAE,MAAM,CAAA;QACjB,aAAa,EAAE,MAAM,CAAA;QACrB,QAAQ,EAAE,MAAM,CAAA;QAChB,KAAK,EAAE,MAAM,CAAA;KACd,GAAG,MAAM,EAAE;IAuHZ,MAAM,CAAC,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,oBAAoB;gBAclD,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM;IAKrD;;;;SAIK;IACE,OAAO,IAAI,OAAO;IAYzB,gBAAgB,IAAI,MAAM,EAAE;CAI7B"}

package/dist/types/src/primitives/index.d.ts

@@ -0,0 +1,9 @@
+export { default as BigNumber } from './BigNumber.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 } from './PrivateKey.js';
+export { default as SymmetricKey } from './SymmetricKey.js';
+export * as Hash from './Hash.js';
+export { default as Random } from './Random.js';
+//# sourceMappingURL=index.d.ts.map

package/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,SAAS,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACvD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAC3D,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,aAAa,CAAA"}

package/dist/types/src/primitives/utils.d.ts

@@ -0,0 +1,118 @@
+import BigNumber from './BigNumber.js';
+/**
+ * Appends a '0' to a single-character word to ensure it has two characters.
+ * @param {string} word - The input word.
+ * @returns {string} - The word with a leading '0' if it's a single character; otherwise, the original word.
+ */
+export declare const zero2: (word: string) => string;
+/**
+ * Converts an array of numbers to a hexadecimal string representation.
+ * @param {number[]} msg - The input array of numbers.
+ * @returns {string} - The hexadecimal string representation of the input array.
+ */
+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')} 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[];
+/**
+ * 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) => {
+    prefix: string | number[];
+    data: string | number[];
+};
+export declare class Writer {
+    bufs: number[][];
+    constructor(bufs?: number[][]);
+    getLength(): number;
+    toArray(): number[];
+    write(buf: number[]): Writer;
+    writeReverse(buf: number[]): Writer;
+    writeUInt8(n: number): Writer;
+    writeInt8(n: number): Writer;
+    writeUInt16BE(n: number): Writer;
+    writeInt16BE(n: number): Writer;
+    writeUInt16LE(n: number): Writer;
+    writeInt16LE(n: number): Writer;
+    writeUInt32BE(n: number): Writer;
+    writeInt32BE(n: number): Writer;
+    writeUInt32LE(n: number): Writer;
+    writeInt32LE(n: number): Writer;
+    writeUInt64BEBn(bn: BigNumber): Writer;
+    writeUInt64LEBn(bn: BigNumber): Writer;
+    writeUInt64LE(n: number): Writer;
+    writeVarIntNum(n: number): Writer;
+    writeVarIntBn(bn: BigNumber): Writer;
+    static varIntNum(n: number): number[];
+    static varIntBn(bn: BigNumber): number[];
+}
+export declare class Reader {
+    bin: number[];
+    pos: number;
+    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;
+    readVarIntNum(): number;
+    readVarInt(): number[];
+    readVarIntBn(): BigNumber;
+}
+//# sourceMappingURL=utils.d.ts.map

package/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/dist/types/src/script/LockingScript.d.ts

@@ -0,0 +1,25 @@
+import Script from './Script.js';
+/**
+ * The LockingScript class represents a locking script in a Bitcoin SV transaction.
+ * It extends the Script class and is used specifically for output scripts that lock funds.
+ *
+ * Inherits all properties and methods from the Script class.
+ *
+ * @extends {Script}
+ * @see {@link Script} for more information on Script.
+ */
+export default class LockingScript extends Script {
+    /**
+     * @method isLockingScript
+     * Determines if the script is a locking script.
+     * @returns {boolean} Always returns true for a LockingScript instance.
+     */
+    isLockingScript(): boolean;
+    /**
+     * @method isUnlockingScript
+     * Determines if the script is an unlocking script.
+     * @returns {boolean} Always returns false for a LockingScript instance.
+     */
+    isUnlockingScript(): boolean;
+}
+//# sourceMappingURL=LockingScript.d.ts.map

package/dist/types/src/script/LockingScript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LockingScript.d.ts","sourceRoot":"","sources":["../../../../src/script/LockingScript.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,aAAa,CAAA;AAEhC;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,MAAM;IAC/C;;;;OAIG;IACH,eAAe,IAAK,OAAO;IAI3B;;;;OAIG;IACH,iBAAiB,IAAK,OAAO;CAG9B"}