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

package/src/transaction/builders/TransactionBuilder.ts

@@ -1,44 +1,49 @@
+import type { Script } from '@btc-vision/bitcoin';
 import bitcoin, {
+    equals,
+    fromHex,
     getFinalScripts,
-    initEccLib,
-    Network,
+    type Network,
     opcodes,
     Psbt,
-    PsbtInputExtended,
-    PsbtOutputExtended,
+    type PsbtInputExtended,
+    type PsbtOutputExtended,
     script,
-    Signer,
+    type Signer,
+    toSatoshi,
     toXOnly,
     Transaction,
 } from '@btc-vision/bitcoin';
 import { witnessStackToScriptWitness } from '../utils/WitnessUtils.js';
-import * as ecc from '@bitcoinerlab/secp256k1';
-import { UpdateInput } from '../interfaces/Tap.js';
+import type { UpdateInput } from '../interfaces/Tap.js';
 import { TransactionType } from '../enums/TransactionType.js';
-import {
+import type {
     IFundingTransactionParameters,
     ITransactionParameters,
 } from '../interfaces/ITransactionParameters.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
-import { UTXO } from '../../utxo/interfaces/IUTXO.js';
-import { ECPairInterface } from 'ecpair';
+import type { UTXO } from '../../utxo/interfaces/IUTXO.js';
+import { type UniversalSigner } from '@btc-vision/ecpair';
 import { AddressVerificator } from '../../keypair/AddressVerificator.js';
 import { TweakedTransaction } from '../shared/TweakedTransaction.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
-import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
+import type { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
 import { P2WDADetector } from '../../p2wda/P2WDADetector.js';
-import { Feature, FeaturePriority, Features, MLDSALinkRequest } from '../../generators/Features.js';
+import {
+    type Feature,
+    FeaturePriority,
+    Features,
+    type MLDSALinkRequest,
+} 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: bigint = 330n; //540n;
 export const MINIMUM_AMOUNT_CA: bigint = 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.
@@ -50,11 +55,11 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
     public static readonly MINIMUM_DUST: bigint = 330n;
 
     public abstract readonly type: T;
-    public readonly logColor: string = '#785def';
+    public override readonly logColor: string = '#785def';
     public debugFees: boolean = false;
 
     // Cancel script
-    public LOCK_LEAF_SCRIPT: Buffer;
+    public LOCK_LEAF_SCRIPT: Script;
 
     /**
      * @description The overflow fees of the transaction
@@ -105,12 +110,12 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
     /**
      * @description The signer of the transaction
      */
-    protected readonly signer: Signer | ECPairInterface | UnisatSigner;
+    protected override readonly signer: Signer | UniversalSigner | UnisatSigner;
 
     /**
      * @description The network where the transaction will be broadcasted
      */
-    protected readonly network: Network;
+    protected override readonly network: Network;
 
     /**
      * @description The fee rate of the transaction
@@ -163,7 +168,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
      */
     protected anchor: boolean;
 
-    protected note?: Buffer;
+    protected note?: Uint8Array;
 
     private optionalOutputsAdded: boolean = false;
 
@@ -188,7 +193,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
 
         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;
             }
@@ -219,7 +224,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
 
     public static getFrom(
         from: string | undefined,
-        keypair: ECPairInterface | Signer,
+        keypair: UniversalSigner | Signer,
         network: Network,
     ): string {
         return from || EcKeyPair.getTaprootAddress(keypair, network);
@@ -231,23 +236,34 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
      * @protected
      * @returns {Buffer}
      */
-    public static witnessStackToScriptWitness(witness: Buffer[]): Buffer {
+    public static witnessStackToScriptWitness(witness: Uint8Array[]): Uint8Array {
         return witnessStackToScriptWitness(witness);
     }
 
-    public addOPReturn(buffer: Buffer): void {
+    public override [Symbol.dispose](): void {
+        super[Symbol.dispose]();
+
+        this.updateInputs.length = 0;
+        this.outputs.length = 0;
+        this.feeOutput = null;
+        this.optionalOutputs = undefined;
+        this.utxos = [];
+        this.optionalInputs = [];
+    }
+
+    public addOPReturn(buffer: Uint8Array): void {
         const compileScript = script.compile([opcodes.OP_RETURN, buffer]);
 
         this.addOutput({
-            value: 0,
+            value: toSatoshi(0n),
             script: compileScript,
         });
     }
 
     public addAnchor(): void {
         this.addOutput({
-            value: 0,
-            script: ANCHOR_SCRIPT,
+            value: toSatoshi(0n),
+            script: ANCHOR_SCRIPT as Script,
         });
     }
 
@@ -266,10 +282,12 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             gasSatFee: this.gasSatFee ?? 0n,
             from: this.from,
             amount: this.estimatedFees,
-            optionalOutputs: this.optionalOutputs,
             optionalInputs: this.optionalInputs,
             mldsaSigner: null,
-        };
+            ...(this.optionalOutputs !== undefined
+                ? { optionalOutputs: this.optionalOutputs }
+                : {}),
+        } satisfies IFundingTransactionParameters;
     }
 
     /**
@@ -354,7 +372,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             this.transaction.addInputs(inputs, checkPartialSigs);
 
             for (let i = 0; i < this.updateInputs.length; i++) {
-                this.transaction.updateInput(i, this.updateInputs[i]);
+                this.transaction.updateInput(i, this.updateInputs[i] as UpdateInput);
             }
 
             this.transaction.addOutputs(outputs);
@@ -393,25 +411,28 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
      * @returns {void}
      */
     public addOutput(output: PsbtOutputExtended, bypassMinCheck: boolean = false): void {
-        if (output.value === 0) {
-            const script = output as {
-                script: Buffer;
+        if (output.value === toSatoshi(0n)) {
+            const scriptOutput = output as {
+                script: Uint8Array;
             };
 
-            if (!script.script || script.script.length === 0) {
+            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}`,
             );
@@ -460,26 +481,26 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         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: number, input: PsbtInputExtended) => {
             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: Buffer[] = [];
+                const dummyDataSlots: Uint8Array[] = [];
                 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,
@@ -490,11 +511,11 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             }
 
             if (inputIndex === 0 && this.tapLeafScript) {
-                const dummySecret = Buffer.alloc(32, 0);
+                const dummySecret = new Uint8Array(32);
                 const dummyScript = this.tapLeafScript.script;
 
                 // A control block for a 2-leaf tree contains one 32-byte hash.
-                const dummyControlBlock = Buffer.alloc(1 + 32 + 32, 0);
+                const dummyControlBlock = new Uint8Array(1 + 32 + 32);
 
                 return {
                     finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness([
@@ -560,14 +581,14 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
                         lastOp === opcodes.OP_CHECKMULTISIG
                     ) {
                         const m = firstOp - opcodes.OP_1 + 1;
-                        const signatures: Buffer[] = [];
+                        const signatures: Uint8Array[] = [];
                         for (let i = 0; i < m; i++) {
                             signatures.push(dummyEcdsaSig);
                         }
 
                         return {
                             finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness([
-                                Buffer.alloc(0), // OP_0 due to multisig bug
+                                new Uint8Array(0), // OP_0 due to multisig bug
                                 ...signatures,
                                 input.witnessScript,
                             ]),
@@ -587,7 +608,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
                     decompiled &&
                     decompiled.length === 2 &&
                     decompiled[0] === opcodes.OP_0 &&
-                    Buffer.isBuffer(decompiled[1]) &&
+                    decompiled[1] instanceof Uint8Array &&
                     decompiled[1].length === 20
                 ) {
                     // P2SH-P2WPKH
@@ -609,8 +630,8 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
                 };
             }
 
-            const script = input.witnessUtxo?.script;
-            if (!script) return { finalScriptSig: undefined, finalScriptWitness: undefined };
+            const inputScript = input.witnessUtxo?.script;
+            if (!inputScript) return { finalScriptSig: undefined, finalScriptWitness: undefined };
 
             if (input.tapInternalKey) {
                 return {
@@ -620,7 +641,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
                 };
             }
 
-            if (script.length === 22 && script[0] === opcodes.OP_0) {
+            if (inputScript.length === 22 && inputScript[0] === opcodes.OP_0) {
                 return {
                     finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness([
                         dummyEcdsaSig,
@@ -641,7 +662,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             return getFinalScripts(
                 inputIndex,
                 input,
-                script,
+                inputScript as Script,
                 true,
                 !!input.redeemScript,
                 !!input.witnessScript,
@@ -715,7 +736,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
 
         let total = 0n;
         for (let i = 0; i < this.optionalOutputs.length; i++) {
-            total += BigInt(this.optionalOutputs[i].value);
+            total += BigInt((this.optionalOutputs[i] as PsbtOutputExtended).value);
         }
 
         return total;
@@ -733,103 +754,59 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             this.addAnchor();
         }
 
-        // Initialize variables for iteration
-        let previousFee = -1n;
-        let estimatedFee = 0n;
-        let iterations = 0;
-        const maxIterations = 5; // Prevent infinite loops
+        // 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();
 
-        let sendBackAmount = 0n;
-        // Iterate until fee stabilizes
-        while (iterations < maxIterations && estimatedFee !== previousFee) {
-            previousFee = estimatedFee;
+        const sendBackAmount = this.totalInputAmount - amountSpent - feeWithChange;
 
-            // Calculate the fee with current outputs
-            estimatedFee = await this.estimateTransactionFees();
+        if (this.debugFees) {
+            this.log(
+                `Fee with change: ${feeWithChange} sats, inputAmount=${this.totalInputAmount}, amountSpent=${amountSpent}, sendBackAmount=${sendBackAmount}`,
+            );
+        }
 
-            // Total amount that needs to be spent (outputs + fee)
-            const totalSpent = amountSpent + estimatedFee;
+        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;
 
-            // Calculate refund
-            sendBackAmount = this.totalInputAmount - totalSpent;
+            const feeWithoutChange = await this.estimateTransactionFees();
+            this.transactionFee = feeWithoutChange;
 
             if (this.debugFees) {
-                this.log(
-                    `Iteration ${iterations + 1}: inputAmount=${this.totalInputAmount}, totalSpent=${totalSpent}, sendBackAmount=${sendBackAmount}`,
+                this.warn(
+                    `Amount to send back (${sendBackAmount} sat) is less than minimum dust. Fee without change: ${feeWithoutChange} sats`,
                 );
             }
 
-            // Determine if we should add a change output
-            if (sendBackAmount >= TransactionBuilder.MINIMUM_DUST) {
-                // Create the appropriate change output
-                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,
-                    };
-                }
-
-                // Set overflowFees when we have a change output
-                this.overflowFees = sendBackAmount;
-            } else {
-                // No change output if below dust
-                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`,
+                );
             }
 
-            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`);
+            if (expectRefund && sendBackAmount < 0n) {
+                throw new Error(
+                    `Insufficient funds: need at least ${-sendBackAmount} more sats to cover fees.`,
+                );
+            }
         }
 
-        // Store the final fee
-        this.transactionFee = estimatedFee;
-
         if (this.debugFees) {
             this.log(
-                `Final fee: ${estimatedFee} sats, Change output: ${this.feeOutput ? `${this.feeOutput.value} sats` : 'none'}`,
+                `Final fee: ${this.transactionFee} sats, Change output: ${this.feeOutput ? `${this.feeOutput.value} sats` : 'none'}`,
             );
         }
     }
 
-    protected defineLockScript(): Buffer {
-        return script.compile([toXOnly(Buffer.from(this.signer.publicKey)), opcodes.OP_CHECKSIG]);
+    protected defineLockScript(): Script {
+        return script.compile([toXOnly(this.signer.publicKey), opcodes.OP_CHECKSIG]);
     }
 
     /**
@@ -839,15 +816,19 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
      * @returns {void}
      */
     protected addValueToToOutput(value: number | bigint): void {
-        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] as PsbtOutputExtended;
             if ('address' in output && output.address === this.to) {
-                output.value += Number(value);
+                this.outputs[i] = {
+                    ...output,
+                    value: toSatoshi(BigInt(output.value) + BigInt(value)),
+                } as PsbtOutputExtended;
                 return;
             }
         }
@@ -855,7 +836,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         throw new Error('Output not found');
     }
 
-    protected generateLegacySignature(): Buffer {
+    protected generateLegacySignature(): Uint8Array {
         this.tweakSigner();
 
         if (!this.tweakedSigner) {
@@ -888,10 +869,10 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             throw new Error('Could not verify generated legacy signature for MLDSA link request');
         }
 
-        return Buffer.from(signature.signature);
+        return new Uint8Array(signature.signature);
     }
 
-    protected generateMLDSASignature(): Buffer {
+    protected generateMLDSASignature(): Uint8Array {
         if (!this.mldsaSigner) {
             throw new Error('MLDSA signer is not defined');
         }
@@ -937,7 +918,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             throw new Error('Could not verify generated MLDSA signature for link request');
         }
 
-        return Buffer.from(signature.signature);
+        return new Uint8Array(signature.signature);
     }
 
     protected generateMLDSALinkRequest(
@@ -947,7 +928,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         const mldsaSigner = this.mldsaSigner;
         const legacySignature = this.generateLegacySignature();
 
-        let mldsaSignature: Buffer | null = null;
+        let mldsaSignature: Uint8Array | null = null;
         if (parameters.revealMLDSAPublicKey) {
             mldsaSignature = this.generateMLDSASignature();
         }
@@ -1029,8 +1010,10 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         let refundedFromOptionalOutputs: bigint = 0n;
 
         for (let i = 0; i < this.optionalOutputs.length; i++) {
-            this.addOutput(this.optionalOutputs[i]);
-            refundedFromOptionalOutputs += BigInt(this.optionalOutputs[i].value);
+            this.addOutput(this.optionalOutputs[i] as PsbtOutputExtended);
+            refundedFromOptionalOutputs += BigInt(
+                (this.optionalOutputs[i] as PsbtOutputExtended).value,
+            );
         }
 
         this.optionalOutputsAdded = true;
@@ -1054,7 +1037,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             }
 
             for (let i = 0; i < this.utxos.length; i++) {
-                const utxo = this.utxos[i];
+                const utxo = this.utxos[i] as UTXO;
 
                 // Register signer BEFORE generating input (needed for tapInternalKey)
                 this.registerInputSigner(i, utxo);
@@ -1070,7 +1053,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
                 i < this.optionalInputs.length + this.utxos.length;
                 i++
             ) {
-                const utxo = this.optionalInputs[i - this.utxos.length];
+                const utxo = this.optionalInputs[i - this.utxos.length] as UTXO;
 
                 // Register signer BEFORE generating input (needed for tapInternalKey)
                 this.registerInputSigner(i, utxo);
@@ -1133,7 +1116,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             // ALWAYS THE FIRST INPUT.
             this.addOutput(
                 {
-                    value: Number(amountToCA),
+                    value: toSatoshi(amountToCA),
                     address: contractAddress,
                 },
                 true,
@@ -1146,7 +1129,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             ) {
                 this.addOutput(
                     {
-                        value: Number(amountSpent - amountToCA),
+                        value: toSatoshi(amountSpent - amountToCA),
                         address: epochChallenge.address,
                     },
                     true,
@@ -1160,7 +1143,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
 
             this.addOutput(
                 {
-                    value: Number(amountToEpoch),
+                    value: toSatoshi(amountToEpoch),
                     address: epochChallenge.address,
                 },
                 true,
@@ -1173,7 +1156,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
      * @protected
      * @returns {Buffer}
      */
-    protected getWitness(): Buffer {
+    protected getWitness(): Uint8Array {
         if (!this.tapData || !this.tapData.witness) {
             throw new Error('Witness is required');
         }
@@ -1182,7 +1165,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             throw new Error('Witness is empty');
         }
 
-        return this.tapData.witness[this.tapData.witness.length - 1];
+        return this.tapData.witness[this.tapData.witness.length - 1] as Uint8Array;
     }
 
     /**
@@ -1190,7 +1173,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
      * @protected
      * @returns {Buffer}
      */
-    protected getTapOutput(): Buffer {
+    protected getTapOutput(): Uint8Array {
         if (!this.tapData || !this.tapData.output) {
             throw new Error('Tap data is required');
         }
@@ -1216,110 +1199,6 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         }
     }
 
-    /**
-     * Set transaction fee output.
-     * @param {PsbtOutputExtended} output - The output to set the fees
-     * @protected
-     * @returns {Promise<void>}
-     */
-    protected async setFeeOutput(output: PsbtOutputExtended): Promise<void> {
-        const initialValue = output.value;
-        this.feeOutput = null; // Start with no fee output
-
-        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;
-                // Re-estimate fee one last time without the change output
-                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;
-        }
-    }
-    /*protected async setFeeOutput(output: PsbtOutputExtended): Promise<void> {
-        const initialValue = output.value;
-
-        const fee = await this.estimateTransactionFees();
-        output.value = initialValue - Number(fee);
-
-        if (output.value < TransactionBuilder.MINIMUM_DUST) {
-            this.feeOutput = null;
-
-            if (output.value < 0) {
-                throw new Error(
-                    `setFeeOutput: Insufficient funds to pay the fees. Fee: ${fee} < Value: ${initialValue}. Total input: ${this.totalInputAmount} sat`,
-                );
-            }
-        } else {
-            this.feeOutput = output;
-
-            const fee = await this.estimateTransactionFees();
-            if (fee > BigInt(initialValue)) {
-                throw new Error(
-                    `estimateTransactionFees: Insufficient funds to pay the fees. Fee: ${fee} > Value: ${initialValue}. Total input: ${this.totalInputAmount} sat`,
-                );
-            }
-
-            const valueLeft = initialValue - Number(fee);
-            if (valueLeft < TransactionBuilder.MINIMUM_DUST) {
-                this.feeOutput = null;
-            } else {
-                this.feeOutput.value = valueLeft;
-            }
-
-            this.overflowFees = BigInt(valueLeft);
-        }
-    }*/
-
     /**
      * Builds the transaction.
      * @param {Psbt} transaction - The transaction to build
@@ -1340,7 +1219,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             transaction.addInputs(inputs, checkPartialSigs);
 
             for (let i = 0; i < this.updateInputs.length; i++) {
-                transaction.updateInput(i, this.updateInputs[i]);
+                transaction.updateInput(i, this.updateInputs[i] as UpdateInput);
             }
 
             transaction.addOutputs(outputs);
@@ -1364,4 +1243,29 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
 
         return false;
     }
+
+    private createChangeOutput(amount: bigint): PsbtOutputExtended {
+        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,
+            };
+        }
+    }
 }