@atomicfinance/bitcoin-dlc-provider 4.2.8 → 4.3.1

package/.yalc/@node-dlc/core/__tests__/dlc/TxBuilder.spec.ts

@@ -0,0 +1,424 @@
+import { Value } from '@node-dlc/bitcoin';
+import {
+  DlcAcceptWithoutSigs,
+  DlcOffer,
+  FundingInput,
+} from '@node-dlc/messaging';
+import { expect } from 'chai';
+
+import { BatchDlcTxBuilder, DlcTxBuilder, DUST_LIMIT } from '../../lib';
+
+describe('TxBuilder', () => {
+  // Helper function to create test FundingInput
+  const createTestFundingInput = (
+    value: bigint,
+    serialId = 1,
+    maxWitnessLen = 108,
+  ): FundingInput => {
+    // Create proper transaction hex with correct output value encoding
+    // Based on working format from existing tests
+    const valueBuffer = Buffer.allocUnsafe(8);
+    valueBuffer.writeBigUInt64LE(value, 0);
+    const valueHex = valueBuffer.toString('hex');
+
+    // Use a working transaction format: version + input + outputs + locktime
+    const prevTxHex =
+      '02000000' + // version
+      '01' + // num inputs
+      'f58f85b356ad5bb5b6d0ef3eb863be8a6cb95e08e1e9e92885b4b22e7e51eb9d' + // input txid
+      '00000000' + // input vout
+      '00' + // script sig length
+      'ffffffff' + // sequence
+      '01' + // num outputs
+      valueHex + // output value (8 bytes, little endian)
+      '2200201234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef' + // P2WSH script
+      '00000000'; // locktime
+
+    return FundingInput.fromJSON({
+      inputSerialId: serialId,
+      prevTx: prevTxHex,
+      prevTxVout: 0,
+      sequence: 4294967295,
+      maxWitnessLen,
+      redeemScript: '',
+    });
+  };
+
+  // Helper function to create test DlcOffer
+  const createTestDlcOffer = (
+    offerCollateral: bigint,
+    fundingInputs: FundingInput[],
+    feeRate = BigInt(1),
+  ): DlcOffer => {
+    const offer = new DlcOffer();
+    offer.offerCollateral = offerCollateral;
+    offer.fundingInputs = fundingInputs;
+    offer.feeRatePerVb = feeRate;
+    // Valid compressed public key (Bitcoin Generator Point)
+    offer.fundingPubkey = Buffer.from(
+      '0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798',
+      'hex',
+    );
+    offer.payoutSpk = Buffer.from(
+      '0014' + Buffer.alloc(20).toString('hex'),
+      'hex',
+    );
+    offer.changeSpk = Buffer.from(
+      '0014' + Buffer.alloc(20).toString('hex'),
+      'hex',
+    );
+    offer.fundOutputSerialId = BigInt(1);
+    offer.payoutSerialId = BigInt(2);
+    offer.changeSerialId = BigInt(3);
+    return offer;
+  };
+
+  // Helper function to create test DlcAccept
+  const createTestDlcAccept = (
+    acceptCollateral: bigint,
+    fundingInputs: FundingInput[] = [],
+  ): DlcAcceptWithoutSigs => {
+    return new DlcAcceptWithoutSigs(
+      1, // protocolVersion
+      Buffer.alloc(32), // temporaryContractId
+      acceptCollateral,
+      // Valid compressed public key (different from offer)
+      Buffer.from(
+        '02F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9',
+        'hex',
+      ),
+      Buffer.from('0014' + Buffer.alloc(20).toString('hex'), 'hex'), // payoutSpk
+      BigInt(4), // payoutSerialId
+      fundingInputs,
+      Buffer.from('0014' + Buffer.alloc(20).toString('hex'), 'hex'), // changeSpk
+      BigInt(5), // changeSerialId
+    );
+  };
+
+  describe('DUST_LIMIT', () => {
+    it('should export the dust limit constant', () => {
+      expect(DUST_LIMIT).to.equal(BigInt(1000));
+    });
+  });
+
+  describe('BatchDlcTxBuilder.calculateMaxCollateral', () => {
+    it('should calculate maximum collateral for single input', () => {
+      const fundingInputs = [createTestFundingInput(BigInt(1000000))];
+      const feeRate = BigInt(1);
+
+      const maxCollateral = BatchDlcTxBuilder.calculateMaxCollateral(
+        fundingInputs,
+        feeRate,
+        1,
+      );
+
+      // Should be input value minus fees
+      expect(Number(maxCollateral)).to.be.greaterThan(0);
+      expect(Number(maxCollateral)).to.be.lessThan(1000000);
+    });
+
+    it('should calculate maximum collateral for multiple inputs', () => {
+      const fundingInputs = [
+        createTestFundingInput(BigInt(500000)),
+        createTestFundingInput(BigInt(300000), 2),
+      ];
+      const feeRate = BigInt(1);
+
+      const maxCollateral = BatchDlcTxBuilder.calculateMaxCollateral(
+        fundingInputs,
+        feeRate,
+        1,
+      );
+
+      // Should be total input value minus fees
+      expect(Number(maxCollateral)).to.be.greaterThan(0);
+      expect(Number(maxCollateral)).to.be.lessThan(800000);
+    });
+
+    it('should account for higher fee rates', () => {
+      const fundingInputs = [createTestFundingInput(BigInt(1000000))];
+      const lowFeeRate = BigInt(1);
+      const highFeeRate = BigInt(10);
+
+      const maxCollateralLowFee = BatchDlcTxBuilder.calculateMaxCollateral(
+        fundingInputs,
+        lowFeeRate,
+        1,
+      );
+      const maxCollateralHighFee = BatchDlcTxBuilder.calculateMaxCollateral(
+        fundingInputs,
+        highFeeRate,
+        1,
+      );
+
+      // Higher fee rate should result in lower max collateral
+      expect(Number(maxCollateralHighFee)).to.be.lessThan(
+        Number(maxCollateralLowFee),
+      );
+    });
+
+    it('should account for multiple contracts', () => {
+      const fundingInputs = [createTestFundingInput(BigInt(1000000))];
+      const feeRate = BigInt(1);
+
+      const maxCollateralSingle = BatchDlcTxBuilder.calculateMaxCollateral(
+        fundingInputs,
+        feeRate,
+        1,
+      );
+      const maxCollateralMultiple = BatchDlcTxBuilder.calculateMaxCollateral(
+        fundingInputs,
+        feeRate,
+        3,
+      );
+
+      // Multiple contracts should result in lower max collateral due to higher fees
+      expect(Number(maxCollateralMultiple)).to.be.lessThan(
+        Number(maxCollateralSingle),
+      );
+    });
+
+    it('should return zero when fees exceed input value', () => {
+      const fundingInputs = [createTestFundingInput(BigInt(100))]; // Very small input
+      const feeRate = BigInt(1000); // Very high fee rate
+
+      const maxCollateral = BatchDlcTxBuilder.calculateMaxCollateral(
+        fundingInputs,
+        feeRate,
+        1,
+      );
+
+      expect(maxCollateral).to.equal(BigInt(0));
+    });
+
+    it('should handle empty funding inputs', () => {
+      const fundingInputs: FundingInput[] = [];
+      const feeRate = BigInt(1);
+
+      const maxCollateral = BatchDlcTxBuilder.calculateMaxCollateral(
+        fundingInputs,
+        feeRate,
+        1,
+      );
+
+      expect(maxCollateral).to.equal(BigInt(0));
+    });
+  });
+
+  describe('BatchDlcTxBuilder.buildFundingTransaction - Dust Filtering', () => {
+    it('should create change outputs when above dust threshold', () => {
+      // Create inputs with sufficient value for both collateral and change
+      const offerInput = createTestFundingInput(BigInt(1010000)); // 1.01 BTC in sats
+      const acceptInput = createTestFundingInput(BigInt(1005000), 2); // 1.005 BTC in sats
+
+      const offer = createTestDlcOffer(BigInt(1000000), [offerInput]); // 1 BTC collateral
+      const accept = createTestDlcAccept(BigInt(1000000), [acceptInput]); // 1 BTC collateral
+
+      const builder = new BatchDlcTxBuilder([offer], [accept]);
+      const tx = builder.buildFundingTransaction();
+
+      // Should have 3 outputs: funding output + 2 change outputs
+      expect(tx.outputs.length).to.equal(3);
+
+      // Verify all outputs have value above zero
+      tx.outputs.forEach((output) => {
+        expect(Number(output.value.sats)).to.be.greaterThan(0);
+      });
+    });
+
+    it('should filter out dust change outputs', () => {
+      // Create inputs that result in dust change
+      const offerInput = createTestFundingInput(BigInt(1000500)); // Just above collateral + fees
+      const acceptInput = createTestFundingInput(BigInt(1000300), 2); // Just above collateral + fees
+
+      const offer = createTestDlcOffer(BigInt(1000000), [offerInput]); // 1 BTC collateral
+      const accept = createTestDlcAccept(BigInt(1000000), [acceptInput]); // 1 BTC collateral
+
+      const builder = new BatchDlcTxBuilder([offer], [accept]);
+      const tx = builder.buildFundingTransaction();
+
+      // Should have only 1 output: just the funding output (no change outputs due to dust)
+      expect(tx.outputs.length).to.be.lessThan(3);
+      expect(tx.outputs.length).to.be.at.least(1);
+
+      // The funding output should be present
+      const fundingOutputValue = tx.outputs[0].value.sats;
+      expect(Number(fundingOutputValue)).to.be.greaterThan(2000000); // Should contain both collaterals + future fees
+    });
+
+    it('should handle exact amount scenarios (no change)', () => {
+      // Use calculateMaxCollateral to determine exact amounts
+      const offerInput = createTestFundingInput(BigInt(1000000));
+      const maxCollateral = BatchDlcTxBuilder.calculateMaxCollateral(
+        [offerInput],
+        BigInt(1),
+        1,
+      );
+
+      const offer = createTestDlcOffer(maxCollateral, [offerInput]);
+      const accept = createTestDlcAccept(BigInt(0), []); // Single-funded DLC
+
+      const builder = new BatchDlcTxBuilder([offer], [accept]);
+      const tx = builder.buildFundingTransaction();
+
+      // Should have only 1 output: the funding output
+      expect(tx.outputs.length).to.equal(1);
+
+      // Verify the funding output value
+      const fundingOutputValue = tx.outputs[0].value.sats;
+      expect(Number(fundingOutputValue)).to.be.greaterThan(0);
+    });
+
+    it('should handle mixed scenarios (one party has change, other has dust)', () => {
+      // Offer has significant change, accept has dust change
+      const offerInput = createTestFundingInput(BigInt(1050000)); // Large change
+      const acceptInput = createTestFundingInput(BigInt(1000300), 2); // Dust change
+
+      const offer = createTestDlcOffer(BigInt(1000000), [offerInput]);
+      const accept = createTestDlcAccept(BigInt(1000000), [acceptInput]);
+
+      const builder = new BatchDlcTxBuilder([offer], [accept]);
+      const tx = builder.buildFundingTransaction();
+
+      // Should have 2 outputs: funding output + offer change output (accept change filtered)
+      expect(tx.outputs.length).to.equal(2);
+
+      // Find the change output (not the largest one which should be funding)
+      const sortedOutputs = tx.outputs.sort((a, b) =>
+        Number(b.value.sats - a.value.sats),
+      );
+      const changeOutput = sortedOutputs[1];
+
+      // Verify change output is above dust threshold
+      expect(Number(changeOutput.value.sats)).to.be.at.least(
+        Number(DUST_LIMIT),
+      );
+    });
+  });
+
+  describe('BatchDlcTxBuilder.buildFundingTransaction - Error Handling', () => {
+    it('should throw error when offerer has insufficient funds', () => {
+      const offerInput = createTestFundingInput(BigInt(500000)); // Insufficient
+      const acceptInput = createTestFundingInput(BigInt(1000000), 2);
+
+      const offer = createTestDlcOffer(BigInt(1000000), [offerInput]); // Requires more than input
+      const accept = createTestDlcAccept(BigInt(500000), [acceptInput]);
+
+      const builder = new BatchDlcTxBuilder([offer], [accept]);
+
+      expect(() => builder.buildFundingTransaction()).to.throw(
+        /Insufficient funds for offerer/,
+      );
+    });
+
+    it('should throw error when accepter has insufficient funds', () => {
+      const offerInput = createTestFundingInput(BigInt(1000000));
+      const acceptInput = createTestFundingInput(BigInt(300000), 2); // Insufficient
+
+      const offer = createTestDlcOffer(BigInt(500000), [offerInput]);
+      const accept = createTestDlcAccept(BigInt(1000000), [acceptInput]); // Requires more than input
+
+      const builder = new BatchDlcTxBuilder([offer], [accept]);
+
+      expect(() => builder.buildFundingTransaction()).to.throw(
+        /Insufficient funds for accepter/,
+      );
+    });
+
+    it('should provide clear error messages with actual values', () => {
+      const offerInput = createTestFundingInput(BigInt(500000));
+      const offer = createTestDlcOffer(BigInt(1000000), [offerInput]);
+      const accept = createTestDlcAccept(BigInt(0), []);
+
+      const builder = new BatchDlcTxBuilder([offer], [accept]);
+
+      try {
+        builder.buildFundingTransaction();
+        expect.fail('Should have thrown an error');
+      } catch (error) {
+        expect(error.message).to.include('need');
+        expect(error.message).to.include('have');
+        expect(error.message).to.include('500000');
+      }
+    });
+  });
+
+  describe('DlcTxBuilder', () => {
+    it('should build funding transaction for single DLC', () => {
+      const offerInput = createTestFundingInput(BigInt(1000000));
+      const acceptInput = createTestFundingInput(BigInt(1000000), 2);
+
+      const offer = createTestDlcOffer(BigInt(500000), [offerInput]);
+      const accept = createTestDlcAccept(BigInt(500000), [acceptInput]);
+
+      const builder = new DlcTxBuilder(offer, accept);
+      const tx = builder.buildFundingTransaction();
+
+      expect(tx.outputs.length).to.be.at.least(1);
+      expect(tx.inputs.length).to.equal(2);
+    });
+  });
+
+  describe('Integration Tests', () => {
+    it('should handle DLC splicing scenario with exact amounts', () => {
+      // Simulate splicing: use a DLC funding output + additional UTXO
+      const dlcFundingInput = createTestFundingInput(BigInt(970332)); // Existing DLC output
+      const additionalInput = createTestFundingInput(BigInt(100000), 2); // Additional UTXO
+
+      const totalInputs = [dlcFundingInput, additionalInput];
+      const maxCollateral = BatchDlcTxBuilder.calculateMaxCollateral(
+        totalInputs,
+        BigInt(1),
+        1,
+      );
+
+      // Create offer using exact max collateral (no change scenario)
+      const offer = createTestDlcOffer(maxCollateral, totalInputs);
+      const accept = createTestDlcAccept(BigInt(0), []); // Single-funded
+
+      const builder = new BatchDlcTxBuilder([offer], [accept]);
+      const tx = builder.buildFundingTransaction();
+
+      // Should successfully create transaction with no change outputs
+      expect(tx.outputs.length).to.equal(1); // Only funding output
+      expect(tx.inputs.length).to.equal(2); // Both inputs used
+
+      // Verify the transaction balances
+      const totalInputValue = BigInt(970332) + BigInt(100000);
+      const outputValue = tx.outputs[0].value.sats;
+
+      // Output should be less than input (due to fees) but close
+      expect(Number(outputValue)).to.be.lessThan(Number(totalInputValue));
+      expect(Number(outputValue)).to.be.greaterThan(
+        Number(totalInputValue - BigInt(10000)),
+      ); // Reasonable fee range
+    });
+
+    it('should handle batch DLC scenarios', () => {
+      const offerInput1 = createTestFundingInput(BigInt(500000));
+      const offerInput2 = createTestFundingInput(BigInt(500000), 2);
+      const acceptInput = createTestFundingInput(BigInt(800000), 3);
+
+      const offer1 = createTestDlcOffer(BigInt(400000), [
+        offerInput1,
+        offerInput2,
+      ]);
+      const offer2 = createTestDlcOffer(BigInt(400000), [
+        offerInput1,
+        offerInput2,
+      ]);
+      const accept1 = createTestDlcAccept(BigInt(300000), [acceptInput]);
+      const accept2 = createTestDlcAccept(BigInt(300000), [acceptInput]);
+
+      const builder = new BatchDlcTxBuilder(
+        [offer1, offer2],
+        [accept1, accept2],
+      );
+      const tx = builder.buildFundingTransaction();
+
+      // Should have 2 funding outputs + change outputs (if any)
+      expect(tx.outputs.length).to.be.at.least(2);
+      expect(tx.inputs.length).to.equal(3); // All unique inputs
+    });
+  });
+});