@btc-vision/transaction 1.1.15 → 1.1.17

package/src/transaction/TransactionFactory.ts

@@ -51,15 +51,6 @@ export interface BitcoinTransferResponse {
     readonly nextUTXOs: UTXO[];
 }
 
-/*export interface UnwrapResult {
-    readonly fundingTransaction: string;
-    readonly psbt: string;
-
-    readonly feeRefundOrLoss: bigint;
-
-    readonly utxos: UTXO[];
-}*/
-
 export class TransactionFactory {
     /**
      * @description Generate a transaction with a custom script.
@@ -283,220 +274,6 @@ export class TransactionFactory {
         };
     }
 
-    /**
-     * Basically it's fun to manage UTXOs.
-     * @param {IWrapParameters} wrapParameters - The wrap parameters
-     * @returns {Promise<WrapResult>} - The signed transaction
-     * @throws {Error} - If the transaction could not be signed
-     */
-    /*public async wrap(wrapParameters: Omit<IWrapParameters, 'calldata'>): Promise<WrapResult> {
-        if (wrapParameters.amount < currentConsensusConfig.VAULT_MINIMUM_AMOUNT) {
-            throw new Error(
-                `Amount is too low. Minimum consolidation is ${currentConsensusConfig.VAULT_MINIMUM_AMOUNT} sat. Received ${wrapParameters.amount} sat. Make sure that you cover the unwrap consolidation fees of ${currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT}sat.`,
-            );
-        }
-
-        const childTransactionRequiredValue: bigint =
-            wrapParameters.amount +
-            currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT +
-            this.getPriorityFee(wrapParameters);
-
-        const wbtc: wBTC = new wBTC(wrapParameters.network, wrapParameters.chainId);
-        const to = wbtc.getAddress();
-        const fundingParameters: IFundingTransactionParameters = {
-            ...wrapParameters,
-            amount: childTransactionRequiredValue,
-            to: wrapParameters.to ?? to,
-        };
-
-        const preFundingTransaction = await this.createFundTransaction(fundingParameters);
-        wrapParameters.utxos = this.getUTXOAsTransaction(preFundingTransaction.tx, to, 0);
-
-        const preTransaction: WrapTransaction = new WrapTransaction(wrapParameters);
-
-        // Initial generation
-        await preTransaction.signTransaction();
-
-        const parameters: IFundingTransactionParameters =
-            await preTransaction.getFundingTransactionParameters();
-
-        // We add the amount
-        parameters.amount += childTransactionRequiredValue;
-        parameters.utxos = fundingParameters.utxos;
-
-        const signedTransaction = await this.createFundTransaction(parameters);
-        if (!signedTransaction) {
-            throw new Error('Could not sign funding transaction.');
-        }
-
-        const newParams: IWrapParameters = {
-            ...wrapParameters,
-            utxos: this.getUTXOAsTransaction(signedTransaction.tx, to, 0), // always 0
-            randomBytes: preTransaction.getRndBytes(),
-            nonWitnessUtxo: signedTransaction.tx.toBuffer(),
-        };
-
-        const finalTransaction: WrapTransaction = new WrapTransaction(newParams);
-
-        // We have to regenerate using the new utxo
-        const outTx: Transaction = await finalTransaction.signTransaction();
-        return {
-            transaction: [signedTransaction.tx.toHex(), outTx.toHex()],
-            vaultAddress: finalTransaction.vault,
-            amount: finalTransaction.amount,
-            receiverAddress: finalTransaction.receiver.p2tr(wrapParameters.network),
-            utxos: this.getUTXOAsTransaction(signedTransaction.tx, wrapParameters.from, 1),
-        };
-    }*/
-
-    /**
-     * Unwrap bitcoin.
-     * @param {IUnwrapParameters} unwrapParameters - The unwrap parameters
-     * @returns {Promise<UnwrapResult>} - The signed transaction
-     * @throws {Error} - If the transaction could not be signed
-     * @deprecated
-     */
-    /*public async unwrapSegwit(unwrapParameters: IUnwrapParameters): Promise<UnwrapResult> {
-        console.error('The "unwrap" method is deprecated. Use unwrapTap instead.');
-
-        const transaction: UnwrapSegwitTransaction = new UnwrapSegwitTransaction(unwrapParameters);
-        await transaction.signTransaction();
-
-        const to = transaction.toAddress();
-        if (!to) throw new Error('To address is required');
-
-        // Initial generation
-        const estimatedGas = await transaction.estimateTransactionFees();
-        const estimatedFees = transaction.preEstimateTransactionFees(
-            BigInt(unwrapParameters.feeRate),
-            this.calculateNumInputs(unwrapParameters.unwrapUTXOs),
-            2n,
-            this.calculateNumSignatures(unwrapParameters.unwrapUTXOs),
-            this.maxPubKeySize(unwrapParameters.unwrapUTXOs),
-        );
-
-        const fundingParameters: IFundingTransactionParameters = {
-            ...unwrapParameters,
-            amount: estimatedGas + estimatedFees,
-            to: to,
-        };
-
-        const preFundingTransaction = await this.createFundTransaction(fundingParameters);
-        unwrapParameters.utxos = this.getUTXOAsTransaction(preFundingTransaction.tx, to, 0);
-
-        const preTransaction: UnwrapSegwitTransaction = new UnwrapSegwitTransaction({
-            ...unwrapParameters,
-            randomBytes: transaction.getRndBytes(),
-        });
-
-        // Initial generation
-        await preTransaction.signTransaction();
-
-        const parameters: IFundingTransactionParameters =
-            await preTransaction.getFundingTransactionParameters();
-
-        parameters.utxos = fundingParameters.utxos;
-        parameters.amount = (await preTransaction.estimateTransactionFees()) + estimatedFees;
-
-        const signedTransaction = await this.createFundTransaction(parameters);
-        if (!signedTransaction) {
-            throw new Error('Could not sign funding transaction.');
-        }
-
-        const newParams: IUnwrapParameters = {
-            ...unwrapParameters,
-            utxos: this.getUTXOAsTransaction(signedTransaction.tx, to, 0), // always 0
-            randomBytes: preTransaction.getRndBytes(),
-            nonWitnessUtxo: signedTransaction.tx.toBuffer(),
-        };
-
-        const finalTransaction: UnwrapSegwitTransaction = new UnwrapSegwitTransaction(newParams);
-
-        // We have to regenerate using the new utxo
-        const outTx: Psbt = await finalTransaction.signPSBT();
-        const asBase64 = outTx.toBase64();
-        const psbt = this.writePSBTHeader(PSBTTypes.UNWRAP, asBase64);
-
-        return {
-            fundingTransaction: signedTransaction.tx.toHex(),
-            psbt: psbt,
-            feeRefundOrLoss: estimatedFees,
-            utxos: [],
-        };
-    }*/
-
-    /**
-     * Unwrap bitcoin via taproot.
-     * @param {IUnwrapParameters} unwrapParameters - The unwrap parameters
-     * @returns {Promise<UnwrapResult>} - The signed transaction
-     * @throws {Error} - If the transaction could not be signed
-     */
-
-    /*public async unwrap(unwrapParameters: IUnwrapParameters): Promise<UnwrapResult> {
-        if (!unwrapParameters.from) {
-            throw new Error('Field "from" not provided.');
-        }
-
-        const transaction: UnwrapTransaction = new UnwrapTransaction(unwrapParameters);
-        await transaction.signTransaction();
-
-        const to = transaction.toAddress();
-        if (!to) throw new Error('To address is required');
-
-        // Initial generation
-        const estimatedGas = await transaction.estimateTransactionFees();
-        const fundingParameters: IFundingTransactionParameters = {
-            ...unwrapParameters,
-            amount: estimatedGas,
-            to: to,
-        };
-
-        const preFundingTransaction = await this.createFundTransaction(fundingParameters);
-        unwrapParameters.utxos = this.getUTXOAsTransaction(preFundingTransaction.tx, to, 0);
-
-        const preTransaction: UnwrapTransaction = new UnwrapTransaction({
-            ...unwrapParameters,
-            randomBytes: transaction.getRndBytes(),
-        });
-
-        // Initial generation
-        await preTransaction.signTransaction();
-
-        const parameters: IFundingTransactionParameters =
-            await preTransaction.getFundingTransactionParameters();
-
-        parameters.utxos = fundingParameters.utxos;
-        parameters.amount =
-            (await preTransaction.estimateTransactionFees()) +
-            this.getPriorityFee(unwrapParameters);
-
-        const signedTransaction = await this.createFundTransaction(parameters);
-        if (!signedTransaction) {
-            throw new Error('Could not sign funding transaction.');
-        }
-
-        const newParams: IUnwrapParameters = {
-            ...unwrapParameters,
-            utxos: this.getUTXOAsTransaction(signedTransaction.tx, to, 0), // always 0
-            randomBytes: preTransaction.getRndBytes(),
-            nonWitnessUtxo: signedTransaction.tx.toBuffer(),
-        };
-
-        const finalTransaction: UnwrapTransaction = new UnwrapTransaction(newParams);
-
-        // We have to regenerate using the new utxo
-        const outTx: Psbt = await finalTransaction.signPSBT();
-        const asBase64 = outTx.toBase64();
-        const psbt = this.writePSBTHeader(PSBTTypes.UNWRAP, asBase64);
-
-        return {
-            fundingTransaction: signedTransaction.tx.toHex(),
-            psbt: psbt,
-            feeRefundOrLoss: finalTransaction.getFeeLossOrRefund(),
-            utxos: this.getUTXOAsTransaction(signedTransaction.tx, unwrapParameters.from, 1),
-        };
-    }*/
-
     /**
      * @description Creates a funding transaction.
      * @param {IFundingTransactionParameters} parameters - The funding transaction parameters
@@ -566,36 +343,6 @@ export class TransactionFactory {
         };
     }
 
-    /*private calculateNumSignatures(vault: VaultUTXOs[]): bigint {
-        let numSignatures = 0n;
-
-        for (const v of vault) {
-            numSignatures += BigInt(v.minimum * v.utxos.length);
-        }
-
-        return numSignatures;
-    }
-
-    private calculateNumInputs(vault: VaultUTXOs[]): bigint {
-        let numSignatures = 0n;
-
-        for (const v of vault) {
-            numSignatures += BigInt(v.utxos.length);
-        }
-
-        return numSignatures;
-    }
-
-    private maxPubKeySize(vault: VaultUTXOs[]): bigint {
-        let size = 0;
-
-        for (const v of vault) {
-            size = Math.max(size, v.publicKeys.length);
-        }
-
-        return BigInt(size);
-    }*/
-
     private writePSBTHeader(type: PSBTTypes, psbt: string): string {
         const buf = Buffer.from(psbt, 'base64');
 

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

@@ -2,9 +2,7 @@ import {
     crypto as bitCrypto,
     Network,
     networks,
-    opcodes,
     Psbt,
-    PsbtInput,
     script as bitScript,
     TapScriptSig,
 } from '@btc-vision/bitcoin';
@@ -14,6 +12,7 @@ import { CustomKeypair } from '../BrowserSignerBase.js';
 import { PsbtSignatureOptions, Unisat, UnisatNetwork } from '../types/Unisat.js';
 import { PartialSig } from 'bip174/src/lib/interfaces.js';
 import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import { canSignNonTaprootInput, isTaprootInput } from '../../../signer/SignerUtils.js';
 
 declare global {
     interface Window {
@@ -219,14 +218,10 @@ export class UnisatSigner extends CustomKeypair {
                                 viaTaproot = true;
                             }
                         }
-                    } else {
+                    } else if (canSignNonTaprootInput(input, this.publicKey)) {
                         // Non-Taproot input
-                        const script = getInputRelevantScript(input);
-
-                        if (script && pubkeyInScript(this.publicKey, script)) {
-                            needsToSign = true;
-                            viaTaproot = false;
-                        }
+                        needsToSign = true;
+                        viaTaproot = false;
                     }
 
                     if (needsToSign) {
@@ -357,37 +352,6 @@ export class UnisatSigner extends CustomKeypair {
     }
 }
 
-// Helper functions
-function isTaprootInput(input: PsbtInput): boolean {
-    if (input.tapInternalKey || input.tapKeySig || input.tapScriptSig || input.tapLeafScript) {
-        return true;
-    }
-
-    if (input.witnessUtxo) {
-        const script = input.witnessUtxo.script;
-        return script.length === 34 && script[0] === opcodes.OP_1 && script[1] === 0x20;
-    }
-
-    return false;
-}
-
-function getInputRelevantScript(input: PsbtInput): Buffer | null {
-    if (input.redeemScript) {
-        return input.redeemScript;
-    }
-    if (input.witnessScript) {
-        return input.witnessScript;
-    }
-    if (input.witnessUtxo) {
-        return input.witnessUtxo.script;
-    }
-    if (input.nonWitnessUtxo) {
-        // Additional logic can be added here if needed
-        return null;
-    }
-    return null;
-}
-
 function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean {
     return pubkeyPositionInScript(pubkey, script) !== -1;
 }

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

@@ -1,13 +1,4 @@
-import {
-    crypto as bitCrypto,
-    script as bitScript,
-    Network,
-    networks,
-    opcodes,
-    Psbt,
-    PsbtInput,
-    TapScriptSig,
-} from '@btc-vision/bitcoin';
+import { Network, networks, Psbt, TapScriptSig } from '@btc-vision/bitcoin';
 import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
 import { PartialSig } from 'bip174/src/lib/interfaces.js';
 import { ECPairInterface } from 'ecpair';
@@ -15,6 +6,11 @@ import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
 import { CustomKeypair } from '../BrowserSignerBase.js';
 import { PsbtSignatureOptions } from '../types/Unisat.js';
 import { Xverse, XverseRPCGetAccountResponse, XverseRPCSignPsbtResponse } from '../types/Xverse.js';
+import {
+    canSignNonTaprootInput,
+    isTaprootInput,
+    pubkeyInScript,
+} from '../../../signer/SignerUtils.js';
 
 declare global {
     interface Window {
@@ -226,14 +222,10 @@ export class XverseSigner extends CustomKeypair {
                                 viaTaproot = true;
                             }
                         }
-                    } else {
+                    } else if (canSignNonTaprootInput(input, this.publicKey)) {
                         // Non-Taproot input
-                        const script = getInputRelevantScript(input);
-
-                        if (script && pubkeyInScript(this.publicKey, script)) {
-                            needsToSign = true;
-                            viaTaproot = false;
-                        }
+                        needsToSign = true;
+                        viaTaproot = false;
                     }
 
                     if (needsToSign) {
@@ -376,54 +368,3 @@ export class XverseSigner extends CustomKeypair {
         return nonDuplicate;
     }
 }
-
-// Helper functions
-function isTaprootInput(input: PsbtInput): boolean {
-    if (input.tapInternalKey || input.tapKeySig || input.tapScriptSig || input.tapLeafScript) {
-        return true;
-    }
-
-    if (input.witnessUtxo) {
-        const script = input.witnessUtxo.script;
-        return script.length === 34 && script[0] === opcodes.OP_1 && script[1] === 0x20;
-    }
-
-    return false;
-}
-
-function getInputRelevantScript(input: PsbtInput): Buffer | null {
-    if (input.redeemScript) {
-        return input.redeemScript;
-    }
-    if (input.witnessScript) {
-        return input.witnessScript;
-    }
-    if (input.witnessUtxo) {
-        return input.witnessUtxo.script;
-    }
-    if (input.nonWitnessUtxo) {
-        // Additional logic can be added here if needed
-        return null;
-    }
-    return null;
-}
-
-function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean {
-    return pubkeyPositionInScript(pubkey, script) !== -1;
-}
-
-function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number {
-    const pubkeyHash = bitCrypto.hash160(pubkey);
-    const pubkeyXOnly = toXOnly(pubkey);
-
-    const decompiled = bitScript.decompile(script);
-    if (decompiled === null) throw new Error('Unknown script error');
-
-    return decompiled.findIndex((element) => {
-        if (typeof element === 'number') return false;
-        return (
-            Buffer.isBuffer(element) &&
-            (element.equals(pubkey) || element.equals(pubkeyHash) || element.equals(pubkeyXOnly))
-        );
-    });
-}

package/src/transaction/builders/FundingTransaction.ts

@@ -1,6 +1,6 @@
 import { TransactionType } from '../enums/TransactionType.js';
 import { IFundingTransactionParameters } from '../interfaces/ITransactionParameters.js';
-import { Signer } from '@btc-vision/bitcoin';
+import { opcodes, script, Signer } from '@btc-vision/bitcoin';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { ECPairInterface } from 'ecpair';
 
@@ -29,9 +29,14 @@ export class FundingTransaction extends TransactionBuilder<TransactionType.FUNDI
         if (this.splitInputsInto > 1) {
             this.splitInputs(this.amount);
         } else if (this.isPubKeyDestination) {
+            const p2pkScript = script.compile([
+                Buffer.from(this.to.replace('0x', ''), 'hex'),
+                opcodes.OP_CHECKSIG,
+            ]);
+
             this.addOutput({
                 value: Number(this.amount),
-                script: Buffer.from(this.to.slice(2), 'hex'),
+                script: p2pkScript,
             });
         } else {
             this.addOutput({

package/src/transaction/builders/TransactionBuilder.ts

@@ -151,7 +151,9 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         this.utxos = parameters.utxos;
         this.to = parameters.to || undefined;
 
-        this.isPubKeyDestination = this.to ? this.to.startsWith('0x') : false;
+        this.isPubKeyDestination = this.to
+            ? AddressVerificator.isValidPublicKey(this.to, this.network)
+            : false;
 
         this.optionalOutputs = parameters.optionalOutputs;