@btc-vision/transaction 1.0.41 → 1.0.44

package/src/transaction/TransactionFactory.ts

@@ -52,9 +52,11 @@ export class TransactionFactory {
 
     /**
      * @description Generates the required transactions.
-     * @returns {[Transaction, Transaction]} - The signed transaction
+     * @returns {Promise<[string, string]>} - The signed transaction
      */
-    public signInteraction(interactionParameters: IInteractionParameters): [string, string] {
+    public async signInteraction(
+        interactionParameters: IInteractionParameters,
+    ): Promise<[string, string]> {
         if (!interactionParameters.to) {
             throw new Error('Field "to" not provided.');
         }
@@ -63,16 +65,16 @@ export class TransactionFactory {
             interactionParameters,
         );
 
-        transaction.signTransaction();
+        await transaction.signTransaction();
 
         // Initial generation
-        const estimatedGas = transaction.estimateTransactionFees();
+        const estimatedGas = await transaction.estimateTransactionFees();
         const fundingParameters: IFundingTransactionParameters = {
             ...interactionParameters,
             childTransactionRequiredValue: estimatedGas,
         };
 
-        const preFundingTransaction = this.createFundTransaction(fundingParameters);
+        const preFundingTransaction = await this.createFundTransaction(fundingParameters);
         interactionParameters.utxos = this.getUTXOAsTransaction(
             preFundingTransaction.tx,
             interactionParameters.to,
@@ -84,15 +86,16 @@ export class TransactionFactory {
         );
 
         // Initial generation
-        preTransaction.signTransaction();
+        await preTransaction.signTransaction();
 
         const parameters: IFundingTransactionParameters =
-            preTransaction.getFundingTransactionParameters();
+            await preTransaction.getFundingTransactionParameters();
 
         parameters.utxos = fundingParameters.utxos;
-        parameters.childTransactionRequiredValue = preTransaction.estimateTransactionFees();
+        parameters.childTransactionRequiredValue = await preTransaction.estimateTransactionFees();
+        parameters.estimatedFees = preFundingTransaction.estimatedFees;
 
-        const signedTransaction = this.createFundTransaction(parameters);
+        const signedTransaction = await this.createFundTransaction(parameters);
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');
         }
@@ -102,12 +105,13 @@ export class TransactionFactory {
             utxos: this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0), // always 0
             randomBytes: preTransaction.getRndBytes(),
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
+            estimatedFees: preTransaction.estimatedFees,
         };
 
         const finalTransaction: InteractionTransaction = new InteractionTransaction(newParams);
 
         // We have to regenerate using the new utxo
-        const outTx: Transaction = finalTransaction.signTransaction();
+        const outTx: Transaction = await finalTransaction.signTransaction();
 
         return [signedTransaction.tx.toHex(), outTx.toHex()];
     }
@@ -115,21 +119,23 @@ export class TransactionFactory {
     /**
      * @description Generates the required transactions.
      * @param {IDeploymentParameters} deploymentParameters - The deployment parameters
-     * @returns {DeploymentResult} - The signed transaction
+     * @returns {Promise<DeploymentResult>} - The signed transaction
      */
-    public signDeployment(deploymentParameters: IDeploymentParameters): DeploymentResult {
+    public async signDeployment(
+        deploymentParameters: IDeploymentParameters,
+    ): Promise<DeploymentResult> {
         const preTransaction: DeploymentTransaction = new DeploymentTransaction(
             deploymentParameters,
         );
 
         // Initial generation
-        preTransaction.signTransaction();
+        await preTransaction.signTransaction();
 
         const parameters: IFundingTransactionParameters =
-            preTransaction.getFundingTransactionParameters();
+            await preTransaction.getFundingTransactionParameters();
 
         const fundingTransaction: FundingTransaction = new FundingTransaction(parameters);
-        const signedTransaction: Transaction = fundingTransaction.signTransaction();
+        const signedTransaction: Transaction = await fundingTransaction.signTransaction();
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');
         }
@@ -155,7 +161,7 @@ export class TransactionFactory {
         const finalTransaction: DeploymentTransaction = new DeploymentTransaction(newParams);
 
         // We have to regenerate using the new utxo
-        const outTx: Transaction = finalTransaction.signTransaction();
+        const outTx: Transaction = await finalTransaction.signTransaction();
 
         return {
             transaction: [signedTransaction.toHex(), outTx.toHex()],
@@ -167,10 +173,10 @@ export class TransactionFactory {
     /**
      * Basically it's fun to manage UTXOs.
      * @param {IWrapParameters} warpParameters - The wrap parameters
-     * @returns {WrapResult | undefined} - The signed transaction
+     * @returns {Promise<WrapResult>} - The signed transaction
      * @throws {Error} - If the transaction could not be signed
      */
-    public wrap(warpParameters: IWrapParameters): WrapResult {
+    public async wrap(warpParameters: IWrapParameters): Promise<WrapResult> {
         if (warpParameters.amount < currentConsensusConfig.VAULT_MINIMUM_AMOUNT) {
             throw new Error(
                 `Amount is too low. Minimum consolidation is ${currentConsensusConfig.VAULT_MINIMUM_AMOUNT} sat. Received ${warpParameters.amount} sat. Make sure that you cover the unwrap consolidation fees of ${currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT}sat.`,
@@ -188,22 +194,22 @@ export class TransactionFactory {
             to: to,
         };
 
-        const preFundingTransaction = this.createFundTransaction(fundingParameters);
+        const preFundingTransaction = await this.createFundTransaction(fundingParameters);
         warpParameters.utxos = this.getUTXOAsTransaction(preFundingTransaction.tx, to, 0);
 
         const preTransaction: WrapTransaction = new WrapTransaction(warpParameters);
 
         // Initial generation
-        preTransaction.signTransaction();
+        await preTransaction.signTransaction();
 
         const parameters: IFundingTransactionParameters =
-            preTransaction.getFundingTransactionParameters();
+            await preTransaction.getFundingTransactionParameters();
 
         // We add the amount
         parameters.childTransactionRequiredValue += childTransactionRequiredValue;
         parameters.utxos = fundingParameters.utxos;
 
-        const signedTransaction = this.createFundTransaction(parameters);
+        const signedTransaction = await this.createFundTransaction(parameters);
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');
         }
@@ -218,7 +224,7 @@ export class TransactionFactory {
         const finalTransaction: WrapTransaction = new WrapTransaction(newParams);
 
         // We have to regenerate using the new utxo
-        const outTx: Transaction = finalTransaction.signTransaction();
+        const outTx: Transaction = await finalTransaction.signTransaction();
         return {
             transaction: [signedTransaction.tx.toHex(), outTx.toHex()],
             vaultAddress: finalTransaction.vault,
@@ -230,7 +236,7 @@ export class TransactionFactory {
     /**
      * Unwrap bitcoin.
      * @param {IUnwrapParameters} unwrapParameters - The unwrap parameters
-     * @returns {UnwrapResult} - The signed transaction
+     * @returns {Promise<UnwrapResult>} - The signed transaction
      * @throws {Error} - If the transaction could not be signed
      * @deprecated
      */
@@ -238,13 +244,13 @@ export class TransactionFactory {
         console.error('The "unwrap" method is deprecated. Use unwrapTap instead.');
 
         const transaction: UnwrapSegwitTransaction = new UnwrapSegwitTransaction(unwrapParameters);
-        transaction.signTransaction();
+        await transaction.signTransaction();
 
         const to = transaction.toAddress();
         if (!to) throw new Error('To address is required');
 
         // Initial generation
-        const estimatedGas = transaction.estimateTransactionFees();
+        const estimatedGas = await transaction.estimateTransactionFees();
         const estimatedFees = transaction.preEstimateTransactionFees(
             BigInt(unwrapParameters.feeRate),
             this.calculateNumInputs(unwrapParameters.unwrapUTXOs),
@@ -259,7 +265,7 @@ export class TransactionFactory {
             to: to,
         };
 
-        const preFundingTransaction = this.createFundTransaction(fundingParameters);
+        const preFundingTransaction = await this.createFundTransaction(fundingParameters);
         unwrapParameters.utxos = this.getUTXOAsTransaction(preFundingTransaction.tx, to, 0);
 
         const preTransaction: UnwrapSegwitTransaction = new UnwrapSegwitTransaction({
@@ -268,16 +274,16 @@ export class TransactionFactory {
         });
 
         // Initial generation
-        preTransaction.signTransaction();
+        await preTransaction.signTransaction();
 
         const parameters: IFundingTransactionParameters =
-            preTransaction.getFundingTransactionParameters();
+            await preTransaction.getFundingTransactionParameters();
 
         parameters.utxos = fundingParameters.utxos;
         parameters.childTransactionRequiredValue =
-            preTransaction.estimateTransactionFees() + estimatedFees;
+            (await preTransaction.estimateTransactionFees()) + estimatedFees;
 
-        const signedTransaction = this.createFundTransaction(parameters);
+        const signedTransaction = await this.createFundTransaction(parameters);
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');
         }
@@ -292,7 +298,7 @@ export class TransactionFactory {
         const finalTransaction: UnwrapSegwitTransaction = new UnwrapSegwitTransaction(newParams);
 
         // We have to regenerate using the new utxo
-        const outTx: Psbt = finalTransaction.signPSBT();
+        const outTx: Psbt = await finalTransaction.signPSBT();
         const asBase64 = outTx.toBase64();
         const psbt = this.writePSBTHeader(PSBTTypes.UNWRAP, asBase64);
 
@@ -306,25 +312,25 @@ export class TransactionFactory {
     /**
      * Unwrap bitcoin via taproot.
      * @param {IUnwrapParameters} unwrapParameters - The unwrap parameters
-     * @returns {UnwrapResult} - The signed transaction
+     * @returns {Promise<UnwrapResult>} - The signed transaction
      * @throws {Error} - If the transaction could not be signed
      */
     public async unwrap(unwrapParameters: IUnwrapParameters): Promise<UnwrapResult> {
         const transaction: UnwrapTransaction = new UnwrapTransaction(unwrapParameters);
-        transaction.signTransaction();
+        await transaction.signTransaction();
 
         const to = transaction.toAddress();
         if (!to) throw new Error('To address is required');
 
         // Initial generation
-        const estimatedGas = transaction.estimateTransactionFees();
+        const estimatedGas = await transaction.estimateTransactionFees();
         const fundingParameters: IFundingTransactionParameters = {
             ...unwrapParameters,
             childTransactionRequiredValue: estimatedGas,
             to: to,
         };
 
-        const preFundingTransaction = this.createFundTransaction(fundingParameters);
+        const preFundingTransaction = await this.createFundTransaction(fundingParameters);
         unwrapParameters.utxos = this.getUTXOAsTransaction(preFundingTransaction.tx, to, 0);
 
         const preTransaction: UnwrapTransaction = new UnwrapTransaction({
@@ -333,15 +339,15 @@ export class TransactionFactory {
         });
 
         // Initial generation
-        preTransaction.signTransaction();
+        await preTransaction.signTransaction();
 
         const parameters: IFundingTransactionParameters =
-            preTransaction.getFundingTransactionParameters();
+            await preTransaction.getFundingTransactionParameters();
 
         parameters.utxos = fundingParameters.utxos;
-        parameters.childTransactionRequiredValue = preTransaction.estimateTransactionFees();
+        parameters.childTransactionRequiredValue = await preTransaction.estimateTransactionFees();
 
-        const signedTransaction = this.createFundTransaction(parameters);
+        const signedTransaction = await this.createFundTransaction(parameters);
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');
         }
@@ -356,7 +362,7 @@ export class TransactionFactory {
         const finalTransaction: UnwrapTransaction = new UnwrapTransaction(newParams);
 
         // We have to regenerate using the new utxo
-        const outTx: Psbt = finalTransaction.signPSBT();
+        const outTx: Psbt = await finalTransaction.signPSBT();
         const asBase64 = outTx.toBase64();
         const psbt = this.writePSBTHeader(PSBTTypes.UNWRAP, asBase64);
 
@@ -422,12 +428,13 @@ export class TransactionFactory {
         return [newUtxo];
     }
 
-    private createFundTransaction(parameters: IFundingTransactionParameters): {
+    private async createFundTransaction(parameters: IFundingTransactionParameters): Promise<{
         tx: Transaction;
         original: FundingTransaction;
-    } {
+        estimatedFees: bigint;
+    }> {
         const fundingTransaction: FundingTransaction = new FundingTransaction(parameters);
-        const signedTransaction: Transaction = fundingTransaction.signTransaction();
+        const signedTransaction: Transaction = await fundingTransaction.signTransaction();
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');
         }
@@ -435,6 +442,7 @@ export class TransactionFactory {
         return {
             tx: signedTransaction,
             original: fundingTransaction,
+            estimatedFees: await fundingTransaction.estimateTransactionFees(),
         };
     }
 }

package/src/transaction/browser/BrowserSignerBase.ts

@@ -0,0 +1,44 @@
+import { Network, Psbt, Signer } from 'bitcoinjs-lib';
+import { Address } from '@btc-vision/bsi-binary';
+
+/**
+ * Create a custom keypair.
+ * @class CustomKeypair
+ */
+export abstract class CustomKeypair implements Signer {
+    public abstract network: Network;
+
+    public abstract publicKey: Buffer;
+
+    public abstract addresses: Address[];
+
+    public abstract p2tr: Address;
+    public abstract p2pkh: Address;
+
+    protected constructor() {}
+
+    /*public abstract signTransaction(
+        transaction: Psbt,
+        input: PsbtInput,
+        i: number,
+        sighashTypes: number[],
+    ): Promise<Psbt>;*/
+
+    public abstract signTaprootInput(
+        transaction: Psbt,
+        i: number,
+        sighashTypes: number[],
+    ): Promise<void>;
+
+    public abstract signInput(transaction: Psbt, i: number, sighashTypes: number[]): Promise<void>;
+
+    public abstract getPublicKey(): Buffer;
+
+    public abstract sign(hash: Buffer, lowR?: boolean): Buffer;
+
+    public abstract signSchnorr(hash: Buffer): Buffer;
+
+    public abstract verify(hash: Buffer, signature: Buffer): boolean;
+
+    public abstract init(): Promise<void>;
+}

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

@@ -0,0 +1,218 @@
+import { CustomKeypair } from '../BrowserSignerBase.js';
+import { Network, networks, Psbt } from 'bitcoinjs-lib';
+import { PsbtSignatureOptions, Unisat, UnisatNetwork } from '../types/Unisat.js';
+import { Address } from '@btc-vision/bsi-binary';
+import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
+import { ECPairInterface } from 'ecpair';
+import { TapScriptSig } from 'bip174/src/lib/interfaces.js';
+
+declare global {
+    interface Window {
+        unisat?: Unisat;
+    }
+}
+
+export class UnisatSigner extends CustomKeypair {
+    private isInitialized: boolean = false;
+
+    constructor() {
+        super();
+
+        if (!window) {
+            throw new Error('UnisatSigner can only be used in a browser environment');
+        }
+    }
+
+    private _p2tr: Address | undefined;
+
+    public get p2tr(): Address {
+        if (!this._p2tr) {
+            throw new Error('P2TR address not set');
+        }
+
+        return this._p2tr;
+    }
+
+    private _p2pkh: Address | undefined;
+
+    public get p2pkh(): Address {
+        if (!this._p2pkh) {
+            throw new Error('P2PKH address not set');
+        }
+
+        return this._p2pkh;
+    }
+
+    private _addresses: Address[] | undefined;
+
+    public get addresses(): Address[] {
+        if (!this._addresses) {
+            throw new Error('Addresses not set');
+        }
+
+        return this._addresses;
+    }
+
+    private _publicKey: Buffer | undefined;
+
+    public get publicKey(): Buffer {
+        if (!this._publicKey) {
+            throw new Error('Public key not set');
+        }
+
+        return this._publicKey;
+    }
+
+    public _network: Network | undefined;
+
+    public get network(): Network {
+        if (!this._network) {
+            throw new Error('Network not set');
+        }
+
+        return this._network;
+    }
+
+    public get unisat(): Unisat {
+        if (!window.unisat) {
+            throw new Error('Unisat extension not found');
+        }
+
+        return window.unisat;
+    }
+
+    public async init(): Promise<void> {
+        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 as unknown as ECPairInterface, this.network);
+
+        this._p2tr = EcKeyPair.getTaprootAddress(this as unknown as ECPairInterface, this.network);
+
+        this._addresses = [this._p2pkh, this._p2tr];
+
+        this.isInitialized = true;
+    }
+
+    public getPublicKey(): Buffer {
+        if (!this.isInitialized) {
+            throw new Error('UnisatSigner not initialized');
+        }
+
+        return this.publicKey;
+    }
+
+    public sign(hash: Buffer, lowR?: boolean): Buffer {
+        throw new Error('Not implemented: sign');
+    }
+
+    public signSchnorr(hash: Buffer): Buffer {
+        throw new Error('Not implemented: signSchnorr');
+    }
+
+    public verify(hash: Buffer, signature: Buffer): boolean {
+        throw new Error('Not implemented: verify');
+    }
+
+    public async signTaprootInput(
+        transaction: Psbt,
+        i: number,
+        sighashTypes: number[],
+    ): Promise<void> {
+        let firstSignature = await this.signTweaked(transaction, i, sighashTypes, false);
+        this.combine(transaction, firstSignature, i);
+    }
+
+    public async signInput(transaction: Psbt, i: number, sighashTypes: number[]): Promise<void> {
+        const secondSignature = await this.signTweaked(transaction, i, sighashTypes, true);
+
+        this.combine(transaction, secondSignature, i);
+    }
+
+    private combine(transaction: Psbt, newPsbt: Psbt, i: number): void {
+        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 });
+            }
+        }
+    }
+
+    private async signTweaked(
+        transaction: Psbt,
+        i: number,
+        sighashTypes: number[],
+        disableTweakSigner: boolean = false,
+    ): Promise<Psbt> {
+        const opts: PsbtSignatureOptions = {
+            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);
+    }
+
+    private getNonDuplicateScriptSig(
+        scriptSig1: TapScriptSig[],
+        scriptSig2: TapScriptSig[],
+    ): TapScriptSig[] {
+        const nonDuplicate: TapScriptSig[] = [];
+        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/src/transaction/browser/types/Unisat.ts

@@ -0,0 +1,77 @@
+import { Address } from '@btc-vision/bsi-binary';
+
+export enum UnisatNetwork {
+    testnet = 'testnet',
+    mainnet = 'livenet',
+    regtest = 'regtest',
+}
+
+export interface Balance {
+    readonly confirmed: number;
+    readonly unconfirmed: number;
+    readonly total: number;
+}
+
+export 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;
+}

package/src/transaction/builders/DeploymentTransaction.ts

@@ -139,7 +139,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * Build the transaction
      * @protected
      */
-    protected override buildTransaction(): void {
+    protected override async buildTransaction(): Promise<void> {
         if (!this.to) {
             this.to = this.getScriptAddress();
         }
@@ -174,7 +174,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
             address: this.to,
         });
 
-        this.addRefundOutput(amountSpent);
+        await this.addRefundOutput(amountSpent);
     }
 
     /**
@@ -182,9 +182,9 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * @param {Psbt} transaction The transaction to sign
      * @protected
      */
-    protected signInputs(transaction: Psbt): void {
+    protected async signInputs(transaction: Psbt): Promise<void> {
         if (!this.contractSigner) {
-            super.signInputs(transaction);
+            await super.signInputs(transaction);
 
             return;
         }