@atomicfinance/bitcoin-wallet-provider 4.2.8 → 4.3.0

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

@@ -0,0 +1,492 @@
+import { Value } from '@node-dlc/bitcoin';
+import {
+  ContractDescriptorV1,
+  ContractInfoV0,
+  OracleAnnouncement,
+  PayoutFunctionV0,
+} from '@node-dlc/messaging';
+import { BitcoinNetworks } from 'bitcoin-networks';
+import { expect } from 'chai';
+import sinon from 'sinon';
+
+import {
+  buildCoveredCallOrderOffer,
+  buildCustomStrategyOrderOffer,
+  buildLongCallOrderOffer,
+  buildLongPutOrderOffer,
+  buildRoundingIntervalsFromIntervals,
+  buildShortPutOrderOffer,
+  computeRoundingModulus,
+  UNIT_MULTIPLIER,
+} from '../../../lib/dlc/finance/Builder';
+
+describe('OrderOffer Builder', () => {
+  describe('buildCoveredCallOrderOffer', () => {
+    const strikePrice = 50000;
+    const contractSize = Value.fromSats(100000000);
+    const premium = Value.fromSats(25000);
+    const threeXPremium = Value.fromSats(75000);
+    const totalCollateral = contractSize;
+    const oracleAnnouncementBuf = Buffer.from(
+      'fdd824fd02ab1efe41fa42ea1dcd103a0251929dd2b192d2daece8a4ce4d81f68a183b750d92d6f02d796965dc79adf4e7786e08f861a1ecc897afbba2dab9cff6eb0a81937eb8b005b07acf849ad2cec22107331dedbf5a607654fad4eafe39c278e27dde68fdd822fd02450011f9313f1edd903fab297d5350006b669506eb0ffda0bb58319b4df89ac24e14fd15f9791dc78d1596b06f4969bdb37d9e394dc9fedaa18d694027fa32b5ea2a5e60080c58e13727367c3a4ce1ad65dfb3c7e3ca1ea912b0299f6e383bab2875058aa96a1c74633130af6fbd008788de6ac9db76da4ecc7303383cc1a49f525316413850f7e3ac385019d560e84c5b3a3e9ae6c83f59fe4286ddfd23ea46d7ae04610a175cd28a9bf5f574e245c3dfe230dc4b0adf4daaea96780e594f6464f676505f4b74cfe3ffc33415a23de795bf939ce64c0c02033bbfc6c9ff26fb478943a1ece775f38f5db067ca4b2a9168b40792398def9164bfe5c46838472dc3c162af16c811b7a116e9417d5bccb9e5b8a5d7d26095aba993696188c3f85a02f7ab8d12ada171c352785eb63417228c7e248909fc2d673e1bb453140bf8bf429375819afb5e9556663b76ff09c2a7ba9779855ffddc6d360cb459cf8c42a2b949d0de19fe96163d336fd66a4ce2f1791110e679572a20036ffae50204ef520c01058ff4bef28218d1c0e362ee3694ad8b2ae83a51c86c4bc1630ed6202a158810096726f809fc828fafdcf053496affdf887ae8c54b6ca4323ccecf6a51121c4f0c60e790536dab41b221db1c6b35065dc19a9d31cf75901aa35eefecbb6fefd07296cda13cb34ce3b58eba20a0eb8f9614994ec7fee3cc290e30e6b1e3211ae1f3a85b6de6abdbb77d6d9ed33a1cee3bd5cd93a71f12c9c45e385d744ad0e7286660305100fdd80a11000200076274632f75736400000000001109425443205072696365',
+      'hex',
+    );
+
+    const oracleAnnouncement = OracleAnnouncement.deserialize(
+      oracleAnnouncementBuf,
+    );
+
+    it('should build a covered call OrderOffer correctly', () => {
+      sinon.stub(Date.prototype, 'getTime').returns(Date.UTC(2021, 1, 5));
+
+      const orderOffer = buildCoveredCallOrderOffer(
+        oracleAnnouncement,
+        contractSize,
+        strikePrice,
+        premium,
+        12,
+        10000,
+        'bitcoin',
+      );
+
+      expect(() => orderOffer.validate()).to.not.throw(Error);
+    });
+
+    it('should build a short put OrderOffer correctly', () => {
+      const orderOffer = buildShortPutOrderOffer(
+        oracleAnnouncement,
+        contractSize,
+        strikePrice,
+        totalCollateral,
+        premium,
+        12,
+        10000,
+        'bitcoin',
+      );
+
+      expect(() => orderOffer.validate()).to.not.throw(Error);
+    });
+
+    it('should build a long call OrderOffer correctly', () => {
+      const orderOffer = buildLongCallOrderOffer(
+        oracleAnnouncement,
+        contractSize,
+        strikePrice,
+        threeXPremium,
+        premium,
+        12,
+        10000,
+        'bitcoin',
+      );
+
+      expect(() => orderOffer.validate()).to.not.throw(Error);
+    });
+
+    it('should build a long put OrderOffer correctly', () => {
+      const orderOffer = buildLongPutOrderOffer(
+        oracleAnnouncement,
+        contractSize,
+        strikePrice,
+        threeXPremium,
+        premium,
+        12,
+        10000,
+        'bitcoin',
+      );
+
+      expect(() => orderOffer.validate()).to.not.throw(Error);
+    });
+
+    it('should fail to build an OrderOffer with an invalid oracleAnnouncement', () => {
+      oracleAnnouncement.announcementSig = Buffer.from('deadbeef', 'hex');
+
+      const orderOffer = buildShortPutOrderOffer(
+        oracleAnnouncement,
+        contractSize,
+        strikePrice,
+        totalCollateral,
+        premium,
+        12,
+        10000,
+        'bitcoin',
+      );
+
+      expect(() => orderOffer.validate()).to.throw(Error);
+    });
+  });
+
+  describe('buildCustomStrategyOrderOffer', () => {
+    const contractSizes: Value[] = [
+      Value.fromBitcoin(1),
+      Value.fromBitcoin(0.1),
+      Value.fromBitcoin(0.5),
+      Value.fromBitcoin(1.5),
+      Value.fromBitcoin(2),
+    ];
+
+    const defaultContractSize = Value.fromBitcoin(1);
+
+    const maxLoss = Value.fromBitcoin(0.2);
+    const maxGain = Value.fromBitcoin(0.04);
+    const feeRate = 2n;
+
+    const highestPrecisionRounding = Value.fromSats(10000);
+    const highPrecisionRounding = Value.fromSats(25000);
+    const mediumPrecisionRounding = Value.fromSats(100000);
+    const lowPrecisionRounding = Value.fromSats(200000);
+
+    const network = BitcoinNetworks.bitcoin;
+
+    const oracleAnnouncementBuf = Buffer.from(
+      'fdd824fd032e4a2b121973a7d2be4784fb6fb0c7b97405b757fb078b58bb729756a7372bf1bdc05c373472fc57fde0a07dcdad027f48f313fa1e349ab8bb936472735fce5221ff9c4885aa0c5987046ada7e729dac33591777a37af8bf14dedb95997d0c7d4bfdd822fd02c800154a2b121973a7d2be4784fb6fb0c7b97405b757fb078b58bb729756a7372bf1bdd7cb55eee59faac9a590e7d3bab782276daa0744786aaff3f69a1e51de99012339492f00198932d8057eb6742bd5245e37fd22b44e0bfaa68577ce5654b478786eb7dc091559699292dc060ee82864cffd863eb8fa876682099af34a8f3eab9174773231e6950b077df212df3fc91c199c34200cd8ce00f1c8a050ad471bfc1478e90d06bd77f11fc3804435556ed5dc1eb19b95a978f595ba127ea225c4662e22ea614cab60054d9b21da904cd9eac5b514a6a011de635ad08e0c72766a7bbc9144df24fe6bf3e0d631a61a1da27e93c6f4ea6829795f4c63628747415a41ffe199129639d7a6c430184aa925b9ab224c9180b64c86959bd7abc9ffa08fe4421952114839d5120f4ea9c9437364b4956b25a141aeefbc30d3e6cc811f9424d266671dc330b7f3d00f1f7a521e14697a0259499e6cc8fa0da13a095279f827cfe2cf11508c6d8d1405f6cb337d68fbe29fde5acbb094ff397c14c24f084ac6ef466b1d85d5160de41ed8ed435ab52f948788dc45406e07f02683c9822431d91d95a04e11e4fdb521485aa8737bdd8c67cfefd0d103f86005491181e704adafc7f49cc9700ce8cffda9c9b265bc64ed19b42d4b5e4449f6b0da81342923c45f37b1381b3a29b9acce9818f4ec6af0ecbddc063e64868f350281054d13599e6e35d503532b6fa9c0db85db703dde1de21142b351ecce626128f98ddb5dab11f669c16de45d3dd054786aa5e3fb6369114b97bee6c26d21be0f71258dfa3e8ec8b8890719eef8e817b69072f74325088781a50b4cd5fe74493828dfe9cb21b698901e48f9f4d7b70a636794feae500aac237add2630bad1257b0cac1b71a8fcd5dbd7540a84ccac5d48b76afae2b3dfe3ea8eb8cd6e67febb6a1433504329948e426064108cfdd80a0e00020004626974730000000000150f73747261746567794f7574636f6d65',
+      'hex',
+    );
+
+    const oracleAnnouncement = OracleAnnouncement.deserialize(
+      oracleAnnouncementBuf,
+    );
+
+    const unit = 'bits';
+
+    for (const contractSize of contractSizes) {
+      it(`should build a CSO OrderOffer with contract size ${contractSize.bitcoin} BTC correctly`, () => {
+        const roundingIntervals = buildRoundingIntervalsFromIntervals(
+          contractSize,
+          [
+            { beginInterval: 0n, rounding: lowPrecisionRounding },
+            { beginInterval: 750000n, rounding: mediumPrecisionRounding },
+            { beginInterval: 850000n, rounding: highPrecisionRounding },
+            { beginInterval: 950000n, rounding: highestPrecisionRounding },
+          ],
+        );
+
+        const orderOffer = buildCustomStrategyOrderOffer(
+          oracleAnnouncement,
+          contractSize,
+          maxLoss,
+          maxGain,
+          feeRate,
+          roundingIntervals,
+          network,
+        );
+
+        const payoutCurvePieces = (((orderOffer.contractInfo as ContractInfoV0)
+          .contractDescriptor as ContractDescriptorV1)
+          .payoutFunction as PayoutFunctionV0).payoutFunctionPieces;
+
+        expect(() => orderOffer.validate()).to.not.throw(Error);
+        expect(orderOffer.contractInfo.totalCollateral).to.equal(
+          contractSize.sats,
+        );
+        expect(orderOffer.offerCollateralSatoshis).to.equal(
+          contractSize.sats - (contractSize.sats * maxGain.sats) / BigInt(1e8),
+        );
+        expect(payoutCurvePieces[0].endPoint.eventOutcome).to.equal(
+          (defaultContractSize.sats - maxLoss.sats) /
+            BigInt(UNIT_MULTIPLIER[unit]),
+        );
+        expect(payoutCurvePieces[1].endPoint.eventOutcome).to.equal(
+          (defaultContractSize.sats + maxGain.sats) /
+            BigInt(UNIT_MULTIPLIER[unit]),
+        );
+        expect(payoutCurvePieces[0].endPoint.outcomePayout).to.equal(
+          contractSize.sats -
+            (maxLoss.sats * contractSize.sats) / BigInt(1e8) -
+            (maxGain.sats * contractSize.sats) / BigInt(1e8),
+        );
+        expect(payoutCurvePieces[1].endPoint.outcomePayout).to.equal(
+          contractSize.sats,
+        );
+      });
+    }
+
+    it('should build a CSO OrderOffer and shift the payout curve correctly for offeror fees', () => {
+      const contractSize = contractSizes[0];
+
+      const roundingIntervals = buildRoundingIntervalsFromIntervals(
+        contractSize,
+        [
+          { beginInterval: 0n, rounding: lowPrecisionRounding },
+          { beginInterval: 750000n, rounding: mediumPrecisionRounding },
+          { beginInterval: 850000n, rounding: highPrecisionRounding },
+          { beginInterval: 950000n, rounding: highestPrecisionRounding },
+        ],
+      );
+
+      const offerFees = Value.fromSats(10000);
+
+      const orderOffer = buildCustomStrategyOrderOffer(
+        oracleAnnouncement,
+        contractSize,
+        maxLoss,
+        maxGain,
+        feeRate,
+        roundingIntervals,
+        network,
+        'offeror',
+        offerFees,
+      );
+
+      const payoutCurvePieces = (((orderOffer.contractInfo as ContractInfoV0)
+        .contractDescriptor as ContractDescriptorV1)
+        .payoutFunction as PayoutFunctionV0).payoutFunctionPieces;
+
+      expect(() => orderOffer.validate()).to.not.throw(Error);
+      expect(orderOffer.contractInfo.totalCollateral).to.equal(
+        contractSize.sats,
+      );
+      expect(orderOffer.offerCollateralSatoshis).to.equal(
+        contractSize.sats - (contractSize.sats * maxGain.sats) / BigInt(1e8),
+      );
+      expect(payoutCurvePieces[0].endPoint.eventOutcome).to.equal(
+        (defaultContractSize.sats - maxLoss.sats + offerFees.sats) /
+          BigInt(UNIT_MULTIPLIER[unit]),
+      );
+      expect(payoutCurvePieces[1].endPoint.eventOutcome).to.equal(
+        (defaultContractSize.sats + maxGain.sats + offerFees.sats) /
+          BigInt(UNIT_MULTIPLIER[unit]),
+      );
+      expect(payoutCurvePieces[0].endPoint.outcomePayout).to.equal(
+        contractSize.sats -
+          (maxLoss.sats * contractSize.sats) / BigInt(1e8) -
+          (maxGain.sats * contractSize.sats) / BigInt(1e8),
+      );
+      expect(payoutCurvePieces[1].endPoint.outcomePayout).to.equal(
+        contractSize.sats,
+      );
+    });
+
+    it('should build a CSO OrderOffer and shift the payout curve correctly for acceptor fees', () => {
+      const acceptFees = Value.fromSats(10000);
+
+      const contractSize = contractSizes[0];
+
+      const roundingIntervals = buildRoundingIntervalsFromIntervals(
+        contractSize,
+        [
+          { beginInterval: 0n, rounding: lowPrecisionRounding },
+          { beginInterval: 750000n, rounding: mediumPrecisionRounding },
+          { beginInterval: 850000n, rounding: highPrecisionRounding },
+          { beginInterval: 950000n, rounding: highestPrecisionRounding },
+        ],
+      );
+
+      const orderOffer = buildCustomStrategyOrderOffer(
+        oracleAnnouncement,
+        contractSize,
+        maxLoss,
+        maxGain,
+        feeRate,
+        roundingIntervals,
+        network,
+        'acceptor',
+        acceptFees,
+      );
+
+      const payoutCurvePieces = (((orderOffer.contractInfo as ContractInfoV0)
+        .contractDescriptor as ContractDescriptorV1)
+        .payoutFunction as PayoutFunctionV0).payoutFunctionPieces;
+
+      expect(() => orderOffer.validate()).to.not.throw(Error);
+      expect(orderOffer.contractInfo.totalCollateral).to.equal(
+        contractSize.sats,
+      );
+      expect(orderOffer.offerCollateralSatoshis).to.equal(
+        contractSize.sats - (contractSize.sats * maxGain.sats) / BigInt(1e8),
+      );
+      expect(payoutCurvePieces[0].endPoint.eventOutcome).to.equal(
+        (defaultContractSize.sats - maxLoss.sats - acceptFees.sats) /
+          BigInt(UNIT_MULTIPLIER[unit]),
+      );
+      expect(payoutCurvePieces[1].endPoint.eventOutcome).to.equal(
+        (defaultContractSize.sats + maxGain.sats - acceptFees.sats) /
+          BigInt(UNIT_MULTIPLIER[unit]),
+      );
+      expect(payoutCurvePieces[0].endPoint.outcomePayout).to.equal(
+        contractSize.sats -
+          (maxLoss.sats * contractSize.sats) / BigInt(1e8) -
+          (maxGain.sats * contractSize.sats) / BigInt(1e8),
+      );
+      expect(payoutCurvePieces[1].endPoint.outcomePayout).to.equal(
+        contractSize.sats,
+      );
+    });
+
+    it('should fail to build a CSO OrderOffer with contractSize 0', () => {
+      const contractSize = Value.zero();
+
+      const roundingIntervals = buildRoundingIntervalsFromIntervals(
+        contractSize,
+        [
+          { beginInterval: 0n, rounding: lowPrecisionRounding },
+          { beginInterval: 750000n, rounding: mediumPrecisionRounding },
+          { beginInterval: 850000n, rounding: highPrecisionRounding },
+          { beginInterval: 950000n, rounding: highestPrecisionRounding },
+        ],
+      );
+
+      try {
+        buildCustomStrategyOrderOffer(
+          oracleAnnouncement,
+          contractSize,
+          maxLoss,
+          maxGain,
+          feeRate,
+          roundingIntervals,
+          network,
+        );
+        // If the function call does not throw, fail the test
+        expect.fail(
+          'Expected buildCustomStrategyOrderOffer to throw an error due to contractSize being 0',
+        );
+      } catch (error) {
+        // Assert that the error message is as expected
+        expect(error.message).to.equal('contractSize must be greater than 0');
+      }
+    });
+
+    it('should fail to build a CSO OrderOffer with an invalid oracleAnnouncement', () => {
+      const contractSize = contractSizes[0];
+
+      const roundingIntervals = buildRoundingIntervalsFromIntervals(
+        contractSize,
+        [
+          { beginInterval: 0n, rounding: lowPrecisionRounding },
+          { beginInterval: 750000n, rounding: mediumPrecisionRounding },
+          { beginInterval: 850000n, rounding: highPrecisionRounding },
+          { beginInterval: 950000n, rounding: highestPrecisionRounding },
+        ],
+      );
+
+      oracleAnnouncement.announcementSig = Buffer.from(
+        'deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef',
+        'hex',
+      );
+
+      const skipValidation = true;
+
+      const orderOffer = buildCustomStrategyOrderOffer(
+        oracleAnnouncement,
+        contractSize,
+        maxLoss,
+        maxGain,
+        feeRate,
+        roundingIntervals,
+        network,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        skipValidation,
+      );
+
+      expect(() => orderOffer.validate()).to.throw(Error);
+    });
+  });
+
+  describe('computeRoundingModulus', () => {
+    describe('with satoshi inputs (existing functionality)', () => {
+      it('should properly compute the rounding modulus for 0.0001 BTC', () => {
+        const modulus = computeRoundingModulus(BigInt(100000), BigInt(10000));
+        expect(modulus).to.equal(BigInt(10));
+      });
+
+      it('should properly compute the rounding modulus for 1 BTC', () => {
+        const modulus = computeRoundingModulus(
+          BigInt(100000),
+          BigInt(100000000),
+        );
+        expect(modulus).to.equal(BigInt(100000));
+      });
+
+      it('should properly compute the rounding modulus for 1.25 BTC', () => {
+        const modulus = computeRoundingModulus(BigInt(5000), BigInt(125000000));
+        expect(modulus).to.equal(BigInt(6250));
+      });
+
+      it('should properly compute the rounding modulus for 0.9 BTC', () => {
+        const modulus = computeRoundingModulus(
+          BigInt(100000),
+          BigInt(90000000),
+        );
+        expect(modulus).to.equal(BigInt(90000));
+      });
+    });
+
+    describe('with bitcoin amount inputs (new functionality)', () => {
+      it('should properly compute the rounding modulus for 0.001 BTC rounding with 0.1 BTC contract size', () => {
+        const modulus = computeRoundingModulus(0.001, 0.1); // 0.001 BTC rounding, 0.1 BTC contract
+        expect(modulus).to.equal(BigInt(10000)); // (0.001 * 1e8) * (0.1 * 1e8) / 1e8 = 10000
+      });
+
+      it('should properly compute the rounding modulus for 0.0001 BTC rounding with 1 BTC contract size', () => {
+        const modulus = computeRoundingModulus(0.0001, 1); // 0.0001 BTC rounding, 1 BTC contract
+        expect(modulus).to.equal(BigInt(10000)); // (0.0001 * 1e8) * (1 * 1e8) / 1e8 = 10000
+      });
+
+      it('should properly compute the rounding modulus for 0.001 BTC rounding with 1.5 BTC contract size', () => {
+        const modulus = computeRoundingModulus(0.001, 1.5); // 0.001 BTC rounding, 1.5 BTC contract
+        expect(modulus).to.equal(BigInt(150000)); // (0.001 * 1e8) * (1.5 * 1e8) / 1e8 = 150000
+      });
+
+      it('should properly compute the rounding modulus for 0.0005 BTC rounding with 0.5 BTC contract size', () => {
+        const modulus = computeRoundingModulus(0.0005, 0.5); // 0.0005 BTC rounding, 0.5 BTC contract
+        expect(modulus).to.equal(BigInt(25000)); // (0.0005 * 1e8) * (0.5 * 1e8) / 1e8 = 25000
+      });
+
+      it('should handle fractional bitcoin amounts correctly', () => {
+        const modulus = computeRoundingModulus(0.00001, 0.12345); // Very small amounts
+        expect(modulus).to.equal(BigInt(123)); // (0.00001 * 1e8) * (0.12345 * 1e8) / 1e8 = 123.45 -> 123 (rounded down)
+      });
+    });
+
+    describe('with Value object inputs', () => {
+      it('should properly compute the rounding modulus with Value objects', () => {
+        const rounding = Value.fromBitcoin(0.001);
+        const contractSize = Value.fromBitcoin(1);
+        const modulus = computeRoundingModulus(rounding, contractSize);
+        expect(modulus).to.equal(BigInt(100000)); // (0.001 * 1e8) * (1 * 1e8) / 1e8 = 100000
+      });
+
+      it('should properly compute the rounding modulus with mixed Value and number inputs', () => {
+        const rounding = Value.fromBitcoin(0.001);
+        const contractSize = 1.5; // number input
+        const modulus = computeRoundingModulus(rounding, contractSize);
+        expect(modulus).to.equal(BigInt(150000)); // (0.001 * 1e8) * (1.5 * 1e8) / 1e8 = 150000
+      });
+    });
+
+    describe('with BigInt inputs', () => {
+      it('should properly compute the rounding modulus with BigInt inputs', () => {
+        const modulus = computeRoundingModulus(
+          BigInt(100000),
+          BigInt(100000000),
+        );
+        expect(modulus).to.equal(BigInt(100000));
+      });
+
+      it('should properly compute the rounding modulus with mixed BigInt and number inputs', () => {
+        const modulus = computeRoundingModulus(BigInt(100000), 1); // BigInt rounding, number contract size
+        expect(modulus).to.equal(BigInt(100000)); // 100000 * (1 * 1e8) / 1e8 = 100000
+      });
+    });
+
+    describe('edge cases', () => {
+      it('should handle zero rounding correctly', () => {
+        const modulus = computeRoundingModulus(0, 1);
+        expect(modulus).to.equal(BigInt(0));
+      });
+
+      it('should handle zero contract size correctly', () => {
+        const modulus = computeRoundingModulus(0.001, 0);
+        expect(modulus).to.equal(BigInt(0));
+      });
+
+      it('should handle very small bitcoin amounts', () => {
+        const modulus = computeRoundingModulus(0.00000001, 0.00000001); // 1 satoshi each
+        expect(modulus).to.equal(BigInt(0)); // (1 * 1) / 1e8 = 0 (rounded down)
+      });
+    });
+  });
+});

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

@@ -0,0 +1,112 @@
+import { HyperbolaPayoutCurvePiece } from '@node-dlc/messaging';
+import { expect } from 'chai';
+
+import { CoveredCall } from '../../../lib/dlc/finance/CoveredCall';
+import { HyperbolaPayoutCurve } from '../../../lib/dlc/HyperbolaPayoutCurve';
+
+describe('CoveredCall', () => {
+  describe('1BTC-50k-base2-20digit curve', () => {
+    const strikePrice = BigInt(50000);
+    const contractSize = BigInt(10) ** BigInt(8);
+    const oracleBase = 2;
+    const oracleDigits = 20;
+
+    const { maxOutcome, totalCollateral, payoutCurve } = CoveredCall.buildCurve(
+      strikePrice,
+      contractSize,
+      oracleBase,
+      oracleDigits,
+    );
+
+    describe('payout', () => {
+      it('should be a negative past max outcome', () => {
+        expect(
+          payoutCurve.getPayout(maxOutcome + BigInt(1)).toNumber(),
+        ).to.be.lessThan(0);
+      });
+
+      it('should be equal to totalCollateral at strike price', () => {
+        expect(payoutCurve.getPayout(strikePrice).toNumber()).to.equal(
+          Number(totalCollateral),
+        );
+      });
+    });
+
+    describe('buildPayoutFunction', () => {
+      it('should build payout function', () => {
+        const {
+          payoutFunction,
+          totalCollateral,
+        } = CoveredCall.buildPayoutFunction(4000n, 1000000n, 2, 17);
+
+        // Test basic structure
+        expect(payoutFunction).to.not.be.undefined;
+        expect(totalCollateral).to.not.be.undefined;
+
+        // Test payout function structure
+        expect(payoutFunction.payoutFunctionPieces).to.have.length(1);
+        expect(payoutFunction.lastEndpoint).to.not.be.undefined;
+
+        // Test the payout function piece
+        const piece = payoutFunction.payoutFunctionPieces[0];
+        expect(piece.endPoint).to.not.be.undefined;
+        expect(piece.payoutCurvePiece).to.not.be.undefined;
+
+        // Test end point values - should be at maxOutcome (2^17 - 1 = 131071)
+        const maxOutcome = BigInt(2 ** 17 - 1); // 131071
+        expect(piece.endPoint.eventOutcome).to.equal(maxOutcome);
+        expect(piece.endPoint.outcomePayout).to.equal(0n);
+        expect(piece.endPoint.extraPrecision).to.equal(0);
+
+        // Test last endpoint matches the piece endpoint
+        expect(payoutFunction.lastEndpoint.eventOutcome).to.equal(maxOutcome);
+        expect(payoutFunction.lastEndpoint.outcomePayout).to.equal(0n);
+        expect(payoutFunction.lastEndpoint.extraPrecision).to.equal(0);
+
+        // Test hyperbola curve piece properties
+        const curvePiece = piece.payoutCurvePiece as HyperbolaPayoutCurvePiece;
+        expect(curvePiece.usePositivePiece).to.equal(true);
+        expect(curvePiece.leftEndPoint).to.not.be.undefined;
+        expect(curvePiece.rightEndPoint).to.not.be.undefined;
+
+        // Test left endpoint (start of curve)
+        expect(curvePiece.leftEndPoint.eventOutcome).to.equal(0n);
+        expect(curvePiece.leftEndPoint.outcomePayout).to.equal(totalCollateral);
+        expect(curvePiece.leftEndPoint.extraPrecision).to.equal(0);
+
+        // Test right endpoint (end of curve)
+        expect(curvePiece.rightEndPoint.eventOutcome).to.equal(maxOutcome);
+        expect(curvePiece.rightEndPoint.outcomePayout).to.equal(0n);
+        expect(curvePiece.rightEndPoint.extraPrecision).to.equal(0);
+
+        // Test hyperbola parameters
+        expect(curvePiece.a.toNumber()).to.equal(1);
+        expect(curvePiece.b.toNumber()).to.equal(0);
+        expect(curvePiece.c.toNumber()).to.equal(0);
+        expect(curvePiece.d.toNumber()).to.equal(4000000000); // strikePrice * contractSize
+        expect(curvePiece.translateOutcome.toNumber()).to.equal(0);
+
+        // Test total collateral is reasonable (should be less than contract size)
+        expect(Number(totalCollateral)).to.be.greaterThan(0);
+        expect(Number(totalCollateral)).to.be.lessThan(1000000); // less than contractSize
+
+        // For a covered call with strike=4000, contractSize=1000000:
+        // At maxOutcome, payout should be ~0, so most collateral is retained
+        expect(Number(totalCollateral)).to.be.greaterThan(900000); // Should retain most collateral
+      });
+    });
+
+    it('should serialize and deserialize properly', () => {
+      const payout = payoutCurve.getPayout(strikePrice);
+
+      const _tlv = payoutCurve.toPayoutCurvePiece().serialize();
+      const pf = HyperbolaPayoutCurvePiece.deserialize(_tlv);
+
+      const deserializedCurve = HyperbolaPayoutCurve.fromPayoutCurvePiece(pf);
+
+      expect(payout.toNumber()).to.be.eq(
+        deserializedCurve.getPayout(strikePrice).toNumber(),
+      );
+    });
+  });
+});