@btc-vision/transaction 1.0.106 → 1.0.107

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,12 +107,6 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
      */
     protected _maximumFeeRate: number = 100000000;
 
-    /**
-     * @param {ITransactionParameters} parameters - The transaction parameters
-     */
-
-    public optionalOutputs: PsbtOutputExtended[] | undefined;
-
     protected constructor(parameters: ITransactionParameters) {
         super(parameters);
 
@@ -259,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.',
@@ -273,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]);
@@ -364,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(
@@ -501,6 +502,7 @@ 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
@@ -655,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]);

package/src/transaction/processor/PsbtTransaction.ts

@@ -119,8 +119,8 @@ export class PsbtTransaction extends TweakedTransaction {
      * @description Add an input to the transaction
      * @param input
      */
-    public addInput(input: PsbtInputExtended): void {
-        this.transaction.addInput(input);
+    public addInput(input: PsbtInputExtended, checkPartialSigs: boolean = false): void {
+        this.transaction.addInput(input, checkPartialSigs);
     }
 
     /**

package/src/transaction/shared/TweakedTransaction.ts

@@ -7,8 +7,8 @@ import { PsbtInput } from 'bip174/src/lib/interfaces.js';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { PsbtInputExtended, TapLeafScript } from '../interfaces/Tap.js';
 import { AddressVerificator } from '../../keypair/AddressVerificator.js';
-import { varuint } from 'bitcoinjs-lib/src/bufferutils.js';
 import { ChainId } from '../../network/ChainId.js';
+import { varuint } from 'bitcoinjs-lib/src/bufferutils.js';
 
 export interface ITweakedTransactionData {
     readonly signer: Signer;
@@ -109,17 +109,17 @@ export abstract class TweakedTransaction extends Logger {
      * Read witnesses
      * @protected
      */
-    public static readScriptWitnessToWitnessStack(buffer: Buffer): Buffer[] {
+    public static readScriptWitnessToWitnessStack(Buffer: Buffer): Buffer[] {
         let offset = 0;
 
         function readSlice(n: number): Buffer {
-            const slice = buffer.subarray(offset, offset + n);
+            const slice = Buffer.subarray(offset, offset + n);
             offset += n;
             return slice;
         }
 
         function readVarInt(): number {
-            const varint = varuint.decode(buffer, offset);
+            const varint = varuint.decode(Buffer, offset);
             offset += varuint.decode.bytes;
             return varint;
         }
@@ -421,6 +421,20 @@ export abstract class TweakedTransaction extends Logger {
         }
     }
 
+    protected splitArray<T>(arr: T[], chunkSize: number): T[][] {
+        if (chunkSize <= 0) {
+            throw new Error('Chunk size must be greater than 0.');
+        }
+
+        const result: T[][] = [];
+
+        for (let i = 0; i < arr.length; i += chunkSize) {
+            result.push(arr.slice(i, i + chunkSize));
+        }
+
+        return result;
+    }
+
     /**
      * Signs all the inputs of the transaction.
      * @param {Psbt} transaction - The transaction to sign
@@ -428,14 +442,28 @@ export abstract class TweakedTransaction extends Logger {
      * @returns {Promise<void>}
      */
     protected async signInputs(transaction: Psbt): Promise<void> {
-        for (let i = 0; i < transaction.data.inputs.length; i++) {
-            const input: PsbtInput = transaction.data.inputs[i];
+        const txs: PsbtInput[] = transaction.data.inputs;
+
+        const batchSize: number = 20;
+        const batches = this.splitArray(txs, batchSize);
+
+        for (let i = 0; i < batches.length; i++) {
+            const batch = batches[i];
+            const promises: Promise<void>[] = [];
+            const offset = i * batchSize;
+
+            for (let j = 0; j < batch.length; j++) {
+                const index = offset + j;
+                const input = batch[j];
 
-            try {
-                await this.signInput(transaction, input, i);
-            } catch (e) {
-                this.log(`Failed to sign input ${i}: ${(e as Error).stack}`);
+                try {
+                    promises.push(this.signInput(transaction, input, index));
+                } catch (e) {
+                    this.log(`Failed to sign input ${index}: ${(e as Error).stack}`);
+                }
             }
+
+            await Promise.all(promises);
         }
 
         try {

package/src/utxo/OPNetLimitedProvider.ts

@@ -132,7 +132,7 @@ export class OPNetLimitedProvider {
                 minAmount: settings.minAmount,
                 requestedAmount: settings.requestedAmount,
                 optimized: settings.optimized,
-                usePendingUTXO: false,
+                usePendingUTXO: settings.usePendingUTXO,
             };
 
             const promise = this.fetchUTXO(params).catch(() => {

package/src/utxo/interfaces/IUTXO.ts

@@ -20,6 +20,7 @@ export interface FetchUTXOParamsMultiAddress {
     readonly minAmount: bigint;
     readonly requestedAmount: bigint;
     readonly optimized?: boolean;
+    readonly usePendingUTXO?: boolean;
 }
 
 export interface RawUTXOResponse {