@btc-vision/transaction 1.8.0-beta.0 → 1.8.0-beta.10

package/build/transaction/builders/TransactionBuilder.js

@@ -1,33 +1,124 @@
-import bitcoin, { getFinalScripts, initEccLib, opcodes, Psbt, script, toXOnly, Transaction, } from '@btc-vision/bitcoin';
+import bitcoin, { equals, fromHex, getFinalScripts, opcodes, Psbt, script, toSatoshi, toXOnly, Transaction, } from '@btc-vision/bitcoin';
 import { witnessStackToScriptWitness } from '../utils/WitnessUtils.js';
-import * as ecc from '@bitcoinerlab/secp256k1';
+import { TransactionType } from '../enums/TransactionType.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
+import {} from '@btc-vision/ecpair';
 import { AddressVerificator } from '../../keypair/AddressVerificator.js';
 import { TweakedTransaction } from '../shared/TweakedTransaction.js';
+import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 import { P2WDADetector } from '../../p2wda/P2WDADetector.js';
-import { FeaturePriority, Features } from '../../generators/Features.js';
+import { FeaturePriority, Features, } from '../../generators/Features.js';
 import { BITCOIN_PROTOCOL_ID, getChainId } from '../../chain/ChainData.js';
 import { BinaryWriter } from '../../buffer/BinaryWriter.js';
 import { MLDSASecurityLevel } from '@btc-vision/bip32';
 import { MessageSigner } from '../../keypair/MessageSigner.js';
 import { getLevelFromPublicKeyLength } from '../../generators/MLDSAData.js';
-initEccLib(ecc);
-export const MINIMUM_AMOUNT_REWARD = 330n;
+export const MINIMUM_AMOUNT_REWARD = 330n; //540n;
 export const MINIMUM_AMOUNT_CA = 297n;
-export const ANCHOR_SCRIPT = Buffer.from('51024e73', 'hex');
+export const ANCHOR_SCRIPT = fromHex('51024e73');
+/**
+ * Allows to build a transaction like you would on Ethereum.
+ * @description The transaction builder class
+ * @abstract
+ * @class TransactionBuilder
+ */
 export class TransactionBuilder extends TweakedTransaction {
+    static MINIMUM_DUST = 330n;
+    logColor = '#785def';
+    debugFees = false;
+    // Cancel script
+    LOCK_LEAF_SCRIPT;
+    /**
+     * @description The overflow fees of the transaction
+     * @public
+     */
+    overflowFees = 0n;
+    /**
+     * @description Cost in satoshis of the transaction fee
+     */
+    transactionFee = 0n;
+    /**
+     * @description The estimated fees of the transaction
+     */
+    estimatedFees = 0n;
+    /**
+     * @param {ITransactionParameters} parameters - The transaction parameters
+     */
+    optionalOutputs;
+    /**
+     * @description The transaction itself.
+     */
+    transaction;
+    /**
+     * @description Inputs to update later on.
+     */
+    updateInputs = [];
+    /**
+     * @description The outputs of the transaction
+     */
+    outputs = [];
+    /**
+     * @description Output that will be used to pay the fees
+     */
+    feeOutput = null;
+    /**
+     * @description The total amount of satoshis in the inputs
+     */
+    totalInputAmount;
+    /**
+     * @description The signer of the transaction
+     */
+    signer;
+    /**
+     * @description The network where the transaction will be broadcasted
+     */
+    network;
+    /**
+     * @description The fee rate of the transaction
+     */
+    feeRate;
+    /**
+     * @description The opnet priority fee of the transaction
+     */
+    priorityFee;
+    gasSatFee;
+    /**
+     * @description The utxos used in the transaction
+     */
+    utxos;
+    /**
+     * @description The inputs of the transaction
+     * @protected
+     */
+    optionalInputs;
+    /**
+     * @description The address where the transaction is sent to
+     * @protected
+     */
+    to;
+    /**
+     * @description The address where the transaction is sent from
+     * @protected
+     */
+    from;
+    /**
+     * @description The maximum fee rate of the transaction
+     */
+    _maximumFeeRate = 100000000;
+    /**
+     * @description Is the destionation P2PK
+     * @protected
+     */
+    isPubKeyDestination;
+    /**
+     * @description If the transaction need an anchor output
+     * @protected
+     */
+    anchor;
+    note;
+    optionalOutputsAdded = false;
     constructor(parameters) {
         super(parameters);
-        this.logColor = '#785def';
-        this.debugFees = false;
-        this.overflowFees = 0n;
-        this.transactionFee = 0n;
-        this.estimatedFees = 0n;
-        this.updateInputs = [];
-        this.outputs = [];
-        this.feeOutput = null;
-        this._maximumFeeRate = 100000000;
-        this.optionalOutputsAdded = false;
         if (parameters.estimatedFees) {
             this.estimatedFees = parameters.estimatedFees;
         }
@@ -43,7 +134,7 @@ export class TransactionBuilder extends TweakedTransaction {
         this.LOCK_LEAF_SCRIPT = this.defineLockScript();
         if (parameters.note) {
             if (typeof parameters.note === 'string') {
-                this.note = Buffer.from(parameters.note, 'utf8');
+                this.note = new TextEncoder().encode(parameters.note);
             }
             else {
                 this.note = parameters.note;
@@ -68,19 +159,34 @@ export class TransactionBuilder extends TweakedTransaction {
     static getFrom(from, keypair, network) {
         return from || EcKeyPair.getTaprootAddress(keypair, network);
     }
+    /**
+     * @description Converts the witness stack to a script witness
+     * @param {Buffer[]} witness - The witness stack
+     * @protected
+     * @returns {Buffer}
+     */
     static witnessStackToScriptWitness(witness) {
         return witnessStackToScriptWitness(witness);
     }
+    [Symbol.dispose]() {
+        super[Symbol.dispose]();
+        this.updateInputs.length = 0;
+        this.outputs.length = 0;
+        this.feeOutput = null;
+        this.optionalOutputs = undefined;
+        this.utxos = [];
+        this.optionalInputs = [];
+    }
     addOPReturn(buffer) {
         const compileScript = script.compile([opcodes.OP_RETURN, buffer]);
         this.addOutput({
-            value: 0,
+            value: toSatoshi(0n),
             script: compileScript,
         });
     }
     addAnchor() {
         this.addOutput({
-            value: 0,
+            value: toSatoshi(0n),
             script: ANCHOR_SCRIPT,
         });
     }
@@ -98,17 +204,34 @@ export class TransactionBuilder extends TweakedTransaction {
             gasSatFee: this.gasSatFee ?? 0n,
             from: this.from,
             amount: this.estimatedFees,
-            optionalOutputs: this.optionalOutputs,
             optionalInputs: this.optionalInputs,
             mldsaSigner: null,
+            ...(this.optionalOutputs !== undefined
+                ? { optionalOutputs: this.optionalOutputs }
+                : {}),
         };
     }
+    /**
+     * Set the destination address of the transaction
+     * @param {string} address - The address to set
+     */
     setDestinationAddress(address) {
-        this.to = address;
+        this.to = address; // this.getScriptAddress()
     }
+    /**
+     * Set the maximum fee rate of the transaction in satoshis per byte
+     * @param {number} feeRate - The fee rate to set
+     * @public
+     */
     setMaximumFeeRate(feeRate) {
         this._maximumFeeRate = feeRate;
     }
+    /**
+     * @description Signs the transaction
+     * @public
+     * @returns {Promise<Transaction>} - The signed transaction in hex format
+     * @throws {Error} - If something went wrong
+     */
     async signTransaction() {
         if (!this.utxos.length) {
             throw new Error('No UTXOs specified');
@@ -131,6 +254,10 @@ export class TransactionBuilder extends TweakedTransaction {
         }
         throw new Error('Could not sign transaction');
     }
+    /**
+     * @description Generates the transaction minimal signatures
+     * @public
+     */
     async generateTransactionMinimalSignatures(checkPartialSigs = false) {
         if (this.to &&
             !this.isPubKeyDestination &&
@@ -149,42 +276,81 @@ export class TransactionBuilder extends TweakedTransaction {
             this.transaction.addOutputs(outputs);
         }
     }
+    /**
+     * @description Signs the transaction
+     * @public
+     * @returns {Promise<Psbt>} - The signed transaction in hex format
+     * @throws {Error} - If something went wrong
+     */
     async signPSBT() {
         if (await this.signTransaction()) {
             return this.transaction;
         }
         throw new Error('Could not sign transaction');
     }
+    /**
+     * Add an input to the transaction.
+     * @param {PsbtInputExtended} input - The input to add
+     * @public
+     * @returns {void}
+     */
     addInput(input) {
         this.inputs.push(input);
     }
+    /**
+     * Add an output to the transaction.
+     * @param {PsbtOutputExtended} output - The output to add
+     * @param bypassMinCheck
+     * @public
+     * @returns {void}
+     */
     addOutput(output, bypassMinCheck = false) {
-        if (output.value === 0) {
-            const script = output;
-            if (!script.script || script.script.length === 0) {
+        if (output.value === toSatoshi(0n)) {
+            const scriptOutput = output;
+            if (!scriptOutput.script || scriptOutput.script.length === 0) {
                 throw new Error('Output value is 0 and no script provided');
             }
-            if (script.script.length < 2) {
+            if (scriptOutput.script.length < 2) {
                 throw new Error('Output script is too short');
             }
-            if (script.script[0] !== opcodes.OP_RETURN && !script.script.equals(ANCHOR_SCRIPT)) {
+            if (scriptOutput.script[0] !== opcodes.OP_RETURN &&
+                !equals(scriptOutput.script, ANCHOR_SCRIPT)) {
                 throw new Error('Output script must start with OP_RETURN or be an ANCHOR when value is 0');
             }
         }
-        else if (!bypassMinCheck && output.value < TransactionBuilder.MINIMUM_DUST) {
+        else if (!bypassMinCheck && BigInt(output.value) < TransactionBuilder.MINIMUM_DUST) {
             throw new Error(`Output value is less than the minimum dust ${output.value} < ${TransactionBuilder.MINIMUM_DUST}`);
         }
         this.outputs.push(output);
     }
+    /**
+     * Returns the total value of all outputs added so far (excluding the fee/change output).
+     * @public
+     * @returns {bigint}
+     */
     getTotalOutputValue() {
         return this.outputs.reduce((total, output) => total + BigInt(output.value), 0n);
     }
+    /**
+     * Receiver address.
+     * @public
+     * @returns {string} - The receiver address
+     */
     toAddress() {
         return this.to;
     }
+    /**
+     * @description Returns the script address
+     * @returns {string} - The script address
+     */
     address() {
         return this.tapData?.address;
     }
+    /**
+     * Estimates the transaction fees with accurate size calculation.
+     * @public
+     * @returns {Promise<bigint>}
+     */
     async estimateTransactionFees() {
         await Promise.resolve();
         const fakeTx = new Psbt({ network: this.network });
@@ -192,22 +358,23 @@ export class TransactionBuilder extends TweakedTransaction {
         const outputs = this.getOutputs();
         fakeTx.addInputs(inputs);
         fakeTx.addOutputs(outputs);
-        const dummySchnorrSig = Buffer.alloc(64, 0);
-        const dummyEcdsaSig = Buffer.alloc(72, 0);
-        const dummyCompressedPubkey = Buffer.alloc(33, 2);
+        const dummySchnorrSig = new Uint8Array(64);
+        const dummyEcdsaSig = new Uint8Array(72);
+        const dummyCompressedPubkey = new Uint8Array(33).fill(2);
         const finalizer = (inputIndex, input) => {
             if (input.isPayToAnchor || this.anchorInputIndices.has(inputIndex)) {
                 return {
                     finalScriptSig: undefined,
-                    finalScriptWitness: Buffer.from([0]),
+                    finalScriptWitness: Uint8Array.from([0]),
                 };
             }
             if (input.witnessScript && P2WDADetector.isP2WDAWitnessScript(input.witnessScript)) {
+                // Create dummy witness stack for P2WDA
                 const dummyDataSlots = [];
                 for (let i = 0; i < 10; i++) {
-                    dummyDataSlots.push(Buffer.alloc(0));
+                    dummyDataSlots.push(new Uint8Array(0));
                 }
-                const dummyEcdsaSig = Buffer.alloc(72, 0);
+                const dummyEcdsaSig = new Uint8Array(72);
                 return {
                     finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness([
                         ...dummyDataSlots,
@@ -217,14 +384,15 @@ export class TransactionBuilder extends TweakedTransaction {
                 };
             }
             if (inputIndex === 0 && this.tapLeafScript) {
-                const dummySecret = Buffer.alloc(32, 0);
+                const dummySecret = new Uint8Array(32);
                 const dummyScript = this.tapLeafScript.script;
-                const dummyControlBlock = Buffer.alloc(1 + 32 + 32, 0);
+                // A control block for a 2-leaf tree contains one 32-byte hash.
+                const dummyControlBlock = new Uint8Array(1 + 32 + 32);
                 return {
                     finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness([
                         dummySecret,
-                        dummySchnorrSig,
-                        dummySchnorrSig,
+                        dummySchnorrSig, // It's a tapScriptSig, which is Schnorr
+                        dummySchnorrSig, // Second Schnorr signature
                         dummyScript,
                         dummyControlBlock,
                     ]),
@@ -250,6 +418,7 @@ export class TransactionBuilder extends TweakedTransaction {
             }
             if (input.witnessScript) {
                 if (this.csvInputIndices.has(inputIndex)) {
+                    // CSV P2WSH needs: [signature, witnessScript]
                     return {
                         finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness([
                             dummyEcdsaSig,
@@ -258,6 +427,7 @@ export class TransactionBuilder extends TweakedTransaction {
                     };
                 }
                 if (input.redeemScript) {
+                    // P2SH-P2WSH needs redeemScript in scriptSig and witness data
                     const dummyWitness = [dummyEcdsaSig, input.witnessScript];
                     return {
                         finalScriptSig: input.redeemScript,
@@ -268,6 +438,7 @@ export class TransactionBuilder extends TweakedTransaction {
                 if (decompiled && decompiled.length >= 4) {
                     const firstOp = decompiled[0];
                     const lastOp = decompiled[decompiled.length - 1];
+                    // Check if it's M-of-N multisig
                     if (typeof firstOp === 'number' &&
                         firstOp >= opcodes.OP_1 &&
                         lastOp === opcodes.OP_CHECKMULTISIG) {
@@ -278,7 +449,7 @@ export class TransactionBuilder extends TweakedTransaction {
                         }
                         return {
                             finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness([
-                                Buffer.alloc(0),
+                                new Uint8Array(0), // OP_0 due to multisig bug
                                 ...signatures,
                                 input.witnessScript,
                             ]),
@@ -297,8 +468,9 @@ export class TransactionBuilder extends TweakedTransaction {
                 if (decompiled &&
                     decompiled.length === 2 &&
                     decompiled[0] === opcodes.OP_0 &&
-                    Buffer.isBuffer(decompiled[1]) &&
+                    decompiled[1] instanceof Uint8Array &&
                     decompiled[1].length === 20) {
+                    // P2SH-P2WPKH
                     return {
                         finalScriptSig: input.redeemScript,
                         finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness([
@@ -309,13 +481,14 @@ export class TransactionBuilder extends TweakedTransaction {
                 }
             }
             if (input.redeemScript && !input.witnessScript && !input.witnessUtxo) {
+                // Pure P2SH needs signatures + redeemScript in scriptSig
                 return {
                     finalScriptSig: bitcoin.script.compile([dummyEcdsaSig, input.redeemScript]),
                     finalScriptWitness: undefined,
                 };
             }
-            const script = input.witnessUtxo?.script;
-            if (!script)
+            const inputScript = input.witnessUtxo?.script;
+            if (!inputScript)
                 return { finalScriptSig: undefined, finalScriptWitness: undefined };
             if (input.tapInternalKey) {
                 return {
@@ -324,7 +497,7 @@ export class TransactionBuilder extends TweakedTransaction {
                     ]),
                 };
             }
-            if (script.length === 22 && script[0] === opcodes.OP_0) {
+            if (inputScript.length === 22 && inputScript[0] === opcodes.OP_0) {
                 return {
                     finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness([
                         dummyEcdsaSig,
@@ -340,7 +513,7 @@ export class TransactionBuilder extends TweakedTransaction {
                     ]),
                 };
             }
-            return getFinalScripts(inputIndex, input, script, true, !!input.redeemScript, !!input.witnessScript);
+            return getFinalScripts(inputIndex, input, inputScript, true, !!input.redeemScript, !!input.witnessScript);
         };
         try {
             for (let i = 0; i < fakeTx.data.inputs.length; i++) {
@@ -374,9 +547,19 @@ export class TransactionBuilder extends TweakedTransaction {
     setPSBT(psbt) {
         this.transaction = psbt;
     }
+    /**
+     * Returns the inputs of the transaction.
+     * @protected
+     * @returns {PsbtInputExtended[]}
+     */
     getInputs() {
         return this.inputs;
     }
+    /**
+     * Returns the outputs of the transaction.
+     * @protected
+     * @returns {PsbtOutputExtended[]}
+     */
     getOutputs() {
         const outputs = [...this.outputs];
         if (this.feeOutput)
@@ -399,78 +582,59 @@ export class TransactionBuilder extends TweakedTransaction {
         if (this.anchor) {
             this.addAnchor();
         }
-        let previousFee = -1n;
-        let estimatedFee = 0n;
-        let iterations = 0;
-        const maxIterations = 5;
-        let sendBackAmount = 0n;
-        while (iterations < maxIterations && estimatedFee !== previousFee) {
-            previousFee = estimatedFee;
-            estimatedFee = await this.estimateTransactionFees();
-            const totalSpent = amountSpent + estimatedFee;
-            sendBackAmount = this.totalInputAmount - totalSpent;
+        // Add a dummy change output to estimate fee with the change-output shape
+        this.feeOutput = this.createChangeOutput(TransactionBuilder.MINIMUM_DUST);
+        const feeWithChange = await this.estimateTransactionFees();
+        const sendBackAmount = this.totalInputAmount - amountSpent - feeWithChange;
+        if (this.debugFees) {
+            this.log(`Fee with change: ${feeWithChange} sats, inputAmount=${this.totalInputAmount}, amountSpent=${amountSpent}, sendBackAmount=${sendBackAmount}`);
+        }
+        if (sendBackAmount >= TransactionBuilder.MINIMUM_DUST) {
+            // Change output is viable, set it to the real value
+            this.feeOutput = this.createChangeOutput(sendBackAmount);
+            this.overflowFees = sendBackAmount;
+            this.transactionFee = feeWithChange;
+        }
+        else {
+            // Change output not viable, remove it and re-estimate without it
+            this.feeOutput = null;
+            this.overflowFees = 0n;
+            const feeWithoutChange = await this.estimateTransactionFees();
+            this.transactionFee = feeWithoutChange;
             if (this.debugFees) {
-                this.log(`Iteration ${iterations + 1}: inputAmount=${this.totalInputAmount}, totalSpent=${totalSpent}, sendBackAmount=${sendBackAmount}`);
-            }
-            if (sendBackAmount >= TransactionBuilder.MINIMUM_DUST) {
-                if (AddressVerificator.isValidP2TRAddress(this.from, this.network)) {
-                    this.feeOutput = {
-                        value: Number(sendBackAmount),
-                        address: this.from,
-                        tapInternalKey: this.internalPubKeyToXOnly(),
-                    };
-                }
-                else if (AddressVerificator.isValidPublicKey(this.from, this.network)) {
-                    const pubKeyScript = script.compile([
-                        Buffer.from(this.from.replace('0x', ''), 'hex'),
-                        opcodes.OP_CHECKSIG,
-                    ]);
-                    this.feeOutput = {
-                        value: Number(sendBackAmount),
-                        script: pubKeyScript,
-                    };
-                }
-                else {
-                    this.feeOutput = {
-                        value: Number(sendBackAmount),
-                        address: this.from,
-                    };
-                }
-                this.overflowFees = sendBackAmount;
+                this.warn(`Amount to send back (${sendBackAmount} sat) is less than minimum dust. Fee without change: ${feeWithoutChange} sats`);
             }
-            else {
-                this.feeOutput = null;
-                this.overflowFees = 0n;
-                if (sendBackAmount < 0n && iterations === maxIterations) {
-                    throw new Error(`Insufficient funds: need ${totalSpent} sats but only have ${this.totalInputAmount} sats`);
-                }
-                if (this.debugFees) {
-                    this.warn(`Amount to send back (${sendBackAmount} sat) is less than minimum dust...`);
-                }
+            if (this.totalInputAmount <= amountSpent) {
+                throw new Error(`Insufficient funds: need ${amountSpent + feeWithoutChange} sats but only have ${this.totalInputAmount} sats`);
+            }
+            if (expectRefund && sendBackAmount < 0n) {
+                throw new Error(`Insufficient funds: need at least ${-sendBackAmount} more sats to cover fees.`);
             }
-            iterations++;
-        }
-        if (expectRefund && sendBackAmount < 0n) {
-            throw new Error(`Insufficient funds: need at least ${-sendBackAmount} more sats to cover fees.`);
-        }
-        if (iterations >= maxIterations) {
-            this.warn(`Fee calculation did not stabilize after ${maxIterations} iterations`);
         }
-        this.transactionFee = estimatedFee;
         if (this.debugFees) {
-            this.log(`Final fee: ${estimatedFee} sats, Change output: ${this.feeOutput ? `${this.feeOutput.value} sats` : 'none'}`);
+            this.log(`Final fee: ${this.transactionFee} sats, Change output: ${this.feeOutput ? `${this.feeOutput.value} sats` : 'none'}`);
         }
     }
     defineLockScript() {
-        return script.compile([toXOnly(Buffer.from(this.signer.publicKey)), opcodes.OP_CHECKSIG]);
-    }
+        return script.compile([toXOnly(this.signer.publicKey), opcodes.OP_CHECKSIG]);
+    }
+    /**
+     * @description Adds the value to the output
+     * @param {number | bigint} value - The value to add
+     * @protected
+     * @returns {void}
+     */
     addValueToToOutput(value) {
-        if (value < TransactionBuilder.MINIMUM_DUST) {
+        if (BigInt(value) < TransactionBuilder.MINIMUM_DUST) {
             throw new Error(`Value to send is less than the minimum dust ${value} < ${TransactionBuilder.MINIMUM_DUST}`);
         }
-        for (const output of this.outputs) {
+        for (let i = 0; i < this.outputs.length; i++) {
+            const output = this.outputs[i];
             if ('address' in output && output.address === this.to) {
-                output.value += Number(value);
+                this.outputs[i] = {
+                    ...output,
+                    value: toSatoshi(BigInt(output.value) + BigInt(value)),
+                };
                 return;
             }
         }
@@ -488,6 +652,7 @@ export class TransactionBuilder extends TweakedTransaction {
         }
         const chainId = getChainId(this.network);
         const writer = new BinaryWriter();
+        // ONLY SUPPORT MLDSA-44 FOR NOW.
         writer.writeU8(MLDSASecurityLevel.LEVEL2);
         writer.writeBytes(this.hashedPublicKey);
         writer.writeBytes(tweakedKey);
@@ -500,7 +665,7 @@ export class TransactionBuilder extends TweakedTransaction {
         if (!isValid) {
             throw new Error('Could not verify generated legacy signature for MLDSA link request');
         }
-        return Buffer.from(signature.signature);
+        return new Uint8Array(signature.signature);
     }
     generateMLDSASignature() {
         if (!this.mldsaSigner) {
@@ -534,7 +699,7 @@ export class TransactionBuilder extends TweakedTransaction {
         if (!isValid) {
             throw new Error('Could not verify generated MLDSA signature for link request');
         }
-        return Buffer.from(signature.signature);
+        return new Uint8Array(signature.signature);
     }
     generateMLDSALinkRequest(parameters, features) {
         const mldsaSigner = this.mldsaSigner;
@@ -557,6 +722,11 @@ export class TransactionBuilder extends TweakedTransaction {
         };
         features.push(mldsaRequest);
     }
+    /**
+     * @description Returns the transaction opnet fee
+     * @protected
+     * @returns {bigint}
+     */
     getTransactionOPNetFee() {
         const totalFee = this.priorityFee + this.gasSatFee;
         if (totalFee > TransactionBuilder.MINIMUM_DUST) {
@@ -564,6 +734,11 @@ export class TransactionBuilder extends TweakedTransaction {
         }
         return TransactionBuilder.MINIMUM_DUST;
     }
+    /**
+     * @description Returns the total amount of satoshis in the inputs
+     * @protected
+     * @returns {bigint}
+     */
     calculateTotalUTXOAmount() {
         let total = 0n;
         for (const utxo of this.utxos) {
@@ -574,6 +749,11 @@ export class TransactionBuilder extends TweakedTransaction {
         }
         return total;
     }
+    /**
+     * @description Returns the total amount of satoshis in the outputs
+     * @protected
+     * @returns {bigint}
+     */
     calculateTotalVOutAmount() {
         let total = 0n;
         for (const utxo of this.utxos) {
@@ -584,6 +764,11 @@ export class TransactionBuilder extends TweakedTransaction {
         }
         return total;
     }
+    /**
+     * @description Adds optional outputs to transaction and returns their total value in satoshi to calculate refund transaction
+     * @protected
+     * @returns {bigint}
+     */
     addOptionalOutputsAndGetAmount() {
         if (!this.optionalOutputs || this.optionalOutputsAdded)
             return 0n;
@@ -595,13 +780,20 @@ export class TransactionBuilder extends TweakedTransaction {
         this.optionalOutputsAdded = true;
         return refundedFromOptionalOutputs;
     }
+    /**
+     * @description Adds the inputs from the utxos
+     * @protected
+     * @returns {void}
+     */
     addInputsFromUTXO() {
         if (this.utxos.length) {
+            //throw new Error('No UTXOs specified');
             if (this.totalInputAmount < TransactionBuilder.MINIMUM_DUST) {
                 throw new Error(`Total input amount is ${this.totalInputAmount} sat which is less than the minimum dust ${TransactionBuilder.MINIMUM_DUST} sat.`);
             }
             for (let i = 0; i < this.utxos.length; i++) {
                 const utxo = this.utxos[i];
+                // Register signer BEFORE generating input (needed for tapInternalKey)
                 this.registerInputSigner(i, utxo);
                 const input = this.generatePsbtInputExtended(utxo, i);
                 this.addInput(input);
@@ -610,19 +802,38 @@ export class TransactionBuilder extends TweakedTransaction {
         if (this.optionalInputs) {
             for (let i = this.utxos.length; i < this.optionalInputs.length + this.utxos.length; i++) {
                 const utxo = this.optionalInputs[i - this.utxos.length];
+                // Register signer BEFORE generating input (needed for tapInternalKey)
                 this.registerInputSigner(i, utxo);
                 const input = this.generatePsbtInputExtended(utxo, i, true);
                 this.addInput(input);
             }
         }
     }
+    /**
+     * Internal init.
+     * @protected
+     */
     internalInit() {
         this.verifyUTXOValidity();
         super.internalInit();
     }
+    /**
+     * Add an input update
+     * @param {UpdateInput} input - The input to update
+     * @protected
+     * @returns {void}
+     */
     updateInput(input) {
         this.updateInputs.push(input);
     }
+    /**
+     * Adds the fee to the output.
+     * @param amountSpent
+     * @param contractAddress
+     * @param epochChallenge
+     * @param addContractOutput
+     * @protected
+     */
     addFeeToOutput(amountSpent, contractAddress, epochChallenge, addContractOutput) {
         if (addContractOutput) {
             let amountToCA;
@@ -632,26 +843,35 @@ export class TransactionBuilder extends TweakedTransaction {
             else {
                 amountToCA = amountSpent;
             }
+            // ALWAYS THE FIRST INPUT.
             this.addOutput({
-                value: Number(amountToCA),
+                value: toSatoshi(amountToCA),
                 address: contractAddress,
             }, true);
+            // ALWAYS SECOND.
             if (amountToCA === MINIMUM_AMOUNT_CA &&
                 amountSpent - MINIMUM_AMOUNT_CA > MINIMUM_AMOUNT_REWARD) {
                 this.addOutput({
-                    value: Number(amountSpent - amountToCA),
+                    value: toSatoshi(amountSpent - amountToCA),
                     address: epochChallenge.address,
                 }, true);
             }
         }
         else {
+            // When SEND_AMOUNT_TO_CA is false, always send to epochChallenge
+            // Use the maximum of amountSpent or MINIMUM_AMOUNT_REWARD
             const amountToEpoch = amountSpent < MINIMUM_AMOUNT_REWARD ? MINIMUM_AMOUNT_REWARD : amountSpent;
             this.addOutput({
-                value: Number(amountToEpoch),
+                value: toSatoshi(amountToEpoch),
                 address: epochChallenge.address,
             }, true);
         }
     }
+    /**
+     * Returns the witness of the tap transaction.
+     * @protected
+     * @returns {Buffer}
+     */
     getWitness() {
         if (!this.tapData || !this.tapData.witness) {
             throw new Error('Witness is required');
@@ -661,12 +881,21 @@ export class TransactionBuilder extends TweakedTransaction {
         }
         return this.tapData.witness[this.tapData.witness.length - 1];
     }
+    /**
+     * Returns the tap output.
+     * @protected
+     * @returns {Buffer}
+     */
     getTapOutput() {
         if (!this.tapData || !this.tapData.output) {
             throw new Error('Tap data is required');
         }
         return this.tapData.output;
     }
+    /**
+     * Verifies that the utxos are valid.
+     * @protected
+     */
     verifyUTXOValidity() {
         for (const utxo of this.utxos) {
             if (!utxo.scriptPubKey) {
@@ -679,49 +908,14 @@ export class TransactionBuilder extends TweakedTransaction {
             }
         }
     }
-    async setFeeOutput(output) {
-        const initialValue = output.value;
-        this.feeOutput = null;
-        let estimatedFee = 0n;
-        let lastFee = -1n;
-        this.log(`setFeeOutput: Starting fee calculation for change. Initial available value: ${initialValue} sats.`);
-        for (let i = 0; i < 3 && estimatedFee !== lastFee; i++) {
-            lastFee = estimatedFee;
-            estimatedFee = await this.estimateTransactionFees();
-            const valueLeft = BigInt(initialValue) - estimatedFee;
-            if (this.debugFees) {
-                this.log(` -> Iteration ${i + 1}: Estimated fee is ${estimatedFee} sats. Value left for change: ${valueLeft} sats.`);
-            }
-            if (valueLeft >= TransactionBuilder.MINIMUM_DUST) {
-                this.feeOutput = { ...output, value: Number(valueLeft) };
-                this.overflowFees = valueLeft;
-            }
-            else {
-                this.feeOutput = null;
-                this.overflowFees = 0n;
-                estimatedFee = await this.estimateTransactionFees();
-                if (this.debugFees) {
-                    this.log(` -> Change is less than dust. Final fee without change output: ${estimatedFee} sats.`);
-                }
-            }
-        }
-        const finalValueLeft = BigInt(initialValue) - estimatedFee;
-        if (finalValueLeft < 0) {
-            throw new Error(`setFeeOutput: Insufficient funds to pay the fees. Required fee: ${estimatedFee}, Available: ${initialValue}. Total input: ${this.totalInputAmount} sat`);
-        }
-        if (finalValueLeft >= TransactionBuilder.MINIMUM_DUST) {
-            this.feeOutput = { ...output, value: Number(finalValueLeft) };
-            this.overflowFees = finalValueLeft;
-            if (this.debugFees) {
-                this.log(`setFeeOutput: Final change output set to ${finalValueLeft} sats. Final fee: ${estimatedFee} sats.`);
-            }
-        }
-        else {
-            this.warn(`Amount to send back (${finalValueLeft} sat) is less than the minimum dust (${TransactionBuilder.MINIMUM_DUST} sat), it will be consumed in fees instead.`);
-            this.feeOutput = null;
-            this.overflowFees = 0n;
-        }
-    }
+    /**
+     * Builds the transaction.
+     * @param {Psbt} transaction - The transaction to build
+     * @param checkPartialSigs
+     * @protected
+     * @returns {Promise<boolean>}
+     * @throws {Error} - If something went wrong while building the transaction
+     */
     async internalBuildTransaction(transaction, checkPartialSigs = false) {
         if (transaction.data.inputs.length === 0) {
             const inputs = this.getInputs();
@@ -746,5 +940,30 @@ export class TransactionBuilder extends TweakedTransaction {
         }
         return false;
     }
+    createChangeOutput(amount) {
+        if (AddressVerificator.isValidP2TRAddress(this.from, this.network)) {
+            return {
+                value: toSatoshi(amount),
+                address: this.from,
+                tapInternalKey: this.internalPubKeyToXOnly(),
+            };
+        }
+        else if (AddressVerificator.isValidPublicKey(this.from, this.network)) {
+            const pubKeyScript = script.compile([
+                fromHex(this.from.replace('0x', '')),
+                opcodes.OP_CHECKSIG,
+            ]);
+            return {
+                value: toSatoshi(amount),
+                script: pubKeyScript,
+            };
+        }
+        else {
+            return {
+                value: toSatoshi(amount),
+                address: this.from,
+            };
+        }
+    }
 }
-TransactionBuilder.MINIMUM_DUST = 330n;
+//# sourceMappingURL=TransactionBuilder.js.map