Add unit test for Coin Selector

src/wallet/coin-selector.ts

@@ -11,6 +11,7 @@ class CoinPointer {
 
 export class CoinSelector {
     private readonly feeRate: number = 1;
+    public static readonly LONG_TERM_FEERATE: number = 5; // in sats/vB
     constructor(feeRate?: number) {
         this.feeRate = feeRate;
     }
@@ -43,16 +44,10 @@ export class CoinSelector {
             ) - target;
 
         // Calculate the cost of change
-        const LONG_TERM_FEERATE = 5 // in sats/vB
-        const outputSize = 31;  // P2WPKH output is 31 B
-        const inputSizeOfChangeUTXO = 68.0; // P2WPKH input is 68.0 vbytes
-
-        const costOfChangeOutput = outputSize * this.feeRate;
-        const costOfSpendingChange = inputSizeOfChangeUTXO * LONG_TERM_FEERATE;
-        const costOfChange = costOfChangeOutput + costOfSpendingChange;
+        const costOfChange = this.costOfChange;
 
         // Check if change is less than the cost of change
-        if(change <= costOfChange) {
+        if (change <= costOfChange) {
             change = 0;
         }
 
@@ -62,6 +57,36 @@ export class CoinSelector {
         };
     }
 
+    get costOfChange() {
+        // P2WPKH output size in bytes:
+        // Pay-to-Witness-Public-Key-Hash (P2WPKH) outputs have a fixed size of 31 bytes:
+        // - 8 bytes to encode the value
+        // - 1 byte variable-length integer encoding the locking script’s size
+        // - 22 byte locking script
+        const outputSize = 31;
+
+        // P2WPKH input size estimation:
+        // - Composition:
+        //   - PREVOUT: hash (32 bytes), index (4 bytes)
+        //   - SCRIPTSIG: length (1 byte), scriptsig for P2WPKH input is empty
+        //   - sequence (4 bytes)
+        //   - WITNESS STACK:
+        //     - item count (1 byte)
+        //     - signature length (1 byte)
+        //     - signature (71 or 72 bytes)
+        //     - pubkey length (1 byte)
+        //     - pubkey (33 bytes)
+        // - Total:
+        //   32 + 4 + 1 + 4 + (1 + 1 + 72 + 1 + 33) / 4 = 68 vbytes
+        const inputSizeOfChangeUTXO = 68;
+
+        const costOfChangeOutput = outputSize * this.feeRate;
+        const costOfSpendingChange =
+            inputSizeOfChangeUTXO * CoinSelector.LONG_TERM_FEERATE;
+
+        return costOfChangeOutput + costOfSpendingChange;
+    }
+
     private selectCoins(pointers: CoinPointer[], target: number) {
         const selected = this.selectLowestLarger(pointers, target);
         if (selected.length > 0) return selected;

test/coinselector.spec.ts

@@ -0,0 +1,99 @@
+import { Coin } from '../src/wallet/coin';
+import { CoinSelector } from '../src/wallet/coin-selector.ts';
+import { Transaction } from 'bitcoinjs-lib';
+
+describe('CoinSelector', () => {
+    let coinSelector: CoinSelector;
+    const feeRate: number = 5;
+
+    beforeAll(() => {
+        coinSelector = new CoinSelector(feeRate);
+    });
+
+    it('should generate the correct cost of change', () => {
+        // Fixed value for the cost of change based on the current feeRate
+        const correctCostOfChange = 495;
+
+        // Assert the correctness of the CoinSelector result
+        expect(correctCostOfChange).toBe(coinSelector.costOfChange);
+    });
+
+    it('should add change to the fee if it is dust', () => {
+        const coins: Coin[] = [];
+        let totalBalance: number = 0;
+
+        // General Coin values for testing purposes
+        const testValues: number[] = [
+            655, 904, 644, 234, 754, 392, 575, 930, 192, 59,
+        ];
+
+        // Calculate the total balance based on the fixed array of coin values
+        for (const value of testValues) {
+            const roundedValue = Math.round(value);
+            const coin = new Coin({ value: roundedValue });
+            coins.push(coin);
+            // Calculate the total balance by subtracting the spending fee
+            totalBalance += coin.value - coin.estimateSpendingFee(feeRate);
+        }
+
+        // Fixed fees for the transaction
+        const transactionFees = 250;
+
+        // Fixed transaction output value that ensures the cost of change is dust
+        const txOutValue =
+            totalBalance - transactionFees - coinSelector.costOfChange + 1;
+
+        // Set the transaction output value with a random output script
+        const transaction: Transaction = new Transaction();
+        const randomString = [...Array(50)]
+            .map(() => Math.random().toString(36)[2])
+            .join('');
+        transaction.addOutput(Buffer.from(randomString, 'hex'), txOutValue);
+
+        // Select coins and change using the CoinSelector
+        const { coins: selectedCoins, change } = coinSelector.select(
+            coins,
+            transaction,
+        );
+
+        // Assert that the selected coins' size is greater than 0
+        expect(selectedCoins.length).toBeGreaterThan(0);
+
+        // The above calculations ensure that the change is always less than the dust
+        expect(change).toBe(0);
+    });
+
+    it('change should be considered when greater than dust', () => {
+        const coins: Coin[] = [];
+
+        // General Coin values for testing purposes
+        const testValues: number[] = [5000, 4000];
+
+        for (const value of testValues) {
+            const coin = new Coin({ value });
+            coins.push(coin);
+        }
+
+        // Fixed transaction output value that ensures the cost of change is always greater than dust
+        const txOutValue = 500;
+
+        // Set the transaction output value with a random output script
+        const transaction: Transaction = new Transaction();
+        const randomString = [...Array(50)]
+            .map(() => Math.random().toString(36)[2])
+            .join('');
+        transaction.addOutput(Buffer.from(randomString, 'hex'), txOutValue);
+
+        // Select coins and change using the CoinSelector
+        const { coins: selectedCoins, change } = coinSelector.select(
+            coins,
+            transaction,
+        );
+
+        // Assert that the selected coins' size is greater than 0
+        expect(selectedCoins.length).toBeGreaterThan(0);
+
+        // The above calculations ensure that the change is always greater than the dust
+        expect(change).toBeGreaterThan(0);
+    });
+});