@btc-vision/transaction 1.0.88 → 1.0.90

package/src/transaction/TransactionFactory.ts

@@ -19,6 +19,8 @@ import { VaultUTXOs } from './processor/PsbtTransaction.js';
 import { UnwrapSegwitTransaction } from './builders/UnwrapSegwitTransaction.js';
 import { UnwrapTransaction } from './builders/UnwrapTransaction.js';
 import { currentConsensus, currentConsensusConfig } from '../consensus/ConsensusConfig.js';
+import { TransactionBuilder } from './builders/TransactionBuilder.js';
+import { TransactionType } from './enums/TransactionType.js';
 
 export interface DeploymentResult {
     readonly transaction: [string, string];
@@ -37,6 +39,20 @@ export interface WrapResult {
     readonly utxos: UTXO[];
 }
 
+export interface FundingTransactionResponse {
+    readonly tx: Transaction;
+    readonly original: FundingTransaction;
+    readonly estimatedFees: bigint;
+    readonly nextUTXOs: UTXO[];
+}
+
+export interface BitcoinTransferResponse {
+    readonly tx: string;
+    readonly original: FundingTransaction;
+    readonly estimatedFees: bigint;
+    readonly nextUTXOs: UTXO[];
+}
+
 export interface UnwrapResult {
     readonly fundingTransaction: string;
     readonly psbt: string;
@@ -403,11 +419,9 @@ export class TransactionFactory {
      * @param {IFundingTransactionParameters} parameters - The funding transaction parameters
      * @returns {Promise<{ estimatedFees: bigint; tx: string }>} - The signed transaction
      */
-    public async createBTCTransfer(parameters: IFundingTransactionParameters): Promise<{
-        estimatedFees: bigint;
-        tx: string;
-        nextUTXOs: UTXO[];
-    }> {
+    public async createBTCTransfer(
+        parameters: IFundingTransactionParameters,
+    ): Promise<BitcoinTransferResponse> {
         if (!parameters.from) {
             throw new Error('Field "from" not provided.');
         }
@@ -416,16 +430,45 @@ export class TransactionFactory {
 
         return {
             estimatedFees: resp.estimatedFees,
+            original: resp.original,
             tx: resp.tx.toHex(),
-            nextUTXOs: this.getUTXOAsTransaction(resp.tx, parameters.from, 1),
+            nextUTXOs: this.getAllNewUTXOs(resp.original, resp.tx, parameters.from),
         };
     }
 
-    private async createFundTransaction(parameters: IFundingTransactionParameters): Promise<{
-        tx: Transaction;
-        original: FundingTransaction;
-        estimatedFees: bigint;
-    }> {
+    /**
+     * Get all new UTXOs of a generated transaction.
+     * @param {TransactionBuilder<TransactionType>} original - The original transaction
+     * @param {Transaction} tx - The transaction
+     * @param {Address} to - The address to filter
+     */
+    public getAllNewUTXOs(
+        original: TransactionBuilder<TransactionType>,
+        tx: Transaction,
+        to: Address,
+    ): UTXO[] {
+        const outputs = original.getOutputs();
+
+        const utxos: UTXO[] = [];
+        for (let i = 0; i < tx.outs.length; i++) {
+            const output = outputs[i];
+            if ('address' in output) {
+                if (output.address !== to) continue;
+            } else {
+                continue;
+            }
+
+            utxos.push(...this.getUTXOAsTransaction(tx, to, i));
+        }
+
+        return utxos;
+    }
+
+    private async createFundTransaction(
+        parameters: IFundingTransactionParameters,
+    ): Promise<FundingTransactionResponse> {
+        if (!parameters.to) throw new Error('Field "to" not provided.');
+
         const fundingTransaction: FundingTransaction = new FundingTransaction(parameters);
         const signedTransaction: Transaction = await fundingTransaction.signTransaction();
         if (!signedTransaction) {
@@ -435,7 +478,8 @@ export class TransactionFactory {
         return {
             tx: signedTransaction,
             original: fundingTransaction,
-            estimatedFees: await fundingTransaction.estimateTransactionFees(),
+            estimatedFees: fundingTransaction.estimatedFees,
+            nextUTXOs: this.getUTXOAsTransaction(signedTransaction, parameters.to, 0),
         };
     }
 

package/src/transaction/builders/FundingTransaction.ts

@@ -6,13 +6,13 @@ import { TransactionBuilder } from './TransactionBuilder.js';
 export class FundingTransaction extends TransactionBuilder<TransactionType.FUNDING> {
     public readonly type: TransactionType.FUNDING = TransactionType.FUNDING;
 
-    protected childTransactionRequiredFees: bigint;
+    protected amount: bigint;
     protected splitInputsInto: number;
 
     constructor(parameters: IFundingTransactionParameters) {
         super(parameters);
 
-        this.childTransactionRequiredFees = parameters.amount;
+        this.amount = parameters.amount;
         this.splitInputsInto = parameters.splitInputsInto ?? 1;
 
         this.internalInit();
@@ -25,10 +25,16 @@ export class FundingTransaction extends TransactionBuilder<TransactionType.FUNDI
 
         this.addInputsFromUTXO();
 
-        const amountSpent: bigint =
-            this.getTransactionOPNetFee() + this.childTransactionRequiredFees;
+        let amountSpent: bigint = this.amount;
+        if (this.getTransactionOPNetFee() === TransactionBuilder.MINIMUM_DUST) {
+            if (amountSpent < TransactionBuilder.MINIMUM_DUST) {
+                amountSpent += TransactionBuilder.MINIMUM_DUST;
+            }
+        } else {
+            amountSpent += this.getTransactionOPNetFee();
+        }
 
-        if(this.splitInputsInto > 1) {
+        if (this.splitInputsInto > 1) {
             await this.splitInputs(amountSpent);
         } else {
             this.addOutput({

package/src/transaction/builders/TransactionBuilder.ts

@@ -222,6 +222,10 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
      * @throws {Error} - If something went wrong
      */
     public async signTransaction(): Promise<Transaction> {
+        if (!this.utxos.length) {
+            throw new Error('No UTXOs specified');
+        }
+
         if (this.to && !EcKeyPair.verifyContractAddress(this.to, this.network)) {
             throw new Error(
                 'Invalid contract address. The contract address must be a taproot address.',
@@ -337,6 +341,10 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
      * @returns {Promise<bigint>} - The estimated transaction fees
      */
     public async estimateTransactionFees(): Promise<bigint> {
+        if (!this.utxos.length) {
+            throw new Error('No UTXOs specified');
+        }
+
         if (this.estimatedFees) return this.estimatedFees;
 
         const fakeTx = new Psbt({
@@ -372,6 +380,27 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         this.transaction = psbt;
     }
 
+    /**
+     * Returns the inputs of the transaction.
+     * @protected
+     * @returns {PsbtInputExtended[]}
+     */
+    public getInputs(): PsbtInputExtended[] {
+        return this.inputs;
+    }
+
+    /**
+     * Returns the outputs of the transaction.
+     * @protected
+     * @returns {PsbtOutputExtended[]}
+     */
+    public getOutputs(): PsbtOutputExtended[] {
+        const outputs: PsbtOutputExtended[] = [...this.outputs];
+        if (this.feeOutput) outputs.push(this.feeOutput);
+
+        return outputs;
+    }
+
     /**
      * @description Adds the refund output to the transaction
      * @param {bigint} amountSpent - The amount spent
@@ -381,6 +410,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
     protected async addRefundOutput(amountSpent: bigint): Promise<void> {
         /** Add the refund output */
         const sendBackAmount: bigint = this.totalInputAmount - amountSpent;
+
         if (sendBackAmount >= TransactionBuilder.MINIMUM_DUST) {
             if (AddressVerificator.isValidP2TRAddress(this.from, this.network)) {
                 await this.setFeeOutput({
@@ -548,27 +578,6 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         return this.tapData.output;
     }
 
-    /**
-     * Returns the inputs of the transaction.
-     * @protected
-     * @returns {PsbtInputExtended[]}
-     */
-    protected getInputs(): PsbtInputExtended[] {
-        return this.inputs;
-    }
-
-    /**
-     * Returns the outputs of the transaction.
-     * @protected
-     * @returns {PsbtOutputExtended[]}
-     */
-    protected getOutputs(): PsbtOutputExtended[] {
-        const outputs: PsbtOutputExtended[] = [...this.outputs];
-        if (this.feeOutput) outputs.push(this.feeOutput);
-
-        return outputs;
-    }
-
     /**
      * Verifies that the utxos are valid.
      * @protected