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

package/src/transaction/browser/extensions/UnisatSigner.ts

@@ -1,20 +1,30 @@
 import {
     crypto as bitCrypto,
-    Network,
+    equals,
+    fromHex,
+    type Network,
     networks,
     Psbt,
+    type PsbtInput,
     script as bitScript,
-    TapScriptSig,
+    type TapScriptSig,
+    toHex,
     toXOnly,
 } from '@btc-vision/bitcoin';
-import { PartialSig } from 'bip174/src/lib/interfaces.js';
-import { ECPairInterface } from 'ecpair';
+import type { PartialSig } from 'bip174';
+import {
+    createPublicKey,
+    type MessageHash,
+    type PublicKey,
+    type SchnorrSignature,
+    type Signature,
+} from '@btc-vision/ecpair';
 import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
 import { canSignNonTaprootInput, isTaprootInput } from '../../../signer/SignerUtils.js';
 import { CustomKeypair } from '../BrowserSignerBase.js';
-import { PsbtSignatureOptions, SignatureType, Unisat } from '../types/Unisat.js';
+import { type PsbtSignatureOptions, SignatureType, type Unisat } from '../types/Unisat.js';
 import { WalletNetworks } from '../WalletNetworks.js';
-import { OPWallet } from '../types/OPWallet.js';
+import type { OPWallet } from '../types/OPWallet.js';
 
 export interface WindowWithWallets {
     unisat?: Unisat;
@@ -62,9 +72,9 @@ export class UnisatSigner extends CustomKeypair {
         return this._addresses;
     }
 
-    private _publicKey: Buffer | undefined;
+    private _publicKey: PublicKey | undefined;
 
-    public get publicKey(): Buffer {
+    public get publicKey(): PublicKey {
         if (!this._publicKey) {
             throw new Error('Public key not set');
         }
@@ -93,11 +103,11 @@ export class UnisatSigner extends CustomKeypair {
         return module;
     }
 
-    public async signData(data: Buffer, type: SignatureType): Promise<Buffer> {
-        const str = data.toString('hex');
+    public async signData(data: Uint8Array, type: SignatureType): Promise<Uint8Array> {
+        const str = toHex(data);
         const signature = await this.unisat.signData(str, type);
 
-        return Buffer.from(signature, 'hex');
+        return fromHex(signature);
     }
 
     public async init(): Promise<void> {
@@ -125,18 +135,18 @@ export class UnisatSigner extends CustomKeypair {
             throw new Error('Unlock your wallet first');
         }
 
-        this._publicKey = Buffer.from(publicKey, 'hex');
+        this._publicKey = createPublicKey(fromHex(publicKey));
 
-        this._p2wpkh = EcKeyPair.getP2WPKHAddress(this as unknown as ECPairInterface, this.network);
+        this._p2wpkh = EcKeyPair.getP2WPKHAddress(this, this.network);
 
-        this._p2tr = EcKeyPair.getTaprootAddress(this as unknown as ECPairInterface, this.network);
+        this._p2tr = EcKeyPair.getTaprootAddress(this, this.network);
 
         this._addresses = [this._p2wpkh, this._p2tr];
 
         this.isInitialized = true;
     }
 
-    public getPublicKey(): Buffer {
+    public getPublicKey(): PublicKey {
         if (!this.isInitialized) {
             throw new Error('UnisatSigner not initialized');
         }
@@ -144,15 +154,15 @@ export class UnisatSigner extends CustomKeypair {
         return this.publicKey;
     }
 
-    public sign(_hash: Buffer, _lowR?: boolean): Buffer {
+    public sign(_hash: MessageHash, _lowR?: boolean): Signature {
         throw new Error('Not implemented: sign');
     }
 
-    public signSchnorr(_hash: Buffer): Buffer {
+    public signSchnorr(_hash: MessageHash): SchnorrSignature {
         throw new Error('Not implemented: signSchnorr');
     }
 
-    public verify(_hash: Buffer, _signature: Buffer): boolean {
+    public verify(_hash: MessageHash, _signature: Signature): boolean {
         throw new Error('Not implemented: verify');
     }
 
@@ -161,7 +171,7 @@ export class UnisatSigner extends CustomKeypair {
         i: number,
         sighashTypes: number[],
     ): Promise<void> {
-        const input = transaction.data.inputs[i];
+        const input = transaction.data.inputs[i] as PsbtInput;
         if (
             input.tapKeySig ||
             input.finalScriptSig ||
@@ -180,7 +190,7 @@ export class UnisatSigner extends CustomKeypair {
     }
 
     public async signInput(transaction: Psbt, i: number, sighashTypes: number[]): Promise<void> {
-        const input = transaction.data.inputs[i];
+        const input = transaction.data.inputs[i] as PsbtInput;
         if (
             input.tapKeySig ||
             input.finalScriptSig ||
@@ -226,7 +236,7 @@ export class UnisatSigner extends CustomKeypair {
                             const tapInternalKey = input.tapInternalKey;
                             const xOnlyPubKey = toXOnly(this.publicKey);
 
-                            if (tapInternalKey.equals(xOnlyPubKey)) {
+                            if (equals(tapInternalKey, xOnlyPubKey)) {
                                 needsToSign = true;
                                 viaTaproot = true;
                             }
@@ -240,7 +250,7 @@ export class UnisatSigner extends CustomKeypair {
                     if (needsToSign) {
                         return {
                             index: i,
-                            publicKey: this.publicKey.toString('hex'),
+                            publicKey: toHex(this.publicKey),
                             disableTweakSigner: !viaTaproot,
                         };
                     } else {
@@ -255,24 +265,17 @@ export class UnisatSigner extends CustomKeypair {
             });
         }
 
-        const signed = await this.unisat.signPsbt(toSignPsbts[0], options[0]);
-        const signedPsbts = Psbt.fromHex(signed); //signed.map((hex) => Psbt.fromHex(hex));
-
-        /*for (let i = 0; i < signedPsbts.length; i++) {
-            const psbtOriginal = transactions[i];
-            const psbtSigned = signedPsbts[i];
-
-            psbtOriginal.combine(psbtSigned);
-        }*/
+        const signed = await this.unisat.signPsbt(toSignPsbts[0] as string, options[0] as PsbtSignatureOptions);
+        const signedPsbts = Psbt.fromHex(signed);
 
-        transactions[0].combine(signedPsbts);
+        (transactions[0] as Psbt).combine(signedPsbts);
     }
 
     private hasAlreadySignedTapScriptSig(input: TapScriptSig[]): boolean {
         for (let i = 0; i < input.length; i++) {
-            const item = input[i];
-            const buf = Buffer.from(item.pubkey);
-            if (buf.equals(this.publicKey) && item.signature) {
+            const item = input[i] as TapScriptSig;
+            const buf = new Uint8Array(item.pubkey);
+            if (equals(buf, this.publicKey) && item.signature) {
                 return true;
             }
         }
@@ -282,9 +285,9 @@ export class UnisatSigner extends CustomKeypair {
 
     private hasAlreadyPartialSig(input: PartialSig[]): boolean {
         for (let i = 0; i < input.length; i++) {
-            const item = input[i];
-            const buf = Buffer.from(item.pubkey);
-            if (buf.equals(this.publicKey) && item.signature) {
+            const item = input[i] as PartialSig;
+            const buf = new Uint8Array(item.pubkey);
+            if (equals(buf, this.publicKey) && item.signature) {
                 return true;
             }
         }
@@ -293,8 +296,8 @@ export class UnisatSigner extends CustomKeypair {
     }
 
     private combine(transaction: Psbt, newPsbt: Psbt, i: number): void {
-        const signedInput = newPsbt.data.inputs[i];
-        const originalInput = transaction.data.inputs[i];
+        const signedInput = newPsbt.data.inputs[i] as PsbtInput;
+        const originalInput = transaction.data.inputs[i] as PsbtInput;
 
         if (signedInput.partialSig) {
             transaction.updateInput(i, { partialSig: signedInput.partialSig });
@@ -326,7 +329,7 @@ export class UnisatSigner extends CustomKeypair {
         sighashTypes: number[],
         disableTweakSigner: boolean = false,
     ): Promise<Psbt> {
-        const pubKey = this.publicKey.toString('hex');
+        const pubKey = toHex(this.publicKey);
         const toSign = transaction.data.inputs.map((_, i) => {
             return [
                 {
@@ -355,9 +358,10 @@ export class UnisatSigner extends CustomKeypair {
     ): TapScriptSig[] {
         const nonDuplicate: TapScriptSig[] = [];
         for (let i = 0; i < scriptSig2.length; i++) {
-            const found = scriptSig1.find((item) => item.pubkey.equals(scriptSig2[i].pubkey));
+            const sig2 = scriptSig2[i] as TapScriptSig;
+            const found = scriptSig1.find((item) => equals(item.pubkey, sig2.pubkey));
             if (!found) {
-                nonDuplicate.push(scriptSig2[i]);
+                nonDuplicate.push(sig2);
             }
         }
 
@@ -365,13 +369,13 @@ export class UnisatSigner extends CustomKeypair {
     }
 }
 
-function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean {
+function pubkeyInScript(pubkey: Uint8Array, script: Uint8Array): boolean {
     return pubkeyPositionInScript(pubkey, script) !== -1;
 }
 
-function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number {
+function pubkeyPositionInScript(pubkey: Uint8Array, script: Uint8Array): number {
     const pubkeyHash = bitCrypto.hash160(pubkey);
-    const pubkeyXOnly = toXOnly(pubkey);
+    const pubkeyXOnly = toXOnly(pubkey as PublicKey);
 
     const decompiled = bitScript.decompile(script);
     if (decompiled === null) throw new Error('Unknown script error');
@@ -379,8 +383,8 @@ function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number {
     return decompiled.findIndex((element) => {
         if (typeof element === 'number') return false;
         return (
-            Buffer.isBuffer(element) &&
-            (element.equals(pubkey) || element.equals(pubkeyHash) || element.equals(pubkeyXOnly))
+            element instanceof Uint8Array &&
+            (equals(element, pubkey) || equals(element, pubkeyHash) || equals(element, pubkeyXOnly))
         );
     });
 }

package/src/transaction/browser/extensions/XverseSigner.ts

@@ -1,6 +1,22 @@
-import { Network, networks, Psbt, TapScriptSig, toXOnly } from '@btc-vision/bitcoin';
-import { PartialSig } from 'bip174/src/lib/interfaces.js';
-import { ECPairInterface } from 'ecpair';
+import {
+    equals,
+    fromHex,
+    type Network,
+    networks,
+    Psbt,
+    type PsbtInput,
+    type TapScriptSig,
+    toHex,
+    toXOnly,
+} from '@btc-vision/bitcoin';
+import type { PartialSig } from 'bip174';
+import {
+    createPublicKey,
+    type MessageHash,
+    type PublicKey,
+    type SchnorrSignature,
+    type Signature,
+} from '@btc-vision/ecpair';
 import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
 import {
     canSignNonTaprootInput,
@@ -8,8 +24,8 @@ import {
     pubkeyInScript,
 } from '../../../signer/SignerUtils.js';
 import { CustomKeypair } from '../BrowserSignerBase.js';
-import { PsbtSignatureOptions } from '../types/Unisat.js';
-import { SigningProtocol, Xverse } from '../types/Xverse.js';
+import type { PsbtSignatureOptions } from '../types/Unisat.js';
+import { SigningProtocol, type Xverse } from '../types/Xverse.js';
 
 declare global {
     interface Window {
@@ -58,9 +74,9 @@ export class XverseSigner extends CustomKeypair {
         return this._addresses;
     }
 
-    private _publicKey: Buffer | undefined;
+    private _publicKey: PublicKey | undefined;
 
-    public get publicKey(): Buffer {
+    public get publicKey(): PublicKey {
         if (!this._publicKey) {
             throw new Error('Public key not set');
         }
@@ -112,11 +128,11 @@ export class XverseSigner extends CustomKeypair {
 
         this._network = network;
 
-        this._publicKey = Buffer.from(payementAddress.publicKey, 'hex');
+        this._publicKey = createPublicKey(fromHex(payementAddress.publicKey));
 
-        this._p2wpkh = EcKeyPair.getP2WPKHAddress(this as unknown as ECPairInterface, this.network);
+        this._p2wpkh = EcKeyPair.getP2WPKHAddress(this, this.network);
 
-        this._p2tr = EcKeyPair.getTaprootAddress(this as unknown as ECPairInterface, this.network);
+        this._p2tr = EcKeyPair.getTaprootAddress(this, this.network);
 
         this._addresses = [this._p2wpkh, this._p2tr];
 
@@ -124,17 +140,17 @@ export class XverseSigner extends CustomKeypair {
     }
 
     public async signData(
-        data: Buffer,
+        data: Uint8Array,
         address: string,
         protocol: SigningProtocol,
-    ): Promise<Buffer> {
+    ): Promise<Uint8Array> {
         if (!this.isInitialized) {
             throw new Error('UnisatSigner not initialized');
         }
 
         const callSign = await this.BitcoinProvider.request('signMessage', {
             address,
-            message: data.toString(),
+            message: new TextDecoder().decode(data),
             protocol,
         });
 
@@ -150,10 +166,10 @@ export class XverseSigner extends CustomKeypair {
             throw new Error('Signature not found');
         }
 
-        return Buffer.from(res.signature, 'hex');
+        return fromHex(res.signature);
     }
 
-    public getPublicKey(): Buffer {
+    public getPublicKey(): PublicKey {
         if (!this.isInitialized) {
             throw new Error('UnisatSigner not initialized');
         }
@@ -161,15 +177,15 @@ export class XverseSigner extends CustomKeypair {
         return this.publicKey;
     }
 
-    public sign(_hash: Buffer, _lowR?: boolean): Buffer {
+    public sign(_hash: MessageHash, _lowR?: boolean): Signature {
         throw new Error('Not implemented: sign');
     }
 
-    public signSchnorr(_hash: Buffer): Buffer {
+    public signSchnorr(_hash: MessageHash): SchnorrSignature {
         throw new Error('Not implemented: signSchnorr');
     }
 
-    public verify(_hash: Buffer, _signature: Buffer): boolean {
+    public verify(_hash: MessageHash, _signature: Signature): boolean {
         throw new Error('Not implemented: verify');
     }
 
@@ -178,7 +194,7 @@ export class XverseSigner extends CustomKeypair {
         i: number,
         sighashTypes: number[],
     ): Promise<void> {
-        const input = transaction.data.inputs[i];
+        const input = transaction.data.inputs[i] as PsbtInput;
         if (
             input.tapKeySig ||
             input.finalScriptSig ||
@@ -197,7 +213,7 @@ export class XverseSigner extends CustomKeypair {
     }
 
     public async signInput(transaction: Psbt, i: number, sighashTypes: number[]): Promise<void> {
-        const input = transaction.data.inputs[i];
+        const input = transaction.data.inputs[i] as PsbtInput;
         if (
             input.tapKeySig ||
             input.finalScriptSig ||
@@ -243,7 +259,7 @@ export class XverseSigner extends CustomKeypair {
                             const tapInternalKey = input.tapInternalKey;
                             const xOnlyPubKey = toXOnly(this.publicKey);
 
-                            if (tapInternalKey.equals(xOnlyPubKey)) {
+                            if (equals(tapInternalKey, xOnlyPubKey)) {
                                 needsToSign = true;
                                 viaTaproot = true;
                             }
@@ -257,7 +273,7 @@ export class XverseSigner extends CustomKeypair {
                     if (needsToSign) {
                         return {
                             index: i,
-                            publicKey: this.publicKey.toString('hex'),
+                            publicKey: toHex(this.publicKey),
                             disableTweakSigner: !viaTaproot,
                         };
                     } else {
@@ -275,26 +291,26 @@ export class XverseSigner extends CustomKeypair {
         const toSignInputs: {
             [x: string]: number[];
         } = {
-            [this.p2wpkh]: options[0].toSignInputs?.map((input) => input.index) || [],
+            [this.p2wpkh]: (options[0] as PsbtSignatureOptions).toSignInputs?.map((input) => input.index) || [],
         };
 
         const callSign = await this.BitcoinProvider.request('signPsbt', {
-            psbt: toSignPsbts[0],
+            psbt: toSignPsbts[0] as string,
             signInputs: toSignInputs,
         });
 
         if ('error' in callSign) throw new Error(callSign.error.message);
 
-        const signedPsbts = Psbt.fromBase64(callSign.result.psbt);
+        const signedPsbts = Psbt.fromBase64((callSign.result as { psbt: string }).psbt);
 
-        transactions[0].combine(signedPsbts);
+        (transactions[0] as Psbt).combine(signedPsbts);
     }
 
     private hasAlreadySignedTapScriptSig(input: TapScriptSig[]): boolean {
         for (let i = 0; i < input.length; i++) {
-            const item = input[i];
-            const buf = Buffer.from(item.pubkey);
-            if (buf.equals(this.publicKey) && item.signature) {
+            const item = input[i] as TapScriptSig;
+            const buf = new Uint8Array(item.pubkey);
+            if (equals(buf, this.publicKey) && item.signature) {
                 return true;
             }
         }
@@ -304,9 +320,9 @@ export class XverseSigner extends CustomKeypair {
 
     private hasAlreadyPartialSig(input: PartialSig[]): boolean {
         for (let i = 0; i < input.length; i++) {
-            const item = input[i];
-            const buf = Buffer.from(item.pubkey);
-            if (buf.equals(this.publicKey) && item.signature) {
+            const item = input[i] as PartialSig;
+            const buf = new Uint8Array(item.pubkey);
+            if (equals(buf, this.publicKey) && item.signature) {
                 return true;
             }
         }
@@ -315,8 +331,8 @@ export class XverseSigner extends CustomKeypair {
     }
 
     private combine(transaction: Psbt, newPsbt: Psbt, i: number): void {
-        const signedInput = newPsbt.data.inputs[i];
-        const originalInput = transaction.data.inputs[i];
+        const signedInput = newPsbt.data.inputs[i] as PsbtInput;
+        const originalInput = transaction.data.inputs[i] as PsbtInput;
 
         if (signedInput.partialSig) {
             transaction.updateInput(i, { partialSig: signedInput.partialSig });
@@ -348,7 +364,7 @@ export class XverseSigner extends CustomKeypair {
         sighashTypes: number[],
         disableTweakSigner: boolean = false,
     ): Promise<Psbt> {
-        const pubKey = this.publicKey.toString('hex');
+        const pubKey = toHex(this.publicKey);
         const toSign = transaction.data.inputs.map((_, i) => {
             return [
                 {
@@ -380,7 +396,7 @@ export class XverseSigner extends CustomKeypair {
 
         if ('error' in callSign) throw new Error(callSign.error.message);
 
-        return Psbt.fromBase64(callSign.result.psbt);
+        return Psbt.fromBase64((callSign.result as { psbt: string }).psbt);
     }
 
     private getNonDuplicateScriptSig(
@@ -389,9 +405,10 @@ export class XverseSigner extends CustomKeypair {
     ): TapScriptSig[] {
         const nonDuplicate: TapScriptSig[] = [];
         for (let i = 0; i < scriptSig2.length; i++) {
-            const found = scriptSig1.find((item) => item.pubkey.equals(scriptSig2[i].pubkey));
+            const sig2 = scriptSig2[i] as TapScriptSig;
+            const found = scriptSig1.find((item) => equals(item.pubkey, sig2.pubkey));
             if (!found) {
-                nonDuplicate.push(scriptSig2[i]);
+                nonDuplicate.push(sig2);
             }
         }
 

package/src/transaction/browser/types/OPWallet.ts

@@ -1,5 +1,5 @@
-import { Unisat } from './Unisat.js';
-import { Web3Provider } from '../Web3Provider.js';
+import type { Unisat } from './Unisat.js';
+import type { Web3Provider } from '../Web3Provider.js';
 
 /**
  * OPWallet interface extending Unisat with ML-DSA (FIPS 204) support

package/src/transaction/browser/types/Unisat.ts

@@ -1,4 +1,4 @@
-import { Web3Provider } from '../Web3Provider.js';
+import type { Web3Provider } from '../Web3Provider.js';
 import { UnisatChainType, WalletNetworks } from '../WalletNetworks.js';
 
 export interface UnisatChainInfo {

package/src/transaction/builders/CancelTransaction.ts

@@ -1,10 +1,20 @@
 import { TransactionType } from '../enums/TransactionType.js';
-import { P2TRPayment, PaymentType, Psbt, PsbtInput, Taptree } from '@btc-vision/bitcoin';
+import {
+    type FinalScriptsFunc,
+    fromHex,
+    type P2TRPayment,
+    PaymentType,
+    Psbt,
+    type PsbtInput,
+    type TapScriptSig,
+    type Taptree,
+} from '@btc-vision/bitcoin';
 import { TransactionBuilder } from './TransactionBuilder.js';
-import { TapLeafScript } from '../interfaces/Tap.js';
-import { SharedInteractionParameters } from '../interfaces/ITransactionParameters.js';
-import { ICancelTransactionParameters } from '../interfaces/ICancelTransactionParameters.js';
+import type { TapLeafScript } from '../interfaces/Tap.js';
+import type { ICancelTransactionParameters } from '../interfaces/ICancelTransactionParameters.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
+import type { SharedInteractionParameters } from '../interfaces/ITransactionParameters.js';
+import { isUniversalSigner } from '../../signer/TweakedSigner.js';
 
 export class CancelTransaction extends TransactionBuilder<TransactionType.CANCEL> {
     public type: TransactionType.CANCEL = TransactionType.CANCEL;
@@ -12,12 +22,12 @@ export class CancelTransaction extends TransactionBuilder<TransactionType.CANCEL
     /**
      * The tap leaf script for spending
      */
-    protected tapLeafScript: TapLeafScript | null = null;
+    protected override tapLeafScript: TapLeafScript | null = null;
 
-    protected readonly compiledTargetScript: Buffer;
+    protected readonly compiledTargetScript: Uint8Array;
     protected readonly scriptTree: Taptree;
 
-    protected readonly contractSecret: Buffer;
+    protected readonly contractSecret: Uint8Array;
     protected leftOverFundsScriptRedeem: P2TRPayment | null = null;
 
     public constructor(parameters: ICancelTransactionParameters) {
@@ -29,12 +39,12 @@ export class CancelTransaction extends TransactionBuilder<TransactionType.CANCEL
             calldata: Buffer.alloc(0),
         } as unknown as SharedInteractionParameters);
 
-        this.contractSecret = Buffer.alloc(0);
+        this.contractSecret = new Uint8Array(0);
 
-        if (Buffer.isBuffer(parameters.compiledTargetScript)) {
+        if (parameters.compiledTargetScript instanceof Uint8Array) {
             this.compiledTargetScript = parameters.compiledTargetScript;
         } else {
-            this.compiledTargetScript = Buffer.from(parameters.compiledTargetScript, 'hex');
+            this.compiledTargetScript = fromHex(parameters.compiledTargetScript);
         }
 
         // Generate the minimal script tree needed for recovery
@@ -163,7 +173,7 @@ export class CancelTransaction extends TransactionBuilder<TransactionType.CANCEL
         }
 
         // For the simple lock script, we only need the signature
-        const scriptSolution = [input.tapScriptSig[0].signature];
+        const scriptSolution = [(input.tapScriptSig[0] as TapScriptSig).signature];
 
         const witness = scriptSolution
             .concat(this.tapLeafScript.script)
@@ -203,24 +213,49 @@ export class CancelTransaction extends TransactionBuilder<TransactionType.CANCEL
     }
 
     protected override async signInputsNonWalletBased(transaction: Psbt): Promise<void> {
-        for (let i = 0; i < transaction.data.inputs.length; i++) {
-            if (i === 0) {
+        // Input 0: always sequential (script-path with custom finalizer)
+        await this.signInput(transaction, transaction.data.inputs[0] as PsbtInput, 0, this.getSignerKey());
+        transaction.finalizeInput(0, this.customFinalizer.bind(this));
+
+        // Inputs 1+: parallel key-path if available, then sequential for remaining
+        let parallelSignedIndices = new Set<number>();
+
+        if (this.canUseParallelSigning && isUniversalSigner(this.signer)) {
+            try {
+                const result = await this.signKeyPathInputsParallel(
+                    transaction,
+                    new Set([0]),
+                );
+                if (result.success) {
+                    parallelSignedIndices = new Set(result.signatures.keys());
+                }
+            } catch (e) {
+                this.error(
+                    `Parallel signing failed, falling back to sequential: ${(e as Error).message}`,
+                );
+            }
+        }
+
+        for (let i = 1; i < transaction.data.inputs.length; i++) {
+            if (!parallelSignedIndices.has(i)) {
                 await this.signInput(
                     transaction,
-                    transaction.data.inputs[i],
+                    transaction.data.inputs[i] as PsbtInput,
                     i,
-                    this.getSignerKey(),
+                    this.signer,
                 );
+            }
+        }
 
-                transaction.finalizeInput(0, this.customFinalizer.bind(this));
-            } else {
-                await this.signInput(transaction, transaction.data.inputs[i], i, this.signer);
-
-                try {
-                    transaction.finalizeInput(i, this.customFinalizerP2SH.bind(this));
-                } catch (e) {
-                    transaction.finalizeInput(i);
-                }
+        // Finalize inputs 1+
+        for (let i = 1; i < transaction.data.inputs.length; i++) {
+            try {
+                transaction.finalizeInput(
+                    i,
+                    this.customFinalizerP2SH.bind(this) as FinalScriptsFunc,
+                );
+            } catch {
+                transaction.finalizeInput(i);
             }
         }
     }

package/src/transaction/builders/ChallengeSolutionTransaction.ts

@@ -1,7 +1,7 @@
 /*import { TransactionType } from '../enums/TransactionType.js';
 import { getFinalScripts, opcodes, Psbt, PsbtInput, script, Signer } from '@btc-vision/bitcoin';
 import { TransactionBuilder } from './TransactionBuilder.js';
-import { ECPairInterface } from 'ecpair';
+import { type UniversalSigner } from '@btc-vision/ecpair';
 
 export class ChallengeSolutionTransaction extends TransactionBuilder<TransactionType.CHALLENGE_SOLUTION> {
     public readonly type: TransactionType.CHALLENGE_SOLUTION = TransactionType.CHALLENGE_SOLUTION;
@@ -49,7 +49,7 @@ export class ChallengeSolutionTransaction extends TransactionBuilder<Transaction
         transaction: Psbt,
         input: PsbtInput,
         i: number,
-        signer: Signer | ECPairInterface,
+        signer: Signer | UniversalSigner,
         reverse: boolean = false,
         errored: boolean = false,
     ): Promise<void> {
@@ -81,7 +81,7 @@ export class ChallengeSolutionTransaction extends TransactionBuilder<Transaction
         return getFinalScripts(inputIndex, input, scriptA, isSegwit, isP2SH, isP2WSH, false);
     };
 
-    protected override getSignerKey(): Signer | ECPairInterface {
+    protected override getSignerKey(): Signer | UniversalSigner {
         return this.signer;
     }
 }*/