@btc-vision/transaction 1.6.6 → 1.6.7

package/build/transaction/builders/TransactionBuilder.js

@@ -1,16 +1,18 @@
-import { initEccLib, opcodes, Psbt, script, Transaction, varuint, } from '@btc-vision/bitcoin';
+import bitcoin, { getFinalScripts, initEccLib, opcodes, Psbt, script, Transaction, varuint, } from '@btc-vision/bitcoin';
 import * as ecc from '@bitcoinerlab/secp256k1';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { AddressVerificator } from '../../keypair/AddressVerificator.js';
 import { TweakedTransaction } from '../shared/TweakedTransaction.js';
+import { P2WDADetector } from '../../p2wda/P2WDADetector.js';
 initEccLib(ecc);
-export const MINIMUM_AMOUNT_REWARD = 540n;
+export const MINIMUM_AMOUNT_REWARD = 330n;
 export const MINIMUM_AMOUNT_CA = 297n;
 export const ANCHOR_SCRIPT = Buffer.from('51024e73', 'hex');
 export class TransactionBuilder extends TweakedTransaction {
     constructor(parameters) {
         super(parameters);
         this.logColor = '#785def';
+        this.debugFees = false;
         this.overflowFees = 0n;
         this.transactionFee = 0n;
         this.estimatedFees = 0n;
@@ -18,6 +20,7 @@ export class TransactionBuilder extends TweakedTransaction {
         this.outputs = [];
         this.feeOutput = null;
         this._maximumFeeRate = 100000000;
+        this.optionalOutputsAdded = false;
         if (parameters.estimatedFees) {
             this.estimatedFees = parameters.estimatedFees;
         }
@@ -29,6 +32,7 @@ export class TransactionBuilder extends TweakedTransaction {
         this.utxos = parameters.utxos;
         this.optionalInputs = parameters.optionalInputs || [];
         this.to = parameters.to || undefined;
+        this.debugFees = parameters.debugFees || false;
         if (parameters.note) {
             if (typeof parameters.note === 'string') {
                 this.note = Buffer.from(parameters.note, 'utf8');
@@ -164,7 +168,7 @@ export class TransactionBuilder extends TweakedTransaction {
     addInput(input) {
         this.inputs.push(input);
     }
-    addOutput(output) {
+    addOutput(output, bypassMinCheck = false) {
         if (output.value === 0) {
             const script = output;
             if (!script.script || script.script.length === 0) {
@@ -177,11 +181,14 @@ export class TransactionBuilder extends TweakedTransaction {
                 throw new Error('Output script must start with OP_RETURN or be an ANCHOR when value is 0');
             }
         }
-        else if (output.value < TransactionBuilder.MINIMUM_DUST) {
+        else if (!bypassMinCheck && 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);
     }
+    getTotalOutputValue() {
+        return this.outputs.reduce((total, output) => total + BigInt(output.value), 0n);
+    }
     toAddress() {
         return this.to;
     }
@@ -189,25 +196,169 @@ export class TransactionBuilder extends TweakedTransaction {
         return this.tapData?.address;
     }
     async estimateTransactionFees() {
-        if (!this.utxos.length) {
-            throw new Error('No UTXOs specified');
+        await Promise.resolve();
+        const fakeTx = new Psbt({ network: this.network });
+        const inputs = this.getInputs();
+        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 finalizer = (inputIndex, input) => {
+            if (input.isPayToAnchor || this.anchorInputIndices.has(inputIndex)) {
+                return {
+                    finalScriptSig: undefined,
+                    finalScriptWitness: Buffer.from([0]),
+                };
+            }
+            if (input.witnessScript && P2WDADetector.isP2WDAWitnessScript(input.witnessScript)) {
+                const dummyDataSlots = [];
+                for (let i = 0; i < 10; i++) {
+                    dummyDataSlots.push(Buffer.alloc(0));
+                }
+                const dummyEcdsaSig = Buffer.alloc(72, 0);
+                return {
+                    finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness([
+                        ...dummyDataSlots,
+                        dummyEcdsaSig,
+                        input.witnessScript,
+                    ]),
+                };
+            }
+            if (inputIndex === 0 && this.tapLeafScript) {
+                const dummySecret = Buffer.alloc(32, 0);
+                const dummyScript = this.tapLeafScript.script;
+                const dummyControlBlock = Buffer.alloc(1 + 32 + 32, 0);
+                return {
+                    finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness([
+                        dummySecret,
+                        dummySchnorrSig,
+                        dummySchnorrSig,
+                        dummyScript,
+                        dummyControlBlock,
+                    ]),
+                };
+            }
+            if (!input.witnessUtxo && input.nonWitnessUtxo) {
+                return {
+                    finalScriptSig: bitcoin.script.compile([dummyEcdsaSig, dummyCompressedPubkey]),
+                    finalScriptWitness: undefined,
+                };
+            }
+            if (input.witnessScript) {
+                if (this.csvInputIndices.has(inputIndex)) {
+                    return {
+                        finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness([
+                            dummyEcdsaSig,
+                            input.witnessScript,
+                        ]),
+                    };
+                }
+                if (input.redeemScript) {
+                    const dummyWitness = [dummyEcdsaSig, input.witnessScript];
+                    return {
+                        finalScriptSig: input.redeemScript,
+                        finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness(dummyWitness),
+                    };
+                }
+                const decompiled = bitcoin.script.decompile(input.witnessScript);
+                if (decompiled && decompiled.length >= 4) {
+                    const firstOp = decompiled[0];
+                    const lastOp = decompiled[decompiled.length - 1];
+                    if (typeof firstOp === 'number' &&
+                        firstOp >= opcodes.OP_1 &&
+                        lastOp === opcodes.OP_CHECKMULTISIG) {
+                        const m = firstOp - opcodes.OP_1 + 1;
+                        const signatures = [];
+                        for (let i = 0; i < m; i++) {
+                            signatures.push(dummyEcdsaSig);
+                        }
+                        return {
+                            finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness([
+                                Buffer.alloc(0),
+                                ...signatures,
+                                input.witnessScript,
+                            ]),
+                        };
+                    }
+                }
+                return {
+                    finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness([
+                        dummyEcdsaSig,
+                        input.witnessScript,
+                    ]),
+                };
+            }
+            else if (input.redeemScript) {
+                const decompiled = bitcoin.script.decompile(input.redeemScript);
+                if (decompiled &&
+                    decompiled.length === 2 &&
+                    decompiled[0] === opcodes.OP_0 &&
+                    Buffer.isBuffer(decompiled[1]) &&
+                    decompiled[1].length === 20) {
+                    return {
+                        finalScriptSig: input.redeemScript,
+                        finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness([
+                            dummyEcdsaSig,
+                            dummyCompressedPubkey,
+                        ]),
+                    };
+                }
+            }
+            if (input.redeemScript && !input.witnessScript && !input.witnessUtxo) {
+                return {
+                    finalScriptSig: bitcoin.script.compile([dummyEcdsaSig, input.redeemScript]),
+                    finalScriptWitness: undefined,
+                };
+            }
+            const script = input.witnessUtxo?.script;
+            if (!script)
+                return { finalScriptSig: undefined, finalScriptWitness: undefined };
+            if (input.tapInternalKey) {
+                return {
+                    finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness([
+                        dummySchnorrSig,
+                    ]),
+                };
+            }
+            if (script.length === 22 && script[0] === opcodes.OP_0) {
+                return {
+                    finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness([
+                        dummyEcdsaSig,
+                        dummyCompressedPubkey,
+                    ]),
+                };
+            }
+            if (input.redeemScript?.length === 22 && input.redeemScript[0] === opcodes.OP_0) {
+                return {
+                    finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness([
+                        dummyEcdsaSig,
+                        dummyCompressedPubkey,
+                    ]),
+                };
+            }
+            return getFinalScripts(inputIndex, input, script, true, !!input.redeemScript, !!input.witnessScript);
+        };
+        try {
+            for (let i = 0; i < fakeTx.data.inputs.length; i++) {
+                const fullInput = inputs[i];
+                if (fullInput) {
+                    fakeTx.finalizeInput(i, (idx) => finalizer(idx, fullInput));
+                }
+            }
         }
-        if (this.estimatedFees)
-            return this.estimatedFees;
-        const fakeTx = new Psbt({
-            network: this.network,
-        });
-        const builtTx = await this.internalBuildTransaction(fakeTx);
-        if (builtTx) {
-            const tx = fakeTx.extractTransaction(true, true);
-            const size = tx.virtualSize();
-            const fee = this.feeRate * size;
-            this.estimatedFees = BigInt(Math.ceil(fee) + 1);
-            return this.estimatedFees;
+        catch (e) {
+            this.warn(`Could not finalize dummy tx: ${e.message}`);
         }
-        else {
-            throw new Error(`Could not build transaction to estimate fee. Something went wrong while building the transaction.`);
+        const tx = fakeTx.extractTransaction(true, true);
+        const size = tx.virtualSize();
+        const fee = this.feeRate * size;
+        const finalFee = BigInt(Math.ceil(fee));
+        if (this.debugFees) {
+            this.log(`Estimating fees: feeRate=${this.feeRate}, accurate_vSize=${size}, fee=${finalFee}n`);
         }
+        return finalFee;
     }
     async rebuildFromBase64(base64) {
         this.transaction = Psbt.fromBase64(base64, {
@@ -246,34 +397,63 @@ export class TransactionBuilder extends TweakedTransaction {
         if (this.anchor) {
             this.addAnchor();
         }
-        const sendBackAmount = this.totalInputAmount - amountSpent;
-        if (sendBackAmount >= TransactionBuilder.MINIMUM_DUST) {
-            if (AddressVerificator.isValidP2TRAddress(this.from, this.network)) {
-                await this.setFeeOutput({
-                    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,
-                ]);
-                await this.setFeeOutput({
-                    value: Number(sendBackAmount),
-                    script: pubKeyScript,
-                });
+        let previousFee = -1n;
+        let estimatedFee = 0n;
+        let iterations = 0;
+        const maxIterations = 5;
+        while (iterations < maxIterations && estimatedFee !== previousFee) {
+            previousFee = estimatedFee;
+            estimatedFee = await this.estimateTransactionFees();
+            const totalSpent = amountSpent + estimatedFee;
+            const sendBackAmount = this.totalInputAmount - totalSpent;
+            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;
             }
             else {
-                await this.setFeeOutput({
-                    value: Number(sendBackAmount),
-                    address: this.from,
-                });
+                this.feeOutput = null;
+                this.overflowFees = 0n;
+                if (sendBackAmount < 0n) {
+                    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...`);
+                }
             }
-            return;
+            iterations++;
+        }
+        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.warn(`Amount to send back (${sendBackAmount} sat) is less than the minimum dust (${TransactionBuilder.MINIMUM_DUST} sat), it will be consumed in fees instead.`);
     }
     addValueToToOutput(value) {
         if (value < TransactionBuilder.MINIMUM_DUST) {
@@ -315,13 +495,14 @@ export class TransactionBuilder extends TweakedTransaction {
         return total;
     }
     addOptionalOutputsAndGetAmount() {
-        if (!this.optionalOutputs)
+        if (!this.optionalOutputs || this.optionalOutputsAdded)
             return 0n;
         let refundedFromOptionalOutputs = 0n;
         for (let i = 0; i < this.optionalOutputs.length; i++) {
             this.addOutput(this.optionalOutputs[i]);
             refundedFromOptionalOutputs += BigInt(this.optionalOutputs[i].value);
         }
+        this.optionalOutputsAdded = true;
         return refundedFromOptionalOutputs;
     }
     addInputsFromUTXO() {
@@ -350,6 +531,35 @@ export class TransactionBuilder extends TweakedTransaction {
     updateInput(input) {
         this.updateInputs.push(input);
     }
+    addFeeToOutput(amountSpent, contractAddress, epochChallenge, addContractOutput) {
+        if (addContractOutput) {
+            let amountToCA;
+            if (amountSpent > MINIMUM_AMOUNT_REWARD + MINIMUM_AMOUNT_CA) {
+                amountToCA = MINIMUM_AMOUNT_CA;
+            }
+            else {
+                amountToCA = amountSpent;
+            }
+            this.addOutput({
+                value: Number(amountToCA),
+                address: contractAddress,
+            }, true);
+            if (amountToCA === MINIMUM_AMOUNT_CA &&
+                amountSpent - MINIMUM_AMOUNT_CA > MINIMUM_AMOUNT_REWARD) {
+                this.addOutput({
+                    value: Number(amountSpent - amountToCA),
+                    address: epochChallenge.address,
+                }, true);
+            }
+        }
+        else {
+            const amountToEpoch = amountSpent < MINIMUM_AMOUNT_REWARD ? MINIMUM_AMOUNT_REWARD : amountSpent;
+            this.addOutput({
+                value: Number(amountToEpoch),
+                address: epochChallenge.address,
+            }, true);
+        }
+    }
     getWitness() {
         if (!this.tapData || !this.tapData.witness) {
             throw new Error('Witness is required');
@@ -379,28 +589,45 @@ export class TransactionBuilder extends TweakedTransaction {
     }
     async setFeeOutput(output) {
         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`);
+        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.`);
             }
-        }
-        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`);
+            if (valueLeft >= TransactionBuilder.MINIMUM_DUST) {
+                this.feeOutput = { ...output, value: Number(valueLeft) };
+                this.overflowFees = valueLeft;
             }
-            const valueLeft = initialValue - Number(fee);
-            if (valueLeft < TransactionBuilder.MINIMUM_DUST) {
+            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.`);
+                }
             }
-            else {
-                this.feeOutput.value = valueLeft;
+        }
+        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.`);
             }
-            this.overflowFees = BigInt(valueLeft);
+        }
+        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;
         }
     }
     async internalBuildTransaction(transaction, checkPartialSigs = false) {
@@ -432,4 +659,4 @@ TransactionBuilder.LOCK_LEAF_SCRIPT = script.compile([
     opcodes.OP_FALSE,
     opcodes.OP_VERIFY,
 ]);
-TransactionBuilder.MINIMUM_DUST = 50n;
+TransactionBuilder.MINIMUM_DUST = 330n;

package/build/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/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.6.6",
+    "version": "1.6.7",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {

package/src/_version.ts

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