@bsv/sdk 1.0.29 → 1.0.32

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,40 @@
+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 Script from '../Script.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 or address string
+     *
+     * @param {number[] | string} pubkeyhash or address - An array or address representing the public key hash.
+     * @returns {LockingScript} - A P2PKH locking script.
+     */
+    lock(pubkeyhash: string | 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.
+     * @param {number} sourceSatoshis - Optional. The amount being unlocked. Otherwise the input.sourceTransaction is required.
+     * @param {Script} lockingScript - Optional. The lockinScript. Otherwise the input.sourceTransaction is required.
+     * @returns {Object} - An object containing the `sign` and `estimateLength` functions.
+     */
+    unlock(privateKey: PrivateKey, signOutputs?: 'all' | 'none' | 'single', anyoneCanPay?: boolean, sourceSatoshis?: number, lockingScript?: Script): {
+        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;AAEjD,OAAO,aAAa,MAAM,qBAAqB,CAAA;AAC/C,OAAO,eAAe,MAAM,uBAAuB,CAAA;AACnD,OAAO,WAAW,MAAM,kCAAkC,CAAA;AAC1D,OAAO,UAAU,MAAM,gCAAgC,CAAA;AAGvD,OAAO,MAAM,MAAM,cAAc,CAAA;AAEjC;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,KAAM,YAAW,cAAc;IAClD;;;;;OAKG;IACH,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,aAAa;IAkBlD;;;;;;;;;;;;;;OAcG;IACH,MAAM,CACJ,UAAU,EAAE,UAAU,EACtB,WAAW,GAAE,KAAK,GAAG,MAAM,GAAG,QAAgB,EAC9C,YAAY,GAAE,OAAe,EAC7B,cAAc,CAAC,EAAE,MAAM,EACvB,aAAa,CAAC,EAAE,MAAM,GACrB;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;CAyEF"}

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"}

package/dist/types/src/transaction/Broadcaster.d.ts

@@ -0,0 +1,39 @@
+import Transaction from './Transaction.js';
+/**
+ * Defines the structure of a successful broadcast response.
+ *
+ * @interface
+ * @property {string} status - The status of the response, indicating success.
+ * @property {string} txid - The transaction ID of the broadcasted transaction.
+ * @property {string} message - A human-readable success message.
+ */
+export interface BroadcastResponse {
+    status: 'success';
+    txid: string;
+    message: string;
+}
+/**
+ * Defines the structure of a failed broadcast response.
+ *
+ * @interface
+ * @property {string} status - The status of the response, indicating an error.
+ * @property {string} code - A machine-readable error code representing the type of error encountered.
+ * @property {string} description - A detailed description of the error.
+ */
+export interface BroadcastFailure {
+    status: 'error';
+    code: string;
+    description: string;
+}
+/**
+ * Represents the interface for a transaction broadcaster.
+ * This interface defines a standard method for broadcasting transactions.
+ *
+ * @interface
+ * @property {function} broadcast - A function that takes a Transaction object and returns a promise.
+ *                                  The promise resolves to either a BroadcastResponse or a BroadcastFailure.
+ */
+export interface Broadcaster {
+    broadcast: (transaction: Transaction) => Promise<BroadcastResponse | BroadcastFailure>;
+}
+//# sourceMappingURL=Broadcaster.d.ts.map

package/dist/types/src/transaction/Broadcaster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Broadcaster.d.ts","sourceRoot":"","sources":["../../../../src/transaction/Broadcaster.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,kBAAkB,CAAA;AAE1C;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,SAAS,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,CAAC,WAAW,EAAE,WAAW,KACpC,OAAO,CAAC,iBAAiB,GAAG,gBAAgB,CAAC,CAAA;CAC9C"}

package/dist/types/src/transaction/ChainTracker.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The Chain Tracker is responsible for verifying the validity of a given Merkle root
+ * for a specific block height within the blockchain.
+ *
+ * Chain Trackers ensure the integrity of the blockchain by
+ * validating new headers against the chain's history. They use accumulated
+ * proof-of-work and protocol adherence as metrics to assess the legitimacy of blocks.
+ *
+ * @interface ChainTracker
+ * @function isValidRootForHeight - A method to verify the validity of a Merkle root
+ *          for a given block height.
+ *
+ * @example
+ * const chainTracker = {
+ *   isValidRootForHeight: async (root, height) => {
+ *     // Implementation to check if the Merkle root is valid for the specified block height.
+ *   }
+ * };
+ */
+export default interface ChainTracker {
+    isValidRootForHeight: (root: string, height: number) => Promise<boolean>;
+}
+//# sourceMappingURL=ChainTracker.d.ts.map

package/dist/types/src/transaction/ChainTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChainTracker.d.ts","sourceRoot":"","sources":["../../../../src/transaction/ChainTracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,OAAO,WAAW,YAAY;IACnC,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CACzE"}

package/dist/types/src/transaction/FeeModel.d.ts

@@ -0,0 +1,12 @@
+import Transaction from './Transaction.js';
+/**
+ * Represents the interface for a transaction fee model.
+ * This interface defines a standard method for computing a fee when given a transaction.
+ *
+ * @interface
+ * @property {function} computeFee - A function that takes a Transaction object and returns a BigNumber representing the number of satoshis the transaction should cost.
+ */
+export default interface FeeModel {
+    computeFee: (transaction: Transaction) => Promise<number>;
+}
+//# sourceMappingURL=FeeModel.d.ts.map

package/dist/types/src/transaction/FeeModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeeModel.d.ts","sourceRoot":"","sources":["../../../../src/transaction/FeeModel.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,kBAAkB,CAAA;AAG1C;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,WAAW,QAAQ;IAC/B,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;CAC1D"}

package/dist/types/src/transaction/MerklePath.d.ts

@@ -0,0 +1,91 @@
+import { Reader } from '../primitives/utils.js';
+import ChainTracker from './ChainTracker.js';
+/**
+ * Represents a Merkle Path, which is used to provide a compact proof of inclusion for a
+ * transaction in a block. This class encapsulates all the details required for creating
+ * and verifying Merkle Proofs.
+ *
+ * @class MerklePath
+ * @property {number} blockHeight - The height of the block in which the transaction is included.
+ * @property {Array<Array<{offset: number, hash?: string, txid?: boolean, duplicate?: boolean}>>} path -
+ *           A tree structure representing the Merkle Path, with each level containing information
+ *           about the nodes involved in constructing the proof.
+ *
+ * @example
+ * // Creating and verifying a Merkle Path
+ * const merklePath = MerklePath.fromHex('...');
+ * const isValid = merklePath.verify(txid, chainTracker);
+ *
+ * @description
+ * The MerklePath class is useful for verifying transactions in a lightweight and efficient manner without
+ * needing the entire block data. This class offers functionalities for creating, converting,
+ * and verifying these proofs.
+ */
+export default class MerklePath {
+    blockHeight: number;
+    path: Array<Array<{
+        offset: number;
+        hash?: string;
+        txid?: boolean;
+        duplicate?: boolean;
+    }>>;
+    /**
+     * Creates a MerklePath instance from a hexadecimal string.
+     *
+     * @static
+     * @param {string} hex - The hexadecimal string representation of the Merkle Path.
+     * @returns {MerklePath} - A new MerklePath instance.
+     */
+    static fromHex(hex: string): MerklePath;
+    static fromReader(reader: Reader): MerklePath;
+    /**
+     * Creates a MerklePath instance from a binary array.
+     *
+     * @static
+     * @param {number[]} bump - The binary array representation of the Merkle Path.
+     * @returns {MerklePath} - A new MerklePath instance.
+     */
+    static fromBinary(bump: number[]): MerklePath;
+    constructor(blockHeight: number, path: Array<Array<{
+        offset: number;
+        hash?: string;
+        txid?: boolean;
+        duplicate?: boolean;
+    }>>);
+    /**
+     * Converts the MerklePath to a binary array format.
+     *
+     * @returns {number[]} - The binary array representation of the Merkle Path.
+     */
+    toBinary(): number[];
+    /**
+     * Converts the MerklePath to a hexadecimal string format.
+     *
+     * @returns {string} - The hexadecimal string representation of the Merkle Path.
+     */
+    toHex(): string;
+    /**
+     * Computes the Merkle root from the provided transaction ID.
+     *
+     * @param {string} txid - The transaction ID to compute the Merkle root for. If not provided, the root will be computed from an unspecified branch, and not all branches will be validated!
+     * @returns {string} - The computed Merkle root as a hexadecimal string.
+     * @throws {Error} - If the transaction ID is not part of the Merkle Path.
+     */
+    computeRoot(txid?: string): string;
+    /**
+     * Verifies if the given transaction ID is part of the Merkle tree at the specified block height.
+     *
+     * @param {string} txid - The transaction ID to verify.
+     * @param {ChainTracker} chainTracker - The ChainTracker instance used to verify the Merkle root.
+     * @returns {boolean} - True if the transaction ID is valid within the Merkle Path at the specified block height.
+     */
+    verify(txid: string, chainTracker: ChainTracker): Promise<boolean>;
+    /**
+     * Combines this MerklePath with another to create a compound proof.
+     *
+     * @param {MerklePath} other - Another MerklePath to combine with this path.
+     * @throws {Error} - If the paths have different block heights or roots.
+     */
+    combine(other: MerklePath): void;
+}
+//# sourceMappingURL=MerklePath.d.ts.map

package/dist/types/src/transaction/MerklePath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MerklePath.d.ts","sourceRoot":"","sources":["../../../../src/transaction/MerklePath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAA0B,MAAM,wBAAwB,CAAA;AAEvE,OAAO,YAAY,MAAM,mBAAmB,CAAA;AAE5C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,OAAO,OAAO,UAAU;IAC7B,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC;QAChB,MAAM,EAAE,MAAM,CAAA;QACd,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,IAAI,CAAC,EAAE,OAAO,CAAA;QACd,SAAS,CAAC,EAAE,OAAO,CAAA;KACpB,CAAC,CAAC,CAAA;IAEH;;;;;;OAMG;IACH,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU;IAIvC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU;IAgC7C;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU;gBAKjC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC;QACjD,MAAM,EAAE,MAAM,CAAA;QACd,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,IAAI,CAAC,EAAE,OAAO,CAAA;QACd,SAAS,CAAC,EAAE,OAAO,CAAA;KACpB,CAAC,CAAC;IAsCH;;;;OAIG;IACH,QAAQ,IAAI,MAAM,EAAE;IA0BpB;;;;OAIG;IACH,KAAK,IAAI,MAAM;IAIf;;;;;;OAMG;IACH,WAAW,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM;IAgClC;;;;;;OAMG;IACG,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAMxE;;;;;OAKG;IACH,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;CA4BjC"}

package/dist/types/src/transaction/Transaction.d.ts

@@ -0,0 +1,215 @@
+import TransactionInput from './TransactionInput.js';
+import TransactionOutput from './TransactionOutput.js';
+import FeeModel from './FeeModel.js';
+import { Broadcaster, BroadcastResponse, BroadcastFailure } from './Broadcaster.js';
+import MerklePath from './MerklePath.js';
+import ChainTracker from './ChainTracker.js';
+/**
+ * Represents a complete Bitcoin transaction. This class encapsulates all the details
+ * required for creating, signing, and processing a Bitcoin transaction, including
+ * inputs, outputs, and various transaction-related methods.
+ *
+ * @class Transaction
+ * @property {number} version - The version number of the transaction. Used to specify
+ *           which set of rules this transaction follows.
+ * @property {TransactionInput[]} inputs - An array of TransactionInput objects, representing
+ *           the inputs for the transaction. Each input references a previous transaction's output.
+ * @property {TransactionOutput[]} outputs - An array of TransactionOutput objects, representing
+ *           the outputs for the transaction. Each output specifies the amount of satoshis to be
+ *           transferred and the conditions under which they can be spent.
+ * @property {number} lockTime - The lock time of the transaction. If non-zero, it specifies the
+ *           earliest time or block height at which the transaction can be added to the block chain.
+ * @property {Record<string, any>} metadata - A key-value store for attaching additional data to
+ *           the transaction object, not included in the transaction itself. Useful for adding descriptions, internal reference numbers, or other information.
+ * @property {MerkleProof} [merkleProof] - Optional. A merkle proof demonstrating the transaction's
+ *           inclusion in a block. Useful for transaction verification using SPV.
+ *
+ * @example
+ * // Creating a new transaction
+ * let tx = new Transaction();
+ * tx.addInput(...);
+ * tx.addOutput(...);
+ * await tx.fee();
+ * await tx.sign();
+ * await tx.broadcast();
+ *
+ * @description
+ * The Transaction class provides comprehensive
+ * functionality to handle various aspects of transaction creation, including
+ * adding inputs and outputs, computing fees, signing the transaction, and
+ * generating its binary or hexadecimal representation.
+ */
+export default class Transaction {
+    version: number;
+    inputs: TransactionInput[];
+    outputs: TransactionOutput[];
+    lockTime: number;
+    metadata: Record<string, any>;
+    merklePath?: MerklePath;
+    private cachedHash?;
+    /**
+     * Creates a new transaction, linked to its inputs and their associated merkle paths, from a BEEF (BRC-62) structure.
+     * @param beef A binary representation of a transaction in BEEF format.
+     * @returns An anchored transaction, linked to its associated inputs populated with merkle paths.
+     */
+    static fromBEEF(beef: number[]): Transaction;
+    /**
+     * Since the validation of blockchain data is atomically transaction data validation,
+     * any application seeking to validate data in output scripts must store the entire transaction as well.
+     * Since the transaction data includes the output script data, saving a second copy of potentially
+     * large scripts can bloat application storage requirements.
+     *
+     * This function efficiently parses binary transaction data to determine the offsets and lengths of each script.
+     * This supports the efficient retreival of script data from transaction data.
+     *
+     * @param bin binary transaction data
+     * @returns {
+     *   inputs: { vin: number, offset: number, length: number }[]
+     *   outputs: { vout: number, offset: number, length: number }[]
+     * }
+     */
+    static parseScriptOffsets(bin: number[]): {
+        inputs: {
+            vin: number;
+            offset: number;
+            length: number;
+        }[];
+        outputs: {
+            vout: number;
+            offset: number;
+            length: number;
+        }[];
+    };
+    private static fromReader;
+    /**
+     * Creates a Transaction instance from a binary array.
+     *
+     * @static
+     * @param {number[]} bin - The binary array representation of the transaction.
+     * @returns {Transaction} - A new Transaction instance.
+     */
+    static fromBinary(bin: number[]): Transaction;
+    /**
+     * Creates a Transaction instance from a hexadecimal string.
+     *
+     * @static
+     * @param {string} hex - The hexadecimal string representation of the transaction.
+     * @returns {Transaction} - A new Transaction instance.
+     */
+    static fromHex(hex: string): Transaction;
+    /**
+     * Creates a Transaction instance from a hexadecimal string encoded BEEF.
+     *
+     * @static
+     * @param {string} hex - The hexadecimal string representation of the transaction BEEF.
+     * @returns {Transaction} - A new Transaction instance.
+     */
+    static fromHexBEEF(hex: string): Transaction;
+    constructor(version?: number, inputs?: TransactionInput[], outputs?: TransactionOutput[], lockTime?: number, metadata?: Record<string, any>, merklePath?: MerklePath);
+    /**
+     * Adds a new input to the transaction.
+     *
+     * @param {TransactionInput} input - The TransactionInput object to add to the transaction.
+     * @throws {Error} - If the input does not have a sourceTXID or sourceTransaction defined.
+     */
+    addInput(input: TransactionInput): void;
+    /**
+     * Adds a new output to the transaction.
+     *
+     * @param {TransactionOutput} output - The TransactionOutput object to add to the transaction.
+     */
+    addOutput(output: TransactionOutput): void;
+    /**
+     * Updates the transaction's metadata.
+     *
+     * @param {Record<string, any>} metadata - The metadata object to merge into the existing metadata.
+     */
+    updateMetadata(metadata: Record<string, any>): void;
+    /**
+     * Computes fees prior to signing.
+     * If no fee model is provided, uses a SatoshisPerKilobyte fee model that pays 10 sat/kb.
+     *
+     * @param model - The initialized fee model to use
+     * @param changeDistribution - Specifies how the change should be distributed
+     * amongst the change outputs
+     *
+     * TODO: Benford's law change distribution.
+     */
+    fee(model?: FeeModel, changeDistribution?: 'equal' | 'random'): Promise<void>;
+    /**
+     * Signs a transaction, hydrating all its unlocking scripts based on the provided script templates where they are available.
+     */
+    sign(): Promise<void>;
+    /**
+     * Broadcasts a transaction.
+     *
+     * @param broadcaster The Broadcaster instance wwhere the transaction will be sent
+     * @returns A BroadcastResponse or BroadcastFailure from the Broadcaster
+     */
+    broadcast(broadcaster: Broadcaster): Promise<BroadcastResponse | BroadcastFailure>;
+    /**
+     * Converts the transaction to a binary array format.
+     *
+     * @returns {number[]} - The binary array representation of the transaction.
+     */
+    toBinary(): number[];
+    /**
+     * Converts the transaction to a BRC-30 EF format.
+     *
+     * @returns {number[]} - The BRC-30 EF representation of the transaction.
+     */
+    toEF(): number[];
+    /**
+     * Converts the transaction to a hexadecimal string EF.
+     *
+     * @returns {string} - The hexadecimal string representation of the transaction EF.
+     */
+    toHexEF(): string;
+    /**
+     * Converts the transaction to a hexadecimal string format.
+     *
+     * @returns {string} - The hexadecimal string representation of the transaction.
+     */
+    toHex(): string;
+    /**
+     * Converts the transaction to a hexadecimal string BEEF.
+     *
+     * @returns {string} - The hexadecimal string representation of the transaction BEEF.
+     */
+    toHexBEEF(): string;
+    /**
+     * Calculates the transaction's hash.
+     *
+     * @param {'hex' | undefined} enc - The encoding to use for the hash. If 'hex', returns a hexadecimal string; otherwise returns a binary array.
+     * @returns {string | number[]} - The hash of the transaction in the specified format.
+     */
+    hash(enc?: 'hex'): number[] | string;
+    /**
+     * Calculates the transaction's ID in binary array.
+     *
+     * @returns {number[]} - The ID of the transaction in the binary array format.
+     */
+    id(): number[];
+    /**
+     * Calculates the transaction's ID in hexadecimal format.
+     *
+     * @param {'hex'} enc - The encoding to use for the ID. If 'hex', returns a hexadecimal string.
+     * @returns {string} - The ID of the transaction in the hex format.
+     */
+    id(enc: 'hex'): string;
+    /**
+     * Verifies the legitimacy of the Bitcoin transaction according to the rules of SPV by ensuring all the input transactions link back to valid block headers, the chain of spends for all inputs are valid, and the sum of inputs is not less than the sum of outputs.
+     *
+     * @param chainTracker - An instance of ChainTracker, a Bitcoin block header tracker. If the value is set to 'scripts only', headers will not be verified.
+     *
+     * @returns Whether the transaction is valid according to the rules of SPV.
+     */
+    verify(chainTracker: ChainTracker | 'scripts only'): Promise<boolean>;
+    /**
+     * Serializes this transaction, together with its inputs and the respective merkle proofs, into the BEEF (BRC-62) format. This enables efficient verification of its compliance with the rules of SPV.
+     *
+     * @returns The serialized BEEF structure
+     */
+    toBEEF(): number[];
+}
+//# sourceMappingURL=Transaction.d.ts.map

package/dist/types/src/transaction/Transaction.d.ts.map

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

package/dist/types/src/transaction/TransactionInput.d.ts

@@ -0,0 +1,63 @@
+import UnlockingScript from '../script/UnlockingScript.js';
+import Transaction from './Transaction.js';
+/**
+ * Represents an input to a Bitcoin transaction.
+ * This interface defines the structure and components required to construct
+ * a transaction input in the Bitcoin blockchain.
+ *
+ * @interface TransactionInput
+ * @property {Transaction} [sourceTransaction] - Optional. The source transaction
+ *           from which this input is derived. This is the transaction whose output
+ *           is being spent by this input. Preferably provided if available.
+ * @property {string} [sourceTXID] - Optional. The transaction ID (TXID) of the source
+ *           transaction. Required if the source transaction itself is not provided.
+ *           This uniquely identifies the transaction within the blockchain.
+ * @property {number} sourceOutputIndex - The index of the output in the source transaction
+ *           that this input is spending. It is zero-based, indicating the position of the
+ *           output in the array of outputs of the source transaction.
+ * @property {UnlockingScript} [unlockingScript] - Optional. The script that 'unlocks' the
+ *           source output for spending. This script typically contains signatures and
+ *           public keys that evidence the ownership of the output.
+ * @property {Object} [unlockingScriptTemplate] - Optional. A template for generating the
+ *           unlocking script. Useful when the unlocking script needs to be generated
+ *           dynamically.
+ *    @property {Function} unlockingScriptTemplate.sign - A function that, when given the
+ *              current transaction and the index of this input, returns a Promise that
+ *              resolves to the UnlockingScript.
+ *    @property {Function} unlockingScriptTemplate.estimateLength - A function that estimates
+ *              the length of the unlocking script, given the transaction and the input index.
+ * @property {number} sequence - A sequence number for the input. Used to enable
+ *           updates to this input. If set to a non-final value (less than 0xFFFFFFFF),
+ *           it indicates that the input may be replaced in the future.
+ *
+ * @example
+ * // Creating a simple transaction input
+ * let txInput = {
+ *   sourceTXID: '123abc...',
+ *   sourceOutputIndex: 0,
+ *   sequence: 0xFFFFFFFF
+ * };
+ *
+ * // Using an unlocking script template
+ * txInput.unlockingScriptTemplate = {
+ *   sign: async (tx, index) => { ... },
+ *   estimateLength: async (tx, index) => { ... }
+ * };
+ *
+ * @description
+ * This interface links an input to a
+ * previous output and provides mechanisms (through unlocking scripts) to authorize the
+ * spending of that output.
+ */
+export default interface TransactionInput {
+    sourceTransaction?: Transaction;
+    sourceTXID?: string;
+    sourceOutputIndex: number;
+    unlockingScript?: UnlockingScript;
+    unlockingScriptTemplate?: {
+        sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>;
+        estimateLength: (tx: Transaction, inputIndex: number) => Promise<number>;
+    };
+    sequence: number;
+}
+//# sourceMappingURL=TransactionInput.d.ts.map

package/dist/types/src/transaction/TransactionInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionInput.d.ts","sourceRoot":"","sources":["../../../../src/transaction/TransactionInput.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,MAAM,8BAA8B,CAAA;AAC1D,OAAO,WAAW,MAAM,kBAAkB,CAAA;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,MAAM,CAAC,OAAO,WAAW,gBAAgB;IACvC,iBAAiB,CAAC,EAAE,WAAW,CAAA;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,iBAAiB,EAAE,MAAM,CAAA;IACzB,eAAe,CAAC,EAAE,eAAe,CAAA;IACjC,uBAAuB,CAAC,EAAE;QACxB,IAAI,EAAE,CAAC,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,CAAC,CAAA;QACvE,cAAc,EAAE,CAAC,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;KACzE,CAAA;IACD,QAAQ,EAAE,MAAM,CAAA;CACjB"}