@bsv/sdk 1.0.0

package/dist/types/src/script/OP.d.ts

@@ -0,0 +1,193 @@
+/**
+ * An object mapping opcode names (such as OP_DUP) to their corresponding numbers (such as 0x76), and vice versa.
+ */
+declare const OP: {
+    OP_FALSE: number;
+    OP_0: number;
+    OP_PUSHDATA1: number;
+    OP_PUSHDATA2: number;
+    OP_PUSHDATA4: number;
+    OP_1NEGATE: number;
+    OP_RESERVED: number;
+    OP_TRUE: number;
+    OP_1: number;
+    OP_2: number;
+    OP_3: number;
+    OP_4: number;
+    OP_5: number;
+    OP_6: number;
+    OP_7: number;
+    OP_8: number;
+    OP_9: number;
+    OP_10: number;
+    OP_11: number;
+    OP_12: number;
+    OP_13: number;
+    OP_14: number;
+    OP_15: number;
+    OP_16: number;
+    OP_NOP: number;
+    OP_VER: number;
+    OP_IF: number;
+    OP_NOTIF: number;
+    OP_VERIF: number;
+    OP_VERNOTIF: number;
+    OP_ELSE: number;
+    OP_ENDIF: number;
+    OP_VERIFY: number;
+    OP_RETURN: number;
+    OP_TOALTSTACK: number;
+    OP_FROMALTSTACK: number;
+    OP_2DROP: number;
+    OP_2DUP: number;
+    OP_3DUP: number;
+    OP_2OVER: number;
+    OP_2ROT: number;
+    OP_2SWAP: number;
+    OP_IFDUP: number;
+    OP_DEPTH: number;
+    OP_DROP: number;
+    OP_DUP: number;
+    OP_NIP: number;
+    OP_OVER: number;
+    OP_PICK: number;
+    OP_ROLL: number;
+    OP_ROT: number;
+    OP_SWAP: number;
+    OP_TUCK: number;
+    OP_CAT: number;
+    OP_SUBSTR: number;
+    OP_SPLIT: number;
+    OP_LEFT: number;
+    OP_NUM2BIN: number;
+    OP_RIGHT: number;
+    OP_BIN2NUM: number;
+    OP_SIZE: number;
+    OP_INVERT: number;
+    OP_AND: number;
+    OP_OR: number;
+    OP_XOR: number;
+    OP_EQUAL: number;
+    OP_EQUALVERIFY: number;
+    OP_RESERVED1: number;
+    OP_RESERVED2: number;
+    OP_1ADD: number;
+    OP_1SUB: number;
+    OP_2MUL: number;
+    OP_2DIV: number;
+    OP_NEGATE: number;
+    OP_ABS: number;
+    OP_NOT: number;
+    OP_0NOTEQUAL: number;
+    OP_ADD: number;
+    OP_SUB: number;
+    OP_MUL: number;
+    OP_DIV: number;
+    OP_MOD: number;
+    OP_LSHIFT: number;
+    OP_RSHIFT: number;
+    OP_BOOLAND: number;
+    OP_BOOLOR: number;
+    OP_NUMEQUAL: number;
+    OP_NUMEQUALVERIFY: number;
+    OP_NUMNOTEQUAL: number;
+    OP_LESSTHAN: number;
+    OP_GREATERTHAN: number;
+    OP_LESSTHANOREQUAL: number;
+    OP_GREATERTHANOREQUAL: number;
+    OP_MIN: number;
+    OP_MAX: number;
+    OP_WITHIN: number;
+    OP_RIPEMD160: number;
+    OP_SHA1: number;
+    OP_SHA256: number;
+    OP_HASH160: number;
+    OP_HASH256: number;
+    OP_CODESEPARATOR: number;
+    OP_CHECKSIG: number;
+    OP_CHECKSIGVERIFY: number;
+    OP_CHECKMULTISIG: number;
+    OP_CHECKMULTISIGVERIFY: number;
+    OP_NOP1: number;
+    OP_NOP2: number;
+    OP_NOP3: number;
+    OP_NOP4: number;
+    OP_NOP5: number;
+    OP_NOP6: number;
+    OP_NOP7: number;
+    OP_NOP8: number;
+    OP_NOP9: number;
+    OP_NOP10: number;
+    OP_NOP11: number;
+    OP_NOP12: number;
+    OP_NOP13: number;
+    OP_NOP14: number;
+    OP_NOP15: number;
+    OP_NOP16: number;
+    OP_NOP17: number;
+    OP_NOP18: number;
+    OP_NOP19: number;
+    OP_NOP20: number;
+    OP_NOP21: number;
+    OP_NOP22: number;
+    OP_NOP23: number;
+    OP_NOP24: number;
+    OP_NOP25: number;
+    OP_NOP26: number;
+    OP_NOP27: number;
+    OP_NOP28: number;
+    OP_NOP29: number;
+    OP_NOP30: number;
+    OP_NOP31: number;
+    OP_NOP32: number;
+    OP_NOP33: number;
+    OP_NOP34: number;
+    OP_NOP35: number;
+    OP_NOP36: number;
+    OP_NOP37: number;
+    OP_NOP38: number;
+    OP_NOP39: number;
+    OP_NOP40: number;
+    OP_NOP41: number;
+    OP_NOP42: number;
+    OP_NOP43: number;
+    OP_NOP44: number;
+    OP_NOP45: number;
+    OP_NOP46: number;
+    OP_NOP47: number;
+    OP_NOP48: number;
+    OP_NOP49: number;
+    OP_NOP50: number;
+    OP_NOP51: number;
+    OP_NOP52: number;
+    OP_NOP53: number;
+    OP_NOP54: number;
+    OP_NOP55: number;
+    OP_NOP56: number;
+    OP_NOP57: number;
+    OP_NOP58: number;
+    OP_NOP59: number;
+    OP_NOP60: number;
+    OP_NOP61: number;
+    OP_NOP62: number;
+    OP_NOP63: number;
+    OP_NOP64: number;
+    OP_NOP65: number;
+    OP_NOP66: number;
+    OP_NOP67: number;
+    OP_NOP68: number;
+    OP_NOP69: number;
+    OP_NOP70: number;
+    OP_NOP71: number;
+    OP_NOP72: number;
+    OP_NOP73: number;
+    OP_NOP77: number;
+    OP_SMALLDATA: number;
+    OP_SMALLINTEGER: number;
+    OP_PUBKEYS: number;
+    OP_PUBKEYHASH: number;
+    OP_PUBKEY: number;
+    OP_INVALIDOPCODE: number;
+};
+export default OP;
+//# sourceMappingURL=OP.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"OP.d.ts","sourceRoot":"","sources":["../../../../src/script/OP.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,QAAA,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgNP,CAAA;AAOD,eAAe,EAAE,CAAA"}

package/dist/types/src/script/Script.d.ts

@@ -0,0 +1,148 @@
+import ScriptChunk from './ScriptChunk.js';
+import BigNumber from '../primitives/BigNumber.js';
+/**
+ * The Script class represents a script in a Bitcoin SV transaction,
+ * encapsulating the functionality to construct, parse, and serialize
+ * scripts used in both locking (output) and unlocking (input) scripts.
+ *
+ * @property {ScriptChunk[]} chunks - An array of script chunks that make up the script.
+ */
+export default class Script {
+    chunks: ScriptChunk[];
+    /**
+     * @method fromASM
+     * Static method to construct a Script instance from an ASM (Assembly) formatted string.
+     * @param asm - The script in ASM string format.
+     * @returns A new Script instance.
+     * @example
+     * const script = Script.fromASM("OP_DUP OP_HASH160 abcd... OP_EQUALVERIFY OP_CHECKSIG")
+     */
+    static fromASM(asm: string): Script;
+    /**
+     * @method fromHex
+     * Static method to construct a Script instance from a hexadecimal string.
+     * @param hex - The script in hexadecimal format.
+     * @returns A new Script instance.
+     * @example
+     * const script = Script.fromHex("76a9...");
+     */
+    static fromHex(hex: string): Script;
+    /**
+     * @method fromBinary
+     * Static method to construct a Script instance from a binary array.
+     * @param bin - The script in binary array format.
+     * @returns A new Script instance.
+     * @example
+     * const script = Script.fromBinary([0x76, 0xa9, ...])
+     */
+    static fromBinary(bin: number[]): Script;
+    /**
+     * @constructor
+     * Constructs a new Script object.
+     * @param chunks=[] - An array of script chunks to directly initialize the script.
+     */
+    constructor(chunks?: ScriptChunk[]);
+    /**
+     * @method toASM
+     * Serializes the script to an ASM formatted string.
+     * @returns The script in ASM string format.
+     */
+    toASM(): string;
+    /**
+     * @method toHex
+     * Serializes the script to a hexadecimal string.
+     * @returns The script in hexadecimal format.
+     */
+    toHex(): string;
+    /**
+     * @method toBinary
+     * Serializes the script to a binary array.
+     * @returns The script in binary array format.
+     */
+    toBinary(): number[];
+    /**
+     * @method writeScript
+     * Appends another script to this script.
+     * @param script - The script to append.
+     * @returns This script instance for chaining.
+     */
+    writeScript(script: Script): Script;
+    /**
+     * @method writeOpCode
+     * Appends an opcode to the script.
+     * @param op - The opcode to append.
+     * @returns This script instance for chaining.
+     */
+    writeOpCode(op: number): Script;
+    /**
+     * @method setChunkOpCode
+     * Sets the opcode of a specific chunk in the script.
+     * @param i - The index of the chunk.
+     * @param op - The opcode to set.
+     * @returns This script instance for chaining.
+     */
+    setChunkOpCode(i: number, op: number): Script;
+    /**
+     * @method writeBn
+    * Appends a BigNumber to the script as an opcode.
+    * @param bn - The BigNumber to append.
+    * @returns This script instance for chaining.
+     */
+    writeBn(bn: BigNumber): Script;
+    /**
+     * @method writeBin
+     * Appends binary data to the script, determining the appropriate opcode based on length.
+     * @param bin - The binary data to append.
+     * @returns This script instance for chaining.
+     * @throws {Error} Throws an error if the data is too large to be pushed.
+     */
+    writeBin(bin: number[]): Script;
+    /**
+     * @method writeNumber
+     * Appends a number to the script.
+     * @param num - The number to append.
+     * @returns This script instance for chaining.
+     */
+    writeNumber(num: number): Script;
+    /**
+     * @method removeCodeseparators
+     * Removes all OP_CODESEPARATOR opcodes from the script.
+     * @returns This script instance for chaining.
+     */
+    removeCodeseparators(): Script;
+    /**
+     * Deletes the given item wherever it appears in the current script.
+     *
+     * @param script - The script containing the item to delete from the current script.
+     *
+     * @returns This script instance for chaining.
+     */
+    findAndDelete(script: Script): Script;
+    /**
+     * @method isPushOnly
+     * Checks if the script contains only push data operations.
+     * @returns True if the script is push-only, otherwise false.
+     */
+    isPushOnly(): boolean;
+    /**
+     * @method isLockingScript
+     * Determines if the script is a locking script.
+     * @returns True if the script is a locking script, otherwise false.
+     */
+    isLockingScript(): boolean;
+    /**
+     * @method isUnlockingScript
+     * Determines if the script is an unlocking script.
+     * @returns True if the script is an unlocking script, otherwise false.
+     */
+    isUnlockingScript(): boolean;
+    /**
+     * @private
+     * @method _chunkToString
+     * Converts a script chunk to its string representation.
+     * @param chunk - The script chunk.
+     * @returns The string representation of the chunk.
+     */
+    private _chunkToString;
+}
+//# sourceMappingURL=Script.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Script.d.ts","sourceRoot":"","sources":["../../../../src/script/Script.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,kBAAkB,CAAA;AAG1C,OAAO,SAAS,MAAM,4BAA4B,CAAA;AAElD;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,MAAM;IACzB,MAAM,EAAE,WAAW,EAAE,CAAA;IAErB;;;;;;;OAOG;IACH,MAAM,CAAC,OAAO,CAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAuEpC;;;;;;;OAOG;IACH,MAAM,CAAC,OAAO,CAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAIpC;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CAAE,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM;IA2DzC;;;;OAIG;gBACU,MAAM,GAAE,WAAW,EAAO;IAIvC;;;;OAIG;IACH,KAAK,IAAK,MAAM;IAUhB;;;;OAIG;IACH,KAAK,IAAK,MAAM;IAIhB;;;;OAIG;IACH,QAAQ,IAAK,MAAM,EAAE;IA0BrB;;;;;OAKG;IACH,WAAW,CAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAKpC;;;;;OAKG;IACH,WAAW,CAAE,EAAE,EAAE,MAAM,GAAG,MAAM;IAKhC;;;;;;OAMG;IACH,cAAc,CAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM;IAK9C;;;;;OAKG;IACH,OAAO,CAAE,EAAE,EAAE,SAAS,GAAG,MAAM;IAqB/B;;;;;;OAMG;IACH,QAAQ,CAAE,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM;IAsBhC;;;;;OAKG;IACH,WAAW,CAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAKjC;;;;OAIG;IACH,oBAAoB,IAAK,MAAM;IAW/B;;;;;;OAMG;IACH,aAAa,CAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAYtC;;;;OAIG;IACH,UAAU,IAAK,OAAO;IAWtB;;;;OAIG;IACH,eAAe,IAAK,OAAO;IAI3B;;;;OAIG;IACH,iBAAiB,IAAK,OAAO;IAI7B;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;CAWvB"}

package/dist/types/src/script/ScriptChunk.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A representation of a chunk of a script, which includes an opcode. For push operations, the associated data to push onto the stack is also included.
+ */
+export default interface ScriptChunk {
+    op: number;
+    data?: number[];
+}
+//# sourceMappingURL=ScriptChunk.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScriptChunk.d.ts","sourceRoot":"","sources":["../../../../src/script/ScriptChunk.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,OAAO,WAAW,WAAW;IAClC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;CAChB"}

package/dist/types/src/script/ScriptTemplate.d.ts

@@ -0,0 +1,33 @@
+import LockingScript from './LockingScript.js';
+import UnlockingScript from './UnlockingScript.js';
+import Transaction from '../transaction/Transaction.js';
+/**
+ * @interface
+ *
+ * This interface defines the structure for script templates used in Bitcoin transactions.
+ * It provides methods for creating locking scripts, unlocking scripts, and estimating the length of unlocking scripts.
+ */
+export default interface ScriptTemplate {
+    /**
+     * Creates a locking script with the given parameters.
+     *
+     * @param {...any} params - The parameters required to create the locking script.
+     * @returns {LockingScript} - An instance of LockingScript.
+     */
+    lock: (...params: any) => LockingScript;
+    /**
+     * Creates a function that generates an unlocking script along with its signature and length estimation.
+     *
+     * This method returns an object containing two functions:
+     * 1. `sign` - A function that, when called with a transaction and an input index, returns an UnlockingScript instance.
+     * 2. `estimateLength` - A function that returns the estimated length of the unlocking script in bytes.
+     *
+     * @param {...any} params - The parameters required to create the unlocking script.
+     * @returns {Object} - An object containing the `sign` and `estimateLength` functions.
+     */
+    unlock: (...params: any) => {
+        sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>;
+        estimateLength: (tx: Transaction, inputIndex: number) => Promise<number>;
+    };
+}
+//# sourceMappingURL=ScriptTemplate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScriptTemplate.d.ts","sourceRoot":"","sources":["../../../../src/script/ScriptTemplate.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,oBAAoB,CAAA;AAC9C,OAAO,eAAe,MAAM,sBAAsB,CAAA;AAClD,OAAO,WAAW,MAAM,+BAA+B,CAAA;AAEvD;;;;;GAKG;AACH,MAAM,CAAC,OAAO,WAAW,cAAc;IACrC;;;;;OAKG;IACH,IAAI,EAAE,CAAC,GAAG,MAAM,EAAE,GAAG,KAAK,aAAa,CAAA;IAEvC;;;;;;;;;OASG;IACH,MAAM,EAAE,CAAC,GAAG,MAAM,EAAE,GAAG,KACvB;QACE,IAAI,EAAE,CAAC,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,KAC1C,OAAO,CAAC,eAAe,CAAC,CAAA;QACxB,cAAc,EAAE,CAAC,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;KACzE,CAAA;CACF"}

package/dist/types/src/script/Spend.d.ts

@@ -0,0 +1,103 @@
+import LockingScript from './LockingScript.js';
+import UnlockingScript from './UnlockingScript.js';
+import TransactionInput from '../transaction/TransactionInput.js';
+import TransactionOutput from '../transaction/TransactionOutput.js';
+/**
+ * The Spend class represents a spend action within a Bitcoin SV transaction.
+ * It encapsulates all the necessary data required for spending a UTXO (Unspent Transaction Output)
+ * and includes details about the source transaction, output, and the spending transaction itself.
+ *
+ * @property {string} sourceTXID - The transaction ID of the source UTXO.
+ * @property {number} sourceOutputIndex - The index of the output in the source transaction.
+ * @property {BigNumber} sourceSatoshis - The amount of satoshis in the source UTXO.
+ * @property {LockingScript} lockingScript - The locking script associated with the UTXO.
+ * @property {number} transactionVersion - The version of the current transaction.
+ * @property {Array<{ sourceTXID: string, sourceOutputIndex: number, sequence: number }>} otherInputs -
+ *           An array of other inputs in the transaction, each with a txid, outputIndex, and sequence number.
+ * @property {Array<{ satoshis: BigNumber, lockingScript: LockingScript }>} outputs -
+ *           An array of outputs of the current transaction, including the satoshi value and locking script for each.
+ * @property {number} inputIndex - The index of this input in the current transaction.
+ * @property {UnlockingScript} unlockingScript - The unlocking script that unlocks the UTXO for spending.
+ * @property {number} inputSequence - The sequence number of this input.
+ */
+export default class Spend {
+    sourceTXID: string;
+    sourceOutputIndex: number;
+    sourceSatoshis: number;
+    lockingScript: LockingScript;
+    transactionVersion: number;
+    otherInputs: TransactionInput[];
+    outputs: TransactionOutput[];
+    inputIndex: number;
+    unlockingScript: UnlockingScript;
+    inputSequence: number;
+    lockTime: number;
+    context: 'UnlockingScript' | 'LockingScript';
+    programCounter: number;
+    lastCodeSeparator: number | null;
+    stack: number[][];
+    altStack: number[][];
+    ifStack: boolean[];
+    /**
+     * @constructor
+     * Constructs the Spend object with necessary transaction details.
+     * @param {string} params.sourceTXID - The transaction ID of the source UTXO.
+     * @param {number} params.sourceOutputIndex - The index of the output in the source transaction.
+     * @param {BigNumber} params.sourceSatoshis - The amount of satoshis in the source UTXO.
+     * @param {LockingScript} params.lockingScript - The locking script associated with the UTXO.
+     * @param {number} params.transactionVersion - The version of the current transaction.
+     * @param {Array<{ sourceTXID: string, sourceOutputIndex: number, sequence: number }>} params.otherInputs -
+     *        An array of other inputs in the transaction.
+     * @param {Array<{ satoshis: BigNumber, lockingScript: LockingScript }>} params.outputs -
+     *        The outputs of the current transaction.
+     * @param {number} params.inputIndex - The index of this input in the current transaction.
+     * @param {UnlockingScript} params.unlockingScript - The unlocking script for this spend.
+     * @param {number} params.inputSequence - The sequence number of this input.
+     * @param {number} params.lockTime - The lock time of the transaction.
+     *
+     * @example
+     * const spend = new Spend({
+     *   sourceTXID: "abcd1234", // sourceTXID
+     *   sourceOutputIndex: 0, // sourceOutputIndex
+     *   sourceSatoshis: new BigNumber(1000), // sourceSatoshis
+     *   lockingScript: LockingScript.fromASM("OP_DUP OP_HASH160 abcd1234... OP_EQUALVERIFY OP_CHECKSIG"),
+     *   transactionVersion: 1, // transactionVersion
+     *   otherInputs: [{ sourceTXID: "abcd1234", sourceOutputIndex: 1, sequence: 0xffffffff }], // otherInputs
+     *   outputs: [{ satoshis: new BigNumber(500), lockingScript: LockingScript.fromASM("OP_DUP...") }], // outputs
+     *   inputIndex: 0, // inputIndex
+     *   unlockingScript: UnlockingScript.fromASM("3045... 02ab..."),
+     *   inputSequence: 0xffffffff // inputSequence
+     * });
+     */
+    constructor(params: {
+        sourceTXID: string;
+        sourceOutputIndex: number;
+        sourceSatoshis: number;
+        lockingScript: LockingScript;
+        transactionVersion: number;
+        otherInputs: TransactionInput[];
+        outputs: TransactionOutput[];
+        unlockingScript: UnlockingScript;
+        inputSequence: number;
+        inputIndex: number;
+        lockTime: number;
+    });
+    reset(): void;
+    step(): void;
+    /**
+     * @method validate
+     * Validates the spend action by interpreting the locking and unlocking scripts.
+     * @returns {boolean} Returns true if the scripts are valid and the spend is legitimate, otherwise false.
+     * @example
+     * if (spend.validate()) {
+     *   console.log("Spend is valid!");
+     * } else {
+     *   console.log("Invalid spend!");
+     * }
+     */
+    validate(): boolean;
+    private stacktop;
+    private castToBool;
+    private scriptEvaluationError;
+}
+//# sourceMappingURL=Spend.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Spend.d.ts","sourceRoot":"","sources":["../../../../src/script/Spend.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,oBAAoB,CAAA;AAC9C,OAAO,eAAe,MAAM,sBAAsB,CAAA;AAUlD,OAAO,gBAAgB,MAAM,oCAAoC,CAAA;AACjE,OAAO,iBAAiB,MAAM,qCAAqC,CAAA;AAWnE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,OAAO,OAAO,KAAK;IACxB,UAAU,EAAE,MAAM,CAAA;IAClB,iBAAiB,EAAE,MAAM,CAAA;IACzB,cAAc,EAAE,MAAM,CAAA;IACtB,aAAa,EAAE,aAAa,CAAA;IAC5B,kBAAkB,EAAE,MAAM,CAAA;IAC1B,WAAW,EAAE,gBAAgB,EAAE,CAAA;IAC/B,OAAO,EAAE,iBAAiB,EAAE,CAAA;IAC5B,UAAU,EAAE,MAAM,CAAA;IAClB,eAAe,EAAE,eAAe,CAAA;IAChC,aAAa,EAAE,MAAM,CAAA;IACrB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,iBAAiB,GAAG,eAAe,CAAA;IAC5C,cAAc,EAAE,MAAM,CAAA;IACtB,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAA;IACjB,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAA;IACpB,OAAO,EAAE,OAAO,EAAE,CAAA;IAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;gBACS,MAAM,EAAE;QAClB,UAAU,EAAE,MAAM,CAAA;QAClB,iBAAiB,EAAE,MAAM,CAAA;QACzB,cAAc,EAAE,MAAM,CAAA;QACtB,aAAa,EAAE,aAAa,CAAA;QAC5B,kBAAkB,EAAE,MAAM,CAAA;QAC1B,WAAW,EAAE,gBAAgB,EAAE,CAAA;QAC/B,OAAO,EAAE,iBAAiB,EAAE,CAAA;QAC5B,eAAe,EAAE,eAAe,CAAA;QAChC,aAAa,EAAE,MAAM,CAAA;QACrB,UAAU,EAAE,MAAM,CAAA;QAClB,QAAQ,EAAE,MAAM,CAAA;KACjB;IAeD,KAAK,IAAI,IAAI;IASb,IAAI,IAAI,IAAI;IA4qCZ;;;;;;;;;;OAUG;IACH,QAAQ,IAAI,OAAO;IAwBnB,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,UAAU;IAalB,OAAO,CAAC,qBAAqB;CAG9B"}

package/dist/types/src/script/UnlockingScript.d.ts

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

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

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

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

@@ -0,0 +1,8 @@
+export { default as OP } from './OP.js';
+export { default as Script } from './Script.js';
+export { default as LockingScript } from './LockingScript.js';
+export { default as UnlockingScript } from './UnlockingScript.js';
+export { default as Spend } from './Spend.js';
+export type { default as ScriptTemplate } from './ScriptTemplate.js';
+export * from './templates/index.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/script/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,EAAE,EAAE,MAAM,SAAS,CAAA;AACvC,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAC7D,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,sBAAsB,CAAA;AACjE,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,YAAY,CAAA;AAC7C,YAAY,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACpE,cAAc,sBAAsB,CAAA"}

package/dist/types/src/script/templates/P2PKH.d.ts

@@ -0,0 +1,37 @@
+import ScriptTemplate from '../ScriptTemplate.js';
+import LockingScript from '../LockingScript.js';
+import UnlockingScript from '../UnlockingScript.js';
+import Transaction from '../../transaction/Transaction.js';
+import PrivateKey from '../../primitives/PrivateKey.js';
+/**
+ * P2PKH (Pay To Public Key Hash) class implementing ScriptTemplate.
+ *
+ * This class provides methods to create Pay To Public Key Hash locking and unlocking scripts, including the unlocking of P2PKH UTXOs with the private key.
+ */
+export default class P2PKH implements ScriptTemplate {
+    /**
+     * Creates a P2PKH locking script for a given public key hash.
+     *
+     * @param {number[]} pubkeyhash - An array representing the public key hash.
+     * @returns {LockingScript} - A P2PKH locking script.
+     */
+    lock(pubkeyhash: number[]): LockingScript;
+    /**
+     * Creates a function that generates a P2PKH unlocking script along with its signature and length estimation.
+     *
+     * The returned object contains:
+     * 1. `sign` - A function that, when invoked with a transaction and an input index,
+     *    produces an unlocking script suitable for a P2PKH locked output.
+     * 2. `estimateLength` - A function that returns the estimated length of the unlocking script in bytes.
+     *
+     * @param {PrivateKey} privateKey - The private key used for signing the transaction.
+     * @param {'all'|'none'|'single'} signOutputs - The signature scope for outputs.
+     * @param {boolean} anyoneCanPay - Flag indicating if the signature allows for other inputs to be added later.
+     * @returns {Object} - An object containing the `sign` and `estimateLength` functions.
+     */
+    unlock(privateKey: PrivateKey, signOutputs?: 'all' | 'none' | 'single', anyoneCanPay?: boolean): {
+        sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>;
+        estimateLength: () => Promise<106>;
+    };
+}
+//# sourceMappingURL=P2PKH.d.ts.map

package/dist/types/src/script/templates/P2PKH.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"P2PKH.d.ts","sourceRoot":"","sources":["../../../../../src/script/templates/P2PKH.ts"],"names":[],"mappings":"AACA,OAAO,cAAc,MAAM,sBAAsB,CAAA;AACjD,OAAO,aAAa,MAAM,qBAAqB,CAAA;AAC/C,OAAO,eAAe,MAAM,uBAAuB,CAAA;AACnD,OAAO,WAAW,MAAM,kCAAkC,CAAA;AAC1D,OAAO,UAAU,MAAM,gCAAgC,CAAA;AAIvD;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,KAAM,YAAW,cAAc;IAClD;;;;;OAKG;IACH,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,aAAa;IAUzC;;;;;;;;;;;;OAYG;IACH,MAAM,CACJ,UAAU,EAAE,UAAU,EACtB,WAAW,GAAE,KAAK,GAAG,MAAM,GAAG,QAAgB,EAC9C,YAAY,GAAE,OAAe,GAC5B;QACD,IAAI,EAAE,CAAC,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,CAAC,CAAA;QACvE,cAAc,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAA;KACnC;CAyDF"}

package/dist/types/src/script/templates/RPuzzle.d.ts

@@ -0,0 +1,47 @@
+import ScriptTemplate from '../ScriptTemplate.js';
+import LockingScript from '../LockingScript.js';
+import UnlockingScript from '../UnlockingScript.js';
+import Transaction from '../../transaction/Transaction.js';
+import PrivateKey from '../../primitives/PrivateKey.js';
+import BigNumber from '../../primitives/BigNumber.js';
+/**
+ * RPuzzle class implementing ScriptTemplate.
+ *
+ * This class provides methods to create R Puzzle and R Puzzle Hash locking and unlocking scripts, including the unlocking of UTXOs with the correct K value.
+ */
+export default class RPuzzle implements ScriptTemplate {
+    type: 'raw' | 'SHA1' | 'SHA256' | 'HASH256' | 'RIPEMD160' | 'HASH160';
+    /**
+     * @constructor
+     * Constructs an R Puzzle template instance for a given puzzle type
+     *
+     * @param {'raw'|'SHA1'|'SHA256'|'HASH256'|'RIPEMD160'|'HASH160'} type Denotes the type of puzzle to create
+     */
+    constructor(type?: 'raw' | 'SHA1' | 'SHA256' | 'HASH256' | 'RIPEMD160' | 'HASH160');
+    /**
+     * Creates an R puzzle locking script for a given R value or R value hash.
+     *
+     * @param {number[]} value - An array representing the R value or its hash.
+     * @returns {LockingScript} - An R puzzle locking script.
+     */
+    lock(value: number[]): LockingScript;
+    /**
+     * Creates a function that generates an R puzzle unlocking script along with its signature and length estimation.
+     *
+     * The returned object contains:
+     * 1. `sign` - A function that, when invoked with a transaction and an input index,
+     *    produces an unlocking script suitable for an R puzzle locked output.
+     * 2. `estimateLength` - A function that returns the estimated length of the unlocking script in bytes.
+     *
+     * @param {BigNumber} k — The K-value used to unlock the R-puzzle.
+     * @param {PrivateKey} privateKey - The private key used for signing the transaction. If not provided, a random key will be generated.
+     * @param {'all'|'none'|'single'} signOutputs - The signature scope for outputs.
+     * @param {boolean} anyoneCanPay - Flag indicating if the signature allows for other inputs to be added later.
+     * @returns {Object} - An object containing the `sign` and `estimateLength` functions.
+     */
+    unlock(k: BigNumber, privateKey: PrivateKey, signOutputs?: 'all' | 'none' | 'single', anyoneCanPay?: boolean): {
+        sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>;
+        estimateLength: () => Promise<106>;
+    };
+}
+//# sourceMappingURL=RPuzzle.d.ts.map

package/dist/types/src/script/templates/RPuzzle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RPuzzle.d.ts","sourceRoot":"","sources":["../../../../../src/script/templates/RPuzzle.ts"],"names":[],"mappings":"AACA,OAAO,cAAc,MAAM,sBAAsB,CAAA;AACjD,OAAO,aAAa,MAAM,qBAAqB,CAAA;AAC/C,OAAO,eAAe,MAAM,uBAAuB,CAAA;AACnD,OAAO,WAAW,MAAM,kCAAkC,CAAA;AAC1D,OAAO,UAAU,MAAM,gCAAgC,CAAA;AAIvD,OAAO,SAAS,MAAM,+BAA+B,CAAA;AAErD;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,OAAQ,YAAW,cAAc;IACpD,IAAI,EAAE,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,CAAQ;IAE7E;;;;;OAKG;gBACU,IAAI,GAAE,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,SAAiB;IAI1F;;;;;OAKG;IACH,IAAI,CAAE,KAAK,EAAE,MAAM,EAAE,GAAG,aAAa;IAuBrC;;;;;;;;;;;;;OAaG;IACH,MAAM,CACJ,CAAC,EAAE,SAAS,EACZ,UAAU,EAAE,UAAU,EACtB,WAAW,GAAE,KAAK,GAAG,MAAM,GAAG,QAAgB,EAC9C,YAAY,GAAE,OAAe,GAC5B;QACC,IAAI,EAAE,CAAC,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,CAAC,CAAA;QACvE,cAAc,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAA;KACnC;CA2DJ"}

package/dist/types/src/script/templates/index.d.ts

@@ -0,0 +1,3 @@
+export { default as P2PKH } from './P2PKH.js';
+export { default as RPuzzle } from './RPuzzle.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/script/templates/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/script/templates/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,YAAY,CAAA;AAC7C,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,cAAc,CAAA"}