@atomicfinance/bitcoin-wallet-provider 4.2.8 → 4.3.1

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

@@ -0,0 +1,179 @@
+import { Value } from '@node-dlc/bitcoin';
+import { expect } from 'chai';
+
+import { dualFees, dualFundingCoinSelect, UTXO } from '../../lib';
+
+const getUtxos = (totalCollateral: bigint, numUtxos = 1) => {
+  const utxos: UTXO[] = [];
+
+  for (let i = 0; i < numUtxos; i++) {
+    utxos.push({
+      address: 'bcrt1qjzut0906d9sk4hml4k6sz6cssljktf4c7yl80f',
+      txid: 'c7bf12ac16aba1cf6c7769117294853453f7da3006363dfe4e8979847e32f7e1',
+      value: Math.ceil(Number(totalCollateral) / numUtxos),
+      vout: Math.floor(Math.random() * 11), // random integer between 0 and 10
+    });
+  }
+
+  return utxos;
+};
+
+describe('CoinSelect', () => {
+  describe('dualFundingCoinSelect', () => {
+    it('should select coins correctly for 5 UTXOs and feeRate 450', () => {
+      const feeRate = BigInt(450);
+      const numUtxos = 5;
+      const totalCollateral = Value.fromBitcoin(0.01);
+      const offerCollateral = Value.fromBitcoin(0.0075);
+
+      const utxos = getUtxos(totalCollateral.sats, numUtxos);
+
+      const { fee, inputs } = dualFundingCoinSelect(
+        utxos,
+        [offerCollateral.sats],
+        feeRate,
+      );
+
+      expect(fee).to.equal(BigInt(217350));
+      expect(inputs.length).to.equal(5);
+    });
+
+    it('should fail to select coins if fee is greater than sum of utxos', () => {
+      const feeRate = BigInt(450);
+      const numUtxos = 5;
+      const totalCollateral = Value.fromBitcoin(0.01);
+      const offerCollateral = Value.fromBitcoin(0.096);
+
+      const utxos = getUtxos(totalCollateral.sats, numUtxos);
+
+      const { fee, inputs } = dualFundingCoinSelect(
+        utxos,
+        [offerCollateral.sats],
+        feeRate,
+      );
+
+      expect(fee).to.equal(BigInt(94950));
+      expect(inputs.length).to.equal(0);
+    });
+
+    it('should fail to select coins if detrimental input', () => {
+      const feeRate = BigInt(450);
+      const numUtxos = 1;
+      const totalCollateral = Value.fromSats(30000);
+      const offerCollateral = Value.fromSats(20000);
+
+      const utxos = getUtxos(totalCollateral.sats, numUtxos);
+
+      const { fee, inputs } = dualFundingCoinSelect(
+        utxos,
+        [offerCollateral.sats],
+        feeRate,
+      );
+
+      expect(fee).to.equal(BigInt(94950));
+      expect(inputs.length).to.equal(0);
+    });
+
+    it('should prioritize utxo selection', () => {
+      const feeRate = BigInt(450);
+      const numUtxos = 5;
+      const totalCollateral = Value.fromBitcoin(0.01);
+      const offerCollateral = Value.fromBitcoin(0.0075);
+
+      const utxos = getUtxos(totalCollateral.sats, numUtxos);
+
+      utxos.push({
+        address: 'bcrt1qjzut0906d9sk4hml4k6sz6cssljktf4c7yl80f',
+        txid:
+          'c7bf12ac16aba1cf6c7769117294853453f7da3006363dfe4e8979847e32f7e1',
+        value: 10000,
+        vout: Math.floor(Math.random() * 11), // random integer between 0 and 10
+      });
+
+      const { fee, inputs } = dualFundingCoinSelect(
+        utxos,
+        [offerCollateral.sats],
+        feeRate,
+      );
+
+      expect(fee).to.equal(BigInt(217350));
+      expect(inputs.length).to.equal(5);
+    });
+  });
+
+  describe('Additional CoinSelect Tests', () => {
+    const feeRate = BigInt(450);
+    const totalCollateral = Value.fromBitcoin(0.01);
+    const offerCollateral = Value.fromBitcoin(0.0075);
+
+    it('should fail to select coins when all UTXOs are detrimental due to high fee rate', () => {
+      const highFeeRate = BigInt(10000); // An exaggerated fee rate to make the point
+      const utxos = getUtxos(totalCollateral.sats, 5);
+
+      const { fee, inputs } = dualFundingCoinSelect(
+        utxos,
+        [offerCollateral.sats],
+        highFeeRate,
+      );
+
+      expect(inputs.length).to.equal(0);
+      expect(fee).to.equal(BigInt(2110000));
+    });
+
+    it('should select all UTXOs when they are just enough to cover collateral and fees', () => {
+      const utxos = getUtxos(totalCollateral.sats, 5);
+
+      const { fee, inputs } = dualFundingCoinSelect(
+        utxos,
+        [offerCollateral.sats],
+        feeRate,
+      );
+
+      expect(inputs.length).to.equal(5);
+      expect(fee).to.equal(BigInt(217350));
+    });
+
+    it('should select UTXOs optimally from a mixed set', () => {
+      const mixedUtxos = [
+        ...getUtxos(Value.fromBitcoin(0.005).sats, 2), // smaller UTXOs
+        ...getUtxos(Value.fromBitcoin(0.02).sats, 3), // larger UTXOs
+      ];
+
+      const { fee, inputs } = dualFundingCoinSelect(
+        mixedUtxos,
+        [offerCollateral.sats],
+        feeRate,
+      );
+
+      // Expecting it to select fewer, larger UTXOs over many small ones
+      expect(inputs.length).to.be.lessThan(5);
+      expect(fee).to.equal(BigInt(125550));
+    });
+
+    it('should handle an empty array of UTXOs correctly', () => {
+      const { fee, inputs } = dualFundingCoinSelect(
+        [],
+        [offerCollateral.sats],
+        feeRate,
+      );
+
+      expect(inputs.length).to.equal(0);
+      expect(fee).to.equal(dualFees(feeRate, 1, 1)); // The fee for an attempt with no inputs
+    });
+
+    it('should select fewer UTXOs with a very low fee rate', () => {
+      const lowFeeRate = BigInt(1); // An extremely low fee rate
+      const utxos = getUtxos(totalCollateral.sats, 10); // More UTXOs than needed
+
+      const { fee, inputs } = dualFundingCoinSelect(
+        utxos,
+        [offerCollateral.sats],
+        lowFeeRate,
+      );
+
+      // Expecting it to select fewer UTXOs due to the low cost of adding an input
+      expect(inputs.length).to.be.lessThan(10);
+      expect(fee).to.equal(BigInt(687));
+    });
+  });
+});

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

@@ -0,0 +1,345 @@
+import {
+  MessageType,
+  PayoutFunction,
+  PolynomialPayoutCurvePiece,
+  RoundingIntervals,
+} from '@node-dlc/messaging';
+import BigNumber from 'bignumber.js';
+import { expect } from 'chai';
+
+import { HyperbolaPayoutCurve } from '../../lib';
+import { LinearPayout } from '../../lib/dlc/finance/LinearPayout';
+import { PolynomialPayoutCurve } from '../../lib/dlc/PolynomialPayoutCurve';
+import { fromPrecision } from '../../lib/utils/Precision';
+
+describe('PolynomialPayoutCurve', () => {
+  const points = [
+    {
+      outcome: new BigNumber(1),
+      payout: new BigNumber(1),
+    },
+    {
+      outcome: new BigNumber(2),
+      payout: new BigNumber(3),
+    },
+  ];
+
+  describe('#constructor', () => {
+    it('should create a PolynomialPayoutCurve', () => {
+      const curve = new PolynomialPayoutCurve(points);
+      expect(curve).to.be.instanceOf(PolynomialPayoutCurve);
+    });
+    it('should fail if not 2 points', () => {
+      // 1 point
+      expect(
+        () =>
+          new PolynomialPayoutCurve([
+            {
+              outcome: new BigNumber(1),
+              payout: new BigNumber(1),
+            },
+          ]),
+      ).to.throw('Must have two points');
+
+      // 3 points
+      expect(
+        () =>
+          new PolynomialPayoutCurve([
+            {
+              outcome: new BigNumber(1),
+              payout: new BigNumber(1),
+            },
+            {
+              outcome: new BigNumber(2),
+              payout: new BigNumber(2),
+            },
+            {
+              outcome: new BigNumber(3),
+              payout: new BigNumber(3),
+            },
+          ]),
+      ).to.throw;
+    });
+  });
+
+  describe('#getPayout', () => {
+    it('should get the payout for an outcome', () => {
+      const curve = new PolynomialPayoutCurve(points);
+      const payout = curve.getPayout(BigInt(1));
+      expect(payout).to.deep.equal(new BigNumber(1));
+    });
+
+    it('should get the payout for an outcome', () => {
+      const curve = new PolynomialPayoutCurve(points);
+      const payout = curve.getPayout(BigInt(2));
+      expect(payout).to.deep.equal(new BigNumber(3));
+    });
+  });
+
+  describe('#getOutcomeForPayout', () => {
+    it('should get the outcome for a payout', () => {
+      const curve = new PolynomialPayoutCurve(points);
+      const outcome = curve.getOutcomeForPayout(new BigNumber(1));
+      expect(outcome).to.deep.equal(BigInt(1));
+    });
+
+    it('should get the outcome for a payout', () => {
+      const curve = new PolynomialPayoutCurve(points);
+      const outcome = curve.getOutcomeForPayout(new BigNumber(3));
+      expect(outcome).to.deep.equal(BigInt(2));
+    });
+  });
+
+  describe('#toPayoutCurvePiece', () => {
+    it('should serialize to a PolynomialPayoutCurvePiece', () => {
+      const curve = new PolynomialPayoutCurve(points);
+      const piece = curve.toPayoutCurvePiece();
+      expect(piece).to.deep.equal({
+        type: MessageType.PolynomialPayoutCurvePiece,
+        payoutCurvePieceType: 0, // PayoutCurvePieceType.Polynomial
+        points: [
+          {
+            eventOutcome: BigInt(1),
+            outcomePayout: BigInt(1),
+            extraPrecision: 0,
+          },
+          {
+            eventOutcome: BigInt(2),
+            outcomePayout: BigInt(3),
+            extraPrecision: 0,
+          },
+        ],
+      });
+    });
+  });
+
+  describe('#fromPayoutCurvePiece', () => {
+    const points = [
+      {
+        eventOutcome: BigInt(1),
+        outcomePayout: BigInt(1),
+        extraPrecision: 0,
+      },
+      {
+        eventOutcome: BigInt(2),
+        outcomePayout: BigInt(3),
+        extraPrecision: 0,
+      },
+    ];
+
+    it('should deserialize from a PolynomialPayoutCurvePiece', () => {
+      const piece = new PolynomialPayoutCurvePiece();
+      piece.points = points;
+      const curve = PolynomialPayoutCurve.fromPayoutCurvePiece(piece);
+      expect(curve).to.be.instanceOf(PolynomialPayoutCurve);
+      expect(curve['points']).to.deep.eq(
+        points.map((p) => ({
+          outcome: new BigNumber(p.eventOutcome.toString()),
+          payout: new BigNumber(p.outcomePayout.toString()).plus(
+            fromPrecision(p.extraPrecision),
+          ),
+        })),
+      );
+    });
+  });
+
+  describe('#equals', () => {
+    it('should return true if the curves are equal', () => {
+      const curve1 = new PolynomialPayoutCurve(points);
+      const curve2 = new PolynomialPayoutCurve(points);
+      expect(curve1.equals(curve2)).to.be.true;
+    });
+
+    it('should return false if the curves are not equal', () => {
+      const curve1 = new PolynomialPayoutCurve(points);
+      const curve2 = new PolynomialPayoutCurve([
+        {
+          outcome: new BigNumber(1),
+          payout: new BigNumber(1),
+        },
+        {
+          outcome: new BigNumber(3),
+          payout: new BigNumber(3),
+        },
+      ]);
+      expect(curve1.equals(curve2)).to.be.false;
+    });
+  });
+
+  describe('#computePayouts', () => {
+    it('should compute the correct payouts for simple interval', () => {
+      const numDigits = 18;
+      const oracleBase = 2;
+      const minPayout = 40n;
+      const maxPayout = 60n;
+      const startOutcome = 40n;
+      const endOutcome = 60n;
+
+      const { payoutFunction } = LinearPayout.buildPayoutFunction(
+        minPayout,
+        maxPayout,
+        startOutcome,
+        endOutcome,
+        oracleBase,
+        numDigits,
+      );
+
+      const intervals = [{ beginInterval: 0n, roundingMod: 1n }];
+      const roundingIntervals = new RoundingIntervals();
+      roundingIntervals.intervals = intervals;
+
+      const payouts = PolynomialPayoutCurve.computePayouts(
+        payoutFunction,
+        maxPayout,
+        roundingIntervals,
+      );
+
+      const n = payouts.length - 1;
+
+      const maxOutcome = BigInt(
+        new BigNumber(oracleBase).pow(numDigits).minus(1).toString(10),
+      );
+
+      expect(n).to.eq(20);
+
+      // max loss CETS
+      expect(payouts[0].indexFrom).to.eq(0n);
+      expect(payouts[0].indexTo).to.eq(startOutcome);
+      expect(payouts[0].payout).to.eq(minPayout);
+
+      // payout curve CETS
+      for (let i = 1; i < n - 1; ++i) {
+        expect(payouts[i].indexFrom).to.eq(startOutcome + BigInt(i));
+        expect(payouts[i].indexTo).to.eq(startOutcome + BigInt(i));
+        expect(payouts[i].payout).to.eq(minPayout + BigInt(i));
+      }
+
+      // max gain CETS
+      expect(payouts[n].indexFrom).to.eq(endOutcome);
+      expect(payouts[n].indexTo).to.eq(maxOutcome);
+      expect(payouts[n].payout).to.eq(maxPayout);
+    });
+
+    it('should compute the correct payouts for advanced interval', () => {
+      const numDigits = 18;
+      const oracleBase = 2;
+      const minPayout = 40n;
+      const maxPayout = 60n;
+      const startOutcome = 40n;
+      const endOutcome = 60n;
+
+      const { payoutFunction } = LinearPayout.buildPayoutFunction(
+        minPayout,
+        maxPayout,
+        startOutcome,
+        endOutcome,
+        oracleBase,
+        numDigits,
+      );
+
+      const intervals = [{ beginInterval: 0n, roundingMod: 2n }];
+      const roundingIntervals = new RoundingIntervals();
+      roundingIntervals.intervals = intervals;
+
+      const payouts = PolynomialPayoutCurve.computePayouts(
+        payoutFunction,
+        maxPayout,
+        roundingIntervals,
+      );
+
+      const n = payouts.length - 1;
+
+      const maxOutcome = BigInt(
+        new BigNumber(oracleBase).pow(numDigits).minus(1).toString(10),
+      );
+
+      expect(n).to.eq(10);
+
+      // max loss CETS
+      expect(payouts[0].indexFrom).to.eq(0n);
+      expect(payouts[0].indexTo).to.eq(startOutcome);
+      expect(payouts[0].payout).to.eq(minPayout);
+
+      // payout curve CETS
+      for (let i = 1; i < n; ++i) {
+        expect(payouts[i].indexFrom).to.eq(
+          startOutcome + 2n * BigInt(i - 1) + 1n,
+        );
+        expect(payouts[i].indexTo).to.eq(startOutcome + 2n * BigInt(i));
+        expect(payouts[i].payout).to.eq(minPayout + 2n * BigInt(i));
+      }
+
+      // max gain CETS
+      expect(payouts[n].indexFrom).to.eq(endOutcome - 1n);
+      expect(payouts[n].indexTo).to.eq(maxOutcome);
+      expect(payouts[n].payout).to.eq(maxPayout);
+    });
+
+    it('should fail if < 1 payout function pieces', () => {
+      const maxPayout = 60n;
+
+      const payoutFunction = new PayoutFunction();
+      payoutFunction.payoutFunctionPieces = [];
+      payoutFunction.lastEndpoint = {
+        eventOutcome: BigInt(0),
+        outcomePayout: BigInt(0),
+        extraPrecision: 0,
+      };
+
+      const intervals = [{ beginInterval: 0n, roundingMod: 1n }];
+      const roundingIntervals = new RoundingIntervals();
+      roundingIntervals.intervals = intervals;
+
+      expect(() => {
+        PolynomialPayoutCurve.computePayouts(
+          payoutFunction,
+          maxPayout,
+          roundingIntervals,
+        );
+      }).to.throw('Must have at least one piece');
+    });
+
+    it('should fail if there is a non-polynomial payout curve piece', () => {
+      const maxPayout = 60n;
+
+      const hyperbola = new HyperbolaPayoutCurve(
+        new BigNumber(1),
+        new BigNumber(0),
+        new BigNumber(0),
+        new BigNumber(500000),
+        new BigNumber(0),
+        new BigNumber(0),
+        true,
+      ).toPayoutCurvePiece();
+
+      const payoutFunction = new PayoutFunction();
+      payoutFunction.payoutFunctionPieces = [
+        {
+          endPoint: {
+            eventOutcome: 2n,
+            outcomePayout: 2n,
+            extraPrecision: 0,
+          },
+          payoutCurvePiece: hyperbola,
+        },
+      ];
+      payoutFunction.lastEndpoint = {
+        eventOutcome: 0n,
+        outcomePayout: 0n,
+        extraPrecision: 0,
+      };
+
+      const intervals = [{ beginInterval: 0n, roundingMod: 1n }];
+      const roundingIntervals = new RoundingIntervals();
+      roundingIntervals.intervals = intervals;
+
+      expect(() => {
+        PolynomialPayoutCurve.computePayouts(
+          payoutFunction,
+          maxPayout,
+          roundingIntervals,
+        );
+      }).to.throw('Payout curve piece must be a polynomial');
+    });
+  });
+});