@btc-vision/transaction 1.0.41 → 1.0.44

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

@@ -0,0 +1,150 @@
+import { CustomKeypair } from '../BrowserSignerBase.js';
+import { networks, Psbt } from 'bitcoinjs-lib';
+import { UnisatNetwork } from '../types/Unisat.js';
+import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
+export class UnisatSigner extends CustomKeypair {
+    isInitialized = false;
+    constructor() {
+        super();
+        if (!window) {
+            throw new Error('UnisatSigner can only be used in a browser environment');
+        }
+    }
+    _p2tr;
+    get p2tr() {
+        if (!this._p2tr) {
+            throw new Error('P2TR address not set');
+        }
+        return this._p2tr;
+    }
+    _p2pkh;
+    get p2pkh() {
+        if (!this._p2pkh) {
+            throw new Error('P2PKH address not set');
+        }
+        return this._p2pkh;
+    }
+    _addresses;
+    get addresses() {
+        if (!this._addresses) {
+            throw new Error('Addresses not set');
+        }
+        return this._addresses;
+    }
+    _publicKey;
+    get publicKey() {
+        if (!this._publicKey) {
+            throw new Error('Public key not set');
+        }
+        return this._publicKey;
+    }
+    _network;
+    get network() {
+        if (!this._network) {
+            throw new Error('Network not set');
+        }
+        return this._network;
+    }
+    get unisat() {
+        if (!window.unisat) {
+            throw new Error('Unisat extension not found');
+        }
+        return window.unisat;
+    }
+    async init() {
+        if (this.isInitialized) {
+            return;
+        }
+        const network = await this.unisat.getNetwork();
+        switch (network) {
+            case UnisatNetwork.mainnet:
+                this._network = networks.bitcoin;
+                break;
+            case UnisatNetwork.testnet:
+                this._network = networks.testnet;
+                break;
+            case UnisatNetwork.regtest:
+                this._network = networks.regtest;
+                break;
+            default:
+                throw new Error('Invalid network');
+        }
+        const publicKey = await this.unisat.getPublicKey();
+        this._publicKey = Buffer.from(publicKey, 'hex');
+        this._p2pkh = EcKeyPair.getP2WPKHAddress(this, this.network);
+        this._p2tr = EcKeyPair.getTaprootAddress(this, this.network);
+        this._addresses = [this._p2pkh, this._p2tr];
+        this.isInitialized = true;
+    }
+    getPublicKey() {
+        if (!this.isInitialized) {
+            throw new Error('UnisatSigner not initialized');
+        }
+        return this.publicKey;
+    }
+    sign(hash, lowR) {
+        throw new Error('Not implemented: sign');
+    }
+    signSchnorr(hash) {
+        throw new Error('Not implemented: signSchnorr');
+    }
+    verify(hash, signature) {
+        throw new Error('Not implemented: verify');
+    }
+    async signTaprootInput(transaction, i, sighashTypes) {
+        let firstSignature = await this.signTweaked(transaction, i, sighashTypes, false);
+        this.combine(transaction, firstSignature, i);
+    }
+    async signInput(transaction, i, sighashTypes) {
+        const secondSignature = await this.signTweaked(transaction, i, sighashTypes, true);
+        this.combine(transaction, secondSignature, i);
+    }
+    combine(transaction, newPsbt, i) {
+        const signedInput = newPsbt.data.inputs[i];
+        const originalInput = transaction.data.inputs[i];
+        if (signedInput.partialSig) {
+            transaction.updateInput(i, { partialSig: signedInput.partialSig });
+        }
+        if (signedInput.tapKeySig && !originalInput.tapKeySig) {
+            transaction.updateInput(i, { tapKeySig: signedInput.tapKeySig });
+        }
+        if (signedInput.tapScriptSig?.length) {
+            const lastScriptSig = originalInput.tapScriptSig;
+            if (lastScriptSig) {
+                const getNonDuplicate = this.getNonDuplicateScriptSig(lastScriptSig, signedInput.tapScriptSig);
+                if (getNonDuplicate.length) {
+                    transaction.updateInput(i, { tapScriptSig: getNonDuplicate });
+                }
+            }
+            else {
+                transaction.updateInput(i, { tapScriptSig: signedInput.tapScriptSig });
+            }
+        }
+    }
+    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++) {
+            const found = scriptSig1.find((item) => item.pubkey.equals(scriptSig2[i].pubkey));
+            if (!found) {
+                nonDuplicate.push(scriptSig2[i]);
+            }
+        }
+        return nonDuplicate;
+    }
+}

package/build/transaction/browser/types/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/types/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/DeploymentTransaction.d.ts

@@ -23,8 +23,8 @@ export declare class DeploymentTransaction extends TransactionBuilder<Transactio
     get p2trAddress(): Address;
     getRndBytes(): Buffer;
     protected contractSignerXOnlyPubKey(): Buffer;
-    protected buildTransaction(): void;
-    protected signInputs(transaction: Psbt): void;
+    protected buildTransaction(): Promise<void>;
+    protected signInputs(transaction: Psbt): Promise<void>;
     protected generateScriptAddress(): Payment;
     protected generateTapData(): Payment;
     private getContractSeed;

package/build/transaction/builders/DeploymentTransaction.js

@@ -46,7 +46,7 @@ export class DeploymentTransaction extends TransactionBuilder {
     contractSignerXOnlyPubKey() {
         return toXOnly(this.contractSigner.publicKey);
     }
-    buildTransaction() {
+    async buildTransaction() {
         if (!this.to) {
             this.to = this.getScriptAddress();
         }
@@ -73,11 +73,11 @@ export class DeploymentTransaction extends TransactionBuilder {
             value: Number(amountSpent),
             address: this.to,
         });
-        this.addRefundOutput(amountSpent);
+        await this.addRefundOutput(amountSpent);
     }
-    signInputs(transaction) {
+    async signInputs(transaction) {
         if (!this.contractSigner) {
-            super.signInputs(transaction);
+            await super.signInputs(transaction);
             return;
         }
         for (let i = 0; i < transaction.data.inputs.length; i++) {

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

@@ -6,6 +6,6 @@ export declare class FundingTransaction extends TransactionBuilder<TransactionTy
     readonly type: TransactionType.FUNDING;
     protected childTransactionRequiredFees: bigint;
     constructor(parameters: IFundingTransactionParameters);
-    protected buildTransaction(): void;
+    protected buildTransaction(): Promise<void>;
     protected getSignerKey(): Signer;
 }

package/build/transaction/builders/FundingTransaction.js

@@ -8,7 +8,7 @@ export class FundingTransaction extends TransactionBuilder {
         this.childTransactionRequiredFees = parameters.childTransactionRequiredValue;
         this.internalInit();
     }
-    buildTransaction() {
+    async buildTransaction() {
         if (!this.to) {
             throw new Error('Recipient address is required');
         }
@@ -18,7 +18,7 @@ export class FundingTransaction extends TransactionBuilder {
             value: Number(amountSpent),
             address: this.to,
         });
-        this.addRefundOutput(amountSpent);
+        await this.addRefundOutput(amountSpent);
     }
     getSignerKey() {
         return this.signer;

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

@@ -48,10 +48,10 @@ export declare class MultiSignTransaction extends TransactionBuilder<Transaction
     static dedupeSignatures(original: TapScriptSig[], partial: TapScriptSig[]): TapScriptSig[];
     static attemptFinalizeInputs(psbt: Psbt, startIndex: number, orderedPubKeys: Buffer[][], isFinal: boolean): boolean;
     finalizeTransactionInputs(): boolean;
-    signPSBT(): Psbt;
-    protected buildTransaction(): void;
-    protected internalBuildTransaction(transaction: Psbt): boolean;
-    protected signInputs(_transaction: Psbt): void;
+    signPSBT(): Promise<Psbt>;
+    protected buildTransaction(): Promise<void>;
+    protected internalBuildTransaction(transaction: Psbt): Promise<boolean>;
+    protected signInputs(_transaction: Psbt): Promise<void>;
     protected generateScriptAddress(): Payment;
     protected generateTapData(): Payment;
     protected getScriptSolution(input: PsbtInput): Buffer[];

package/build/transaction/builders/MultiSignTransaction.js

@@ -1,4 +1,4 @@
-import { crypto as bitcoinCrypto, opcodes, Psbt, script, } from 'bitcoinjs-lib';
+import { crypto as bitcoinCrypto, opcodes, Psbt, script } from 'bitcoinjs-lib';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { TransactionType } from '../enums/TransactionType.js';
 import { MultiSignGenerator } from '../../generators/builders/MultiSignGenerator.js';
@@ -239,13 +239,13 @@ export class MultiSignTransaction extends TransactionBuilder {
         }
         return finalized;
     }
-    signPSBT() {
-        if (this.signTransaction()) {
+    async signPSBT() {
+        if (await this.signTransaction()) {
             return this.transaction;
         }
         throw new Error('Could not sign transaction');
     }
-    buildTransaction() {
+    async buildTransaction() {
         const selectedRedeem = this.targetScriptRedeem;
         if (!selectedRedeem) {
             throw new Error('Left over funds script redeem is required');
@@ -275,7 +275,7 @@ export class MultiSignTransaction extends TransactionBuilder {
             value: Number(this.requestedAmount),
         });
     }
-    internalBuildTransaction(transaction) {
+    async internalBuildTransaction(transaction) {
         const inputs = this.getInputs();
         const outputs = this.getOutputs();
         transaction.setMaximumFeeRate(this._maximumFeeRate);
@@ -285,7 +285,7 @@ export class MultiSignTransaction extends TransactionBuilder {
         }
         transaction.addOutputs(outputs);
         try {
-            this.signInputs(transaction);
+            await this.signInputs(transaction);
             return this.finalizeTransactionInputs();
         }
         catch (e) {
@@ -294,7 +294,7 @@ export class MultiSignTransaction extends TransactionBuilder {
         }
         return false;
     }
-    signInputs(_transaction) { }
+    async signInputs(_transaction) { }
     generateScriptAddress() {
         return {
             internalPubkey: toXOnly(MultiSignTransaction.numsPoint),

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

@@ -24,8 +24,8 @@ export declare abstract class SharedInteractionTransaction<T extends Transaction
     protected generateSecret(): Buffer;
     protected scriptSignerXOnlyPubKey(): Buffer;
     protected generateKeyPairFromSeed(): ECPairInterface;
-    protected buildTransaction(): void;
-    protected signInputs(transaction: Psbt): void;
+    protected buildTransaction(): Promise<void>;
+    protected signInputs(transaction: Psbt): Promise<void>;
     protected generateScriptAddress(): Payment;
     protected generateTapData(): Payment;
     protected getScriptSolution(input: PsbtInput): Buffer[];

package/build/transaction/builders/SharedInteractionTransaction.js

@@ -41,7 +41,7 @@ export class SharedInteractionTransaction extends TransactionBuilder {
     generateKeyPairFromSeed() {
         return EcKeyPair.fromSeedKeyPair(this.randomBytes, this.network);
     }
-    buildTransaction() {
+    async buildTransaction() {
         if (!this.to)
             throw new Error('To address is required');
         const selectedRedeem = !!this.scriptSigner
@@ -70,12 +70,12 @@ export class SharedInteractionTransaction extends TransactionBuilder {
             address: this.to,
         });
         if (!this.disableAutoRefund) {
-            this.addRefundOutput(amountSpent);
+            await this.addRefundOutput(amountSpent);
         }
     }
-    signInputs(transaction) {
+    async signInputs(transaction) {
         if (!this.scriptSigner) {
-            super.signInputs(transaction);
+            await super.signInputs(transaction);
             return;
         }
         for (let i = 0; i < transaction.data.inputs.length; i++) {
@@ -83,12 +83,12 @@ export class SharedInteractionTransaction extends TransactionBuilder {
             let finalized = false;
             let signed = false;
             try {
-                this.signInput(transaction, input, i, this.scriptSigner);
+                await this.signInput(transaction, input, i, this.scriptSigner);
                 signed = true;
             }
             catch (e) { }
             try {
-                this.signInput(transaction, input, i);
+                await this.signInput(transaction, input, i);
                 signed = true;
             }
             catch (e) { }

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

@@ -14,6 +14,7 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     readonly logColor: string;
     overflowFees: bigint;
     transactionFee: bigint;
+    estimatedFees: bigint;
     protected transaction: Psbt;
     protected readonly updateInputs: UpdateInput[];
     protected readonly outputs: PsbtOutputExtended[];
@@ -30,32 +31,32 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     protected constructor(parameters: ITransactionParameters);
     static getFrom(from: string | undefined, keypair: ECPairInterface, network: Network): Address;
     static witnessStackToScriptWitness(witness: Buffer[]): Buffer;
-    getFundingTransactionParameters(): IFundingTransactionParameters;
+    getFundingTransactionParameters(): Promise<IFundingTransactionParameters>;
     setDestinationAddress(address: Address): void;
     setMaximumFeeRate(feeRate: number): void;
-    signTransaction(): Transaction;
-    signPSBT(): Psbt;
+    signTransaction(): Promise<Transaction>;
+    signPSBT(): Promise<Psbt>;
     addInput(input: PsbtInputExtended): void;
     addOutput(output: PsbtOutputExtended): void;
     toAddress(): string | undefined;
     address(): Address | undefined;
-    estimateTransactionFees(): bigint;
-    rebuildFromBase64(base64: string): Psbt;
+    estimateTransactionFees(): Promise<bigint>;
+    rebuildFromBase64(base64: string): Promise<Psbt>;
     setPSBT(psbt: Psbt): void;
-    protected addRefundOutput(amountSpent: bigint): void;
+    protected addRefundOutput(amountSpent: bigint): Promise<void>;
     protected addValueToToOutput(value: number | bigint): void;
     protected getTransactionOPNetFee(): bigint;
     protected calculateTotalUTXOAmount(): bigint;
     protected calculateTotalVOutAmount(): bigint;
     protected addInputsFromUTXO(): void;
     protected internalInit(): void;
-    protected abstract buildTransaction(): void;
+    protected abstract buildTransaction(): Promise<void>;
     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 internalBuildTransaction(transaction: Psbt): boolean;
+    protected setFeeOutput(output: PsbtOutputExtended): Promise<void>;
+    protected internalBuildTransaction(transaction: Psbt): Promise<boolean>;
 }

package/build/transaction/builders/TransactionBuilder.js

@@ -13,6 +13,7 @@ export class TransactionBuilder extends TweakedTransaction {
     logColor = '#785def';
     overflowFees = 0n;
     transactionFee = 0n;
+    estimatedFees = 0n;
     transaction;
     updateInputs = [];
     outputs = [];
@@ -28,6 +29,9 @@ export class TransactionBuilder extends TweakedTransaction {
     _maximumFeeRate = 100000000;
     constructor(parameters) {
         super(parameters);
+        if (parameters.estimatedFees) {
+            this.estimatedFees = parameters.estimatedFees;
+        }
         this.signer = parameters.signer;
         this.network = parameters.network;
         this.feeRate = parameters.feeRate;
@@ -69,9 +73,9 @@ export class TransactionBuilder extends TweakedTransaction {
         writeVector(witness);
         return buffer;
     }
-    getFundingTransactionParameters() {
+    async getFundingTransactionParameters() {
         if (!this.transactionFee) {
-            this.transactionFee = this.estimateTransactionFees();
+            this.transactionFee = await this.estimateTransactionFees();
         }
         return {
             utxos: this.utxos,
@@ -90,15 +94,15 @@ export class TransactionBuilder extends TweakedTransaction {
     setMaximumFeeRate(feeRate) {
         this._maximumFeeRate = feeRate;
     }
-    signTransaction() {
+    async signTransaction() {
         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.signed)
             throw new Error('Transaction is already signed');
         this.signed = true;
-        this.buildTransaction();
-        const builtTx = this.internalBuildTransaction(this.transaction);
+        await this.buildTransaction();
+        const builtTx = await this.internalBuildTransaction(this.transaction);
         if (builtTx) {
             if (this.regenerated) {
                 throw new Error('Transaction was regenerated');
@@ -107,8 +111,8 @@ export class TransactionBuilder extends TweakedTransaction {
         }
         throw new Error('Could not sign transaction');
     }
-    signPSBT() {
-        if (this.signTransaction()) {
+    async signPSBT() {
+        if (await this.signTransaction()) {
             return this.transaction;
         }
         throw new Error('Could not sign transaction');
@@ -130,42 +134,45 @@ export class TransactionBuilder extends TweakedTransaction {
     address() {
         return this.tapData?.address;
     }
-    estimateTransactionFees() {
+    async estimateTransactionFees() {
+        if (this.estimatedFees)
+            return this.estimatedFees;
         const fakeTx = new Psbt({
             network: this.network,
         });
-        const builtTx = this.internalBuildTransaction(fakeTx);
+        const builtTx = await this.internalBuildTransaction(fakeTx);
         if (builtTx) {
             const tx = fakeTx.extractTransaction(false);
             const size = tx.virtualSize();
             const fee = this.feeRate * size + 1;
-            return BigInt(Math.ceil(fee) + 1);
+            this.estimatedFees = BigInt(Math.ceil(fee) + 1);
+            return this.estimatedFees;
         }
         else {
             throw new Error(`Could not build transaction to estimate fee. Something went wrong while building the transaction.`);
         }
     }
-    rebuildFromBase64(base64) {
+    async rebuildFromBase64(base64) {
         this.transaction = Psbt.fromBase64(base64, { network: this.network });
         this.signed = false;
         this.sighashTypes = [Transaction.SIGHASH_ANYONECANPAY, Transaction.SIGHASH_ALL];
-        return this.signPSBT();
+        return await this.signPSBT();
     }
     setPSBT(psbt) {
         this.transaction = psbt;
     }
-    addRefundOutput(amountSpent) {
+    async addRefundOutput(amountSpent) {
         const sendBackAmount = this.totalInputAmount - amountSpent;
         if (sendBackAmount >= TransactionBuilder.MINIMUM_DUST) {
             if (AddressVerificator.isValidP2TRAddress(this.from, this.network)) {
-                this.setFeeOutput({
+                await this.setFeeOutput({
                     value: Number(sendBackAmount),
                     address: this.from,
                     tapInternalKey: this.internalPubKeyToXOnly(),
                 });
             }
             else {
-                this.setFeeOutput({
+                await this.setFeeOutput({
                     value: Number(sendBackAmount),
                     address: this.from,
                 });
@@ -256,21 +263,21 @@ export class TransactionBuilder extends TweakedTransaction {
             }
         }
     }
-    setFeeOutput(output) {
+    async setFeeOutput(output) {
         const initialValue = output.value;
-        let fee = this.estimateTransactionFees();
+        let fee = await this.estimateTransactionFees();
         output.value = initialValue - Number(fee);
         if (output.value < TransactionBuilder.MINIMUM_DUST) {
             this.feeOutput = null;
             if (output.value < 0) {
-                throw new Error(`Insufficient funds to pay the fees. Fee: ${fee} > Value: ${initialValue}. Total input: ${this.totalInputAmount} sat`);
+                throw new Error(`setFeeOutput: Insufficient funds to pay the fees. Fee: ${fee} > Value: ${initialValue}. Total input: ${this.totalInputAmount} sat`);
             }
         }
         else {
             this.feeOutput = output;
-            let fee = this.estimateTransactionFees();
+            let fee = await this.estimateTransactionFees();
             if (fee > BigInt(initialValue)) {
-                throw new Error(`Insufficient funds to pay the fees. Fee: ${fee} > Value: ${initialValue}. Total input: ${this.totalInputAmount} sat`);
+                throw new Error(`estimateTransactionFees: Insufficient funds to pay the fees. Fee: ${fee} > Value: ${initialValue}. Total input: ${this.totalInputAmount} sat`);
             }
             const valueLeft = initialValue - Number(fee);
             if (valueLeft < TransactionBuilder.MINIMUM_DUST) {
@@ -282,7 +289,7 @@ export class TransactionBuilder extends TweakedTransaction {
             this.overflowFees = BigInt(valueLeft);
         }
     }
-    internalBuildTransaction(transaction) {
+    async internalBuildTransaction(transaction) {
         if (transaction.data.inputs.length === 0) {
             const inputs = this.getInputs();
             const outputs = this.getOutputs();
@@ -294,7 +301,7 @@ export class TransactionBuilder extends TweakedTransaction {
             transaction.addOutputs(outputs);
         }
         try {
-            this.signInputs(transaction);
+            await this.signInputs(transaction);
             if (this.finalized) {
                 this.transactionFee = BigInt(transaction.getFee());
             }

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

@@ -18,9 +18,9 @@ export declare class UnwrapSegwitTransaction extends SharedInteractionTransactio
     private readonly calculatedSignHash;
     constructor(parameters: IUnwrapParameters);
     static generateBurnCalldata(amount: bigint): Buffer;
-    signPSBT(): Psbt;
-    mergeVaults(input: VaultUTXOs[]): void;
-    protected internalBuildTransaction(transaction: Psbt): boolean;
+    signPSBT(): Promise<Psbt>;
+    mergeVaults(input: VaultUTXOs[]): Promise<void>;
+    protected internalBuildTransaction(transaction: Psbt): Promise<boolean>;
     protected generateMultiSignRedeemScript(publicKeys: string[], minimum: number): {
         witnessUtxo: Buffer;
         redeemScript: Buffer;