@btc-vision/transaction 1.6.6 → 1.6.7

package/browser/transaction/TransactionFactory.d.ts

@@ -36,6 +36,11 @@ export interface BitcoinTransferResponse extends BitcoinTransferBase {
     readonly original: FundingTransaction;
 }
 export declare class TransactionFactory {
+    debug: boolean;
+    private readonly DUMMY_PUBKEY;
+    private readonly P2TR_SCRIPT;
+    private readonly INITIAL_FUNDING_ESTIMATE;
+    private readonly MAX_ITERATIONS;
     createCustomScriptTransaction(interactionParameters: ICustomTransactionParameters): Promise<[string, string, UTXO[]]>;
     signInteraction(interactionParameters: IInteractionParameters | InteractionParametersWithoutSigner): Promise<InteractionResponse>;
     signDeployment(deploymentParameters: IDeploymentParameters): Promise<DeploymentResult>;
@@ -49,5 +54,6 @@ export declare class TransactionFactory {
     private writePSBTHeader;
     private signP2WDAInteraction;
     private getPriorityFee;
+    private iterateFundingAmount;
     private getUTXOAsTransaction;
 }

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

@@ -6,6 +6,7 @@ import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { ECPairInterface } from 'ecpair';
 import { TweakedTransaction } from '../shared/TweakedTransaction.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
+import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
 export declare const MINIMUM_AMOUNT_REWARD: bigint;
 export declare const MINIMUM_AMOUNT_CA: bigint;
 export declare const ANCHOR_SCRIPT: Buffer<ArrayBuffer>;
@@ -14,6 +15,7 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     static readonly MINIMUM_DUST: bigint;
     abstract readonly type: T;
     readonly logColor: string;
+    debugFees: boolean;
     overflowFees: bigint;
     transactionFee: bigint;
     estimatedFees: bigint;
@@ -36,6 +38,7 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     protected isPubKeyDestination: boolean;
     protected anchor: boolean;
     protected note?: Buffer;
+    private optionalOutputsAdded;
     protected constructor(parameters: ITransactionParameters);
     static getFrom(from: string | undefined, keypair: ECPairInterface | Signer, network: Network): string;
     static witnessStackToScriptWitness(witness: Buffer[]): Buffer;
@@ -48,7 +51,8 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     generateTransactionMinimalSignatures(checkPartialSigs?: boolean): Promise<void>;
     signPSBT(): Promise<Psbt>;
     addInput(input: PsbtInputExtended): void;
-    addOutput(output: PsbtOutputExtended): void;
+    addOutput(output: PsbtOutputExtended, bypassMinCheck?: boolean): void;
+    getTotalOutputValue(): bigint;
     toAddress(): string | undefined;
     address(): string | undefined;
     estimateTransactionFees(): Promise<bigint>;
@@ -67,6 +71,7 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     protected internalInit(): void;
     protected abstract buildTransaction(): Promise<void>;
     protected updateInput(input: UpdateInput): void;
+    protected addFeeToOutput(amountSpent: bigint, contractAddress: string, epochChallenge: IP2WSHAddress, addContractOutput: boolean): void;
     protected getWitness(): Buffer;
     protected getTapOutput(): Buffer;
     protected verifyUTXOValidity(): void;

package/browser/transaction/interfaces/ITransactionParameters.d.ts

@@ -9,6 +9,7 @@ export interface LoadedStorage {
 export interface ITransactionParameters extends ITweakedTransactionData {
     readonly from?: string;
     readonly to?: string;
+    readonly debugFees?: boolean;
     utxos: UTXO[];
     nonWitnessUtxo?: Buffer;
     estimatedFees?: bigint;

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.6.6";
+export declare const version = "1.6.7";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.6.6';
+export const version = '1.6.7';

package/build/transaction/TransactionFactory.d.ts

@@ -36,6 +36,11 @@ export interface BitcoinTransferResponse extends BitcoinTransferBase {
     readonly original: FundingTransaction;
 }
 export declare class TransactionFactory {
+    debug: boolean;
+    private readonly DUMMY_PUBKEY;
+    private readonly P2TR_SCRIPT;
+    private readonly INITIAL_FUNDING_ESTIMATE;
+    private readonly MAX_ITERATIONS;
     createCustomScriptTransaction(interactionParameters: ICustomTransactionParameters): Promise<[string, string, UTXO[]]>;
     signInteraction(interactionParameters: IInteractionParameters | InteractionParametersWithoutSigner): Promise<InteractionResponse>;
     signDeployment(deploymentParameters: IDeploymentParameters): Promise<DeploymentResult>;
@@ -49,5 +54,6 @@ export declare class TransactionFactory {
     private writePSBTHeader;
     private signP2WDAInteraction;
     private getPriorityFee;
+    private iterateFundingAmount;
     private getUTXOAsTransaction;
 }

package/build/transaction/TransactionFactory.js

@@ -1,3 +1,4 @@
+import { Transaction } from '@btc-vision/bitcoin';
 import { currentConsensus } from '../consensus/ConsensusConfig.js';
 import { CustomScriptTransaction, } from './builders/CustomScriptTransaction.js';
 import { DeploymentTransaction } from './builders/DeploymentTransaction.js';
@@ -6,7 +7,20 @@ import { InteractionTransaction } from './builders/InteractionTransaction.js';
 import { TransactionBuilder } from './builders/TransactionBuilder.js';
 import { P2WDADetector } from '../p2wda/P2WDADetector.js';
 import { InteractionTransactionP2WDA } from './builders/InteractionTransactionP2WDA.js';
+import { ChallengeSolution } from '../epoch/ChallengeSolution.js';
+import { Address } from '../keypair/Address.js';
+import { BitcoinUtils } from '../utils/BitcoinUtils.js';
 export class TransactionFactory {
+    constructor() {
+        this.debug = false;
+        this.DUMMY_PUBKEY = Buffer.alloc(32, 1);
+        this.P2TR_SCRIPT = Buffer.concat([
+            Buffer.from([0x51, 0x20]),
+            this.DUMMY_PUBKEY,
+        ]);
+        this.INITIAL_FUNDING_ESTIMATE = 2000n;
+        this.MAX_ITERATIONS = 10;
+    }
     async createCustomScriptTransaction(interactionParameters) {
         if (!interactionParameters.to) {
             throw new Error('Field "to" not provided.');
@@ -21,27 +35,24 @@ export class TransactionFactory {
             throw new Error('Field "signer" not provided, OP_WALLET not detected.');
         }
         const inputs = this.parseOptionalInputs(interactionParameters.optionalInputs);
-        const preTransaction = new CustomScriptTransaction({
-            ...interactionParameters,
-            utxos: [interactionParameters.utxos[0]],
-            optionalInputs: inputs,
-        });
-        await preTransaction.generateTransactionMinimalSignatures();
-        const parameters = await preTransaction.getFundingTransactionParameters();
+        const { finalTransaction, estimatedAmount, challenge } = await this.iterateFundingAmount({ ...interactionParameters, optionalInputs: inputs }, CustomScriptTransaction, async (tx) => {
+            const fee = await tx.estimateTransactionFees();
+            const priorityFee = this.getPriorityFee(interactionParameters);
+            const optionalValue = tx.getOptionalOutputValue();
+            return fee + priorityFee + optionalValue;
+        }, 'CustomScript');
+        const parameters = await finalTransaction.getFundingTransactionParameters();
         parameters.utxos = interactionParameters.utxos;
-        parameters.amount =
-            (await preTransaction.estimateTransactionFees()) +
-                this.getPriorityFee(interactionParameters) +
-                preTransaction.getOptionalOutputValue();
-        const feeEstimationFundingTransaction = await this.createFundTransaction({
+        parameters.amount = estimatedAmount;
+        const feeEstimationFunding = await this.createFundTransaction({
             ...parameters,
             optionalOutputs: [],
             optionalInputs: [],
         });
-        if (!feeEstimationFundingTransaction) {
+        if (!feeEstimationFunding) {
             throw new Error('Could not sign funding transaction.');
         }
-        parameters.estimatedFees = feeEstimationFundingTransaction.estimatedFees;
+        parameters.estimatedFees = feeEstimationFunding.estimatedFees;
         const signedTransaction = await this.createFundTransaction({
             ...parameters,
             optionalOutputs: [],
@@ -50,19 +61,16 @@ export class TransactionFactory {
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');
         }
-        interactionParameters.utxos = this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0);
         const newParams = {
             ...interactionParameters,
-            utxos: [
-                ...this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0),
-            ],
-            randomBytes: preTransaction.getRndBytes(),
+            utxos: this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0),
+            randomBytes: finalTransaction.getRndBytes(),
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
-            estimatedFees: preTransaction.estimatedFees,
+            estimatedFees: finalTransaction.estimatedFees,
             optionalInputs: inputs,
         };
-        const finalTransaction = new CustomScriptTransaction(newParams);
-        const outTx = await finalTransaction.signTransaction();
+        const customTransaction = new CustomScriptTransaction(newParams);
+        const outTx = await customTransaction.signTransaction();
         return [
             signedTransaction.tx.toHex(),
             outTx.toHex(),
@@ -91,27 +99,26 @@ export class TransactionFactory {
             return this.signP2WDAInteraction(interactionParameters);
         }
         const inputs = this.parseOptionalInputs(interactionParameters.optionalInputs);
-        const preTransaction = new InteractionTransaction({
-            ...interactionParameters,
-            utxos: [interactionParameters.utxos[0]],
-            optionalInputs: inputs,
-        });
-        await preTransaction.generateTransactionMinimalSignatures();
-        const parameters = await preTransaction.getFundingTransactionParameters();
+        const { finalTransaction, estimatedAmount, challenge } = await this.iterateFundingAmount({ ...interactionParameters, optionalInputs: inputs }, InteractionTransaction, async (tx) => {
+            const fee = await tx.estimateTransactionFees();
+            const outputsValue = tx.getTotalOutputValue();
+            return fee + outputsValue;
+        }, 'Interaction');
+        if (!challenge) {
+            throw new Error('Failed to get challenge from interaction transaction');
+        }
+        const parameters = await finalTransaction.getFundingTransactionParameters();
         parameters.utxos = interactionParameters.utxos;
-        parameters.amount =
-            (await preTransaction.estimateTransactionFees()) +
-                this.getPriorityFee(interactionParameters) +
-                preTransaction.getOptionalOutputValue();
-        const feeEstimationFundingTransaction = await this.createFundTransaction({
+        parameters.amount = estimatedAmount;
+        const feeEstimationFunding = await this.createFundTransaction({
             ...parameters,
             optionalOutputs: [],
             optionalInputs: [],
         });
-        if (!feeEstimationFundingTransaction) {
+        if (!feeEstimationFunding) {
             throw new Error('Could not sign funding transaction.');
         }
-        parameters.estimatedFees = feeEstimationFundingTransaction.estimatedFees;
+        parameters.estimatedFees = feeEstimationFunding.estimatedFees;
         const signedTransaction = await this.createFundTransaction({
             ...parameters,
             optionalOutputs: [],
@@ -120,26 +127,23 @@ export class TransactionFactory {
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');
         }
-        interactionParameters.utxos = this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0);
         const newParams = {
             ...interactionParameters,
-            utxos: [
-                ...this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0),
-            ],
-            randomBytes: preTransaction.getRndBytes(),
-            challenge: preTransaction.getChallenge(),
+            utxos: this.getUTXOAsTransaction(signedTransaction.tx, finalTransaction.getScriptAddress(), 0),
+            randomBytes: finalTransaction.getRndBytes(),
+            challenge: challenge,
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
-            estimatedFees: preTransaction.estimatedFees,
+            estimatedFees: finalTransaction.estimatedFees,
             optionalInputs: inputs,
         };
-        const finalTransaction = new InteractionTransaction(newParams);
-        const outTx = await finalTransaction.signTransaction();
+        const interactionTx = new InteractionTransaction(newParams);
+        const outTx = await interactionTx.signTransaction();
         return {
             fundingTransaction: signedTransaction.tx.toHex(),
             interactionTransaction: outTx.toHex(),
-            estimatedFees: preTransaction.estimatedFees,
+            estimatedFees: interactionTx.transactionFee,
             nextUTXOs: this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.from, 1),
-            challenge: preTransaction.getChallenge().toRaw(),
+            challenge: challenge.toRaw(),
         };
     }
     async signDeployment(deploymentParameters) {
@@ -151,27 +155,27 @@ export class TransactionFactory {
             throw new Error('Field "signer" not provided, OP_WALLET not detected.');
         }
         const inputs = this.parseOptionalInputs(deploymentParameters.optionalInputs);
-        const preTransaction = new DeploymentTransaction({
-            ...deploymentParameters,
-            utxos: [deploymentParameters.utxos[0]],
-            optionalInputs: inputs,
-        });
-        await preTransaction.generateTransactionMinimalSignatures();
-        const parameters = await preTransaction.getFundingTransactionParameters();
+        const { finalTransaction, estimatedAmount, challenge } = await this.iterateFundingAmount({ ...deploymentParameters, optionalInputs: inputs }, DeploymentTransaction, async (tx) => {
+            const fee = await tx.estimateTransactionFees();
+            const priorityFee = this.getPriorityFee(deploymentParameters);
+            const optionalValue = tx.getOptionalOutputValue();
+            return fee + priorityFee + optionalValue;
+        }, 'Deployment');
+        if (!challenge) {
+            throw new Error('Failed to get challenge from deployment transaction');
+        }
+        const parameters = await finalTransaction.getFundingTransactionParameters();
         parameters.utxos = deploymentParameters.utxos;
-        parameters.amount =
-            (await preTransaction.estimateTransactionFees()) +
-                this.getPriorityFee(deploymentParameters) +
-                preTransaction.getOptionalOutputValue();
-        const feeEstimationFundingTransaction = await this.createFundTransaction({
+        parameters.amount = estimatedAmount;
+        const feeEstimationFunding = await this.createFundTransaction({
             ...parameters,
             optionalOutputs: [],
             optionalInputs: [],
         });
-        if (!feeEstimationFundingTransaction) {
+        if (!feeEstimationFunding) {
             throw new Error('Could not sign funding transaction.');
         }
-        parameters.estimatedFees = feeEstimationFundingTransaction.estimatedFees;
+        parameters.estimatedFees = feeEstimationFunding.estimatedFees;
         const fundingTransaction = new FundingTransaction({
             ...parameters,
             optionalInputs: [],
@@ -187,21 +191,21 @@ export class TransactionFactory {
             outputIndex: 0,
             scriptPubKey: {
                 hex: out.script.toString('hex'),
-                address: preTransaction.getScriptAddress(),
+                address: finalTransaction.getScriptAddress(),
             },
             value: BigInt(out.value),
         };
         const newParams = {
             ...deploymentParameters,
             utxos: [newUtxo],
-            randomBytes: preTransaction.getRndBytes(),
-            challenge: preTransaction.getChallenge(),
+            randomBytes: finalTransaction.getRndBytes(),
+            challenge: challenge,
             nonWitnessUtxo: signedTransaction.toBuffer(),
-            estimatedFees: preTransaction.estimatedFees,
+            estimatedFees: finalTransaction.estimatedFees,
             optionalInputs: inputs,
         };
-        const finalTransaction = new DeploymentTransaction(newParams);
-        const outTx = await finalTransaction.signTransaction();
+        const deploymentTx = new DeploymentTransaction(newParams);
+        const outTx = await deploymentTx.signTransaction();
         const out2 = signedTransaction.outs[1];
         const refundUTXO = {
             transactionId: signedTransaction.getId(),
@@ -214,10 +218,10 @@ export class TransactionFactory {
         };
         return {
             transaction: [signedTransaction.toHex(), outTx.toHex()],
-            contractAddress: finalTransaction.getContractAddress(),
-            contractPubKey: finalTransaction.contractPubKey,
+            contractAddress: deploymentTx.getContractAddress(),
+            contractPubKey: deploymentTx.contractPubKey,
             utxos: [refundUTXO],
-            challenge: preTransaction.getChallenge().toRaw(),
+            challenge: challenge.toRaw(),
         };
     }
     async createBTCTransfer(parameters) {
@@ -352,6 +356,92 @@ export class TransactionFactory {
         }
         return totalFee;
     }
+    async iterateFundingAmount(params, TransactionClass, calculateAmount, debugPrefix) {
+        const randomBytes = 'randomBytes' in params
+            ? (params.randomBytes ?? BitcoinUtils.rndBytes())
+            : BitcoinUtils.rndBytes();
+        const dummyAddress = Address.dead().p2tr(params.network);
+        let estimatedFundingAmount = this.INITIAL_FUNDING_ESTIMATE;
+        let previousAmount = 0n;
+        let iterations = 0;
+        let finalPreTransaction = null;
+        let challenge = null;
+        while (iterations < this.MAX_ITERATIONS && estimatedFundingAmount !== previousAmount) {
+            previousAmount = estimatedFundingAmount;
+            const dummyTx = new Transaction();
+            dummyTx.addOutput(this.P2TR_SCRIPT, Number(estimatedFundingAmount));
+            const simulatedFundedUtxo = {
+                transactionId: Buffer.alloc(32, 0).toString('hex'),
+                outputIndex: 0,
+                scriptPubKey: {
+                    hex: this.P2TR_SCRIPT.toString('hex'),
+                    address: dummyAddress,
+                },
+                value: estimatedFundingAmount,
+                nonWitnessUtxo: dummyTx.toBuffer(),
+            };
+            let txParams;
+            if ('challenge' in params && params.challenge) {
+                const withChallenge = {
+                    ...params,
+                    utxos: [simulatedFundedUtxo],
+                    randomBytes: randomBytes,
+                    challenge: challenge ?? params.challenge,
+                };
+                txParams = withChallenge;
+            }
+            else {
+                const withoutChallenge = {
+                    ...params,
+                    utxos: [simulatedFundedUtxo],
+                    randomBytes: randomBytes,
+                };
+                txParams = withoutChallenge;
+            }
+            const preTransaction = new TransactionClass(txParams);
+            try {
+                await preTransaction.generateTransactionMinimalSignatures();
+                estimatedFundingAmount = await calculateAmount(preTransaction);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    const match = error.message.match(/need (\d+) sats but only have (\d+) sats/);
+                    if (match) {
+                        estimatedFundingAmount = BigInt(match[1]);
+                        if (this.debug) {
+                            console.log(`${debugPrefix}: Caught insufficient funds, updating to ${estimatedFundingAmount}`);
+                        }
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                else {
+                    throw new Error('Unknown error during fee estimation');
+                }
+            }
+            finalPreTransaction = preTransaction;
+            if ('getChallenge' in preTransaction &&
+                typeof preTransaction.getChallenge === 'function') {
+                const result = preTransaction.getChallenge();
+                if (result instanceof ChallengeSolution) {
+                    challenge = result;
+                }
+            }
+            iterations++;
+            if (this.debug) {
+                console.log(`${debugPrefix} Iteration ${iterations}: Previous=${previousAmount}, New=${estimatedFundingAmount}`);
+            }
+        }
+        if (!finalPreTransaction) {
+            throw new Error(`Failed to converge on ${debugPrefix} funding amount`);
+        }
+        return {
+            finalTransaction: finalPreTransaction,
+            estimatedAmount: estimatedFundingAmount,
+            challenge,
+        };
+    }
     getUTXOAsTransaction(tx, to, index) {
         if (!tx.outs[index])
             return [];

package/build/transaction/builders/DeploymentTransaction.js

@@ -1,6 +1,6 @@
 import { TransactionType } from '../enums/TransactionType.js';
 import { crypto as bitCrypto, PaymentType, toXOnly, } from '@btc-vision/bitcoin';
-import { MINIMUM_AMOUNT_CA, MINIMUM_AMOUNT_REWARD, TransactionBuilder, } from './TransactionBuilder.js';
+import { TransactionBuilder } from './TransactionBuilder.js';
 import { DeploymentGenerator, versionBuffer, } from '../../generators/builders/DeploymentGenerator.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
@@ -104,24 +104,7 @@ export class DeploymentTransaction extends TransactionBuilder {
         };
         this.addInputsFromUTXO();
         const amountSpent = this.getTransactionOPNetFee();
-        let amountToCA;
-        if (amountSpent > MINIMUM_AMOUNT_REWARD + MINIMUM_AMOUNT_CA) {
-            amountToCA = MINIMUM_AMOUNT_CA;
-        }
-        else {
-            amountToCA = amountSpent;
-        }
-        this.addOutput({
-            value: Number(amountToCA),
-            address: this.getContractAddress(),
-        });
-        if (amountToCA === MINIMUM_AMOUNT_CA &&
-            amountSpent - MINIMUM_AMOUNT_CA > MINIMUM_AMOUNT_REWARD) {
-            this.addOutput({
-                value: Number(amountSpent - amountToCA),
-                address: this.epochChallenge.address,
-            });
-        }
+        this.addFeeToOutput(amountSpent, this.getContractAddress(), this.epochChallenge, true);
         await this.addRefundOutput(amountSpent + this.addOptionalOutputsAndGetAmount());
     }
     async signInputsWalletBased(transaction) {

package/build/transaction/builders/FundingTransaction.js

@@ -33,7 +33,8 @@ export class FundingTransaction extends TransactionBuilder {
                 address: this.to,
             });
         }
-        await this.addRefundOutput(this.amount + this.addOptionalOutputsAndGetAmount());
+        const totalOutputAmount = this.amount + this.addOptionalOutputsAndGetAmount();
+        await this.addRefundOutput(totalOutputAmount);
     }
     splitInputs(amountSpent) {
         if (!this.to) {

package/build/transaction/builders/InteractionTransactionP2WDA.js

@@ -1,7 +1,7 @@
 import { Buffer } from 'buffer';
 import { toXOnly } from '@btc-vision/bitcoin';
 import { TransactionType } from '../enums/TransactionType.js';
-import { MINIMUM_AMOUNT_CA, MINIMUM_AMOUNT_REWARD, TransactionBuilder, } from './TransactionBuilder.js';
+import { TransactionBuilder } from './TransactionBuilder.js';
 import { MessageSigner } from '../../keypair/MessageSigner.js';
 import { Compressor } from '../../bytecode/Compressor.js';
 import { P2WDAGenerator } from '../../generators/builders/P2WDAGenerator.js';
@@ -64,24 +64,7 @@ export class InteractionTransactionP2WDA extends TransactionBuilder {
         if (!this.to)
             throw new Error('To address is required');
         const amountSpent = this.getTransactionOPNetFee();
-        let amountToCA;
-        if (amountSpent > MINIMUM_AMOUNT_REWARD + MINIMUM_AMOUNT_CA) {
-            amountToCA = MINIMUM_AMOUNT_CA;
-        }
-        else {
-            amountToCA = amountSpent;
-        }
-        this.addOutput({
-            value: Number(amountToCA),
-            address: this.to,
-        });
-        if (amountToCA === MINIMUM_AMOUNT_CA &&
-            amountSpent - MINIMUM_AMOUNT_CA > MINIMUM_AMOUNT_REWARD) {
-            this.addOutput({
-                value: Number(amountSpent - amountToCA),
-                address: this.epochChallenge.address,
-            });
-        }
+        this.addFeeToOutput(amountSpent, this.to, this.epochChallenge, false);
         const amount = this.addOptionalOutputsAndGetAmount();
         if (!this.disableAutoRefund) {
             await this.addRefundOutput(amountSpent + amount);

package/build/transaction/builders/SharedInteractionTransaction.js

@@ -1,5 +1,5 @@
 import { PaymentType, toXOnly, } from '@btc-vision/bitcoin';
-import { MINIMUM_AMOUNT_CA, MINIMUM_AMOUNT_REWARD, TransactionBuilder, } from './TransactionBuilder.js';
+import { MINIMUM_AMOUNT_REWARD, TransactionBuilder } from './TransactionBuilder.js';
 import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
 import { Compressor } from '../../bytecode/Compressor.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
@@ -180,28 +180,12 @@ export class SharedInteractionTransaction extends TransactionBuilder {
     async createMineableRewardOutputs() {
         if (!this.to)
             throw new Error('To address is required');
-        const amountSpent = this.getTransactionOPNetFee();
-        let amountToCA;
-        if (amountSpent > MINIMUM_AMOUNT_REWARD + MINIMUM_AMOUNT_CA) {
-            amountToCA = MINIMUM_AMOUNT_CA;
-        }
-        else {
-            amountToCA = amountSpent;
-        }
-        this.addOutput({
-            value: Number(amountToCA),
-            address: this.to,
-        });
-        if (amountToCA === MINIMUM_AMOUNT_CA &&
-            amountSpent - MINIMUM_AMOUNT_CA > MINIMUM_AMOUNT_REWARD) {
-            this.addOutput({
-                value: Number(amountSpent - amountToCA),
-                address: this.epochChallenge.address,
-            });
-        }
-        const amount = this.addOptionalOutputsAndGetAmount();
+        const opnetFee = this.getTransactionOPNetFee();
+        this.addFeeToOutput(opnetFee, this.to, this.epochChallenge, false);
+        const actualOutputAmount = opnetFee < MINIMUM_AMOUNT_REWARD ? MINIMUM_AMOUNT_REWARD : opnetFee;
+        const optionalAmount = this.addOptionalOutputsAndGetAmount();
         if (!this.disableAutoRefund) {
-            await this.addRefundOutput(amountSpent + amount);
+            await this.addRefundOutput(actualOutputAmount + optionalAmount);
         }
     }
     getPubKeys() {

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

@@ -6,6 +6,7 @@ import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { ECPairInterface } from 'ecpair';
 import { TweakedTransaction } from '../shared/TweakedTransaction.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
+import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
 export declare const MINIMUM_AMOUNT_REWARD: bigint;
 export declare const MINIMUM_AMOUNT_CA: bigint;
 export declare const ANCHOR_SCRIPT: Buffer<ArrayBuffer>;
@@ -14,6 +15,7 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     static readonly MINIMUM_DUST: bigint;
     abstract readonly type: T;
     readonly logColor: string;
+    debugFees: boolean;
     overflowFees: bigint;
     transactionFee: bigint;
     estimatedFees: bigint;
@@ -36,6 +38,7 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     protected isPubKeyDestination: boolean;
     protected anchor: boolean;
     protected note?: Buffer;
+    private optionalOutputsAdded;
     protected constructor(parameters: ITransactionParameters);
     static getFrom(from: string | undefined, keypair: ECPairInterface | Signer, network: Network): string;
     static witnessStackToScriptWitness(witness: Buffer[]): Buffer;
@@ -48,7 +51,8 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     generateTransactionMinimalSignatures(checkPartialSigs?: boolean): Promise<void>;
     signPSBT(): Promise<Psbt>;
     addInput(input: PsbtInputExtended): void;
-    addOutput(output: PsbtOutputExtended): void;
+    addOutput(output: PsbtOutputExtended, bypassMinCheck?: boolean): void;
+    getTotalOutputValue(): bigint;
     toAddress(): string | undefined;
     address(): string | undefined;
     estimateTransactionFees(): Promise<bigint>;
@@ -67,6 +71,7 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     protected internalInit(): void;
     protected abstract buildTransaction(): Promise<void>;
     protected updateInput(input: UpdateInput): void;
+    protected addFeeToOutput(amountSpent: bigint, contractAddress: string, epochChallenge: IP2WSHAddress, addContractOutput: boolean): void;
     protected getWitness(): Buffer;
     protected getTapOutput(): Buffer;
     protected verifyUTXOValidity(): void;