@bsv/sdk 1.0.29 → 1.0.32

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

@@ -0,0 +1,124 @@
+import BigNumber from './BigNumber.js';
+/**
+ * Prepends a '0' to an odd character length word to ensure it has an even number of characters.
+ * @param {string} word - The input word.
+ * @returns {string} - The word with a leading '0' if it's an odd character length; otherwise, the original word.
+ */
+export declare const zero2: (word: string) => string;
+/**
+ * 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[];
+/**
+ * Converts an array of numbers to a UTF-8 encoded string.
+ * @param {number[]} arr - The input array of numbers.
+ * @returns {string} - The UTF-8 encoded string.
+ */
+export declare const toUTF8: (arr: number[]) => string;
+/**
+ * Encodes an array of numbers into a specified encoding ('hex' or 'utf8'). If no encoding is provided, returns the original array.
+ * @param {number[]} arr - The input array of numbers.
+ * @param {('hex' | 'utf8')} enc - The desired encoding.
+ * @returns {string | number[]} - The encoded message as a string (for 'hex' and 'utf8') or the original array.
+ */
+export declare const encode: (arr: number[], enc?: 'hex' | 'utf8') => string | number[];
+/**
+ * Converts an array of bytes (each between 0 and 255) into a base64 encoded string.
+ *
+ * @param {number[]} byteArray - An array of numbers where each number is a byte (0-255).
+ * @returns {string} The base64 encoded string.
+ *
+ * @example
+ * const bytes = [72, 101, 108, 108, 111]; // Represents the string "Hello"
+ * console.log(toBase64(bytes)); // Outputs: SGVsbG8=
+ */
+export declare function toBase64(byteArray: number[]): string;
+/**
+ * Converts a string from base58 to a binary array
+ * @param str - The string representation
+ * @returns The binary representation
+ */
+export declare const fromBase58: (str: string) => number[];
+/**
+ * Converts a binary array into a base58 string
+ * @param bin - The binary array to convert to base58
+ * @returns The base58 string representation
+ */
+export declare const toBase58: (bin: number[]) => string;
+/**
+ * Converts a binary array into a base58check string with a checksum
+ * @param bin - The binary array to convert to base58check
+ * @returns The base58check string representation
+ */
+export declare const toBase58Check: (bin: number[], prefix?: number[]) => string;
+/**
+ * Converts a base58check string into a binary array after validating the checksum
+ * @param str - The base58check string to convert to binary
+ * @param enc - If hex, the return values will be hex strings, arrays of numbers otherwise
+ * @param prefixLength - The length of the prefix. Optional, defaults to 1.
+ * @returns The binary array representation
+ */
+export declare const fromBase58Check: (str: string, enc?: 'hex', prefixLength?: number) => {
+    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"}

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;AAMD,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,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAuEnC;;;;;;;OAOG;IACH,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAOnC;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM;IA2DxC;;;;OAIG;gBACS,MAAM,GAAE,WAAW,EAAO;IAItC;;;;OAIG;IACH,KAAK,IAAI,MAAM;IAUf;;;;OAIG;IACH,KAAK,IAAI,MAAM;IAIf;;;;OAIG;IACH,QAAQ,IAAI,MAAM,EAAE;IA0BpB;;;;;OAKG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAKnC;;;;;OAKG;IACH,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAK/B;;;;;;OAMG;IACH,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM;IAK7C;;;;;OAKG;IACH,OAAO,CAAC,EAAE,EAAE,SAAS,GAAG,MAAM;IAqB9B;;;;;;OAMG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM;IAsB/B;;;;;OAKG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAKhC;;;;OAIG;IACH,oBAAoB,IAAI,MAAM;IAW9B;;;;;;OAMG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAYrC;;;;OAIG;IACH,UAAU,IAAI,OAAO;IAWrB;;;;OAIG;IACH,eAAe,IAAI,OAAO;IAI1B;;;;OAIG;IACH,iBAAiB,IAAI,OAAO;IAI5B;;;;;;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, or a Promise for one.
+     */
+    lock: (...params: any) => LockingScript | Promise<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,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;IAEhE;;;;;;;;;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;gBACU,MAAM,EAAE;QACnB,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,IAAK,IAAI;IASd,IAAI,IAAK,IAAI;IA2qCb;;;;;;;;;;OAUG;IACH,QAAQ,IAAK,OAAO;IAwBpB,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,UAAU;IAalB,OAAO,CAAC,qBAAqB;CAG9B"}