@btc-vision/transaction 1.0.59 → 1.0.61

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;
+    }
+}

package/build/transaction/builders/TransactionBuilder.js

@@ -158,7 +158,7 @@ export class TransactionBuilder extends TweakedTransaction {
         });
         const builtTx = await this.internalBuildTransaction(fakeTx);
         if (builtTx) {
-            const tx = fakeTx.extractTransaction(false, true);
+            const tx = fakeTx.extractTransaction(true, true);
             const size = tx.virtualSize();
             const fee = this.feeRate * size;
             this.estimatedFees = BigInt(Math.ceil(fee) + 1);

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

@@ -0,0 +1,34 @@
+/// <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 { Psbt } from 'bitcoinjs-lib';
+import { VaultUTXOs } from '../processor/PsbtTransaction.js';
+export declare class UnwrapTransaction extends SharedInteractionTransaction<TransactionType.WBTC_UNWRAP> {
+    static readonly MINIMUM_CONSOLIDATION_AMOUNT: bigint;
+    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 internalBuildTransaction(transaction: Psbt): boolean;
+    protected generateMultiSignRedeemScript(publicKeys: string[], minimum: number): {
+        witnessUtxo: Buffer;
+        redeemScript: Buffer;
+        witnessScript: Buffer;
+    };
+    private addVaultUTXO;
+    private addVaultInputs;
+    private calculateOutputLeftAmountFromVaults;
+    private getVaultTotalOutputAmount;
+}

package/build/transaction/builders/UnwarpSegwitTransaction.js

@@ -0,0 +1,184 @@
+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';
+const abiCoder = new ABICoder();
+export class UnwrapTransaction extends SharedInteractionTransaction {
+    static MINIMUM_CONSOLIDATION_AMOUNT = 200000n;
+    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 = UnwrapTransaction.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.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(UnwrapTransaction.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');
+        }
+        if (this.signed)
+            throw new Error('Transaction is already signed');
+        this.signed = true;
+        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 total = this.getVaultTotalOutputAmount(input);
+        if (total < this.amount) {
+            throw new Error(`Total vault amount (${total} sat) is less than the amount to unwrap (${this.amount} sat)`);
+        }
+        const outputLeftAmount = this.calculateOutputLeftAmountFromVaults(input);
+        if (outputLeftAmount < UnwrapTransaction.MINIMUM_CONSOLIDATION_AMOUNT) {
+            throw new Error(`Output left amount is below minimum consolidation (${UnwrapTransaction.MINIMUM_CONSOLIDATION_AMOUNT} sat) amount ${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);
+        }
+    }
+    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.signInputs(transaction);
+            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;
+    }
+    generateMultiSignRedeemScript(publicKeys, minimum) {
+        const p2ms = payments.p2ms({
+            m: minimum,
+            pubkeys: publicKeys.map((key) => Buffer.from(key, 'base64')),
+            network: this.network,
+        });
+        const p2wsh = payments.p2wsh({
+            redeem: p2ms,
+            network: this.network,
+        });
+        const witnessUtxo = p2wsh.output;
+        const redeemScript = p2wsh.redeem?.output;
+        const witnessScript = p2ms.output;
+        if (!witnessUtxo || !redeemScript || !witnessScript) {
+            throw new Error('Failed to generate redeem script');
+        }
+        return {
+            witnessUtxo,
+            redeemScript,
+            witnessScript,
+        };
+    }
+    addVaultUTXO(utxo, witness) {
+        const input = {
+            hash: utxo.hash,
+            index: utxo.outputIndex,
+            witnessUtxo: {
+                script: Buffer.from(utxo.output, 'base64'),
+                value: Number(utxo.value),
+            },
+            witnessScript: witness.witnessScript,
+            sequence: this.sequence,
+        };
+        if (this.calculatedSignHash) {
+            input.sighashType = this.calculatedSignHash;
+        }
+        this.addInput(input);
+    }
+    addVaultInputs(vault, firstSigner = this.signer) {
+        const p2wshOutput = this.generateMultiSignRedeemScript(vault.publicKeys, vault.minimum);
+        for (const utxo of vault.utxos) {
+            const inputIndex = this.transaction.inputCount;
+            this.addVaultUTXO(utxo, p2wshOutput);
+            if (firstSigner) {
+                this.log(`Signing input ${inputIndex} with ${firstSigner.publicKey.toString('hex')}`);
+                try {
+                    this.signInput(this.transaction, this.transaction.data.inputs[inputIndex], inputIndex, this.signer);
+                    this.log(`Signed input ${inputIndex} with ${firstSigner.publicKey.toString('hex')}`);
+                }
+                catch (e) {
+                    if (!this.ignoreSignatureErrors) {
+                        this.warn(`Failed to sign input ${inputIndex} with ${firstSigner.publicKey.toString('hex')} ${e.message}`);
+                    }
+                }
+            }
+        }
+    }
+    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;
+    }
+}

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

@@ -0,0 +1,35 @@
+/// <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 { Psbt } from 'bitcoinjs-lib';
+import { VaultUTXOs } from '../processor/PsbtTransaction.js';
+export declare class UnwrapTransaction extends SharedInteractionTransaction<TransactionType.WBTC_UNWRAP> {
+    static readonly MINIMUM_CONSOLIDATION_AMOUNT: bigint;
+    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;
+    estimateVaultFees(feeRate: bigint, numInputs: bigint, numOutputs: bigint, numSignatures: bigint, numPubkeys: bigint): bigint;
+    protected internalBuildTransaction(transaction: Psbt): boolean;
+    protected generateMultiSignRedeemScript(publicKeys: string[], minimum: number): {
+        witnessUtxo: Buffer;
+        redeemScript: Buffer;
+        witnessScript: Buffer;
+    };
+    private addVaultUTXO;
+    private addVaultInputs;
+    private calculateOutputLeftAmountFromVaults;
+    private getVaultTotalOutputAmount;
+}

package/build/transaction/builders/UnwarpTransaction.js

@@ -0,0 +1,199 @@
+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';
+const abiCoder = new ABICoder();
+export class UnwrapTransaction extends SharedInteractionTransaction {
+    static MINIMUM_CONSOLIDATION_AMOUNT = 200000n;
+    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 = UnwrapTransaction.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.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(UnwrapTransaction.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');
+        }
+        if (this.signed)
+            throw new Error('Transaction is already signed');
+        this.signed = true;
+        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 total = this.getVaultTotalOutputAmount(input);
+        if (total < this.amount) {
+            throw new Error(`Total vault amount (${total} sat) is less than the amount to unwrap (${this.amount} sat)`);
+        }
+        const outputLeftAmount = this.calculateOutputLeftAmountFromVaults(input);
+        console.log('outputLeftAmount', outputLeftAmount, this.amount);
+        if (outputLeftAmount < UnwrapTransaction.MINIMUM_CONSOLIDATION_AMOUNT) {
+            throw new Error(`Output left amount is below minimum consolidation (${UnwrapTransaction.MINIMUM_CONSOLIDATION_AMOUNT} sat) amount ${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);
+        }
+    }
+    estimateVaultFees(feeRate, numInputs, numOutputs, numSignatures, numPubkeys) {
+        const txHeaderSize = 10n;
+        const inputBaseSize = 41n;
+        const outputSize = 68n;
+        const signatureSize = 144n;
+        const pubkeySize = 34n;
+        const baseTxSize = txHeaderSize + inputBaseSize * numInputs + outputSize * numOutputs;
+        const redeemScriptSize = 1n + numPubkeys * (1n + pubkeySize) + 1n + numSignatures;
+        const witnessSize = numSignatures * signatureSize + numPubkeys * pubkeySize + redeemScriptSize;
+        const weight = baseTxSize * 3n + (baseTxSize + witnessSize);
+        const vSize = weight / 4n;
+        return vSize * feeRate;
+    }
+    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.signInputs(transaction);
+            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;
+    }
+    generateMultiSignRedeemScript(publicKeys, minimum) {
+        const p2ms = payments.p2ms({
+            m: minimum,
+            pubkeys: publicKeys.map((key) => Buffer.from(key, 'base64')),
+            network: this.network,
+        });
+        const p2wsh = payments.p2wsh({
+            redeem: p2ms,
+            network: this.network,
+        });
+        const witnessUtxo = p2wsh.output;
+        const redeemScript = p2wsh.redeem?.output;
+        const witnessScript = p2ms.output;
+        if (!witnessUtxo || !redeemScript || !witnessScript) {
+            throw new Error('Failed to generate redeem script');
+        }
+        return {
+            witnessUtxo,
+            redeemScript,
+            witnessScript,
+        };
+    }
+    addVaultUTXO(utxo, witness) {
+        console.log(Number(utxo.value), utxo.hash, utxo.outputIndex);
+        const input = {
+            hash: utxo.hash,
+            index: utxo.outputIndex,
+            witnessUtxo: {
+                script: Buffer.from(utxo.output, 'base64'),
+                value: Number(utxo.value),
+            },
+            witnessScript: witness.witnessScript,
+            sequence: this.sequence,
+        };
+        if (this.calculatedSignHash) {
+            input.sighashType = this.calculatedSignHash;
+        }
+        this.addInput(input);
+    }
+    addVaultInputs(vault, firstSigner = this.signer) {
+        const p2wshOutput = this.generateMultiSignRedeemScript(vault.publicKeys, vault.minimum);
+        for (const utxo of vault.utxos) {
+            const inputIndex = this.transaction.inputCount;
+            this.addVaultUTXO(utxo, p2wshOutput);
+            if (firstSigner) {
+                this.log(`Signing input ${inputIndex} with ${firstSigner.publicKey.toString('hex')}`);
+                try {
+                    this.signInput(this.transaction, this.transaction.data.inputs[inputIndex], inputIndex, this.signer);
+                    this.log(`Signed input ${inputIndex} with ${firstSigner.publicKey.toString('hex')}`);
+                }
+                catch (e) {
+                    if (!this.ignoreSignatureErrors) {
+                        this.warn(`Failed to sign input ${inputIndex} with ${firstSigner.publicKey.toString('hex')} ${e.message}`);
+                    }
+                }
+            }
+        }
+    }
+    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;
+    }
+}