@btc-vision/transaction 1.8.6 → 1.8.7

package/build/transaction/offline/OfflineTransactionManager.js

@@ -1,4 +1,4 @@
-import { fromHex, Psbt, toHex } from '@btc-vision/bitcoin';
+import { fromHex, Psbt, toHex, toXOnly } from '@btc-vision/bitcoin';
 import {} from '@btc-vision/ecpair';
 import { TransactionType } from '../enums/TransactionType.js';
 import { TransactionBuilder } from '../builders/TransactionBuilder.js';
@@ -7,6 +7,7 @@ import { TransactionSerializer } from './TransactionSerializer.js';
 import { TransactionReconstructor, } from './TransactionReconstructor.js';
 import { TransactionStateCapture } from './TransactionStateCapture.js';
 import { isMultiSigSpecificData } from './interfaces/ITypeSpecificData.js';
+import { CSVMultisigProvider } from '../mineable/CSVMultisigProvider.js';
 /**
  * Main entry point for offline transaction signing workflow.
  *
@@ -435,5 +436,144 @@ export class OfflineTransactionManager {
         };
         return TransactionSerializer.toBase64(newState);
     }
+    /**
+     * Inspect collaborative signing progress on all CSV multisig inputs.
+     * Returns an empty array when no partial PSBT has been produced yet.
+     */
+    static csvMultisigGetStatus(serializedState) {
+        const state = TransactionSerializer.fromBase64(serializedState);
+        if (!state.partialPsbtBase64)
+            return [];
+        const network = TransactionReconstructor['nameToNetwork'](state.baseParams.networkName);
+        const psbt = Psbt.fromBase64(state.partialPsbtBase64, { network });
+        return this.computeCSVMultisigStatus(state, psbt, network);
+    }
+    /**
+     * Add the given signer's contribution to every CSV multisig input it can sign.
+     * No-op for inputs whose tapscript does not contain the signer's x-only pubkey.
+     *
+     * First call (no partial PSBT yet) builds the PSBT from the funding params
+     * using the provided signer as the builder's signer. Subsequent calls load
+     * the carried PSBT and add the signer's tapScriptSig where applicable.
+     */
+    static async addCSVMultisigSignature(serializedState, signer) {
+        const state = TransactionSerializer.fromBase64(serializedState);
+        const network = TransactionReconstructor['nameToNetwork'](state.baseParams.networkName);
+        let psbt;
+        if (state.partialPsbtBase64) {
+            psbt = Psbt.fromBase64(state.partialPsbtBase64, { network });
+            this.addSignerToCSVInputs(psbt, signer, network);
+        }
+        else {
+            const builder = this.importForSigning(serializedState, { signer });
+            psbt = await builder.signPSBT();
+            // Best-effort: ensure the signer's contribution is recorded on every
+            // CSV input where they're a cosigner (the builder already attempts
+            // this, but this guards against builds that bailed early).
+            this.addSignerToCSVInputs(psbt, signer, network);
+        }
+        const perInput = this.computeCSVMultisigStatus(state, psbt, network);
+        const final = perInput.length > 0 && perInput.every((s) => s.collected >= s.required);
+        const newState = {
+            ...state,
+            partialPsbtBase64: psbt.toBase64(),
+        };
+        return {
+            state: TransactionSerializer.toBase64(newState),
+            final,
+            perInput,
+        };
+    }
+    /**
+     * Finalize every CSV multisig input on the partial PSBT and extract the
+     * raw transaction hex. Throws if any input is still below its threshold.
+     */
+    static csvMultisigFinalize(serializedState) {
+        const state = TransactionSerializer.fromBase64(serializedState);
+        if (!state.partialPsbtBase64) {
+            throw new Error('No partial PSBT in state — call addCSVMultisigSignature first');
+        }
+        const network = TransactionReconstructor['nameToNetwork'](state.baseParams.networkName);
+        const psbt = Psbt.fromBase64(state.partialPsbtBase64, { network });
+        for (let i = 0; i < psbt.data.inputs.length; i++) {
+            const input = psbt.data.inputs[i];
+            if (!input.tapLeafScript || input.tapLeafScript.length === 0)
+                continue;
+            const leaf = input.tapLeafScript[0];
+            if (!leaf)
+                continue;
+            const addr = CSVMultisigProvider.deriveAddressFromTapscript(leaf.script, network);
+            if (!addr)
+                continue;
+            CSVMultisigProvider.finalizePsbtInput(psbt, i, network, addr);
+        }
+        return psbt.extractTransaction(true, true).toHex();
+    }
+    /**
+     * Sign every CSV multisig input whose tapscript contains the signer's
+     * x-only pubkey and does not yet carry a signature from that pubkey.
+     */
+    static addSignerToCSVInputs(psbt, signer, network) {
+        const signerXOnly = toXOnly(signer.publicKey);
+        const signerXOnlyHex = toHex(signerXOnly);
+        for (let i = 0; i < psbt.data.inputs.length; i++) {
+            const input = psbt.data.inputs[i];
+            if (!input.tapLeafScript || input.tapLeafScript.length === 0)
+                continue;
+            const leaf = input.tapLeafScript[0];
+            if (!leaf)
+                continue;
+            const addr = CSVMultisigProvider.deriveAddressFromTapscript(leaf.script, network);
+            if (!addr)
+                continue;
+            const isCosigner = addr.config.pubkeys.some((pk) => toHex(pk) === signerXOnlyHex);
+            if (!isCosigner)
+                continue;
+            const alreadySigned = (input.tapScriptSig ?? []).some((s) => toHex(s.pubkey) === signerXOnlyHex);
+            if (alreadySigned)
+                continue;
+            psbt.signTaprootInput(i, signer);
+        }
+    }
+    /**
+     * Build per-input status for every CSV multisig input.
+     *
+     * Walks state.utxos so we can detect CSV multisig inputs even after the
+     * builder has already finalized them (which clears tapLeafScript). For
+     * partially-signed inputs the signers list reflects collected tapScriptSig
+     * entries; for finalized inputs collected is set to the threshold.
+     */
+    static computeCSVMultisigStatus(state, psbt, network) {
+        const result = [];
+        for (let i = 0; i < state.utxos.length; i++) {
+            const utxo = state.utxos[i];
+            if (!utxo?.witnessScript)
+                continue;
+            const tapscript = fromHex(utxo.witnessScript);
+            const addr = CSVMultisigProvider.deriveAddressFromTapscript(tapscript, network);
+            if (!addr)
+                continue;
+            const input = psbt.data.inputs[i];
+            if (!input)
+                continue;
+            if (input.finalScriptWitness) {
+                // Already finalized — by construction it carried >= threshold sigs.
+                result.push({
+                    inputIndex: i,
+                    required: addr.config.threshold,
+                    collected: addr.config.threshold,
+                    signers: [],
+                });
+                continue;
+            }
+            const tapSigs = input.tapScriptSig ?? [];
+            result.push({
+                inputIndex: i,
+                required: addr.config.threshold,
+                collected: tapSigs.length,
+                signers: tapSigs.map((s) => toHex(s.pubkey)),
+            });
+        }
+        return result;
+    }
 }
-//# sourceMappingURL=OfflineTransactionManager.js.map

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

@@ -75,4 +75,3 @@ export declare class TransactionReconstructor {
      */
     private static nameToNetwork;
 }
-//# sourceMappingURL=TransactionReconstructor.d.ts.map

package/build/transaction/offline/TransactionReconstructor.js

@@ -314,4 +314,3 @@ export class TransactionReconstructor {
         }
     }
 }
-//# sourceMappingURL=TransactionReconstructor.js.map

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

@@ -98,4 +98,3 @@ export declare class TransactionSerializer {
     private static networkNameToU8;
     private static u8ToNetworkName;
 }
-//# sourceMappingURL=TransactionSerializer.d.ts.map

package/build/transaction/offline/TransactionSerializer.js

@@ -35,6 +35,8 @@ export class TransactionSerializer {
         this.writeTypeSpecificData(writer, state.typeSpecificData);
         // Write precomputed data
         this.writePrecomputedData(writer, state.precomputedData);
+        // v2: partial PSBT (empty string when absent)
+        writer.writeStringWithLength(state.partialPsbtBase64 ?? '');
         // Get buffer and calculate checksum
         const dataBuffer = writer.getBuffer();
         const checksum = this.calculateChecksum(dataBuffer);
@@ -82,6 +84,12 @@ export class TransactionSerializer {
         const typeSpecificData = this.readTypeSpecificData(reader, header.transactionType);
         // Read precomputed data
         const precomputedData = this.readPrecomputedData(reader);
+        // v2+: partial PSBT (collaborative signing carryover)
+        let partialPsbtBase64;
+        if (header.formatVersion >= 2) {
+            const stored = reader.readStringWithLength();
+            partialPsbtBase64 = stored.length > 0 ? stored : undefined;
+        }
         return {
             header,
             baseParams,
@@ -92,6 +100,7 @@ export class TransactionSerializer {
             signerMappings,
             typeSpecificData,
             precomputedData,
+            ...(partialPsbtBase64 !== undefined ? { partialPsbtBase64 } : {}),
         };
     }
     /**
@@ -797,4 +806,3 @@ export class TransactionSerializer {
         }
     }
 }
-//# sourceMappingURL=TransactionSerializer.js.map

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

@@ -108,4 +108,3 @@ export declare class TransactionStateCapture {
      */
     private static networkToChainId;
 }
-//# sourceMappingURL=TransactionStateCapture.d.ts.map

package/build/transaction/offline/TransactionStateCapture.js

@@ -366,4 +366,3 @@ export class TransactionStateCapture {
         return ChainId.Bitcoin;
     }
 }
-//# sourceMappingURL=TransactionStateCapture.js.map

package/build/transaction/offline/interfaces/ISerializableState.d.ts

@@ -2,9 +2,10 @@ import { TransactionType } from '../../enums/TransactionType.js';
 import { ChainId } from '../../../network/ChainId.js';
 import type { TypeSpecificData } from './ITypeSpecificData.js';
 /**
- * Format version for serialization compatibility
+ * Format version for serialization compatibility.
+ * v2 adds the optional `partialPsbtBase64` field on the top-level state.
  */
-export declare const SERIALIZATION_FORMAT_VERSION = 1;
+export declare const SERIALIZATION_FORMAT_VERSION = 2;
 /**
  * Magic byte for identifying serialized transaction state
  */
@@ -129,5 +130,11 @@ export interface ISerializableTransactionState {
     readonly typeSpecificData: TypeSpecificData;
     /** Pre-computed data for deterministic rebuild */
     readonly precomputedData: PrecomputedData;
+    /**
+     * Partial PSBT (base64) carrying signatures collected so far.
+     * Used by collaborative flows like CSV multisig where multiple cosigners
+     * accumulate signatures across hops before finalization.
+     * Only present once at least one signing hop has run.
+     */
+    readonly partialPsbtBase64?: string;
 }
-//# sourceMappingURL=ISerializableState.d.ts.map

package/build/transaction/offline/interfaces/ISerializableState.js

@@ -1,11 +1,11 @@
 import { TransactionType } from '../../enums/TransactionType.js';
 import { ChainId } from '../../../network/ChainId.js';
 /**
- * Format version for serialization compatibility
+ * Format version for serialization compatibility.
+ * v2 adds the optional `partialPsbtBase64` field on the top-level state.
  */
-export const SERIALIZATION_FORMAT_VERSION = 1;
+export const SERIALIZATION_FORMAT_VERSION = 2;
 /**
  * Magic byte for identifying serialized transaction state
  */
 export const SERIALIZATION_MAGIC_BYTE = 0x42; // 'B' for Bitcoin
-//# sourceMappingURL=ISerializableState.js.map

package/build/transaction/offline/interfaces/ITypeSpecificData.d.ts

@@ -135,4 +135,3 @@ export declare function isCustomScriptSpecificData(data: TypeSpecificData): data
  * Type guard for CancelSpecificData
  */
 export declare function isCancelSpecificData(data: TypeSpecificData): data is CancelSpecificData;
-//# sourceMappingURL=ITypeSpecificData.d.ts.map

package/build/transaction/offline/interfaces/ITypeSpecificData.js

@@ -35,4 +35,3 @@ export function isCustomScriptSpecificData(data) {
 export function isCancelSpecificData(data) {
     return data.type === TransactionType.CANCEL;
 }
-//# sourceMappingURL=ITypeSpecificData.js.map

package/build/transaction/psbt/PSBTTypes.d.ts

@@ -1,4 +1,3 @@
 export declare enum PSBTTypes {
     UNWRAP = 0
 }
-//# sourceMappingURL=PSBTTypes.d.ts.map

package/build/transaction/psbt/PSBTTypes.js

@@ -2,4 +2,3 @@ export var PSBTTypes;
 (function (PSBTTypes) {
     PSBTTypes[PSBTTypes["UNWRAP"] = 0] = "UNWRAP";
 })(PSBTTypes || (PSBTTypes = {}));
-//# sourceMappingURL=PSBTTypes.js.map

package/build/transaction/shared/P2MR_MS.d.ts

@@ -10,4 +10,3 @@ export declare class P2MR_MS {
      */
     static generateMultiSigAddress(pubKeys: Uint8Array[], minimumSignatureRequired: number, network?: Network): string;
 }
-//# sourceMappingURL=P2MR_MS.d.ts.map

package/build/transaction/shared/P2MR_MS.js

@@ -34,4 +34,3 @@ export class P2MR_MS {
         return address;
     }
 }
-//# sourceMappingURL=P2MR_MS.js.map

package/build/transaction/shared/P2TR_MS.d.ts

@@ -10,4 +10,3 @@ export declare class P2TR_MS {
      */
     static generateMultiSigAddress(pubKeys: Uint8Array[], minimumSignatureRequired: number, network?: Network): string;
 }
-//# sourceMappingURL=P2TR_MS.d.ts.map

package/build/transaction/shared/P2TR_MS.js

@@ -33,4 +33,3 @@ export class P2TR_MS {
         return address;
     }
 }
-//# sourceMappingURL=P2TR_MS.js.map

package/build/transaction/shared/TweakedTransaction.d.ts

@@ -5,6 +5,7 @@ import { type UniversalSigner } from '@btc-vision/ecpair';
 import type { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import type { TapLeafScript } from '../interfaces/Tap.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
+import { type CSVMultisigAddress } from '../mineable/CSVMultisigProvider.js';
 import type { QuantumBIP32Interface } from '@btc-vision/bip32';
 import { type RotationSigner, type SignerMap } from '../../signer/AddressRotation.js';
 import type { ITweakedTransactionData, SupportedTransactionVersion } from '../interfaces/ITweakedTransactionData.js';
@@ -93,6 +94,12 @@ export declare abstract class TweakedTransaction extends Logger implements Dispo
      */
     protected csvInputIndices: Set<number>;
     protected anchorInputIndices: Set<number>;
+    /**
+     * Track P2TR CSV multisig inputs together with the address descriptor needed
+     * to finalize them (tapscript + derived control block + parsed config).
+     * @protected
+     */
+    protected csvMultisigInputs: Map<number, CSVMultisigAddress>;
     protected regenerated: boolean;
     protected ignoreSignatureErrors: boolean;
     protected noSignatures: boolean;
@@ -331,6 +338,18 @@ export declare abstract class TweakedTransaction extends Logger implements Dispo
      * @returns {PsbtInputExtended} The PSBT input extended
      */
     protected generatePsbtInputExtended(utxo: UTXO, i: number, _extra?: boolean): PsbtInputExtended;
+    /**
+     * Detect + configure a P2TR CSV multisig input for script-path spending.
+     *
+     * UTXOs of this shape carry the tapscript in `witnessScript`. The control
+     * block and internal pubkey are fully determined by the tapscript (single
+     * leaf tree, NUMS internal key) so the caller only needs to provide the
+     * tapscript.
+     *
+     * Returns true when the UTXO was recognized and the input was configured,
+     * false otherwise (caller falls back to the default P2TR key-path setup).
+     */
+    protected processCSVMultisigP2TRInput(utxo: UTXO, input: PsbtInputExtended, i: number, scriptPub: Uint8Array): boolean;
     protected processP2WSHInput(utxo: UTXO, input: PsbtInputExtended, i: number): void;
     protected secondsToCSVTimeUnits(seconds: number): number;
     protected createTimeBasedCSV(seconds: number): number;
@@ -357,4 +376,3 @@ export declare abstract class TweakedTransaction extends Logger implements Dispo
     private signTaprootInput;
     private signNonTaprootInput;
 }
-//# sourceMappingURL=TweakedTransaction.d.ts.map

package/build/transaction/shared/TweakedTransaction.js

@@ -1,11 +1,12 @@
 import { Logger } from '@btc-vision/logger';
-import { address as bitAddress, applySignaturesToPsbt, crypto as bitCrypto, fromHex, getFinalScripts, isP2A, isP2MR, isP2MS, isP2PK, isP2PKH, isP2SHScript, isP2TR, isP2WPKH, isP2WSHScript, isUnknownSegwitVersion, opcodes, payments, PaymentType, prepareSigningTasks, Psbt, script, toXOnly, Transaction, varuint, WorkerSigningPool, } from '@btc-vision/bitcoin';
+import { address as bitAddress, applySignaturesToPsbt, crypto as bitCrypto, equals, fromHex, getFinalScripts, isP2A, isP2MR, isP2MS, isP2PK, isP2PKH, isP2SHScript, isP2TR, isP2WPKH, isP2WSHScript, isUnknownSegwitVersion, opcodes, payments, PaymentType, prepareSigningTasks, Psbt, script, toXOnly, Transaction, varuint, WorkerSigningPool, } from '@btc-vision/bitcoin';
 import { isUniversalSigner, TweakedSigner, } from '../../signer/TweakedSigner.js';
 import {} from '@btc-vision/ecpair';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 import { canSignNonTaprootInput, isTaprootInput, pubkeyInScript, } from '../../signer/SignerUtils.js';
 import { witnessStackToScriptWitness } from '../utils/WitnessUtils.js';
 import { P2WDADetector } from '../../p2wda/P2WDADetector.js';
+import { CSVMultisigProvider, } from '../mineable/CSVMultisigProvider.js';
 import { MessageSigner } from '../../keypair/MessageSigner.js';
 import {} from '../../signer/AddressRotation.js';
 import { toTweakedParallelKeyPair } from '../../signer/ParallelSignerAdapter.js';
@@ -87,6 +88,12 @@ export class TweakedTransaction extends Logger {
      */
     csvInputIndices = new Set();
     anchorInputIndices = new Set();
+    /**
+     * Track P2TR CSV multisig inputs together with the address descriptor needed
+     * to finalize them (tapscript + derived control block + parsed config).
+     * @protected
+     */
+    csvMultisigInputs = new Map();
     regenerated = false;
     ignoreSignatureErrors = false;
     noSignatures = false;
@@ -269,6 +276,7 @@ export class TweakedTransaction extends Logger {
         delete this.tweakedSigner;
         this.csvInputIndices.clear();
         this.anchorInputIndices.clear();
+        this.csvMultisigInputs.clear();
         this.inputSignerMap.clear();
         this.tweakedSignerCache.clear();
         delete this.parallelSigningConfig;
@@ -319,7 +327,8 @@ export class TweakedTransaction extends Logger {
         this.sequence = TransactionSequence.FINAL;
         for (const input of this.inputs) {
             // This would disable CSV! You need to check if the input has CSV
-            if (this.csvInputIndices.has(this.inputs.indexOf(input))) {
+            const idx = this.inputs.indexOf(input);
+            if (this.csvInputIndices.has(idx) || this.csvMultisigInputs.has(idx)) {
                 continue;
             }
             input.sequence = TransactionSequence.FINAL;
@@ -571,10 +580,23 @@ export class TweakedTransaction extends Logger {
                 await this.signInputsSequential(transaction);
             }
         }
+        let allFinalized = true;
         for (let i = 0; i < transaction.data.inputs.length; i++) {
-            transaction.finalizeInput(i, this.customFinalizerP2SH.bind(this));
+            try {
+                transaction.finalizeInput(i, this.customFinalizerP2SH.bind(this));
+            }
+            catch (e) {
+                // CSV multisig inputs may legitimately be below threshold during
+                // a collaborative signing hop. Leave them unfinalized so the
+                // partial PSBT can travel to the next cosigner.
+                if (this.csvMultisigInputs.has(i)) {
+                    allFinalized = false;
+                    continue;
+                }
+                throw e;
+            }
         }
-        this.finalized = true;
+        this.finalized = allFinalized;
     }
     /**
      * Signs all inputs sequentially in batches of 20.
@@ -934,8 +956,13 @@ export class TweakedTransaction extends Logger {
                 if (inputSign)
                     input.sighashType = inputSign;
             }
-            // Taproot internal key - use per-input signer in address rotation mode
-            if (this.addressRotationEnabled) {
+            // CSV multisig P2TR: script-path spend with NUMS internal key.
+            // Must come before the default key-path setup below.
+            if (this.processCSVMultisigP2TRInput(utxo, input, i, scriptPub)) {
+                // input fully configured for script-path spend
+            }
+            else if (this.addressRotationEnabled) {
+                // Taproot internal key - use per-input signer in address rotation mode
                 input.tapInternalKey = this.internalPubKeyToXOnlyForInput(i);
             }
             else {
@@ -982,8 +1009,10 @@ export class TweakedTransaction extends Logger {
             this.error(`Unknown or unsupported script type for output: ${utxo.scriptPubKey.hex}`);
         }
         if (i === 0) {
-            // TapLeafScript if available
-            if (this.tapLeafScript) {
+            // TapLeafScript if available — but never clobber a CSV multisig input's
+            // own tapscript; its spend is a script-path that belongs to the UTXO,
+            // not to this transaction's contract leaf.
+            if (this.tapLeafScript && !this.csvMultisigInputs.has(i)) {
                 input.tapLeafScript = [this.tapLeafScript];
             }
             if (this.nonWitnessUtxo) {
@@ -992,6 +1021,44 @@ export class TweakedTransaction extends Logger {
         }
         return input;
     }
+    /**
+     * Detect + configure a P2TR CSV multisig input for script-path spending.
+     *
+     * UTXOs of this shape carry the tapscript in `witnessScript`. The control
+     * block and internal pubkey are fully determined by the tapscript (single
+     * leaf tree, NUMS internal key) so the caller only needs to provide the
+     * tapscript.
+     *
+     * Returns true when the UTXO was recognized and the input was configured,
+     * false otherwise (caller falls back to the default P2TR key-path setup).
+     */
+    processCSVMultisigP2TRInput(utxo, input, i, scriptPub) {
+        if (!utxo.witnessScript)
+            return false;
+        const tapscript = utxo.witnessScript instanceof Uint8Array
+            ? utxo.witnessScript
+            : fromHex(utxo.witnessScript);
+        const addr = CSVMultisigProvider.deriveAddressFromTapscript(tapscript, this.network);
+        if (!addr)
+            return false;
+        // Guard against spoofed witnessScripts on P2TR UTXOs from an unrelated
+        // address: the tapscript must hash back to this exact scriptPubKey.
+        if (!equals(addr.scriptPubKey, scriptPub)) {
+            return false;
+        }
+        input.tapLeafScript = [
+            {
+                leafVersion: addr.leafVersion,
+                script: addr.tapscript,
+                controlBlock: addr.controlBlock,
+            },
+        ];
+        input.tapInternalKey = addr.internalPubkey;
+        // Force a CSV-compatible nSequence so OP_CHECKSEQUENCEVERIFY passes.
+        input.sequence = this.setCSVSequence(addr.config.csvBlocks, this.sequence);
+        this.csvMultisigInputs.set(i, addr);
+        return true;
+    }
     processP2WSHInput(utxo, input, i) {
         // P2WSH requires a witnessScript
         if (!utxo.witnessScript) {
@@ -1047,6 +1114,15 @@ export class TweakedTransaction extends Logger {
                 finalScriptWitness: Uint8Array.from([0]),
             };
         }
+        const csvMultisigAddr = this.csvMultisigInputs.get(inputIndex);
+        if (csvMultisigAddr) {
+            const tapSigs = input.tapScriptSig ?? [];
+            const witnessStack = CSVMultisigProvider.buildFinalWitnessFromTapScriptSigs(tapSigs, csvMultisigAddr);
+            return {
+                finalScriptSig: undefined,
+                finalScriptWitness: witnessStackToScriptWitness(witnessStack),
+            };
+        }
         if (isP2WSH && isSegwit && input.witnessScript) {
             if (!input.partialSig || input.partialSig.length === 0) {
                 throw new Error(`No signatures for P2WSH input #${inputIndex}`);
@@ -1092,11 +1168,20 @@ export class TweakedTransaction extends Logger {
         const signer = this.signer;
         // then, we sign all the remaining inputs with the wallet signer.
         await signer.multiSignPsbt([transaction]);
-        // Then, we finalize every input.
+        let allFinalized = true;
         for (let i = 0; i < transaction.data.inputs.length; i++) {
-            transaction.finalizeInput(i, this.customFinalizerP2SH.bind(this));
+            try {
+                transaction.finalizeInput(i, this.customFinalizerP2SH.bind(this));
+            }
+            catch (e) {
+                if (this.csvMultisigInputs.has(i)) {
+                    allFinalized = false;
+                    continue;
+                }
+                throw e;
+            }
         }
-        this.finalized = true;
+        this.finalized = allFinalized;
     }
     isCSVScript(decompiled) {
         return decompiled.some((op) => op === opcodes.OP_CHECKSEQUENCEVERIFY);
@@ -1233,4 +1318,3 @@ export class TweakedTransaction extends Logger {
         }
     }
 }
-//# sourceMappingURL=TweakedTransaction.js.map

package/build/transaction/utils/WitnessUtils.d.ts

@@ -4,4 +4,3 @@
  * @returns {Uint8Array}
  */
 export declare function witnessStackToScriptWitness(witness: Uint8Array[]): Uint8Array;
-//# sourceMappingURL=WitnessUtils.d.ts.map

package/build/transaction/utils/WitnessUtils.js

@@ -34,4 +34,3 @@ export function witnessStackToScriptWitness(witness) {
     writeVector(witness);
     return buffer;
 }
-//# sourceMappingURL=WitnessUtils.js.map

package/build/utils/BitcoinUtils.d.ts

@@ -23,4 +23,3 @@ export declare class BitcoinUtils {
      */
     static opnetHash(data: Uint8Array): string;
 }
-//# sourceMappingURL=BitcoinUtils.d.ts.map

package/build/utils/BitcoinUtils.js

@@ -54,4 +54,3 @@ export class BitcoinUtils {
         return `0x${toHex(new Uint8Array(hash))}`;
     }
 }
-//# sourceMappingURL=BitcoinUtils.js.map

package/build/utils/BufferHelper.d.ts

@@ -9,4 +9,3 @@ export declare class BufferHelper {
     static valueToUint8Array(value: bigint, length?: number): Uint8Array;
     static uint8ArrayToValue(input: Uint8Array): bigint;
 }
-//# sourceMappingURL=BufferHelper.d.ts.map

package/build/utils/BufferHelper.js

@@ -54,4 +54,3 @@ export class BufferHelper {
         return BigInt('0x' + toHex(input));
     }
 }
-//# sourceMappingURL=BufferHelper.js.map

package/build/utils/StringToBuffer.d.ts

@@ -1,2 +1 @@
 export declare function stringToBuffer(str: string): Uint8Array;
-//# sourceMappingURL=StringToBuffer.d.ts.map

package/build/utils/StringToBuffer.js

@@ -2,4 +2,3 @@ import { fromHex } from '@btc-vision/bitcoin';
 export function stringToBuffer(str) {
     return fromHex(str.startsWith('0x') ? str.slice(2) : str);
 }
-//# sourceMappingURL=StringToBuffer.js.map

package/build/utils/lengths.d.ts

@@ -15,4 +15,3 @@ export declare const I32_BYTE_LENGTH: number;
 export declare const I16_BYTE_LENGTH: number;
 export declare const I8_BYTE_LENGTH: number;
 export declare const BOOLEAN_BYTE_LENGTH: number;
-//# sourceMappingURL=lengths.d.ts.map

package/build/utils/lengths.js

@@ -15,4 +15,3 @@ export const I32_BYTE_LENGTH = 4;
 export const I16_BYTE_LENGTH = 2;
 export const I8_BYTE_LENGTH = 1;
 export const BOOLEAN_BYTE_LENGTH = 1;
-//# sourceMappingURL=lengths.js.map

package/build/utils/types.d.ts

@@ -13,4 +13,3 @@ export type u16 = number;
 export type u32 = number;
 export type u64 = bigint;
 export type Selector = number;
-//# sourceMappingURL=types.d.ts.map

package/build/utils/types.js

@@ -1,2 +1 @@
 import { DeterministicMap } from '../deterministic/DeterministicMap.js';
-//# sourceMappingURL=types.js.map

package/build/utxo/OPNetLimitedProvider.d.ts

@@ -56,4 +56,3 @@ export declare class OPNetLimitedProvider {
      */
     rpcMethod(method: string, paramsMethod: unknown[]): Promise<unknown>;
 }
-//# sourceMappingURL=OPNetLimitedProvider.d.ts.map

package/build/utxo/OPNetLimitedProvider.js

@@ -219,4 +219,3 @@ export class OPNetLimitedProvider {
         return result;
     }
 }
-//# sourceMappingURL=OPNetLimitedProvider.js.map

package/build/utxo/interfaces/BroadcastResponse.d.ts

@@ -7,4 +7,3 @@ export interface BroadcastResponse {
     modifiedTransaction?: string;
     created?: boolean;
 }
-//# sourceMappingURL=BroadcastResponse.d.ts.map

package/build/utxo/interfaces/BroadcastResponse.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=BroadcastResponse.js.map

package/build/utxo/interfaces/IUTXO.d.ts

@@ -36,4 +36,3 @@ export interface RawUTXOResponse {
     readonly scriptPubKey: ScriptPubKey;
     readonly raw: string;
 }
-//# sourceMappingURL=IUTXO.d.ts.map

package/build/utxo/interfaces/IUTXO.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=IUTXO.js.map