@btc-vision/transaction 1.0.105 → 1.0.107

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

@@ -33,7 +33,7 @@ export declare abstract class TweakedTransaction extends Logger {
     protected regenerated: boolean;
     protected ignoreSignatureErrors: boolean;
     protected constructor(data: ITweakedTransactionData);
-    static readScriptWitnessToWitnessStack(buffer: Buffer): Buffer[];
+    static readScriptWitnessToWitnessStack(Buffer: Buffer): Buffer[];
     static preEstimateTaprootTransactionFees(feeRate: bigint, numInputs: bigint, numOutputs: bigint, numWitnessElements: bigint, witnessElementSize: bigint, emptyWitness: bigint, taprootControlWitnessSize?: bigint, taprootScriptSize?: bigint): bigint;
     protected static signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer, sighashTypes: number[]): void;
     protected static calculateSignHash(sighashTypes: number[]): number;
@@ -48,6 +48,7 @@ export declare abstract class TweakedTransaction extends Logger {
     protected generateScriptAddress(): Payment;
     protected getSignerKey(): Signer;
     protected signInput(transaction: Psbt, input: PsbtInput, i: number, signer?: Signer): Promise<void>;
+    protected splitArray<T>(arr: T[], chunkSize: number): T[][];
     protected signInputs(transaction: Psbt): Promise<void>;
     protected internalPubKeyToXOnly(): Buffer;
     protected internalInit(): void;

package/build/transaction/shared/TweakedTransaction.js

@@ -28,15 +28,15 @@ export class TweakedTransaction extends Logger {
         this.nonWitnessUtxo = data.nonWitnessUtxo;
         this.isBrowser = typeof window !== 'undefined';
     }
-    static readScriptWitnessToWitnessStack(buffer) {
+    static readScriptWitnessToWitnessStack(Buffer) {
         let offset = 0;
         function readSlice(n) {
-            const slice = buffer.subarray(offset, offset + n);
+            const slice = Buffer.subarray(offset, offset + n);
             offset += n;
             return slice;
         }
         function readVarInt() {
-            const varint = varuint.decode(buffer, offset);
+            const varint = varuint.decode(Buffer, offset);
             offset += varuint.decode.bytes;
             return varint;
         }
@@ -193,15 +193,35 @@ export class TweakedTransaction extends Logger {
             }
         }
     }
+    splitArray(arr, chunkSize) {
+        if (chunkSize <= 0) {
+            throw new Error('Chunk size must be greater than 0.');
+        }
+        const result = [];
+        for (let i = 0; i < arr.length; i += chunkSize) {
+            result.push(arr.slice(i, i + chunkSize));
+        }
+        return result;
+    }
     async signInputs(transaction) {
-        for (let i = 0; i < transaction.data.inputs.length; i++) {
-            const input = transaction.data.inputs[i];
-            try {
-                await this.signInput(transaction, input, i);
-            }
-            catch (e) {
-                this.log(`Failed to sign input ${i}: ${e.stack}`);
+        const txs = transaction.data.inputs;
+        const batchSize = 20;
+        const batches = this.splitArray(txs, batchSize);
+        for (let i = 0; i < batches.length; i++) {
+            const batch = batches[i];
+            const promises = [];
+            const offset = i * batchSize;
+            for (let j = 0; j < batch.length; j++) {
+                const index = offset + j;
+                const input = batch[j];
+                try {
+                    promises.push(this.signInput(transaction, input, index));
+                }
+                catch (e) {
+                    this.log(`Failed to sign input ${index}: ${e.stack}`);
+                }
             }
+            await Promise.all(promises);
         }
         try {
             transaction.finalizeAllInputs();

package/build/utxo/OPNetLimitedProvider.d.ts

@@ -1,8 +1,15 @@
 import { Address } from '@btc-vision/bsi-binary';
+import { Network } from 'bitcoinjs-lib';
+import { Wallet } from '../opnet.js';
 import { UnwrapGeneration } from '../wbtc/UnwrapGeneration.js';
 import { WrappedGeneration } from '../wbtc/WrappedGenerationParameters.js';
 import { BroadcastResponse } from './interfaces/BroadcastResponse.js';
-import { FetchUTXOParams, FetchUTXOParamsMultiAddress, UTXO } from './interfaces/IUTXO.js';
+import { FetchUTXOParams, FetchUTXOParamsMultiAddress, RawUTXOResponse, UTXO } from './interfaces/IUTXO.js';
+export interface WalletUTXOs {
+    readonly confirmed: RawUTXOResponse[];
+    readonly pending: RawUTXOResponse[];
+    readonly spentTransactions: RawUTXOResponse[];
+}
 export declare class OPNetLimitedProvider {
     private readonly opnetAPIUrl;
     private readonly utxoPath;
@@ -11,6 +18,9 @@ export declare class OPNetLimitedProvider {
     fetchUTXO(settings: FetchUTXOParams): Promise<UTXO[]>;
     fetchUTXOMultiAddr(settings: FetchUTXOParamsMultiAddress): Promise<UTXO[]>;
     broadcastTransaction(transaction: string, psbt: boolean): Promise<BroadcastResponse | undefined>;
+    splitUTXOs(wallet: Wallet, network: Network, splitInputsInto: number, amountPerUTXO: bigint): Promise<BroadcastResponse | {
+        error: string;
+    }>;
     rpcMethod(method: string, paramsMethod: unknown[]): Promise<unknown>;
     fetchWrapParameters(amount: bigint): Promise<WrappedGeneration | undefined>;
     fetchUnWrapParameters(amount: bigint, receiver: Address): Promise<UnwrapGeneration | undefined>;

package/build/utxo/OPNetLimitedProvider.js

@@ -1,4 +1,5 @@
 import { currentConsensusConfig } from '../consensus/ConsensusConfig.js';
+import { TransactionFactory } from '../opnet.js';
 import { UnwrapGeneration } from '../wbtc/UnwrapGeneration.js';
 import { WrappedGeneration } from '../wbtc/WrappedGenerationParameters.js';
 export class OPNetLimitedProvider {
@@ -8,6 +9,12 @@ export class OPNetLimitedProvider {
         this.rpc = 'json-rpc';
     }
     async fetchUTXO(settings) {
+        if (settings.usePendingUTXO === undefined) {
+            settings.usePendingUTXO = true;
+        }
+        if (settings.optimized === undefined) {
+            settings.optimized = true;
+        }
         const params = {
             method: 'GET',
             headers: {
@@ -20,10 +27,21 @@ export class OPNetLimitedProvider {
             throw new Error(`Failed to fetch UTXO data: ${resp.statusText}`);
         }
         const fetchedData = (await resp.json());
-        if (fetchedData.length === 0) {
+        const allUtxos = settings.usePendingUTXO
+            ? [...fetchedData.confirmed, ...fetchedData.pending]
+            : fetchedData.confirmed;
+        const unspentUTXOs = [];
+        for (const utxo of allUtxos) {
+            if (fetchedData.spentTransactions.some((spent) => spent.transactionId === utxo.transactionId &&
+                spent.outputIndex === utxo.outputIndex)) {
+                continue;
+            }
+            unspentUTXOs.push(utxo);
+        }
+        if (unspentUTXOs.length === 0) {
             throw new Error('No UTXO found');
         }
-        const meetCriteria = fetchedData.filter((utxo) => {
+        const meetCriteria = unspentUTXOs.filter((utxo) => {
             return BigInt(utxo.value) >= settings.minAmount;
         });
         if (meetCriteria.length === 0) {
@@ -58,6 +76,7 @@ export class OPNetLimitedProvider {
                 minAmount: settings.minAmount,
                 requestedAmount: settings.requestedAmount,
                 optimized: settings.optimized,
+                usePendingUTXO: settings.usePendingUTXO,
             };
             const promise = this.fetchUTXO(params).catch(() => {
                 return [];
@@ -86,6 +105,34 @@ export class OPNetLimitedProvider {
         }
         return result;
     }
+    async splitUTXOs(wallet, network, splitInputsInto, amountPerUTXO) {
+        const utxoSetting = {
+            addresses: [wallet.p2wpkh, wallet.p2tr],
+            minAmount: 330n,
+            requestedAmount: 1000000000000000n,
+        };
+        const utxos = await this.fetchUTXOMultiAddr(utxoSetting);
+        if (!utxos || !utxos.length)
+            return { error: 'No UTXOs found' };
+        const amount = BigInt(splitInputsInto) * amountPerUTXO;
+        const fundingTransactionParameters = {
+            amount: amount,
+            feeRate: 500,
+            from: wallet.p2tr,
+            utxos: utxos,
+            signer: wallet.keypair,
+            network,
+            to: wallet.p2tr,
+            splitInputsInto,
+            priorityFee: 330n,
+        };
+        const transactionFactory = new TransactionFactory();
+        const fundingTx = await transactionFactory.createBTCTransfer(fundingTransactionParameters);
+        const broadcastResponse = await this.broadcastTransaction(fundingTx.tx, false);
+        if (!broadcastResponse)
+            return { error: 'Could not broadcast transaction' };
+        return broadcastResponse;
+    }
     async rpcMethod(method, paramsMethod) {
         const params = {
             method: 'POST',

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

@@ -9,13 +9,15 @@ export interface FetchUTXOParams {
     readonly address: string;
     readonly minAmount: bigint;
     readonly requestedAmount: bigint;
-    readonly optimized?: boolean;
+    optimized?: boolean;
+    usePendingUTXO?: boolean;
 }
 export interface FetchUTXOParamsMultiAddress {
     readonly addresses: string[];
     readonly minAmount: bigint;
     readonly requestedAmount: bigint;
     readonly optimized?: boolean;
+    readonly usePendingUTXO?: boolean;
 }
 export interface RawUTXOResponse {
     readonly transactionId: string;

package/eslint.config.js

@@ -28,7 +28,6 @@ export default tseslint.config(
             '@typescript-eslint/no-unnecessary-type-parameters': 'off',
             '@typescript-eslint/no-duplicate-enum-values': 'off',
             'prefer-spread': 'off',
-            '@typescript-eslint/no-empty-object-type': 'off',
         },
     },
     {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.0.105",
+    "version": "1.0.107",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {
@@ -92,7 +92,7 @@
         "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
         "@bitcoinerlab/secp256k1": "^1.1.1",
         "@btc-vision/bsi-binary": "^1.0.42",
-        "@btc-vision/bsi-bitcoin-rpc": "^1.0.28",
+        "@btc-vision/bsi-bitcoin-rpc": "^1.0.29",
         "@btc-vision/logger": "^1.0.6",
         "@eslint/js": "^9.10.0",
         "assert": "^2.1.0",

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.0.101';
+export const version = '1.0.107';

package/src/keypair/EcKeyPair.ts

@@ -1,9 +1,9 @@
 import * as ecc from '@bitcoinerlab/secp256k1';
 import { Address } from '@btc-vision/bsi-binary';
-import bip32, { BIP32Factory, BIP32Interface } from 'bip32';
+import bip32, { BIP32API, BIP32Factory, BIP32Interface } from 'bip32';
 import { address, initEccLib, Network, networks, payments } from 'bitcoinjs-lib';
 import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
-import { ECPairFactory, ECPairInterface } from 'ecpair';
+import { ECPairAPI, ECPairFactory, ECPairInterface } from 'ecpair';
 import { IWallet } from './interfaces/IWallet.js';
 
 initEccLib(ecc);
@@ -22,8 +22,8 @@ if (!BIP32factory) {
  * @example import { EcKeyPair } from '@btc-vision/transaction';
  */
 export class EcKeyPair {
-    public static BIP32 = BIP32factory(ecc);
-    public static ECPair = ECPairFactory(ecc);
+    public static BIP32: BIP32API = BIP32factory(ecc);
+    public static ECPair: ECPairAPI = ECPairFactory(ecc);
 
     /**
      * Generate a keypair from a WIF

package/src/transaction/TransactionFactory.ts

@@ -224,8 +224,7 @@ export class TransactionFactory {
         // Initial generation
         await preTransaction.signTransaction();
 
-        const parameters: IFundingTransactionParameters =
-            await preTransaction.getFundingTransactionParameters();
+        const parameters: IFundingTransactionParameters =await preTransaction.getFundingTransactionParameters();
 
         const fundingTransaction: FundingTransaction = new FundingTransaction(parameters);
         const signedTransaction: Transaction = await fundingTransaction.signTransaction();
@@ -249,6 +248,7 @@ export class TransactionFactory {
             utxos: [newUtxo],
             randomBytes: preTransaction.getRndBytes(),
             nonWitnessUtxo: signedTransaction.toBuffer(),
+            optionalOutputs: []
         };
 
         const finalTransaction: DeploymentTransaction = new DeploymentTransaction(newParams);
@@ -291,7 +291,7 @@ export class TransactionFactory {
         const childTransactionRequiredValue: bigint =
             wrapParameters.amount +
             currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT +
-            (wrapParameters.priorityFee || 300n);
+            (wrapParameters.priorityFee || 330n);
 
         const wbtc: wBTC = new wBTC(wrapParameters.network, wrapParameters.chainId);
         const to = wbtc.getAddress();

package/src/transaction/builders/CustomScriptTransaction.ts

@@ -255,17 +255,13 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
     /**
      * Finalize the transaction
      * @param _inputIndex
-     * @param input
+     * @param _input
      */
-    private customFinalizer = (_inputIndex: number, input: PsbtInput) => {
+    private customFinalizer = (_inputIndex: number, _input: PsbtInput) => {
         if (!this.tapLeafScript) {
             throw new Error('Tap leaf script is required');
         }
-
-        if (!input.tapScriptSig) {
-            throw new Error('Tap script signature is required');
-        }
-
+        
         const scriptSolution = this.witnesses;
         const witness = scriptSolution
             .concat(this.tapLeafScript.script)

package/src/transaction/builders/MultiSignTransaction.ts

@@ -493,16 +493,17 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
     /**
      * Builds the transaction.
      * @param {Psbt} transaction - The transaction to build
+     * @param checkPartialSigs
      * @protected
      * @returns {Promise<boolean>}
      * @throws {Error} - If something went wrong while building the transaction
      */
-    protected override async internalBuildTransaction(transaction: Psbt): Promise<boolean> {
+    protected override async internalBuildTransaction(transaction: Psbt, checkPartialSigs: boolean = false): Promise<boolean> {
         const inputs: PsbtInputExtended[] = this.getInputs();
         const outputs: PsbtOutputExtended[] = this.getOutputs();
 
         transaction.setMaximumFeeRate(this._maximumFeeRate);
-        transaction.addInputs(inputs);
+        transaction.addInputs(inputs, checkPartialSigs);
 
         for (let i = 0; i < this.updateInputs.length; i++) {
             transaction.updateInput(i, this.updateInputs[i]);

package/src/transaction/builders/SharedInteractionTransaction.ts

@@ -185,44 +185,37 @@ export abstract class SharedInteractionTransaction<
             return;
         }
 
-        for (let i = 0; i < transaction.data.inputs.length; i++) {
-            const input: PsbtInput = transaction.data.inputs[i];
-            let finalized: boolean = false;
-            let signed: boolean = false;
+        const txs: PsbtInput[] = transaction.data.inputs;
+        for (let i = 0; i < txs.length; i += 20) {
+            const batch = txs.slice(i, i + 20);
 
-            try {
-                await this.signInput(transaction, input, i, this.scriptSigner);
-                signed = true;
-            } catch (e) {}
-
-            try {
-                await this.signInput(transaction, input, i);
-                signed = true;
-            } catch (e) {}
+            const promises: Promise<void>[] = [];
+            for (let y = 0; y < batch.length; y++) {
+                const offset = i * 20 + y;
+                const input = batch[y];
 
-            try {
-                transaction.finalizeInput(0, this.customFinalizer);
-                finalized = true;
-            } catch (e) {}
+                promises.push(this.signIndividualInputs(transaction, input, offset));
+            }
 
-            try {
-                transaction.finalizeInput(i);
-                finalized = true;
-            } catch (e) {}
+            await Promise.all(promises).catch((e: unknown) => {
+                throw e;
+            });
+        }
 
-            if (signed || finalized) {
-                this.log(
-                    `Signed input or finalized input #${i} out of ${transaction.data.inputs.length}! {Signed: ${signed}, Finalized: ${finalized}}`,
-                );
+        try {
+            transaction.finalizeInput(0, this.customFinalizer);
 
-                continue;
-            }
+            this.log(`Finalized input 0!`);
+        } catch (e) {
+            console.log(`Failed to finalize input 0: ${(e as Error).stack}`);
+        }
 
-            if (this.regenerated || this.ignoreSignatureErrors) {
-                continue;
-            }
+        for (let i = 0; i < txs.length; i++) {
+            try {
+                transaction.finalizeInput(i);
 
-            throw new Error('Failed to sign input');
+                this.log(`Finalized input ${i}!`);
+            } catch {}
         }
     }
 
@@ -310,9 +303,11 @@ export abstract class SharedInteractionTransaction<
             throw new Error('Tap leaf script is required');
         }
 
-        if (!input.tapScriptSig) {
-            throw new Error('Tap script signature is required');
-        }
+        //console.log('finalizing input', input);
+
+        //if (!input.tapLeafScript) {
+        //    throw new Error('Tap script signature is required');
+        //}
 
         if (!this.contractSecret) {
             throw new Error('Contract secret is required');
@@ -328,6 +323,38 @@ export abstract class SharedInteractionTransaction<
         };
     };
 
+    private async signIndividualInputs(
+        transaction: Psbt,
+        input: PsbtInput,
+        i: number,
+    ): Promise<void> {
+        let signed: boolean = false;
+
+        try {
+            await this.signInput(transaction, input, i, this.scriptSigner);
+            signed = true;
+        } catch {}
+
+        try {
+            await this.signInput(transaction, input, i);
+            signed = true;
+        } catch {}
+
+        if (signed) {
+            this.log(
+                `Signed input #${i} out of ${transaction.data.inputs.length}! {Signed: ${signed}}`,
+            );
+
+            return;
+        }
+
+        if (this.regenerated || this.ignoreSignatureErrors) {
+            return;
+        }
+
+        throw new Error('Failed to sign input');
+    }
+
     /**
      * Get the public keys
      * @private

package/src/transaction/builders/TransactionBuilder.ts

@@ -47,6 +47,11 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
      * @description The estimated fees of the transaction
      */
     public estimatedFees: bigint = 0n;
+    /**
+     * @param {ITransactionParameters} parameters - The transaction parameters
+     */
+
+    public optionalOutputs: PsbtOutputExtended[] | undefined;
     /**
      * @description The transaction itself.
      */
@@ -102,9 +107,6 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
      */
     protected _maximumFeeRate: number = 100000000;
 
-    /**
-     * @param {ITransactionParameters} parameters - The transaction parameters
-     */
     protected constructor(parameters: ITransactionParameters) {
         super(parameters);
 
@@ -119,6 +121,8 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         this.utxos = parameters.utxos;
         this.to = parameters.to || undefined;
 
+        this.optionalOutputs = parameters.optionalOutputs;
+
         this.from = TransactionBuilder.getFrom(
             parameters.from,
             this.signer as ECPairInterface,
@@ -195,6 +199,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             priorityFee: this.priorityFee ?? 0n,
             from: this.from,
             amount: this.estimatedFees,
+            optionalOutputs: this.optionalOutputs,
         };
     }
 
@@ -253,7 +258,9 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
      * @description Generates the transaction minimal signatures
      * @public
      */
-    public async generateTransactionMinimalSignatures(): Promise<void> {
+    public async generateTransactionMinimalSignatures(
+        checkPartialSigs: boolean = false,
+    ): Promise<void> {
         if (this.to && !EcKeyPair.verifyContractAddress(this.to, this.network)) {
             throw new Error(
                 'Invalid contract address. The contract address must be a taproot address.',
@@ -267,7 +274,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             const outputs: PsbtOutputExtended[] = this.getOutputs();
 
             this.transaction.setMaximumFeeRate(this._maximumFeeRate);
-            this.transaction.addInputs(inputs);
+            this.transaction.addInputs(inputs, checkPartialSigs);
 
             for (let i = 0; i < this.updateInputs.length; i++) {
                 this.transaction.updateInput(i, this.updateInputs[i]);
@@ -358,7 +365,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             const fee: number = this.feeRate * size;
 
             this.estimatedFees = BigInt(Math.ceil(fee) + 1);
-
+            
             return this.estimatedFees;
         } else {
             throw new Error(
@@ -409,8 +416,8 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
      */
     protected async addRefundOutput(amountSpent: bigint): Promise<void> {
         /** Add the refund output */
-        const sendBackAmount: bigint = this.totalInputAmount - amountSpent;
-
+        const sendBackAmount: bigint =
+            this.totalInputAmount - amountSpent - this.addOptionalOutputsAndGetAmount();
         if (sendBackAmount >= TransactionBuilder.MINIMUM_DUST) {
             if (AddressVerificator.isValidP2TRAddress(this.from, this.network)) {
                 await this.setFeeOutput({
@@ -479,7 +486,6 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         for (const utxo of this.utxos) {
             total += utxo.value;
         }
-
         return total;
     }
 
@@ -497,6 +503,23 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         return total;
     }
 
+    /**
+     * @description Adds optional outputs to transaction and returns their total value in satoshi to calculate refund transaction
+     * @protected
+     * @returns {bigint}
+     */
+    protected addOptionalOutputsAndGetAmount(): bigint {
+        if (!this.optionalOutputs) return 0n;
+
+        let refundedFromOptionalOutputs = 0n;
+
+        for (let i = 0; i < this.optionalOutputs.length; i++) {
+            this.addOutput(this.optionalOutputs[i]);
+            refundedFromOptionalOutputs += BigInt(this.optionalOutputs[i].value);
+        }
+        return refundedFromOptionalOutputs;
+    }
+
     /**
      * @description Adds the inputs from the utxos
      * @protected
@@ -634,17 +657,21 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
     /**
      * Builds the transaction.
      * @param {Psbt} transaction - The transaction to build
+     * @param checkPartialSigs
      * @protected
      * @returns {Promise<boolean>}
      * @throws {Error} - If something went wrong while building the transaction
      */
-    protected async internalBuildTransaction(transaction: Psbt): Promise<boolean> {
+    protected async internalBuildTransaction(
+        transaction: Psbt,
+        checkPartialSigs: boolean = false,
+    ): Promise<boolean> {
         if (transaction.data.inputs.length === 0) {
             const inputs: PsbtInputExtended[] = this.getInputs();
             const outputs: PsbtOutputExtended[] = this.getOutputs();
 
             transaction.setMaximumFeeRate(this._maximumFeeRate);
-            transaction.addInputs(inputs);
+            transaction.addInputs(inputs, checkPartialSigs);
 
             for (let i = 0; i < this.updateInputs.length; i++) {
                 transaction.updateInput(i, this.updateInputs[i]);

package/src/transaction/builders/UnwrapSegwitTransaction.ts

@@ -196,13 +196,13 @@ export class UnwrapSegwitTransaction extends SharedInteractionTransaction<Transa
      * @returns {Promise<boolean>}
      * @throws {Error} - If something went wrong while building the transaction
      */
-    protected async internalBuildTransaction(transaction: Psbt): Promise<boolean> {
+    protected async internalBuildTransaction(transaction: Psbt, checkPartialSigs: boolean = false): Promise<boolean> {
         if (transaction.data.inputs.length === 0) {
             const inputs: PsbtInputExtended[] = this.getInputs();
             const outputs: PsbtOutputExtended[] = this.getOutputs();
 
             transaction.setMaximumFeeRate(this._maximumFeeRate);
-            transaction.addInputs(inputs);
+            transaction.addInputs(inputs, checkPartialSigs);
 
             for (let i = 0; i < this.updateInputs.length; i++) {
                 transaction.updateInput(i, this.updateInputs[i]);
@@ -313,9 +313,9 @@ export class UnwrapSegwitTransaction extends SharedInteractionTransaction<Transa
             this.addVaultUTXO(utxo, p2wshOutput);
 
             if (firstSigner) {
-                this.log(
-                    `Signing input ${inputIndex} with ${firstSigner.publicKey.toString('hex')}`,
-                );
+                //this.log(
+                //    `Signing input ${inputIndex} with ${firstSigner.publicKey.toString('hex')}`,
+                //);
 
                 // we don't care if we fail to sign the input
                 try {

package/src/transaction/builders/UnwrapTransaction.ts

@@ -381,17 +381,21 @@ export class UnwrapTransaction extends SharedInteractionTransaction<TransactionT
     /**
      * Builds the transaction.
      * @param {Psbt} transaction - The transaction to build
+     * @param checkPartialSigs
      * @protected
      * @returns {Promise<boolean>}
      * @throws {Error} - If something went wrong while building the transaction
      */
-    protected async internalBuildTransaction(transaction: Psbt): Promise<boolean> {
+    protected async internalBuildTransaction(
+        transaction: Psbt,
+        checkPartialSigs: boolean = false,
+    ): Promise<boolean> {
         if (transaction.data.inputs.length === 0) {
             const inputs: PsbtInputExtended[] = this.getInputs();
             const outputs: PsbtOutputExtended[] = this.getOutputs();
 
             transaction.setMaximumFeeRate(this._maximumFeeRate);
-            transaction.addInputs(inputs);
+            transaction.addInputs(inputs, checkPartialSigs);
 
             for (let i = 0; i < this.updateInputs.length; i++) {
                 transaction.updateInput(i, this.updateInputs[i]);