@btc-vision/transaction 1.0.85 → 1.0.86

package/build/tests/writers/approve.js

@@ -0,0 +1,11 @@
+import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+const abiCoder = new ABICoder();
+const approveSelector = Number(`0x` + abiCoder.encodeSelector('approve'));
+export const MAX_UINT256 = 2n ** 256n - 1n;
+export function approve(spender, amount = MAX_UINT256) {
+    const calldata = new BinaryWriter();
+    calldata.writeSelector(approveSelector);
+    calldata.writeAddress(spender);
+    calldata.writeU256(amount);
+    return Buffer.from(calldata.getBuffer());
+}

package/build/transaction/TransactionBuilder.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="node" />
+import { Logger } from '@btc-vision/bsi-common';
+import { Network, Payment, Psbt, Signer, Transaction } from 'bitcoinjs-lib';
+import { PsbtInputExtended, PsbtOutputExtended, UpdateInput } from './interfaces/Tap.js';
+import { TransactionType } from './enums/TransactionType.js';
+import { ITransactionParameters } from './interfaces/ITransactionParameters.js';
+import { Address } from '@btc-vision/bsi-binary';
+import { UTXO } from '../utxo/interfaces/IUTXO.js';
+export declare abstract class TransactionBuilder<T extends TransactionType> extends Logger {
+    protected static readonly LOCK_LEAF_SCRIPT: Buffer;
+    protected static readonly MINIMUM_DUST: bigint;
+    abstract readonly type: T;
+    readonly logColor: string;
+    transactionFee: bigint;
+    protected readonly transaction: Psbt;
+    protected readonly inputs: PsbtInputExtended[];
+    protected readonly updateInputs: UpdateInput[];
+    protected readonly outputs: PsbtOutputExtended[];
+    protected feeOutput: PsbtOutputExtended | null;
+    protected signed: boolean;
+    protected tapData: Payment | null;
+    protected scriptData: Payment | null;
+    protected totalInputAmount: bigint;
+    protected readonly signer: Signer;
+    protected readonly network: Network;
+    protected readonly feeRate: number;
+    protected readonly priorityFee: bigint;
+    protected readonly utxos: UTXO[];
+    protected to: Address | null;
+    private _maximumFeeRate;
+    protected constructor(parameters: ITransactionParameters);
+    setDestinationAddress(address: Address): void;
+    setMaximumFeeRate(feeRate: number): void;
+    signTransaction(): string | null;
+    getTransaction(): Transaction;
+    getScriptAddress(): string;
+    getTapAddress(): string;
+    addInput(input: PsbtInputExtended): void;
+    addOutput(output: PsbtOutputExtended): void;
+    protected calculateTotalUTXOAmount(): bigint;
+    protected calculateTotalVOutAmount(): bigint;
+    protected addInputsFromUTXO(): void;
+    protected witnessStackToScriptWitness(witness: Buffer[]): Buffer;
+    protected internalInit(): void;
+    protected abstract buildTransaction(to?: Address): void;
+    protected generateScriptAddress(): Payment;
+    protected generateTapData(): Payment;
+    protected updateInput(input: UpdateInput): void;
+    protected getWitness(): Buffer;
+    protected getTapOutput(): Buffer;
+    protected getInputs(): PsbtInputExtended[];
+    protected getOutputs(): PsbtOutputExtended[];
+    protected verifyUTXOValidity(): void;
+    protected setFeeOutput(output: PsbtOutputExtended): void;
+    protected abstract getSignerKey(): Signer;
+    protected internalPubKeyToXOnly(): Buffer;
+    protected signInputs(transaction: Psbt): void;
+    private internalBuildTransaction;
+    private estimateTransactionFees;
+}

package/build/transaction/TransactionBuilder.js

@@ -0,0 +1,244 @@
+import { Logger } from '@btc-vision/bsi-common';
+import { initEccLib, opcodes, payments, Psbt, script, } from 'bitcoinjs-lib';
+import { varuint } from 'bitcoinjs-lib/src/bufferutils.js';
+import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
+import * as ecc from 'tiny-secp256k1';
+import { EcKeyPair } from '../keypair/EcKeyPair.js';
+initEccLib(ecc);
+export class TransactionBuilder extends Logger {
+    static LOCK_LEAF_SCRIPT = script.compile([opcodes.OP_0]);
+    static MINIMUM_DUST = 330n;
+    logColor = '#785def';
+    transactionFee = 0n;
+    transaction;
+    inputs = [];
+    updateInputs = [];
+    outputs = [];
+    feeOutput = null;
+    signed = false;
+    tapData = null;
+    scriptData = null;
+    totalInputAmount;
+    signer;
+    network;
+    feeRate;
+    priorityFee;
+    utxos;
+    to = null;
+    _maximumFeeRate = 1000000;
+    constructor(parameters) {
+        super();
+        this.signer = parameters.signer;
+        this.network = parameters.network;
+        this.feeRate = parameters.feeRate;
+        this.priorityFee = parameters.priorityFee;
+        this.utxos = parameters.utxos;
+        this.to = parameters.to;
+        this.totalInputAmount = this.calculateTotalUTXOAmount();
+        const totalVOut = this.calculateTotalVOutAmount();
+        if (totalVOut < this.totalInputAmount) {
+            throw new Error(`Vout value is less than the value to send`);
+        }
+        if (this.totalInputAmount < TransactionBuilder.MINIMUM_DUST) {
+            throw new Error(`Value is less than the minimum dust`);
+        }
+        this.transaction = new Psbt({
+            network: this.network,
+        });
+    }
+    setDestinationAddress(address) {
+        this.to = address;
+    }
+    setMaximumFeeRate(feeRate) {
+        this._maximumFeeRate = feeRate;
+    }
+    signTransaction() {
+        if (!this.to)
+            throw new Error('Transaction must have a recipient');
+        if (!EcKeyPair.verifyContractAddress(this.to, this.network)) {
+            throw new Error('Invalid contract address. The contract address must be a taproot address.');
+        }
+        if (this.signed)
+            throw new Error('Transaction is already signed');
+        this.signed = true;
+        this.buildTransaction(this.to);
+        const builtTx = this.internalBuildTransaction(this.transaction);
+        if (builtTx) {
+            return this.transaction.extractTransaction(false).toHex();
+        }
+        throw new Error('Could not sign transaction');
+    }
+    getTransaction() {
+        return this.transaction.extractTransaction(false);
+    }
+    getScriptAddress() {
+        if (!this.scriptData || !this.scriptData.address) {
+            throw new Error('Tap data is required');
+        }
+        return this.scriptData.address;
+    }
+    getTapAddress() {
+        if (!this.tapData || !this.tapData.address) {
+            throw new Error('Tap data is required');
+        }
+        return this.tapData.address;
+    }
+    addInput(input) {
+        this.inputs.push(input);
+    }
+    addOutput(output) {
+        this.outputs.push(output);
+    }
+    calculateTotalUTXOAmount() {
+        let total = 0n;
+        for (let utxo of this.utxos) {
+            total += utxo.value;
+        }
+        return total;
+    }
+    calculateTotalVOutAmount() {
+        let total = 0n;
+        for (let utxo of this.utxos) {
+            total += utxo.value;
+        }
+        return total;
+    }
+    addInputsFromUTXO() {
+        for (let utxo of this.utxos) {
+            const input = {
+                hash: utxo.transactionId,
+                index: utxo.outputIndex,
+                witnessUtxo: {
+                    value: Number(utxo.value),
+                    script: Buffer.from(utxo.scriptPubKey.hex, 'hex'),
+                },
+            };
+            this.addInput(input);
+        }
+    }
+    witnessStackToScriptWitness(witness) {
+        let buffer = Buffer.allocUnsafe(0);
+        function writeSlice(slice) {
+            buffer = Buffer.concat([buffer, Buffer.from(slice)]);
+        }
+        function writeVarInt(i) {
+            const currentLen = buffer.length;
+            const varintLen = varuint.encodingLength(i);
+            buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]);
+            varuint.encode(i, buffer, currentLen);
+        }
+        function writeVarSlice(slice) {
+            writeVarInt(slice.length);
+            writeSlice(slice);
+        }
+        function writeVector(vector) {
+            writeVarInt(vector.length);
+            vector.forEach(writeVarSlice);
+        }
+        writeVector(witness);
+        return buffer;
+    }
+    internalInit() {
+        this.verifyUTXOValidity();
+        this.scriptData = payments.p2tr(this.generateScriptAddress());
+        this.tapData = payments.p2tr(this.generateTapData());
+    }
+    generateScriptAddress() {
+        return {
+            internalPubkey: this.internalPubKeyToXOnly(),
+            network: this.network,
+        };
+    }
+    generateTapData() {
+        return {
+            internalPubkey: this.internalPubKeyToXOnly(),
+            network: this.network,
+        };
+    }
+    updateInput(input) {
+        this.updateInputs.push(input);
+    }
+    getWitness() {
+        if (!this.tapData || !this.tapData.witness) {
+            throw new Error('Witness is required');
+        }
+        if (this.tapData.witness.length === 0) {
+            throw new Error('Witness is empty');
+        }
+        return this.tapData.witness[this.tapData.witness.length - 1];
+    }
+    getTapOutput() {
+        if (!this.tapData || !this.tapData.output) {
+            throw new Error('Tap data is required');
+        }
+        return this.tapData.output;
+    }
+    getInputs() {
+        return this.inputs;
+    }
+    getOutputs() {
+        if (!this.feeOutput)
+            throw new Error('Fee output is required');
+        const outputs = [...this.outputs];
+        outputs.push(this.feeOutput);
+        return outputs;
+    }
+    verifyUTXOValidity() {
+        for (let utxo of this.utxos) {
+            if (!utxo.scriptPubKey) {
+                throw new Error('Address is required');
+            }
+        }
+    }
+    setFeeOutput(output) {
+        this.feeOutput = output;
+        const fee = this.estimateTransactionFees();
+        if (fee > BigInt(output.value)) {
+            throw new Error('Insufficient funds');
+        }
+        this.feeOutput.value = this.feeOutput.value - Number(fee);
+    }
+    internalPubKeyToXOnly() {
+        return toXOnly(this.signer.publicKey);
+    }
+    signInputs(transaction) {
+        transaction.signAllInputs(this.getSignerKey());
+        transaction.finalizeAllInputs();
+    }
+    internalBuildTransaction(transaction) {
+        const inputs = this.getInputs();
+        const outputs = this.getOutputs();
+        transaction.setMaximumFeeRate(this._maximumFeeRate);
+        transaction.addInputs(inputs);
+        for (let i = 0; i < this.updateInputs.length; i++) {
+            transaction.updateInput(i, this.updateInputs[i]);
+        }
+        transaction.addOutputs(outputs);
+        try {
+            this.signInputs(transaction);
+            this.transactionFee = BigInt(transaction.getFee());
+            return true;
+        }
+        catch (e) {
+            const err = e;
+            this.error(`[internalBuildTransaction] Something went wrong while getting building the transaction: ${err.stack}`);
+        }
+        return false;
+    }
+    estimateTransactionFees() {
+        const fakeTx = new Psbt({
+            network: this.network,
+        });
+        const builtTx = this.internalBuildTransaction(fakeTx);
+        if (builtTx) {
+            const tx = fakeTx.extractTransaction(false);
+            const size = tx.virtualSize();
+            const fee = this.feeRate * size + 1;
+            this.log(`Transaction fee estimated to: ${fee} - ${fakeTx.getFeeRate()}`);
+            return BigInt(Math.ceil(fee));
+        }
+        else {
+            throw new Error(`Could not build transaction to estimate fee. Something went wrong while building the transaction.`);
+        }
+    }
+}

package/build/transaction/browser/BrowserSigner.d.ts

@@ -0,0 +1,11 @@
+import { Psbt, Transaction } from 'bitcoinjs-lib';
+import { Unisat } from './types/Unisat.js';
+declare global {
+    interface Window {
+        unisat?: Unisat;
+    }
+}
+export declare abstract class BrowserSigner {
+    signTransaction(transaction: Psbt): Promise<Transaction>;
+    generateSigner(): Promise<void>;
+}

package/build/transaction/browser/BrowserSigner.js

@@ -0,0 +1,10 @@
+export class BrowserSigner {
+    async signTransaction(transaction) {
+        if (!window) {
+            throw new Error('BrowserSigner can only be used in a browser environment');
+        }
+        throw new Error('Not implemented');
+    }
+    async generateSigner() {
+    }
+}

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

@@ -0,0 +1,54 @@
+import { Address } from '@btc-vision/bsi-binary';
+export declare enum UnisatNetwork {
+    testnet = "testnet",
+    mainnet = "livenet",
+    regtest = "regtest"
+}
+export interface Balance {
+    readonly confirmed: number;
+    readonly unconfirmed: number;
+    readonly total: number;
+}
+export declare enum MessageType {
+    ecdsa = "ecdsa",
+    bip322 = "bip322-simple"
+}
+interface ToSignInputBase {
+    readonly index: number;
+    readonly sighashTypes?: number[];
+    readonly disableTweakSigner?: boolean;
+}
+export interface ToSignInputPublicKey extends ToSignInputBase {
+    readonly publicKey: string;
+}
+export interface ToSignInputAddress extends ToSignInputBase {
+    readonly address: Address;
+}
+export type ToSignInput = ToSignInputPublicKey | ToSignInputAddress;
+export interface PsbtSignatureOptions {
+    readonly autoFinalized?: boolean;
+    readonly toSignInputs?: ToSignInput[];
+}
+export interface Unisat {
+    sendBitcoin(toAddress: Address, satoshis: number, options: {
+        feeRate: number;
+    }): Promise<string>;
+    requestAccounts(): Promise<string[]>;
+    getNetwork(): Promise<UnisatNetwork>;
+    getAccounts(): Promise<string[]>;
+    switchNetwork(network: UnisatNetwork): Promise<void>;
+    getPublicKey(): Promise<string>;
+    getBalance(): Promise<Balance>;
+    signMessage(message: string, type?: MessageType): Promise<string>;
+    pushTx(options: {
+        rawtx: string;
+    }): Promise<string>;
+    signPsbt(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: 'networkChanged', listener: (network: UnisatNetwork) => void): void;
+    removeListener(event: 'accountsChanged', listener: (accounts: string[]) => void): void;
+    removeListener(event: 'networkChanged', listener: (network: UnisatNetwork) => void): void;
+}
+export {};

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

@@ -0,0 +1,11 @@
+export var UnisatNetwork;
+(function (UnisatNetwork) {
+    UnisatNetwork["testnet"] = "testnet";
+    UnisatNetwork["mainnet"] = "livenet";
+    UnisatNetwork["regtest"] = "regtest";
+})(UnisatNetwork || (UnisatNetwork = {}));
+export var MessageType;
+(function (MessageType) {
+    MessageType["ecdsa"] = "ecdsa";
+    MessageType["bip322"] = "bip322-simple";
+})(MessageType || (MessageType = {}));

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

@@ -0,0 +1,11 @@
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { TransactionType } from '../enums/TransactionType.js';
+import { IFundingTransactionParameters } from '../interfaces/ITransactionParameters.js';
+import { Signer } from 'bitcoinjs-lib';
+export declare class FundingTransaction extends TransactionBuilder<TransactionType.FUNDING> {
+    readonly type: TransactionType.FUNDING;
+    protected childTransactionRequiredFees: bigint;
+    constructor(parameters: IFundingTransactionParameters);
+    protected buildTransaction(): void;
+    protected getSignerKey(): Signer;
+}

package/build/transaction/builders/GenericTransaction.js

@@ -0,0 +1,23 @@
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { TransactionType } from '../enums/TransactionType.js';
+export class FundingTransaction extends TransactionBuilder {
+    type = TransactionType.FUNDING;
+    childTransactionRequiredFees;
+    constructor(parameters) {
+        super(parameters);
+        this.childTransactionRequiredFees = parameters.childTransactionRequiredFees;
+        this.internalInit();
+    }
+    buildTransaction() {
+        this.addInputsFromUTXO();
+        const amountSpent = this.getTransactionOPNetFee() + this.childTransactionRequiredFees;
+        this.setFeeOutput({
+            value: Number(amountSpent),
+            address: this.to,
+        });
+        this.addRefundOutput(amountSpent);
+    }
+    getSignerKey() {
+        return this.signer;
+    }
+}

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

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+import { Taptree } from 'bitcoinjs-lib/src/types.js';
+import { TransactionType } from '../enums/TransactionType.js';
+import { IUnwrapParameters } from '../interfaces/ITransactionParameters.js';
+import { SharedInteractionTransaction } from './SharedInteractionTransaction.js';
+import bitcoin, { Payment, Psbt } from 'bitcoinjs-lib';
+import { VaultUTXOs } from '../processor/PsbtTransaction.js';
+import { PsbtInput } from 'bip174/src/lib/interfaces.js';
+export declare class TapUnwrapTransaction extends SharedInteractionTransaction<TransactionType.WBTC_UNWRAP> {
+    private static readonly UNWRAP_SELECTOR;
+    type: TransactionType.WBTC_UNWRAP;
+    readonly amount: bigint;
+    protected readonly compiledTargetScript: Buffer;
+    protected readonly scriptTree: Taptree;
+    protected sighashTypes: number[];
+    protected readonly contractSecret: Buffer;
+    protected readonly vaultUTXOs: VaultUTXOs[];
+    private readonly wbtc;
+    private readonly calculatedSignHash;
+    constructor(parameters: IUnwrapParameters);
+    static generateBurnCalldata(amount: bigint): Buffer;
+    signPSBT(): Psbt;
+    mergeVaults(input: VaultUTXOs[]): void;
+    protected internalPubKeyToXOnly(): Buffer;
+    protected generateTapDataForInput(pubkeys: Buffer[], minimumSignatures: number): {
+        internalPubkey: Buffer;
+        network: bitcoin.Network;
+        scriptTree: Taptree;
+        redeem: Payment;
+    };
+    protected getScriptSolution(input: PsbtInput): Buffer[];
+    protected internalBuildTransaction(transaction: Psbt): boolean;
+    private addVaultUTXO;
+    private addVaultInputs;
+    private calculateOutputLeftAmountFromVaults;
+    private getVaultTotalOutputAmount;
+}

package/build/transaction/builders/TapUnwarpTransaction.js

@@ -0,0 +1,201 @@
+import { TransactionType } from '../enums/TransactionType.js';
+import { SharedInteractionTransaction } from './SharedInteractionTransaction.js';
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+import { wBTC } from '../../metadata/contracts/wBTC.js';
+import { payments } from 'bitcoinjs-lib';
+import { EcKeyPair } from '../../keypair/EcKeyPair.js';
+import { PsbtTransaction } from '../processor/PsbtTransaction.js';
+import { MultiSignGenerator } from '../../generators/builders/MultiSignGenerator.js';
+import { MultiSignTransaction } from './MultiSignTransaction.js';
+import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
+import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
+const abiCoder = new ABICoder();
+const numsPoint = Buffer.from('50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0', 'hex');
+export class TapUnwrapTransaction extends SharedInteractionTransaction {
+    static UNWRAP_SELECTOR = Number('0x' + abiCoder.encodeSelector('burn'));
+    type = TransactionType.WBTC_UNWRAP;
+    amount;
+    compiledTargetScript;
+    scriptTree;
+    sighashTypes = [];
+    contractSecret;
+    vaultUTXOs;
+    wbtc;
+    calculatedSignHash = PsbtTransaction.calculateSignHash(this.sighashTypes);
+    constructor(parameters) {
+        if (parameters.amount < TransactionBuilder.MINIMUM_DUST) {
+            throw new Error('Amount is below dust limit');
+        }
+        parameters.disableAutoRefund = true;
+        parameters.calldata = TapUnwrapTransaction.generateBurnCalldata(parameters.amount);
+        super(parameters);
+        this.wbtc = new wBTC(parameters.network);
+        this.to = this.wbtc.getAddress();
+        this.vaultUTXOs = parameters.unwrapUTXOs;
+        this.amount = parameters.amount;
+        this.contractSecret = this.generateSecret();
+        this.calldataGenerator = new CalldataGenerator(toXOnly(this.signer.publicKey), this.scriptSignerXOnlyPubKey(), this.network);
+        this.compiledTargetScript = this.calldataGenerator.compile(this.calldata, this.contractSecret);
+        this.scriptTree = this.getScriptTree();
+        this.internalInit();
+    }
+    static generateBurnCalldata(amount) {
+        if (!amount)
+            throw new Error('Amount is required');
+        const bufWriter = new BinaryWriter();
+        bufWriter.writeSelector(TapUnwrapTransaction.UNWRAP_SELECTOR);
+        bufWriter.writeU256(amount);
+        return Buffer.from(bufWriter.getBuffer());
+    }
+    signPSBT() {
+        if (this.to && !EcKeyPair.verifyContractAddress(this.to, this.network)) {
+            throw new Error('Invalid contract address. The contract address must be a taproot address.');
+        }
+        if (!this.vaultUTXOs.length) {
+            throw new Error('No vault UTXOs provided');
+        }
+        this.buildTransaction();
+        this.ignoreSignatureError();
+        this.mergeVaults(this.vaultUTXOs);
+        const builtTx = this.internalBuildTransaction(this.transaction);
+        if (builtTx) {
+            return this.transaction;
+        }
+        throw new Error('Could not sign transaction');
+    }
+    mergeVaults(input) {
+        const firstVault = input[0];
+        if (!firstVault) {
+            throw new Error('No vaults provided');
+        }
+        const outputLeftAmount = this.calculateOutputLeftAmountFromVaults(input);
+        if (outputLeftAmount < 0) {
+            throw new Error(`Output left amount is negative ${outputLeftAmount} for vault ${firstVault.vault}`);
+        }
+        this.addOutput({
+            address: firstVault.vault,
+            value: Number(outputLeftAmount),
+        });
+        this.addOutput({
+            address: this.from,
+            value: Number(this.amount),
+        });
+        for (const vault of input) {
+            this.addVaultInputs(vault);
+        }
+    }
+    internalPubKeyToXOnly() {
+        return toXOnly(numsPoint);
+    }
+    generateTapDataForInput(pubkeys, minimumSignatures) {
+        const compiledTargetScript = MultiSignGenerator.compile(pubkeys, minimumSignatures);
+        const scriptTree = [
+            {
+                output: compiledTargetScript,
+                version: 192,
+            },
+            {
+                output: MultiSignTransaction.LOCK_LEAF_SCRIPT,
+                version: 192,
+            },
+        ];
+        const redeem = {
+            output: compiledTargetScript,
+            redeemVersion: 192,
+        };
+        return {
+            internalPubkey: this.internalPubKeyToXOnly(),
+            network: this.network,
+            scriptTree: scriptTree,
+            redeem: redeem,
+        };
+    }
+    getScriptSolution(input) {
+        if (!input.tapScriptSig) {
+            throw new Error('Tap script signature is required');
+        }
+        return [
+            this.contractSecret,
+            toXOnly(this.signer.publicKey),
+            input.tapScriptSig[0].signature,
+            input.tapScriptSig[1].signature,
+        ];
+    }
+    internalBuildTransaction(transaction) {
+        if (transaction.data.inputs.length === 0) {
+            const inputs = this.getInputs();
+            const outputs = this.getOutputs();
+            transaction.setMaximumFeeRate(this._maximumFeeRate);
+            transaction.addInputs(inputs);
+            for (let i = 0; i < this.updateInputs.length; i++) {
+                transaction.updateInput(i, this.updateInputs[i]);
+            }
+            transaction.addOutputs(outputs);
+        }
+        try {
+            this.signInput(transaction, transaction.data.inputs[0], 0, this.scriptSigner);
+            this.signInput(transaction, transaction.data.inputs[0], 0);
+            try {
+                transaction.finalizeInput(0, this.customFinalizer);
+            }
+            catch (e) {
+                console.log(e);
+            }
+            if (this.finalized) {
+                this.transactionFee = BigInt(transaction.getFee());
+            }
+            return true;
+        }
+        catch (e) {
+            const err = e;
+            this.error(`[internalBuildTransaction] Something went wrong while getting building the transaction: ${err.stack}`);
+        }
+        return false;
+    }
+    addVaultUTXO(utxo, pubkeys, minimumSignatures) {
+        const tapInput = this.generateTapDataForInput(pubkeys, minimumSignatures);
+        const tap = payments.p2tr(tapInput);
+        if (!tap.witness)
+            throw new Error('Failed to generate taproot witness');
+        this.disableRBF();
+        const controlBlock = tap.witness[tap.witness.length - 1];
+        const input = {
+            hash: utxo.hash,
+            index: utxo.outputIndex,
+            witnessUtxo: {
+                script: Buffer.from(utxo.output, 'base64'),
+                value: Number(utxo.value),
+            },
+            tapInternalKey: tapInput.internalPubkey,
+            sequence: this.sequence,
+            tapLeafScript: [
+                {
+                    leafVersion: tapInput.redeem.redeemVersion,
+                    script: tapInput.redeem.output,
+                    controlBlock: controlBlock,
+                },
+            ],
+        };
+        this.addInput(input);
+    }
+    addVaultInputs(vault) {
+        const pubKeys = vault.publicKeys.map((key) => Buffer.from(key, 'base64'));
+        for (const utxo of vault.utxos) {
+            this.addVaultUTXO(utxo, pubKeys, vault.minimum);
+        }
+    }
+    calculateOutputLeftAmountFromVaults(vaults) {
+        const total = this.getVaultTotalOutputAmount(vaults);
+        return total - this.amount;
+    }
+    getVaultTotalOutputAmount(vaults) {
+        let total = BigInt(0);
+        for (const vault of vaults) {
+            for (const utxo of vault.utxos) {
+                total += BigInt(utxo.value);
+            }
+        }
+        return total;
+    }
+}