@btc-vision/transaction 1.8.0-beta.1 → 1.8.0-beta.4

package/build/transaction/offline/OfflineTransactionManager.d.ts

@@ -1,27 +1,80 @@
-import { Signer } from '@btc-vision/bitcoin';
-import { ECPairInterface } from 'ecpair';
+import { type Signer } from '@btc-vision/bitcoin';
+import { type UniversalSigner } from '@btc-vision/ecpair';
 import { TransactionType } from '../enums/TransactionType.js';
 import { TransactionBuilder } from '../builders/TransactionBuilder.js';
-import { ISerializableTransactionState, PrecomputedData } from './interfaces/ISerializableState.js';
-import { ReconstructionOptions } from './TransactionReconstructor.js';
-import { IDeploymentParameters, IFundingTransactionParameters, IInteractionParameters, ITransactionParameters } from '../interfaces/ITransactionParameters.js';
+import type { ISerializableTransactionState, PrecomputedData } from './interfaces/ISerializableState.js';
+import { type ReconstructionOptions } from './TransactionReconstructor.js';
+import type { IDeploymentParameters, IFundingTransactionParameters, IInteractionParameters, ITransactionParameters } from '../interfaces/ITransactionParameters.js';
+/**
+ * Export options for offline transaction signing
+ */
 export interface ExportOptions {
+    /** The original transaction parameters */
     params: ITransactionParameters;
+    /** Transaction type */
     type: TransactionType;
+    /** Precomputed data from the builder */
     precomputed?: Partial<PrecomputedData>;
 }
+/**
+ * Main entry point for offline transaction signing workflow.
+ *
+ * This class provides a complete API for:
+ * 1. Phase 1 (Online): Building transactions and exporting state for offline signing
+ * 2. Phase 2 (Offline): Importing state, providing signers, and signing transactions
+ *
+ * Also supports fee bumping by allowing reconstruction with new fee parameters.
+ *
+ * @example
+ * ```typescript
+ * // Phase 1 (Online environment)
+ * const params: IFundingTransactionParameters = { ... };
+ * const state = OfflineTransactionManager.exportFunding(params);
+ * // Send state to offline environment
+ *
+ * // Phase 2 (Offline environment)
+ * const signedTxHex = await OfflineTransactionManager.importSignAndExport(state, {
+ *     signer: offlineSigner,
+ * });
+ * // Send signedTxHex back to online environment for broadcast
+ * ```
+ */
 export declare class OfflineTransactionManager {
+    /**
+     * Export a FundingTransaction for offline signing
+     * @param params - Funding transaction parameters
+     * @param precomputed - Optional precomputed data
+     * @returns Base64-encoded serialized state
+     */
     static exportFunding(params: IFundingTransactionParameters, precomputed?: Partial<PrecomputedData>): string;
+    /**
+     * Export a DeploymentTransaction for offline signing
+     * @param params - Deployment transaction parameters
+     * @param precomputed - Required precomputed data (randomBytes, compiledTargetScript)
+     * @returns Base64-encoded serialized state
+     */
     static exportDeployment(params: IDeploymentParameters, precomputed: Partial<PrecomputedData> & {
         compiledTargetScript: string;
         randomBytes: string;
     }): string;
+    /**
+     * Export an InteractionTransaction for offline signing
+     * @param params - Interaction transaction parameters
+     * @param precomputed - Required precomputed data (randomBytes, compiledTargetScript)
+     * @returns Base64-encoded serialized state
+     */
     static exportInteraction(params: IInteractionParameters, precomputed: Partial<PrecomputedData> & {
         compiledTargetScript: string;
         randomBytes: string;
     }): string;
+    /**
+     * Export a MultiSignTransaction for offline signing
+     * @param params - MultiSig transaction parameters
+     * @param precomputed - Optional precomputed data
+     * @returns Base64-encoded serialized state
+     */
     static exportMultiSig(params: ITransactionParameters & {
-        pubkeys: Buffer[];
+        pubkeys: Uint8Array[];
         minimumSignatures: number;
         receiver: string;
         requestedAmount: bigint;
@@ -29,41 +82,169 @@ export declare class OfflineTransactionManager {
         originalInputCount?: number;
         existingPsbtBase64?: string;
     }, precomputed?: Partial<PrecomputedData>): string;
+    /**
+     * Export a CustomScriptTransaction for offline signing
+     * @param params - Custom script transaction parameters
+     * @param precomputed - Optional precomputed data
+     * @returns Base64-encoded serialized state
+     */
     static exportCustomScript(params: ITransactionParameters & {
-        scriptElements: (Buffer | number)[];
-        witnesses: Buffer[];
-        annex?: Buffer;
+        scriptElements: (Uint8Array | number)[];
+        witnesses: Uint8Array[];
+        annex?: Uint8Array;
     }, precomputed?: Partial<PrecomputedData>): string;
+    /**
+     * Export a CancelTransaction for offline signing
+     * @param params - Cancel transaction parameters
+     * @param precomputed - Optional precomputed data
+     * @returns Base64-encoded serialized state
+     */
     static exportCancel(params: ITransactionParameters & {
-        compiledTargetScript: Buffer | string;
+        compiledTargetScript: Uint8Array | string;
     }, precomputed?: Partial<PrecomputedData>): string;
+    /**
+     * Export transaction state from a builder instance.
+     * The builder must have been built but not yet signed.
+     * @param builder - Transaction builder instance
+     * @param params - Original construction parameters
+     * @param precomputed - Precomputed data from the builder
+     * @returns Base64-encoded serialized state
+     */
     static exportFromBuilder<T extends TransactionType>(builder: TransactionBuilder<T>, params: ITransactionParameters, precomputed?: Partial<PrecomputedData>): string;
+    /**
+     * Import and reconstruct transaction for signing
+     * @param serializedState - Base64-encoded state from Phase 1
+     * @param options - Signer(s) and optional fee overrides
+     * @returns Reconstructed transaction builder ready for signing
+     */
     static importForSigning(serializedState: string, options: ReconstructionOptions): TransactionBuilder<TransactionType>;
+    /**
+     * Complete signing and export signed transaction
+     * @param builder - Reconstructed builder from importForSigning
+     * @returns Signed transaction hex ready for broadcast
+     */
     static signAndExport(builder: TransactionBuilder<TransactionType>): Promise<string>;
+    /**
+     * Convenience: Full Phase 2 in one call - import, sign, and export
+     * @param serializedState - Base64-encoded state
+     * @param options - Signer(s) and optional fee overrides
+     * @returns Signed transaction hex ready for broadcast
+     */
     static importSignAndExport(serializedState: string, options: ReconstructionOptions): Promise<string>;
+    /**
+     * Rebuild transaction with new fee rate (fee bumping)
+     * @param serializedState - Original state
+     * @param newFeeRate - New fee rate in sat/vB
+     * @returns New serialized state with updated fees (not signed yet)
+     */
     static rebuildWithNewFees(serializedState: string, newFeeRate: number): string;
+    /**
+     * Rebuild and immediately sign with new fee rate
+     * @param serializedState - Original state
+     * @param newFeeRate - New fee rate in sat/vB
+     * @param options - Signer options
+     * @returns Signed transaction hex with new fees
+     */
     static rebuildSignAndExport(serializedState: string, newFeeRate: number, options: ReconstructionOptions): Promise<string>;
+    /**
+     * Inspect serialized state without signing
+     * @param serializedState - Base64-encoded state
+     * @returns Parsed state object for inspection
+     */
     static inspect(serializedState: string): ISerializableTransactionState;
+    /**
+     * Validate serialized state integrity
+     * @param serializedState - Base64-encoded state
+     * @returns True if checksum and format are valid
+     */
     static validate(serializedState: string): boolean;
+    /**
+     * Get transaction type from serialized state
+     * @param serializedState - Base64-encoded state
+     * @returns Transaction type enum value
+     */
     static getType(serializedState: string): TransactionType;
+    /**
+     * Parse base64-encoded state into state object
+     * @param base64State - Base64-encoded state
+     * @returns Parsed state object
+     */
     static fromBase64(base64State: string): ISerializableTransactionState;
+    /**
+     * Serialize state object to base64
+     * @param state - State object to serialize
+     * @returns Base64-encoded state
+     */
     static toBase64(state: ISerializableTransactionState): string;
+    /**
+     * Convert serialized state to hex format
+     * @param serializedState - Base64-encoded state
+     * @returns Hex-encoded state
+     */
     static toHex(serializedState: string): string;
+    /**
+     * Convert hex format back to base64
+     * @param hexState - Hex-encoded state
+     * @returns Base64-encoded state
+     */
     static fromHex(hexState: string): string;
-    static multiSigAddSignature(serializedState: string, signer: Signer | ECPairInterface): Promise<{
+    /**
+     * Add a partial signature to a multisig transaction state.
+     * This method signs the transaction with the provided signer and returns
+     * updated state with the new signature included.
+     *
+     * @param serializedState - Base64-encoded multisig state
+     * @param signer - The signer to add a signature with
+     * @returns Updated state with new signature, and signing result
+     */
+    static multiSigAddSignature(serializedState: string, signer: Signer | UniversalSigner): Promise<{
         state: string;
         signed: boolean;
         final: boolean;
         psbtBase64: string;
     }>;
-    static multiSigHasSigned(serializedState: string, signerPubKey: Buffer | string): boolean;
+    /**
+     * Check if a public key has already signed a multisig transaction
+     *
+     * @param serializedState - Base64-encoded multisig state
+     * @param signerPubKey - Public key to check (Buffer or hex string)
+     * @returns True if the public key has already signed
+     */
+    static multiSigHasSigned(serializedState: string, signerPubKey: Uint8Array | string): boolean;
+    /**
+     * Get the current signature count for a multisig transaction
+     *
+     * @param serializedState - Base64-encoded multisig state
+     * @returns Object with signature count info
+     */
     static multiSigGetSignatureStatus(serializedState: string): {
         required: number;
         collected: number;
         isComplete: boolean;
         signers: string[];
     };
+    /**
+     * Finalize a multisig transaction and extract the signed transaction hex.
+     * Only call this when all required signatures have been collected.
+     *
+     * @param serializedState - Base64-encoded multisig state with all signatures
+     * @returns Signed transaction hex ready for broadcast
+     */
     static multiSigFinalize(serializedState: string): string;
+    /**
+     * Get the PSBT from a multisig state (for external signing tools)
+     *
+     * @param serializedState - Base64-encoded multisig state
+     * @returns PSBT in base64 format, or null if not yet built
+     */
     static multiSigGetPsbt(serializedState: string): string | null;
+    /**
+     * Update the PSBT in a multisig state (after external signing)
+     *
+     * @param serializedState - Base64-encoded multisig state
+     * @param psbtBase64 - New PSBT with additional signatures
+     * @returns Updated state
+     */
     static multiSigUpdatePsbt(serializedState: string, psbtBase64: string): string;
 }
+//# sourceMappingURL=OfflineTransactionManager.d.ts.map

package/build/transaction/offline/OfflineTransactionManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OfflineTransactionManager.d.ts","sourceRoot":"","sources":["../../../src/transaction/offline/OfflineTransactionManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiC,KAAK,MAAM,EAAS,MAAM,qBAAqB,CAAC;AACxF,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAEvE,OAAO,KAAK,EAAE,6BAA6B,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAEzG,OAAO,EAAE,KAAK,qBAAqB,EAA4B,MAAM,+BAA+B,CAAC;AAGrG,OAAO,KAAK,EACR,qBAAqB,EACrB,6BAA6B,EAC7B,sBAAsB,EACtB,sBAAsB,EACzB,MAAM,yCAAyC,CAAC;AAEjD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B,0CAA0C;IAC1C,MAAM,EAAE,sBAAsB,CAAC;IAC/B,uBAAuB;IACvB,IAAI,EAAE,eAAe,CAAC;IACtB,wCAAwC;IACxC,WAAW,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,yBAAyB;IAClC;;;;;OAKG;WACW,aAAa,CACvB,MAAM,EAAE,6BAA6B,EACrC,WAAW,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GACvC,MAAM;IAKT;;;;;OAKG;WACW,gBAAgB,CAC1B,MAAM,EAAE,qBAAqB,EAC7B,WAAW,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG;QACpC,oBAAoB,EAAE,MAAM,CAAC;QAC7B,WAAW,EAAE,MAAM,CAAC;KACvB,GACF,MAAM;IAKT;;;;;OAKG;WACW,iBAAiB,CAC3B,MAAM,EAAE,sBAAsB,EAC9B,WAAW,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG;QACpC,oBAAoB,EAAE,MAAM,CAAC;QAC7B,WAAW,EAAE,MAAM,CAAC;KACvB,GACF,MAAM;IAKT;;;;;OAKG;WACW,cAAc,CACxB,MAAM,EAAE,sBAAsB,GAAG;QAC7B,OAAO,EAAE,UAAU,EAAE,CAAC;QACtB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,QAAQ,EAAE,MAAM,CAAC;QACjB,eAAe,EAAE,MAAM,CAAC;QACxB,WAAW,EAAE,MAAM,CAAC;QACpB,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,kBAAkB,CAAC,EAAE,MAAM,CAAC;KAC/B,EACD,WAAW,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GACvC,MAAM;IAKT;;;;;OAKG;WACW,kBAAkB,CAC5B,MAAM,EAAE,sBAAsB,GAAG;QAC7B,cAAc,EAAE,CAAC,UAAU,GAAG,MAAM,CAAC,EAAE,CAAC;QACxC,SAAS,EAAE,UAAU,EAAE,CAAC;QACxB,KAAK,CAAC,EAAE,UAAU,CAAC;KACtB,EACD,WAAW,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GACvC,MAAM;IAKT;;;;;OAKG;WACW,YAAY,CACtB,MAAM,EAAE,sBAAsB,GAAG;QAC7B,oBAAoB,EAAE,UAAU,GAAG,MAAM,CAAC;KAC7C,EACD,WAAW,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GACvC,MAAM;IAKT;;;;;;;OAOG;WACW,iBAAiB,CAAC,CAAC,SAAS,eAAe,EACrD,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC9B,MAAM,EAAE,sBAAsB,EAC9B,WAAW,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GACvC,MAAM;IAoCT;;;;;OAKG;WACW,gBAAgB,CAC1B,eAAe,EAAE,MAAM,EACvB,OAAO,EAAE,qBAAqB,GAC/B,kBAAkB,CAAC,eAAe,CAAC;IAKtC;;;;OAIG;WACiB,aAAa,CAC7B,OAAO,EAAE,kBAAkB,CAAC,eAAe,CAAC,GAC7C,OAAO,CAAC,MAAM,CAAC;IAKlB;;;;;OAKG;WACiB,mBAAmB,CACnC,eAAe,EAAE,MAAM,EACvB,OAAO,EAAE,qBAAqB,GAC/B,OAAO,CAAC,MAAM,CAAC;IAKlB;;;;;OAKG;WACW,kBAAkB,CAAC,eAAe,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;IAgBrF;;;;;;OAMG;WACiB,oBAAoB,CACpC,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,qBAAqB,GAC/B,OAAO,CAAC,MAAM,CAAC;IAQlB;;;;OAIG;WACW,OAAO,CAAC,eAAe,EAAE,MAAM,GAAG,6BAA6B;IAI7E;;;;OAIG;WACW,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO;IASxD;;;;OAIG;WACW,OAAO,CAAC,eAAe,EAAE,MAAM,GAAG,eAAe;IAK/D;;;;OAIG;WACW,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,6BAA6B;IAI5E;;;;OAIG;WACW,QAAQ,CAAC,KAAK,EAAE,6BAA6B,GAAG,MAAM;IAIpE;;;;OAIG;WACW,KAAK,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM;IAKpD;;;;OAIG;WACW,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAK/C;;;;;;;;OAQG;WACiB,oBAAoB,CACpC,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,MAAM,GAAG,eAAe,GACjC,OAAO,CAAC;QACP,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,OAAO,CAAC;QAChB,KAAK,EAAE,OAAO,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;KACtB,CAAC;IAsEF;;;;;;OAMG;WACW,iBAAiB,CAC3B,eAAe,EAAE,MAAM,EACvB,YAAY,EAAE,UAAU,GAAG,MAAM,GAClC,OAAO;IAsBV;;;;;OAKG;WACW,0BAA0B,CAAC,eAAe,EAAE,MAAM,GAAG;QAC/D,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,OAAO,CAAC;QACpB,OAAO,EAAE,MAAM,EAAE,CAAC;KACrB;IAwDD;;;;;;OAMG;WACW,gBAAgB,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM;IAsC/D;;;;;OAKG;WACW,eAAe,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAUrE;;;;;;OAMG;WACW,kBAAkB,CAAC,eAAe,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;CAiBxF"}

package/build/transaction/offline/OfflineTransactionManager.js

@@ -1,4 +1,5 @@
-import { Psbt } from '@btc-vision/bitcoin';
+import { fromHex, Psbt, toHex } from '@btc-vision/bitcoin';
+import {} from '@btc-vision/ecpair';
 import { TransactionType } from '../enums/TransactionType.js';
 import { TransactionBuilder } from '../builders/TransactionBuilder.js';
 import { MultiSignTransaction } from '../builders/MultiSignTransaction.js';
@@ -6,31 +7,98 @@ import { TransactionSerializer } from './TransactionSerializer.js';
 import { TransactionReconstructor } from './TransactionReconstructor.js';
 import { TransactionStateCapture } from './TransactionStateCapture.js';
 import { isMultiSigSpecificData } from './interfaces/ITypeSpecificData.js';
+/**
+ * Main entry point for offline transaction signing workflow.
+ *
+ * This class provides a complete API for:
+ * 1. Phase 1 (Online): Building transactions and exporting state for offline signing
+ * 2. Phase 2 (Offline): Importing state, providing signers, and signing transactions
+ *
+ * Also supports fee bumping by allowing reconstruction with new fee parameters.
+ *
+ * @example
+ * ```typescript
+ * // Phase 1 (Online environment)
+ * const params: IFundingTransactionParameters = { ... };
+ * const state = OfflineTransactionManager.exportFunding(params);
+ * // Send state to offline environment
+ *
+ * // Phase 2 (Offline environment)
+ * const signedTxHex = await OfflineTransactionManager.importSignAndExport(state, {
+ *     signer: offlineSigner,
+ * });
+ * // Send signedTxHex back to online environment for broadcast
+ * ```
+ */
 export class OfflineTransactionManager {
+    /**
+     * Export a FundingTransaction for offline signing
+     * @param params - Funding transaction parameters
+     * @param precomputed - Optional precomputed data
+     * @returns Base64-encoded serialized state
+     */
     static exportFunding(params, precomputed) {
         const state = TransactionStateCapture.fromFunding(params, precomputed);
         return TransactionSerializer.toBase64(state);
     }
+    /**
+     * Export a DeploymentTransaction for offline signing
+     * @param params - Deployment transaction parameters
+     * @param precomputed - Required precomputed data (randomBytes, compiledTargetScript)
+     * @returns Base64-encoded serialized state
+     */
     static exportDeployment(params, precomputed) {
         const state = TransactionStateCapture.fromDeployment(params, precomputed);
         return TransactionSerializer.toBase64(state);
     }
+    /**
+     * Export an InteractionTransaction for offline signing
+     * @param params - Interaction transaction parameters
+     * @param precomputed - Required precomputed data (randomBytes, compiledTargetScript)
+     * @returns Base64-encoded serialized state
+     */
     static exportInteraction(params, precomputed) {
         const state = TransactionStateCapture.fromInteraction(params, precomputed);
         return TransactionSerializer.toBase64(state);
     }
+    /**
+     * Export a MultiSignTransaction for offline signing
+     * @param params - MultiSig transaction parameters
+     * @param precomputed - Optional precomputed data
+     * @returns Base64-encoded serialized state
+     */
     static exportMultiSig(params, precomputed) {
         const state = TransactionStateCapture.fromMultiSig(params, precomputed);
         return TransactionSerializer.toBase64(state);
     }
+    /**
+     * Export a CustomScriptTransaction for offline signing
+     * @param params - Custom script transaction parameters
+     * @param precomputed - Optional precomputed data
+     * @returns Base64-encoded serialized state
+     */
     static exportCustomScript(params, precomputed) {
         const state = TransactionStateCapture.fromCustomScript(params, precomputed);
         return TransactionSerializer.toBase64(state);
     }
+    /**
+     * Export a CancelTransaction for offline signing
+     * @param params - Cancel transaction parameters
+     * @param precomputed - Optional precomputed data
+     * @returns Base64-encoded serialized state
+     */
     static exportCancel(params, precomputed) {
         const state = TransactionStateCapture.fromCancel(params, precomputed);
         return TransactionSerializer.toBase64(state);
     }
+    /**
+     * Export transaction state from a builder instance.
+     * The builder must have been built but not yet signed.
+     * @param builder - Transaction builder instance
+     * @param params - Original construction parameters
+     * @param precomputed - Precomputed data from the builder
+     * @returns Base64-encoded serialized state
+     */
     static exportFromBuilder(builder, params, precomputed) {
         const type = builder.type;
         let state;
@@ -49,20 +117,45 @@ export class OfflineTransactionManager {
         }
         return TransactionSerializer.toBase64(state);
     }
+    /**
+     * Import and reconstruct transaction for signing
+     * @param serializedState - Base64-encoded state from Phase 1
+     * @param options - Signer(s) and optional fee overrides
+     * @returns Reconstructed transaction builder ready for signing
+     */
     static importForSigning(serializedState, options) {
         const state = TransactionSerializer.fromBase64(serializedState);
         return TransactionReconstructor.reconstruct(state, options);
     }
+    /**
+     * Complete signing and export signed transaction
+     * @param builder - Reconstructed builder from importForSigning
+     * @returns Signed transaction hex ready for broadcast
+     */
     static async signAndExport(builder) {
         const tx = await builder.signTransaction();
         return tx.toHex();
     }
+    /**
+     * Convenience: Full Phase 2 in one call - import, sign, and export
+     * @param serializedState - Base64-encoded state
+     * @param options - Signer(s) and optional fee overrides
+     * @returns Signed transaction hex ready for broadcast
+     */
     static async importSignAndExport(serializedState, options) {
         const builder = this.importForSigning(serializedState, options);
         return this.signAndExport(builder);
     }
+    /**
+     * Rebuild transaction with new fee rate (fee bumping)
+     * @param serializedState - Original state
+     * @param newFeeRate - New fee rate in sat/vB
+     * @returns New serialized state with updated fees (not signed yet)
+     */
     static rebuildWithNewFees(serializedState, newFeeRate) {
+        // Parse the existing state
         const state = TransactionSerializer.fromBase64(serializedState);
+        // Create a new state with updated fee rate
         const newState = {
             ...state,
             baseParams: {
@@ -72,6 +165,13 @@ export class OfflineTransactionManager {
         };
         return TransactionSerializer.toBase64(newState);
     }
+    /**
+     * Rebuild and immediately sign with new fee rate
+     * @param serializedState - Original state
+     * @param newFeeRate - New fee rate in sat/vB
+     * @param options - Signer options
+     * @returns Signed transaction hex with new fees
+     */
     static async rebuildSignAndExport(serializedState, newFeeRate, options) {
         const builder = this.importForSigning(serializedState, {
             ...options,
@@ -79,9 +179,19 @@ export class OfflineTransactionManager {
         });
         return this.signAndExport(builder);
     }
+    /**
+     * Inspect serialized state without signing
+     * @param serializedState - Base64-encoded state
+     * @returns Parsed state object for inspection
+     */
     static inspect(serializedState) {
         return TransactionSerializer.fromBase64(serializedState);
     }
+    /**
+     * Validate serialized state integrity
+     * @param serializedState - Base64-encoded state
+     * @returns True if checksum and format are valid
+     */
     static validate(serializedState) {
         try {
             TransactionSerializer.fromBase64(serializedState);
@@ -91,53 +201,93 @@ export class OfflineTransactionManager {
             return false;
         }
     }
+    /**
+     * Get transaction type from serialized state
+     * @param serializedState - Base64-encoded state
+     * @returns Transaction type enum value
+     */
     static getType(serializedState) {
         const state = TransactionSerializer.fromBase64(serializedState);
         return state.header.transactionType;
     }
+    /**
+     * Parse base64-encoded state into state object
+     * @param base64State - Base64-encoded state
+     * @returns Parsed state object
+     */
     static fromBase64(base64State) {
         return TransactionSerializer.fromBase64(base64State);
     }
+    /**
+     * Serialize state object to base64
+     * @param state - State object to serialize
+     * @returns Base64-encoded state
+     */
     static toBase64(state) {
         return TransactionSerializer.toBase64(state);
     }
+    /**
+     * Convert serialized state to hex format
+     * @param serializedState - Base64-encoded state
+     * @returns Hex-encoded state
+     */
     static toHex(serializedState) {
         const state = TransactionSerializer.fromBase64(serializedState);
         return TransactionSerializer.toHex(state);
     }
+    /**
+     * Convert hex format back to base64
+     * @param hexState - Hex-encoded state
+     * @returns Base64-encoded state
+     */
     static fromHex(hexState) {
         const state = TransactionSerializer.fromHex(hexState);
         return TransactionSerializer.toBase64(state);
     }
+    /**
+     * Add a partial signature to a multisig transaction state.
+     * This method signs the transaction with the provided signer and returns
+     * updated state with the new signature included.
+     *
+     * @param serializedState - Base64-encoded multisig state
+     * @param signer - The signer to add a signature with
+     * @returns Updated state with new signature, and signing result
+     */
     static async multiSigAddSignature(serializedState, signer) {
         const state = TransactionSerializer.fromBase64(serializedState);
         if (!isMultiSigSpecificData(state.typeSpecificData)) {
             throw new Error('State is not a multisig transaction');
         }
         const typeData = state.typeSpecificData;
-        const pubkeys = typeData.pubkeys.map((pk) => Buffer.from(pk, 'hex'));
+        const pubkeys = typeData.pubkeys.map((pk) => fromHex(pk));
+        // Parse existing PSBT or create new one
         let psbt;
         const network = TransactionReconstructor['nameToNetwork'](state.baseParams.networkName);
         if (typeData.existingPsbtBase64) {
             psbt = Psbt.fromBase64(typeData.existingPsbtBase64, { network });
         }
         else {
+            // Need to build the transaction first
             const builder = this.importForSigning(serializedState, {
                 signer,
             });
             psbt = await builder.signPSBT();
         }
+        // Calculate minimums array for each input
         const minimums = [];
         for (let i = typeData.originalInputCount; i < psbt.data.inputs.length; i++) {
             minimums.push(typeData.minimumSignatures);
         }
+        // Sign the PSBT
         const result = MultiSignTransaction.signPartial(psbt, signer, typeData.originalInputCount, minimums);
+        // Finalize inputs (partial finalization to preserve signatures)
         const orderedPubKeys = [];
         for (let i = typeData.originalInputCount; i < psbt.data.inputs.length; i++) {
             orderedPubKeys.push(pubkeys);
         }
         MultiSignTransaction.attemptFinalizeInputs(psbt, typeData.originalInputCount, orderedPubKeys, result.final);
         const newPsbtBase64 = psbt.toBase64();
+        // Update the state with new PSBT
         const newState = {
             ...state,
             typeSpecificData: {
@@ -152,6 +302,13 @@ export class OfflineTransactionManager {
             psbtBase64: newPsbtBase64,
         };
     }
+    /**
+     * Check if a public key has already signed a multisig transaction
+     *
+     * @param serializedState - Base64-encoded multisig state
+     * @param signerPubKey - Public key to check (Buffer or hex string)
+     * @returns True if the public key has already signed
+     */
     static multiSigHasSigned(serializedState, signerPubKey) {
         const state = TransactionSerializer.fromBase64(serializedState);
         if (!isMultiSigSpecificData(state.typeSpecificData)) {
@@ -163,11 +320,15 @@ export class OfflineTransactionManager {
         }
         const network = TransactionReconstructor['nameToNetwork'](state.baseParams.networkName);
         const psbt = Psbt.fromBase64(typeData.existingPsbtBase64, { network });
-        const pubKeyBuffer = Buffer.isBuffer(signerPubKey)
-            ? signerPubKey
-            : Buffer.from(signerPubKey, 'hex');
+        const pubKeyBuffer = signerPubKey instanceof Uint8Array ? signerPubKey : fromHex(signerPubKey);
         return MultiSignTransaction.verifyIfSigned(psbt, pubKeyBuffer);
     }
+    /**
+     * Get the current signature count for a multisig transaction
+     *
+     * @param serializedState - Base64-encoded multisig state
+     * @returns Object with signature count info
+     */
     static multiSigGetSignatureStatus(serializedState) {
         const state = TransactionSerializer.fromBase64(serializedState);
         if (!isMultiSigSpecificData(state.typeSpecificData)) {
@@ -185,19 +346,20 @@ export class OfflineTransactionManager {
         }
         const network = TransactionReconstructor['nameToNetwork'](state.baseParams.networkName);
         const psbt = Psbt.fromBase64(typeData.existingPsbtBase64, { network });
+        // Collect signers from all inputs
         const signerSet = new Set();
         for (let i = typeData.originalInputCount; i < psbt.data.inputs.length; i++) {
             const input = psbt.data.inputs[i];
             if (input.tapScriptSig) {
                 for (const sig of input.tapScriptSig) {
-                    signerSet.add(sig.pubkey.toString('hex'));
+                    signerSet.add(toHex(sig.pubkey));
                 }
             }
             if (input.finalScriptWitness) {
                 const decoded = TransactionBuilder.readScriptWitnessToWitnessStack(input.finalScriptWitness);
                 for (let j = 0; j < decoded.length - 2; j += 3) {
                     const pubKey = decoded[j + 2];
-                    signerSet.add(pubKey.toString('hex'));
+                    signerSet.add(toHex(pubKey));
                 }
             }
         }
@@ -209,6 +371,13 @@ export class OfflineTransactionManager {
             signers,
         };
     }
+    /**
+     * Finalize a multisig transaction and extract the signed transaction hex.
+     * Only call this when all required signatures have been collected.
+     *
+     * @param serializedState - Base64-encoded multisig state with all signatures
+     * @returns Signed transaction hex ready for broadcast
+     */
     static multiSigFinalize(serializedState) {
         const state = TransactionSerializer.fromBase64(serializedState);
         if (!isMultiSigSpecificData(state.typeSpecificData)) {
@@ -220,17 +389,24 @@ export class OfflineTransactionManager {
         }
         const network = TransactionReconstructor['nameToNetwork'](state.baseParams.networkName);
         const psbt = Psbt.fromBase64(typeData.existingPsbtBase64, { network });
-        const pubkeys = typeData.pubkeys.map((pk) => Buffer.from(pk, 'hex'));
+        const pubkeys = typeData.pubkeys.map((pk) => fromHex(pk));
         const orderedPubKeys = [];
         for (let i = typeData.originalInputCount; i < psbt.data.inputs.length; i++) {
             orderedPubKeys.push(pubkeys);
         }
+        // Final finalization
         const success = MultiSignTransaction.attemptFinalizeInputs(psbt, typeData.originalInputCount, orderedPubKeys, true);
         if (!success) {
             throw new Error('Failed to finalize multisig transaction - not enough signatures');
         }
         return psbt.extractTransaction(true, true).toHex();
     }
+    /**
+     * Get the PSBT from a multisig state (for external signing tools)
+     *
+     * @param serializedState - Base64-encoded multisig state
+     * @returns PSBT in base64 format, or null if not yet built
+     */
     static multiSigGetPsbt(serializedState) {
         const state = TransactionSerializer.fromBase64(serializedState);
         if (!isMultiSigSpecificData(state.typeSpecificData)) {
@@ -238,6 +414,13 @@ export class OfflineTransactionManager {
         }
         return state.typeSpecificData.existingPsbtBase64 || null;
     }
+    /**
+     * Update the PSBT in a multisig state (after external signing)
+     *
+     * @param serializedState - Base64-encoded multisig state
+     * @param psbtBase64 - New PSBT with additional signatures
+     * @returns Updated state
+     */
     static multiSigUpdatePsbt(serializedState, psbtBase64) {
         const state = TransactionSerializer.fromBase64(serializedState);
         if (!isMultiSigSpecificData(state.typeSpecificData)) {
@@ -253,3 +436,4 @@ export class OfflineTransactionManager {
         return TransactionSerializer.toBase64(newState);
     }
 }
+//# sourceMappingURL=OfflineTransactionManager.js.map