@atomicfinance/bitcoin-wallet-provider 4.0.3 → 4.1.1

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

@@ -1,1029 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { expect } from 'chai';
-
-import {
-  CETPayout,
-  decompose,
-  groupByIgnoringDigits,
-  RoundingInterval,
-  roundPayout,
-  splitIntoRanges,
-} from '../../lib/dlc/CETCalculator';
-import { CoveredCall } from '../../lib/dlc/finance/CoveredCall';
-import { ShortPut } from '../../lib/dlc/finance/ShortPut';
-import { HyperbolaPayoutCurve } from '../../lib/dlc/HyperbolaPayoutCurve';
-import { BigIntMath } from '../../lib/utils/BigIntUtils';
-
-const decompositionTestCases: {
-  decomposed: number[];
-  composed: string;
-  base: number;
-  nbDigits: number;
-}[] = [
-  {
-    composed: '123456789',
-    decomposed: [1, 2, 3, 4, 5, 6, 7, 8, 9],
-    base: 10,
-    nbDigits: 9,
-  },
-  {
-    composed: '4321',
-    decomposed: [1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1],
-    base: 2,
-    nbDigits: 13,
-  },
-  {
-    composed: '0',
-    decomposed: [0, 0, 0, 0],
-    base: 8,
-    nbDigits: 4,
-  },
-  {
-    composed: '2',
-    decomposed: [0, 2],
-    base: 10,
-    nbDigits: 2,
-  },
-  {
-    composed: '1',
-    decomposed: [1],
-    base: 2,
-    nbDigits: 1,
-  },
-];
-
-const groupingTestCases: {
-  startIndex: bigint;
-  endIndex: bigint;
-  base: number;
-  nbDigits: number;
-  expected: number[][];
-}[] = [
-  {
-    startIndex: BigInt(123),
-    endIndex: BigInt(123),
-    base: 10,
-    nbDigits: 3,
-    expected: [[1, 2, 3]],
-  },
-  {
-    startIndex: BigInt(171),
-    endIndex: BigInt(210),
-    base: 16,
-    nbDigits: 2,
-    expected: [
-      [10, 11],
-      [10, 12],
-      [10, 13],
-      [10, 14],
-      [10, 15],
-      [11],
-      [12],
-      [13, 0],
-      [13, 1],
-      [13, 2],
-    ],
-  },
-  {
-    startIndex: BigInt(73899),
-    endIndex: BigInt(73938),
-    base: 16,
-    nbDigits: 6,
-    expected: [
-      [0, 1, 2, 0, 10, 11],
-      [0, 1, 2, 0, 10, 12],
-      [0, 1, 2, 0, 10, 13],
-      [0, 1, 2, 0, 10, 14],
-      [0, 1, 2, 0, 10, 15],
-      [0, 1, 2, 0, 11],
-      [0, 1, 2, 0, 12],
-      [0, 1, 2, 0, 13, 0],
-      [0, 1, 2, 0, 13, 1],
-      [0, 1, 2, 0, 13, 2],
-    ],
-  },
-  {
-    startIndex: BigInt(1234),
-    endIndex: BigInt(4321),
-    base: 10,
-    nbDigits: 4,
-    expected: [
-      [1, 2, 3, 4],
-      [1, 2, 3, 5],
-      [1, 2, 3, 6],
-      [1, 2, 3, 7],
-      [1, 2, 3, 8],
-      [1, 2, 3, 9],
-      [1, 2, 4],
-      [1, 2, 5],
-      [1, 2, 6],
-      [1, 2, 7],
-      [1, 2, 8],
-      [1, 2, 9],
-      [1, 3],
-      [1, 4],
-      [1, 5],
-      [1, 6],
-      [1, 7],
-      [1, 8],
-      [1, 9],
-      [2],
-      [3],
-      [4, 0],
-      [4, 1],
-      [4, 2],
-      [4, 3, 0],
-      [4, 3, 1],
-      [4, 3, 2, 0],
-      [4, 3, 2, 1],
-    ],
-  },
-  {
-    startIndex: BigInt(1201234),
-    endIndex: BigInt(1204321),
-    base: 10,
-    nbDigits: 8,
-    expected: [
-      [0, 1, 2, 0, 1, 2, 3, 4],
-      [0, 1, 2, 0, 1, 2, 3, 5],
-      [0, 1, 2, 0, 1, 2, 3, 6],
-      [0, 1, 2, 0, 1, 2, 3, 7],
-      [0, 1, 2, 0, 1, 2, 3, 8],
-      [0, 1, 2, 0, 1, 2, 3, 9],
-      [0, 1, 2, 0, 1, 2, 4],
-      [0, 1, 2, 0, 1, 2, 5],
-      [0, 1, 2, 0, 1, 2, 6],
-      [0, 1, 2, 0, 1, 2, 7],
-      [0, 1, 2, 0, 1, 2, 8],
-      [0, 1, 2, 0, 1, 2, 9],
-      [0, 1, 2, 0, 1, 3],
-      [0, 1, 2, 0, 1, 4],
-      [0, 1, 2, 0, 1, 5],
-      [0, 1, 2, 0, 1, 6],
-      [0, 1, 2, 0, 1, 7],
-      [0, 1, 2, 0, 1, 8],
-      [0, 1, 2, 0, 1, 9],
-      [0, 1, 2, 0, 2],
-      [0, 1, 2, 0, 3],
-      [0, 1, 2, 0, 4, 0],
-      [0, 1, 2, 0, 4, 1],
-      [0, 1, 2, 0, 4, 2],
-      [0, 1, 2, 0, 4, 3, 0],
-      [0, 1, 2, 0, 4, 3, 1],
-      [0, 1, 2, 0, 4, 3, 2, 0],
-      [0, 1, 2, 0, 4, 3, 2, 1],
-    ],
-  },
-  {
-    startIndex: BigInt(2200),
-    endIndex: BigInt(4999),
-    base: 10,
-    nbDigits: 4,
-    expected: [
-      [2, 2],
-      [2, 3],
-      [2, 4],
-      [2, 5],
-      [2, 6],
-      [2, 7],
-      [2, 8],
-      [2, 9],
-      [3],
-      [4],
-    ],
-  },
-  {
-    startIndex: BigInt(0),
-    endIndex: BigInt(99),
-    base: 10,
-    nbDigits: 2,
-    expected: [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9]],
-  },
-  {
-    startIndex: BigInt(100),
-    endIndex: BigInt(199),
-    base: 10,
-    nbDigits: 3,
-    expected: [[1]],
-  },
-  {
-    startIndex: BigInt(100),
-    endIndex: BigInt(200),
-    base: 10,
-    nbDigits: 3,
-    expected: [[1], [2, 0, 0]],
-  },
-  {
-    startIndex: BigInt(11),
-    endIndex: BigInt(18),
-    base: 10,
-    nbDigits: 2,
-    expected: [
-      [1, 1],
-      [1, 2],
-      [1, 3],
-      [1, 4],
-      [1, 5],
-      [1, 6],
-      [1, 7],
-      [1, 8],
-    ],
-  },
-  {
-    startIndex: BigInt(11),
-    endIndex: BigInt(23),
-    base: 2,
-    nbDigits: 5,
-    expected: [
-      [0, 1, 0, 1, 1],
-      [0, 1, 1],
-      [1, 0],
-    ],
-  },
-  {
-    startIndex: BigInt(5677),
-    endIndex: BigInt(8621),
-    base: 2,
-    nbDigits: 14,
-    expected: [
-      [0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1],
-      [0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1],
-      [0, 1, 0, 1, 1, 0, 0, 0, 1, 1],
-      [0, 1, 0, 1, 1, 0, 0, 1],
-      [0, 1, 0, 1, 1, 0, 1],
-      [0, 1, 0, 1, 1, 1],
-      [0, 1, 1],
-      [1, 0, 0, 0, 0, 0],
-      [1, 0, 0, 0, 0, 1, 0],
-      [1, 0, 0, 0, 0, 1, 1, 0, 0],
-      [1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0],
-      [1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0],
-      [1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0],
-    ],
-  },
-];
-
-describe('CETCalculator', () => {
-  describe('outcome decomposition tests', () => {
-    it('should properly decompose values', () => {
-      for (const test of decompositionTestCases) {
-        expect(
-          decompose(BigInt(parseInt(test.composed)), test.base, test.nbDigits),
-        ).deep.equal(test.decomposed);
-      }
-    });
-  });
-
-  describe('grouping tests', () => {
-    it('should properly compute all groupings', () => {
-      for (const test of groupingTestCases) {
-        expect(
-          groupByIgnoringDigits(
-            test.startIndex,
-            test.endIndex,
-            test.base,
-            test.nbDigits,
-          ),
-        ).deep.equal(test.expected);
-      }
-    });
-  });
-
-  describe('descending hyperbola a=1 d=5000 tests', () => {
-    const hyperbola = new HyperbolaPayoutCurve(
-      new BigNumber(1),
-      new BigNumber(0),
-      new BigNumber(0),
-      new BigNumber(500000),
-      new BigNumber(0),
-      new BigNumber(0),
-      true,
-    );
-
-    it('should properly split and round with one interval', () => {
-      const roundingIntervals: RoundingInterval[] = [
-        {
-          beginInterval: BigInt(0),
-          roundingMod: BigInt(10),
-        },
-      ];
-
-      const totalCollateral = BigInt(100);
-      const from = BigInt(0);
-      const to = BigInt(999999);
-      const fromPayout = totalCollateral;
-      const toPayout = BigInt(0);
-
-      const ranges = splitIntoRanges(
-        from,
-        to,
-        fromPayout,
-        toPayout,
-        totalCollateral,
-        hyperbola,
-        roundingIntervals,
-      );
-
-      expect(ranges).deep.equal([
-        { payout: BigInt(100), indexFrom: BigInt(0), indexTo: BigInt(5263) },
-        { payout: BigInt(90), indexFrom: BigInt(5264), indexTo: BigInt(5882) },
-        { payout: BigInt(80), indexFrom: BigInt(5883), indexTo: BigInt(6666) },
-        { payout: BigInt(70), indexFrom: BigInt(6667), indexTo: BigInt(7692) },
-        { payout: BigInt(60), indexFrom: BigInt(7693), indexTo: BigInt(9090) },
-        { payout: BigInt(50), indexFrom: BigInt(9091), indexTo: BigInt(11111) },
-        {
-          payout: BigInt(40),
-          indexFrom: BigInt(11112),
-          indexTo: BigInt(14285),
-        },
-        {
-          payout: BigInt(30),
-          indexFrom: BigInt(14286),
-          indexTo: BigInt(20000),
-        },
-        {
-          payout: BigInt(20),
-          indexFrom: BigInt(20001),
-          indexTo: BigInt(33333),
-        },
-        {
-          payout: BigInt(10),
-          indexFrom: BigInt(33334),
-          indexTo: BigInt(100000),
-        },
-        {
-          payout: BigInt(0),
-          indexFrom: BigInt(100001),
-          indexTo: BigInt(999999),
-        },
-      ]);
-
-      validateRanges(
-        ranges,
-        from,
-        fromPayout,
-        to,
-        toPayout,
-        hyperbola,
-        roundingIntervals,
-        totalCollateral,
-      );
-    });
-
-    it('should properly split and round with non-even rounding mod', () => {
-      const roundingIntervals: RoundingInterval[] = [
-        {
-          beginInterval: BigInt(0),
-          roundingMod: BigInt(15),
-        },
-      ];
-
-      const totalCollateral = BigInt(100);
-      const from = BigInt(0);
-      const to = BigInt(999999);
-      const fromPayout = totalCollateral;
-      const toPayout = BigInt(0);
-
-      const ranges = splitIntoRanges(
-        from,
-        to,
-        fromPayout,
-        toPayout,
-        totalCollateral,
-        hyperbola,
-        roundingIntervals,
-      );
-
-      expect(ranges).to.deep.equal([
-        { payout: BigInt(100), indexFrom: BigInt(0), indexTo: BigInt(5128) },
-        { payout: BigInt(90), indexFrom: BigInt(5129), indexTo: BigInt(6060) },
-        { payout: BigInt(75), indexFrom: BigInt(6061), indexTo: BigInt(7407) },
-        { payout: BigInt(60), indexFrom: BigInt(7408), indexTo: BigInt(9523) },
-        { payout: BigInt(45), indexFrom: BigInt(9524), indexTo: BigInt(13333) },
-        {
-          payout: BigInt(30),
-          indexFrom: BigInt(13334),
-          indexTo: BigInt(22222),
-        },
-        {
-          payout: BigInt(15),
-          indexFrom: BigInt(22223),
-          indexTo: BigInt(66666),
-        },
-        {
-          payout: BigInt(0),
-          indexFrom: BigInt(66667),
-          indexTo: BigInt(999999),
-        },
-      ]);
-
-      validateRanges(
-        ranges,
-        from,
-        fromPayout,
-        to,
-        toPayout,
-        hyperbola,
-        roundingIntervals,
-        totalCollateral,
-      );
-    });
-  });
-
-  describe('ascending hyperbola a=-1 d=500000 f2=100 tests', () => {
-    const hyperbola = new HyperbolaPayoutCurve(
-      new BigNumber(-1),
-      new BigNumber(0),
-      new BigNumber(0),
-      new BigNumber(500000),
-      new BigNumber(0),
-      new BigNumber(100),
-      true,
-    );
-
-    it('should properly split and round with one interval', () => {
-      const roundingIntervals: RoundingInterval[] = [
-        {
-          beginInterval: BigInt(0),
-          roundingMod: BigInt(10),
-        },
-      ];
-
-      const totalCollateral = BigInt(100);
-      const from = BigInt(0);
-      const to = BigInt(999999);
-      const fromPayout = BigInt(0);
-      const toPayout = totalCollateral;
-
-      const ranges = splitIntoRanges(
-        from,
-        to,
-        fromPayout,
-        toPayout,
-        totalCollateral,
-        hyperbola,
-        roundingIntervals,
-      );
-
-      expect(ranges).to.deep.equal([
-        { payout: BigInt(0), indexFrom: BigInt(0), indexTo: BigInt(5263) },
-        { payout: BigInt(10), indexFrom: BigInt(5264), indexTo: BigInt(5882) },
-        { payout: BigInt(20), indexFrom: BigInt(5883), indexTo: BigInt(6666) },
-        { payout: BigInt(30), indexFrom: BigInt(6667), indexTo: BigInt(7692) },
-        { payout: BigInt(40), indexFrom: BigInt(7693), indexTo: BigInt(9090) },
-        { payout: BigInt(50), indexFrom: BigInt(9091), indexTo: BigInt(11111) },
-        {
-          payout: BigInt(60),
-          indexFrom: BigInt(11112),
-          indexTo: BigInt(14285),
-        },
-        {
-          payout: BigInt(70),
-          indexFrom: BigInt(14286),
-          indexTo: BigInt(19999),
-        },
-        {
-          payout: BigInt(80),
-          indexFrom: BigInt(20000),
-          indexTo: BigInt(33333),
-        },
-        {
-          payout: BigInt(90),
-          indexFrom: BigInt(33334),
-          indexTo: BigInt(99999),
-        },
-        {
-          payout: BigInt(100),
-          indexFrom: BigInt(100000),
-          indexTo: BigInt(999999),
-        },
-      ]);
-
-      validateRanges(
-        ranges,
-        from,
-        fromPayout,
-        to,
-        toPayout,
-        hyperbola,
-        roundingIntervals,
-        totalCollateral,
-      );
-    });
-
-    it('should properly split and round with multiple rounding intervals', () => {
-      const roundingIntervals: RoundingInterval[] = [
-        {
-          beginInterval: BigInt(0),
-          roundingMod: BigInt(7),
-        },
-        { beginInterval: BigInt(5432), roundingMod: BigInt(12) },
-        { beginInterval: BigInt(6432), roundingMod: BigInt(25) },
-      ];
-
-      const totalCollateral = BigInt(100);
-      const from = BigInt(0);
-      const to = BigInt(999999);
-      const fromPayout = BigInt(0);
-      const toPayout = totalCollateral;
-
-      const ranges = splitIntoRanges(
-        from,
-        to,
-        fromPayout,
-        toPayout,
-        totalCollateral,
-        hyperbola,
-        roundingIntervals,
-      );
-
-      expect(ranges).to.deep.equal([
-        { payout: BigInt(0), indexFrom: BigInt(0), indexTo: BigInt(5181) },
-        { payout: BigInt(7), indexFrom: BigInt(5182), indexTo: BigInt(5431) },
-        { payout: BigInt(12), indexFrom: BigInt(5432), indexTo: BigInt(6097) },
-        { payout: BigInt(24), indexFrom: BigInt(6098), indexTo: BigInt(6431) },
-        { payout: BigInt(25), indexFrom: BigInt(6432), indexTo: BigInt(7999) },
-        { payout: BigInt(50), indexFrom: BigInt(8000), indexTo: BigInt(13333) },
-        {
-          payout: BigInt(75),
-          indexFrom: BigInt(13334),
-          indexTo: BigInt(39999),
-        },
-        {
-          payout: BigInt(100),
-          indexFrom: BigInt(40000),
-          indexTo: BigInt(999999),
-        },
-      ]);
-
-      validateRanges(
-        ranges,
-        from,
-        fromPayout,
-        to,
-        toPayout,
-        hyperbola,
-        roundingIntervals,
-        totalCollateral,
-      );
-    });
-
-    it('should properly split and round with non-even rounding mod', () => {
-      const roundingIntervals: RoundingInterval[] = [
-        {
-          beginInterval: BigInt(0),
-          roundingMod: BigInt(15),
-        },
-      ];
-
-      const totalCollateral = BigInt(100);
-      const from = BigInt(0);
-      const to = BigInt(999999);
-      const fromPayout = BigInt(0);
-      const toPayout = totalCollateral;
-
-      const ranges = splitIntoRanges(
-        from,
-        to,
-        fromPayout,
-        toPayout,
-        totalCollateral,
-        hyperbola,
-        roundingIntervals,
-      );
-
-      expect(ranges).to.deep.equal([
-        { payout: BigInt(0), indexFrom: BigInt(0), indexTo: BigInt(5405) },
-        { payout: BigInt(15), indexFrom: BigInt(5406), indexTo: BigInt(6451) },
-        { payout: BigInt(30), indexFrom: BigInt(6452), indexTo: BigInt(7999) },
-        { payout: BigInt(45), indexFrom: BigInt(8000), indexTo: BigInt(10526) },
-        {
-          payout: BigInt(60),
-          indexFrom: BigInt(10527),
-          indexTo: BigInt(15384),
-        },
-        {
-          payout: BigInt(75),
-          indexFrom: BigInt(15385),
-          indexTo: BigInt(28571),
-        },
-        {
-          payout: BigInt(90),
-          indexFrom: BigInt(28572),
-          indexTo: BigInt(199999),
-        },
-        {
-          payout: BigInt(100),
-          indexFrom: BigInt(200000),
-          indexTo: BigInt(999999),
-        },
-      ]);
-
-      validateRanges(
-        ranges,
-        from,
-        fromPayout,
-        to,
-        toPayout,
-        hyperbola,
-        roundingIntervals,
-        totalCollateral,
-      );
-    });
-  });
-
-  describe('large descending hyperbola a=1 d=5000000000000 tests (50k 1BTC covered call)', () => {
-    const hyperbola = new HyperbolaPayoutCurve(
-      new BigNumber(1),
-      new BigNumber(0),
-      new BigNumber(0),
-      new BigNumber(5000000000000),
-      new BigNumber(0),
-      new BigNumber(0),
-      true,
-    );
-
-    it('should properly split and round with one interval', () => {
-      const roundingIntervals: RoundingInterval[] = [
-        {
-          beginInterval: BigInt(0),
-          roundingMod: BigInt(100000),
-        },
-      ];
-
-      const totalCollateral = BigInt(100000000);
-      const from = BigInt(0);
-      const to = BigInt(999999);
-      const fromPayout = totalCollateral;
-      const toPayout = BigInt(0);
-
-      const ranges = splitIntoRanges(
-        from,
-        to,
-        fromPayout,
-        toPayout,
-        totalCollateral,
-        hyperbola,
-        roundingIntervals,
-      );
-
-      validateRanges(
-        ranges,
-        from,
-        fromPayout,
-        to,
-        toPayout,
-        hyperbola,
-        roundingIntervals,
-        totalCollateral,
-      );
-    });
-
-    it('should properly split and round with non-even rounding mod', () => {
-      const roundingIntervals: RoundingInterval[] = [
-        {
-          beginInterval: BigInt(0),
-          roundingMod: BigInt(150000),
-        },
-      ];
-
-      const totalCollateral = BigInt(100000000);
-      const from = BigInt(0);
-      const to = BigInt(999999);
-      const fromPayout = totalCollateral;
-      const toPayout = BigInt(0);
-
-      const ranges = splitIntoRanges(
-        from,
-        to,
-        fromPayout,
-        toPayout,
-        totalCollateral,
-        hyperbola,
-        roundingIntervals,
-      );
-
-      validateRanges(
-        ranges,
-        from,
-        fromPayout,
-        to,
-        toPayout,
-        hyperbola,
-        roundingIntervals,
-        totalCollateral,
-      );
-    });
-  });
-
-  describe('descending hyperbola a=1 d=7500000000000 f2=-7500000 tests', () => {
-    const hyperbola = new HyperbolaPayoutCurve(
-      new BigNumber(1),
-      new BigNumber(0),
-      new BigNumber(0),
-      new BigNumber(7500000000000),
-      new BigNumber(0),
-      new BigNumber(-7500008),
-      true,
-    );
-
-    it('should properly split and round with one interval', () => {
-      const roundingIntervals: RoundingInterval[] = [
-        {
-          beginInterval: BigInt(0),
-          roundingMod: BigInt(250000),
-        },
-      ];
-
-      const totalCollateral = BigInt(92499992);
-      const from = BigInt(0);
-      const to = BigInt(999999);
-      const fromPayout = totalCollateral;
-      const toPayout = BigInt(0);
-
-      const ranges = splitIntoRanges(
-        from,
-        to,
-        fromPayout,
-        toPayout,
-        totalCollateral,
-        hyperbola,
-        roundingIntervals,
-      );
-
-      validateRanges(
-        ranges,
-        from,
-        fromPayout,
-        to,
-        toPayout,
-        hyperbola,
-        roundingIntervals,
-        totalCollateral,
-      );
-    });
-  });
-
-  describe('descending hyperbola (31520 1BTC covered call)', () => {
-    const {
-      payoutCurve: hyperbola,
-      totalCollateral,
-      maxOutcome,
-    } = CoveredCall.buildCurve(BigInt(31520), BigInt(1e8), 2, 17);
-
-    it('should properly split and round with two intervals', () => {
-      const roundingIntervals: RoundingInterval[] = [
-        {
-          beginInterval: BigInt(0),
-          roundingMod: BigInt(1),
-        },
-        {
-          beginInterval: BigInt(31520),
-          roundingMod: BigInt(100000),
-        },
-      ];
-
-      const from = BigInt(0);
-      const to = maxOutcome;
-      const fromPayout = totalCollateral;
-      const toPayout = BigInt(0);
-
-      const ranges = splitIntoRanges(
-        from,
-        to,
-        fromPayout,
-        toPayout,
-        totalCollateral,
-        hyperbola,
-        roundingIntervals,
-      );
-
-      validateRanges(
-        ranges,
-        from,
-        fromPayout,
-        to,
-        toPayout,
-        hyperbola,
-        roundingIntervals,
-        totalCollateral,
-      );
-    });
-  });
-
-  describe('ascending hyperbola (31520 1BTC short put)', () => {
-    const contractSize = BigInt(1e8);
-    const totalCollateral = contractSize - BigInt(23213);
-
-    const { payoutCurve: hyperbola, maxOutcome } = ShortPut.buildCurve(
-      BigInt(31520),
-      contractSize,
-      totalCollateral,
-      2,
-      17,
-    );
-
-    it('should properly split and round with two intervals', () => {
-      const roundingIntervals: RoundingInterval[] = [
-        {
-          beginInterval: BigInt(0),
-          roundingMod: BigInt(100000),
-        },
-        {
-          beginInterval: BigInt(31520),
-          roundingMod: BigInt(1),
-        },
-      ];
-
-      const from = BigInt(0);
-      const to = maxOutcome;
-      const fromPayout = BigInt(0);
-      const toPayout = totalCollateral;
-
-      const ranges = splitIntoRanges(
-        from,
-        to,
-        fromPayout,
-        toPayout,
-        totalCollateral,
-        hyperbola,
-        roundingIntervals,
-      );
-
-      validateRanges(
-        ranges,
-        from,
-        fromPayout,
-        to,
-        toPayout,
-        hyperbola,
-        roundingIntervals,
-        totalCollateral,
-      );
-    });
-  });
-
-  describe('ascending hyperbola (62000 0.01 BTC short put)', () => {
-    const contractSize = BigInt(1011502);
-    const totalCollateral = BigInt(960926);
-
-    const { payoutCurve: hyperbola, maxOutcome } = ShortPut.buildCurve(
-      BigInt(62000),
-      contractSize,
-      totalCollateral,
-      2,
-      18,
-    );
-
-    it('should properly split and round with two intervals', () => {
-      const roundingIntervals: RoundingInterval[] = [
-        {
-          beginInterval: BigInt(0),
-          roundingMod: BigInt(1011),
-        },
-        {
-          beginInterval: BigInt(62000),
-          roundingMod: BigInt(1),
-        },
-      ];
-
-      const from = BigInt(0);
-      const to = maxOutcome;
-      const fromPayout = BigInt(0);
-      const toPayout = totalCollateral;
-
-      const ranges = splitIntoRanges(
-        from,
-        to,
-        fromPayout,
-        toPayout,
-        totalCollateral,
-        hyperbola,
-        roundingIntervals,
-      );
-
-      validateRanges(
-        ranges,
-        from,
-        fromPayout,
-        to,
-        toPayout,
-        hyperbola,
-        roundingIntervals,
-        totalCollateral,
-      );
-    });
-
-    it('should properly split and round with many interval', () => {
-      const roundingIntervals: RoundingInterval[] = [
-        {
-          beginInterval: BigInt(0),
-          roundingMod: BigInt(1011),
-        },
-        {
-          beginInterval: BigInt(32000),
-          roundingMod: BigInt(4302),
-        },
-        {
-          beginInterval: BigInt(32001),
-          roundingMod: BigInt(1011),
-        },
-        {
-          beginInterval: BigInt(34001),
-          roundingMod: BigInt(7011),
-        },
-        {
-          beginInterval: BigInt(62000),
-          roundingMod: BigInt(1),
-        },
-      ];
-
-      const from = BigInt(0);
-      const to = maxOutcome;
-      const fromPayout = BigInt(0);
-      const toPayout = totalCollateral;
-
-      const ranges = splitIntoRanges(
-        from,
-        to,
-        fromPayout,
-        toPayout,
-        totalCollateral,
-        hyperbola,
-        roundingIntervals,
-      );
-
-      validateRanges(
-        ranges,
-        from,
-        fromPayout,
-        to,
-        toPayout,
-        hyperbola,
-        roundingIntervals,
-        totalCollateral,
-      );
-    });
-  });
-});
-
-function validateRanges(
-  ranges: CETPayout[],
-  from: bigint,
-  fromPayout: bigint,
-  to: bigint,
-  toPayout: bigint,
-  hyperbola: HyperbolaPayoutCurve,
-  roundingIntervals: RoundingInterval[],
-  totalCollateral: bigint,
-) {
-  const reversedIntervals = [...roundingIntervals].reverse();
-
-  // for each rounded payout at indexTo, expect to be equal to range payout
-  ranges.forEach((range) => {
-    if (range.indexFrom === from || range.indexTo === from)
-      return expect(range.payout).to.be.eq(fromPayout);
-    if (range.indexFrom === to || range.indexTo === to)
-      return expect(range.payout).to.be.eq(toPayout);
-
-    const payout = hyperbola.getPayout(range.indexTo);
-    const roundingIndex = reversedIntervals.findIndex(
-      (interval) => interval.beginInterval <= range.indexTo,
-    );
-    const rounding =
-      roundingIndex !== -1
-        ? reversedIntervals[roundingIndex].roundingMod
-        : BigInt(1);
-    const roundedPayout = BigIntMath.clamp(
-      BigInt(0),
-      roundPayout(payout, rounding),
-      totalCollateral,
-    );
-
-    expect(range.payout).to.eq(roundedPayout);
-  });
-
-  // for each rounded payout at indexFrom, expect to be equal to range payout
-  ranges.forEach((range) => {
-    if (range.indexFrom === from || range.indexTo === from)
-      return expect(range.payout).to.be.eq(fromPayout);
-    if (range.indexFrom === to || range.indexTo === to)
-      return expect(range.payout).to.be.eq(toPayout);
-
-    const payout = hyperbola.getPayout(range.indexFrom);
-    const roundingIndex = reversedIntervals.findIndex(
-      (interval) => interval.beginInterval <= range.indexTo,
-    );
-    const rounding =
-      roundingIndex !== -1
-        ? reversedIntervals[roundingIndex].roundingMod
-        : BigInt(1);
-    const roundedPayout = BigIntMath.clamp(
-      BigInt(0),
-      roundPayout(payout, rounding),
-      totalCollateral,
-    );
-
-    expect(roundedPayout).to.eq(range.payout);
-  });
-}