@btc-vision/transaction 1.1.2 → 1.1.3

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

@@ -23,15 +23,15 @@ export declare class UnisatSigner extends CustomKeypair {
     get unisat(): Unisat;
     init(): Promise<void>;
     getPublicKey(): Buffer;
-    sign(hash: Buffer, lowR?: boolean): Buffer;
-    signSchnorr(hash: Buffer): Buffer;
-    verify(hash: Buffer, signature: Buffer): boolean;
+    sign(_hash: Buffer, _lowR?: boolean): Buffer;
+    signSchnorr(_hash: Buffer): Buffer;
+    verify(_hash: Buffer, _signature: Buffer): boolean;
     signTaprootInput(transaction: Psbt, i: number, sighashTypes: number[]): Promise<void>;
     signInput(transaction: Psbt, i: number, sighashTypes: number[]): Promise<void>;
+    multiSignPsbt(transactions: Psbt[]): Promise<void>;
     private hasAlreadySignedTapScriptSig;
     private hasAlreadyPartialSig;
     private combine;
     private signAllTweaked;
-    private signTweaked;
     private getNonDuplicateScriptSig;
 }

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

@@ -62,7 +62,7 @@ export interface Unisat {
         rawtx: string;
     }): Promise<string>;
     signPsbt(psbtHex: string, psbtOptions: PsbtSignatureOptions): Promise<string>;
-    signPsbts(psbtHex: string[], psbtOptions: PsbtSignatureOptions): Promise<string[]>;
+    signPsbts(psbtHex: string[], psbtOptions: PsbtSignatureOptions[]): Promise<string[]>;
     pushPsbt(psbtHex: string): Promise<string>;
     on(event: 'accountsChanged', listener: (accounts: string[]) => void): void;
     on(event: 'chainChanged' | 'networkChanged', listener: (network: UnisatNetwork) => void): void;

package/browser/transaction/builders/DeploymentTransaction.d.ts

@@ -27,6 +27,7 @@ export declare class DeploymentTransaction extends TransactionBuilder<Transactio
     getRndBytes(): Buffer;
     protected contractSignerXOnlyPubKey(): Buffer;
     protected buildTransaction(): Promise<void>;
+    protected signInputsWalletBased(transaction: Psbt): Promise<void>;
     protected signInputs(transaction: Psbt): Promise<void>;
     protected generateScriptAddress(): Payment;
     protected generateTapData(): Payment;

package/browser/transaction/builders/SharedInteractionTransaction.d.ts

@@ -32,6 +32,8 @@ export declare abstract class SharedInteractionTransaction<T extends Transaction
     protected customFinalizer: (_inputIndex: number, input: PsbtInput) => {
         finalScriptWitness: Buffer;
     };
+    protected signInputsWalletBased(transaction: Psbt): Promise<void>;
+    private signInputsNonWalletBased;
     private getPubKeys;
     private generateRedeemScripts;
 }

package/browser/transaction/builders/TransactionBuilder.d.ts

@@ -5,6 +5,7 @@ import { IFundingTransactionParameters, ITransactionParameters } from '../interf
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { ECPairInterface } from 'ecpair';
 import { TweakedTransaction } from '../shared/TweakedTransaction.js';
+import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 export declare abstract class TransactionBuilder<T extends TransactionType> extends TweakedTransaction {
     static readonly LOCK_LEAF_SCRIPT: Buffer;
     static readonly MINIMUM_DUST: bigint;
@@ -19,7 +20,7 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     protected readonly outputs: PsbtOutputExtended[];
     protected feeOutput: PsbtOutputExtended | null;
     protected totalInputAmount: bigint;
-    protected readonly signer: Signer | ECPairInterface;
+    protected readonly signer: Signer | ECPairInterface | UnisatSigner;
     protected readonly network: Network;
     protected readonly feeRate: number;
     protected priorityFee: bigint;

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

@@ -4,8 +4,9 @@ import { ECPairInterface } from 'ecpair';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { ChainId } from '../../network/ChainId.js';
+import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 export interface ITweakedTransactionData {
-    readonly signer: Signer | ECPairInterface;
+    readonly signer: Signer | ECPairInterface | UnisatSigner;
     readonly network: Network;
     readonly chainId?: ChainId;
     readonly nonWitnessUtxo?: Buffer;
@@ -17,7 +18,7 @@ export declare enum TransactionSequence {
 export declare abstract class TweakedTransaction extends Logger {
     readonly logColor: string;
     finalized: boolean;
-    protected signer: Signer | ECPairInterface;
+    protected signer: Signer | ECPairInterface | UnisatSigner;
     protected tweakedSigner?: ECPairInterface;
     protected network: Network;
     protected signed: boolean;
@@ -47,7 +48,7 @@ export declare abstract class TweakedTransaction extends Logger {
     protected generateTapData(): Payment;
     protected generateScriptAddress(): Payment;
     protected getSignerKey(): Signer | ECPairInterface;
-    protected signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer | ECPairInterface): Promise<void>;
+    protected signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer | ECPairInterface, reverse?: boolean): Promise<void>;
     protected splitArray<T>(arr: T[], chunkSize: number): T[][];
     protected signInputs(transaction: Psbt): Promise<void>;
     protected internalPubKeyToXOnly(): Buffer;
@@ -64,6 +65,8 @@ export declare abstract class TweakedTransaction extends Logger {
         finalScriptSig: Buffer | undefined;
         finalScriptWitness: Buffer | undefined;
     };
+    protected signInputsWalletBased(transaction: Psbt): Promise<void>;
+    private attemptSignTaproot;
     private isTaprootScriptSpend;
     private isTaprootInput;
     private canSignNonTaprootInput;

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.1.2";
+export declare const version = "1.1.3";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.1.2';
+export const version = '1.1.3';

package/build/buffer/BinaryWriter.js

@@ -47,7 +47,6 @@ export class BinaryWriter {
         this.allocSafe(32);
         const bytesToHex = BufferHelper.valueToUint8Array(bigIntValue);
         if (bytesToHex.byteLength !== 32) {
-            console.log('Invalid u256 value:', bytesToHex);
             throw new Error(`Invalid u256 value: ${bigIntValue}`);
         }
         for (let i = 0; i < bytesToHex.byteLength; i++) {

package/build/transaction/browser/extensions/UnisatSigner.d.ts

@@ -23,15 +23,15 @@ export declare class UnisatSigner extends CustomKeypair {
     get unisat(): Unisat;
     init(): Promise<void>;
     getPublicKey(): Buffer;
-    sign(hash: Buffer, lowR?: boolean): Buffer;
-    signSchnorr(hash: Buffer): Buffer;
-    verify(hash: Buffer, signature: Buffer): boolean;
+    sign(_hash: Buffer, _lowR?: boolean): Buffer;
+    signSchnorr(_hash: Buffer): Buffer;
+    verify(_hash: Buffer, _signature: Buffer): boolean;
     signTaprootInput(transaction: Psbt, i: number, sighashTypes: number[]): Promise<void>;
     signInput(transaction: Psbt, i: number, sighashTypes: number[]): Promise<void>;
+    multiSignPsbt(transactions: Psbt[]): Promise<void>;
     private hasAlreadySignedTapScriptSig;
     private hasAlreadyPartialSig;
     private combine;
     private signAllTweaked;
-    private signTweaked;
     private getNonDuplicateScriptSig;
 }

package/build/transaction/browser/extensions/UnisatSigner.js

@@ -1,7 +1,8 @@
-import { networks, Psbt } from '@btc-vision/bitcoin';
+import { crypto as bitCrypto, networks, opcodes, Psbt, script as bitScript, } from '@btc-vision/bitcoin';
 import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
 import { CustomKeypair } from '../BrowserSignerBase.js';
 import { UnisatNetwork } from '../types/Unisat.js';
+import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
 export class UnisatSigner extends CustomKeypair {
     constructor() {
         super();
@@ -78,13 +79,13 @@ export class UnisatSigner extends CustomKeypair {
         }
         return this.publicKey;
     }
-    sign(hash, lowR) {
+    sign(_hash, _lowR) {
         throw new Error('Not implemented: sign');
     }
-    signSchnorr(hash) {
+    signSchnorr(_hash) {
         throw new Error('Not implemented: signSchnorr');
     }
-    verify(hash, signature) {
+    verify(_hash, _signature) {
         throw new Error('Not implemented: verify');
     }
     async signTaprootInput(transaction, i, sighashTypes) {
@@ -117,6 +118,63 @@ export class UnisatSigner extends CustomKeypair {
         const firstSignature = await this.signAllTweaked(transaction, sighashTypes, true);
         this.combine(transaction, firstSignature, i);
     }
+    async multiSignPsbt(transactions) {
+        const toSignPsbts = [];
+        const options = [];
+        for (const psbt of transactions) {
+            const hex = psbt.toHex();
+            toSignPsbts.push(hex);
+            const toSignInputs = psbt.data.inputs
+                .map((input, i) => {
+                let needsToSign = false;
+                let viaTaproot = false;
+                if (isTaprootInput(input)) {
+                    if (input.tapLeafScript && input.tapLeafScript.length > 0) {
+                        for (const tapLeafScript of input.tapLeafScript) {
+                            if (pubkeyInScript(this.publicKey, tapLeafScript.script)) {
+                                needsToSign = true;
+                                viaTaproot = false;
+                                break;
+                            }
+                        }
+                    }
+                    if (!needsToSign && input.tapInternalKey) {
+                        const tapInternalKey = input.tapInternalKey;
+                        const xOnlyPubKey = toXOnly(this.publicKey);
+                        if (tapInternalKey.equals(xOnlyPubKey)) {
+                            needsToSign = true;
+                            viaTaproot = true;
+                        }
+                    }
+                }
+                else {
+                    const script = getInputRelevantScript(input);
+                    if (script && pubkeyInScript(this.publicKey, script)) {
+                        needsToSign = true;
+                        viaTaproot = false;
+                    }
+                }
+                if (needsToSign) {
+                    return {
+                        index: i,
+                        publicKey: this.publicKey.toString('hex'),
+                        disableTweakSigner: !viaTaproot,
+                    };
+                }
+                else {
+                    return null;
+                }
+            })
+                .filter((v) => v !== null);
+            options.push({
+                autoFinalized: false,
+                toSignInputs: toSignInputs,
+            });
+        }
+        const signed = await this.unisat.signPsbt(toSignPsbts[0], options[0]);
+        const signedPsbts = Psbt.fromHex(signed);
+        transactions[0].combine(signedPsbts);
+    }
     hasAlreadySignedTapScriptSig(input) {
         for (let i = 0; i < input.length; i++) {
             const item = input[i];
@@ -179,22 +237,6 @@ export class UnisatSigner extends CustomKeypair {
         const signed = await this.unisat.signPsbt(psbt, opts);
         return Psbt.fromHex(signed);
     }
-    async signTweaked(transaction, i, sighashTypes, disableTweakSigner = false) {
-        const opts = {
-            autoFinalized: false,
-            toSignInputs: [
-                {
-                    index: i,
-                    publicKey: this.publicKey.toString('hex'),
-                    sighashTypes,
-                    disableTweakSigner: disableTweakSigner,
-                },
-            ],
-        };
-        const psbt = transaction.toHex();
-        const signed = await this.unisat.signPsbt(psbt, opts);
-        return Psbt.fromHex(signed);
-    }
     getNonDuplicateScriptSig(scriptSig1, scriptSig2) {
         const nonDuplicate = [];
         for (let i = 0; i < scriptSig2.length; i++) {
@@ -206,3 +248,44 @@ export class UnisatSigner extends CustomKeypair {
         return nonDuplicate;
     }
 }
+function isTaprootInput(input) {
+    if (input.tapInternalKey || input.tapKeySig || input.tapScriptSig || input.tapLeafScript) {
+        return true;
+    }
+    if (input.witnessUtxo) {
+        const script = input.witnessUtxo.script;
+        return script.length === 34 && script[0] === opcodes.OP_1 && script[1] === 0x20;
+    }
+    return false;
+}
+function getInputRelevantScript(input) {
+    if (input.redeemScript) {
+        return input.redeemScript;
+    }
+    if (input.witnessScript) {
+        return input.witnessScript;
+    }
+    if (input.witnessUtxo) {
+        return input.witnessUtxo.script;
+    }
+    if (input.nonWitnessUtxo) {
+        return null;
+    }
+    return null;
+}
+function pubkeyInScript(pubkey, script) {
+    return pubkeyPositionInScript(pubkey, script) !== -1;
+}
+function pubkeyPositionInScript(pubkey, script) {
+    const pubkeyHash = bitCrypto.hash160(pubkey);
+    const pubkeyXOnly = toXOnly(pubkey);
+    const decompiled = bitScript.decompile(script);
+    if (decompiled === null)
+        throw new Error('Unknown script error');
+    return decompiled.findIndex((element) => {
+        if (typeof element === 'number')
+            return false;
+        return (Buffer.isBuffer(element) &&
+            (element.equals(pubkey) || element.equals(pubkeyHash) || element.equals(pubkeyXOnly)));
+    });
+}

package/build/transaction/browser/types/Unisat.d.ts

@@ -62,7 +62,7 @@ export interface Unisat {
         rawtx: string;
     }): Promise<string>;
     signPsbt(psbtHex: string, psbtOptions: PsbtSignatureOptions): Promise<string>;
-    signPsbts(psbtHex: string[], psbtOptions: PsbtSignatureOptions): Promise<string[]>;
+    signPsbts(psbtHex: string[], psbtOptions: PsbtSignatureOptions[]): Promise<string[]>;
     pushPsbt(psbtHex: string): Promise<string>;
     on(event: 'accountsChanged', listener: (accounts: string[]) => void): void;
     on(event: 'chainChanged' | 'networkChanged', listener: (network: UnisatNetwork) => void): void;

package/build/transaction/builders/DeploymentTransaction.d.ts

@@ -27,6 +27,7 @@ export declare class DeploymentTransaction extends TransactionBuilder<Transactio
     getRndBytes(): Buffer;
     protected contractSignerXOnlyPubKey(): Buffer;
     protected buildTransaction(): Promise<void>;
+    protected signInputsWalletBased(transaction: Psbt): Promise<void>;
     protected signInputs(transaction: Psbt): Promise<void>;
     protected generateScriptAddress(): Payment;
     protected generateTapData(): Payment;

package/build/transaction/builders/DeploymentTransaction.js

@@ -95,11 +95,28 @@ export class DeploymentTransaction extends TransactionBuilder {
         });
         await this.addRefundOutput(amountSpent);
     }
+    async signInputsWalletBased(transaction) {
+        const signer = this.signer;
+        await this.signInput(transaction, transaction.data.inputs[0], 0, this.contractSigner);
+        await signer.multiSignPsbt([transaction]);
+        for (let i = 0; i < transaction.data.inputs.length; i++) {
+            if (i === 0) {
+                transaction.finalizeInput(i, this.customFinalizer);
+            }
+            else {
+                transaction.finalizeInput(i);
+            }
+        }
+    }
     async signInputs(transaction) {
         if (!this.contractSigner) {
             await super.signInputs(transaction);
             return;
         }
+        if ('multiSignPsbt' in this.signer) {
+            await this.signInputsWalletBased(transaction);
+            return;
+        }
         for (let i = 0; i < transaction.data.inputs.length; i++) {
             if (i === 0) {
                 transaction.signInput(0, this.contractSigner);

package/build/transaction/builders/SharedInteractionTransaction.d.ts

@@ -32,6 +32,8 @@ export declare abstract class SharedInteractionTransaction<T extends Transaction
     protected customFinalizer: (_inputIndex: number, input: PsbtInput) => {
         finalScriptWitness: Buffer;
     };
+    protected signInputsWalletBased(transaction: Psbt): Promise<void>;
+    private signInputsNonWalletBased;
     private getPubKeys;
     private generateRedeemScripts;
 }

package/build/transaction/builders/SharedInteractionTransaction.js

@@ -88,16 +88,11 @@ export class SharedInteractionTransaction extends TransactionBuilder {
             await super.signInputs(transaction);
             return;
         }
-        for (let i = 0; i < transaction.data.inputs.length; i++) {
-            if (i === 0) {
-                await this.signInput(transaction, transaction.data.inputs[i], i, this.scriptSigner);
-                await this.signInput(transaction, transaction.data.inputs[i], i, this.getSignerKey());
-                transaction.finalizeInput(i, this.customFinalizer);
-            }
-            else {
-                await this.signInput(transaction, transaction.data.inputs[i], i, this.getSignerKey());
-                transaction.finalizeInput(i);
-            }
+        if ('multiSignPsbt' in this.signer) {
+            await this.signInputsWalletBased(transaction);
+        }
+        else {
+            await this.signInputsNonWalletBased(transaction);
         }
     }
     generateScriptAddress() {
@@ -151,6 +146,32 @@ export class SharedInteractionTransaction extends TransactionBuilder {
             },
         ];
     }
+    async signInputsWalletBased(transaction) {
+        const signer = this.signer;
+        await this.signInput(transaction, transaction.data.inputs[0], 0, this.scriptSigner);
+        await signer.multiSignPsbt([transaction]);
+        for (let i = 0; i < transaction.data.inputs.length; i++) {
+            if (i === 0) {
+                transaction.finalizeInput(i, this.customFinalizer);
+            }
+            else {
+                transaction.finalizeInput(i);
+            }
+        }
+    }
+    async signInputsNonWalletBased(transaction) {
+        for (let i = 0; i < transaction.data.inputs.length; i++) {
+            if (i === 0) {
+                await this.signInput(transaction, transaction.data.inputs[i], i, this.scriptSigner);
+                await this.signInput(transaction, transaction.data.inputs[i], i, this.getSignerKey());
+                transaction.finalizeInput(i, this.customFinalizer);
+            }
+            else {
+                await this.signInput(transaction, transaction.data.inputs[i], i, this.getSignerKey());
+                transaction.finalizeInput(i);
+            }
+        }
+    }
     getPubKeys() {
         const pubkeys = [Buffer.from(this.signer.publicKey)];
         if (this.scriptSigner) {

package/build/transaction/builders/TransactionBuilder.d.ts

@@ -5,6 +5,7 @@ import { IFundingTransactionParameters, ITransactionParameters } from '../interf
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { ECPairInterface } from 'ecpair';
 import { TweakedTransaction } from '../shared/TweakedTransaction.js';
+import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 export declare abstract class TransactionBuilder<T extends TransactionType> extends TweakedTransaction {
     static readonly LOCK_LEAF_SCRIPT: Buffer;
     static readonly MINIMUM_DUST: bigint;
@@ -19,7 +20,7 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     protected readonly outputs: PsbtOutputExtended[];
     protected feeOutput: PsbtOutputExtended | null;
     protected totalInputAmount: bigint;
-    protected readonly signer: Signer | ECPairInterface;
+    protected readonly signer: Signer | ECPairInterface | UnisatSigner;
     protected readonly network: Network;
     protected readonly feeRate: number;
     protected priorityFee: bigint;

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

@@ -4,8 +4,9 @@ import { ECPairInterface } from 'ecpair';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { ChainId } from '../../network/ChainId.js';
+import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 export interface ITweakedTransactionData {
-    readonly signer: Signer | ECPairInterface;
+    readonly signer: Signer | ECPairInterface | UnisatSigner;
     readonly network: Network;
     readonly chainId?: ChainId;
     readonly nonWitnessUtxo?: Buffer;
@@ -17,7 +18,7 @@ export declare enum TransactionSequence {
 export declare abstract class TweakedTransaction extends Logger {
     readonly logColor: string;
     finalized: boolean;
-    protected signer: Signer | ECPairInterface;
+    protected signer: Signer | ECPairInterface | UnisatSigner;
     protected tweakedSigner?: ECPairInterface;
     protected network: Network;
     protected signed: boolean;
@@ -47,7 +48,7 @@ export declare abstract class TweakedTransaction extends Logger {
     protected generateTapData(): Payment;
     protected generateScriptAddress(): Payment;
     protected getSignerKey(): Signer | ECPairInterface;
-    protected signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer | ECPairInterface): Promise<void>;
+    protected signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer | ECPairInterface, reverse?: boolean): Promise<void>;
     protected splitArray<T>(arr: T[], chunkSize: number): T[][];
     protected signInputs(transaction: Psbt): Promise<void>;
     protected internalPubKeyToXOnly(): Buffer;
@@ -64,6 +65,8 @@ export declare abstract class TweakedTransaction extends Logger {
         finalScriptSig: Buffer | undefined;
         finalScriptWitness: Buffer | undefined;
     };
+    protected signInputsWalletBased(transaction: Psbt): Promise<void>;
+    private attemptSignTaproot;
     private isTaprootScriptSpend;
     private isTaprootInput;
     private canSignNonTaprootInput;

package/build/transaction/shared/TweakedTransaction.js

@@ -154,47 +154,24 @@ export class TweakedTransaction extends Logger {
     getSignerKey() {
         return this.signer;
     }
-    async signInput(transaction, input, i, signer) {
+    async signInput(transaction, input, i, signer, reverse = false) {
         const publicKey = signer.publicKey;
-        const isTaproot = this.isTaprootInput(input);
+        let isTaproot = this.isTaprootInput(input);
+        if (reverse) {
+            isTaproot = !isTaproot;
+        }
         let signed = false;
         if (isTaproot) {
-            const isScriptSpend = this.isTaprootScriptSpend(input, publicKey);
-            if (isScriptSpend) {
-                try {
-                    await this.signTaprootInput(signer, transaction, i);
-                    signed = true;
-                }
-                catch (e) {
-                    this.error(`Failed to sign Taproot script path input ${i}: ${e}`);
-                }
+            try {
+                await this.attemptSignTaproot(transaction, input, i, signer, publicKey);
+                signed = true;
             }
-            else {
-                let tweakedSigner;
-                if (signer !== this.signer) {
-                    tweakedSigner = this.getTweakedSigner(true, signer);
-                }
-                else {
-                    if (!this.tweakedSigner)
-                        this.tweakSigner();
-                    tweakedSigner = this.tweakedSigner;
-                }
-                if (tweakedSigner) {
-                    try {
-                        await this.signTaprootInput(tweakedSigner, transaction, i);
-                        signed = true;
-                    }
-                    catch (e) {
-                        this.error(`Failed to sign Taproot key path input ${i}: ${e}`);
-                    }
-                }
-                else {
-                    this.error(`Failed to obtain tweaked signer for input ${i}.`);
-                }
+            catch (e) {
+                this.error(`Failed to sign Taproot script path input ${i}: ${e}`);
             }
         }
         else {
-            if (this.canSignNonTaprootInput(input, publicKey)) {
+            if (!reverse ? this.canSignNonTaprootInput(input, publicKey) : true) {
                 try {
                     await this.signNonTaprootInput(signer, transaction, i);
                     signed = true;
@@ -205,7 +182,12 @@ export class TweakedTransaction extends Logger {
             }
         }
         if (!signed) {
-            throw new Error(`Cannot sign input ${i} with the provided signer.`);
+            try {
+                await this.signInput(transaction, input, i, signer, true);
+            }
+            catch {
+                throw new Error(`Cannot sign input ${i} with the provided signer.`);
+            }
         }
     }
     splitArray(arr, chunkSize) {
@@ -219,6 +201,10 @@ export class TweakedTransaction extends Logger {
         return result;
     }
     async signInputs(transaction) {
+        if ('multiSignPsbt' in this.signer) {
+            await this.signInputsWalletBased(transaction);
+            return;
+        }
         const txs = transaction.data.inputs;
         const batchSize = 20;
         const batches = this.splitArray(txs, batchSize);
@@ -238,14 +224,10 @@ export class TweakedTransaction extends Logger {
             }
             await Promise.all(promises);
         }
-        transaction.finalizeInput(0, this.customFinalizerP2SH);
-        try {
-            transaction.finalizeAllInputs();
-            this.finalized = true;
-        }
-        catch (e) {
-            this.finalized = false;
+        for (let i = 0; i < transaction.data.inputs.length; i++) {
+            transaction.finalizeInput(i, this.customFinalizerP2SH);
         }
+        this.finalized = true;
     }
     internalPubKeyToXOnly() {
         return toXOnly(Buffer.from(this.signer.publicKey));
@@ -373,6 +355,37 @@ export class TweakedTransaction extends Logger {
         }
         return input;
     }
+    async signInputsWalletBased(transaction) {
+        const signer = this.signer;
+        await signer.multiSignPsbt([transaction]);
+        for (let i = 0; i < transaction.data.inputs.length; i++) {
+            transaction.finalizeInput(i, this.customFinalizerP2SH);
+        }
+        this.finalized = true;
+    }
+    async attemptSignTaproot(transaction, input, i, signer, publicKey) {
+        const isScriptSpend = this.isTaprootScriptSpend(input, publicKey);
+        if (isScriptSpend) {
+            await this.signTaprootInput(signer, transaction, i);
+        }
+        else {
+            let tweakedSigner;
+            if (signer !== this.signer) {
+                tweakedSigner = this.getTweakedSigner(true, signer);
+            }
+            else {
+                if (!this.tweakedSigner)
+                    this.tweakSigner();
+                tweakedSigner = this.tweakedSigner;
+            }
+            if (tweakedSigner) {
+                await this.signTaprootInput(tweakedSigner, transaction, i);
+            }
+            else {
+                this.error(`Failed to obtain tweaked signer for input ${i}.`);
+            }
+        }
+    }
     isTaprootScriptSpend(input, publicKey) {
         if (input.tapLeafScript && input.tapLeafScript.length > 0) {
             for (const tapLeafScript of input.tapLeafScript) {
@@ -432,7 +445,12 @@ export class TweakedTransaction extends Logger {
     }
     async signTaprootInput(signer, transaction, i, tapLeafHash) {
         if ('signTaprootInput' in signer) {
-            await signer.signTaprootInput(transaction, i, tapLeafHash);
+            try {
+                await signer.signTaprootInput(transaction, i, tapLeafHash);
+            }
+            catch {
+                throw new Error('Failed to sign Taproot input with provided signer.');
+            }
         }
         else {
             transaction.signTaprootInput(i, signer);

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.1.2",
+    "version": "1.1.3",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.1.2';
+export const version = '1.1.3';

package/src/buffer/BinaryWriter.ts

@@ -63,8 +63,6 @@ export class BinaryWriter {
 
         const bytesToHex = BufferHelper.valueToUint8Array(bigIntValue);
         if (bytesToHex.byteLength !== 32) {
-            console.log('Invalid u256 value:', bytesToHex);
-
             throw new Error(`Invalid u256 value: ${bigIntValue}`);
         }