@atomicfinance/bitcoin-dlc-provider 4.1.0 → 4.1.1

package/.yalc/@node-dlc/messaging/__tests__/messages/PayoutCurvePiece.spec.ts

@@ -1,220 +0,0 @@
-import { expect } from 'chai';
-
-import {
-  HyperbolaPayoutCurvePiece,
-  PayoutCurvePiece,
-  PolynomialPayoutCurvePiece,
-} from '../../lib/messages/PayoutCurvePiece';
-import { F64 } from '../../lib/serialize/F64';
-
-describe('PayoutCurvePiece', () => {
-  describe('PolynomialPayoutCurvePiece', () => {
-    it('serializes and deserializes correctly', () => {
-      const instance = new PolynomialPayoutCurvePiece();
-
-      instance.points = [
-        {
-          eventOutcome: BigInt(0),
-          outcomePayout: BigInt(0),
-          extraPrecision: 0,
-        },
-        {
-          eventOutcome: BigInt(1),
-          outcomePayout: BigInt(1),
-          extraPrecision: 0,
-        },
-      ];
-
-      // Test that it serializes without errors (new dlcspecs PR #163 format)
-      const serialized = instance.serialize();
-      expect(serialized).to.be.instanceof(Buffer);
-      expect(serialized.length).to.be.greaterThan(0);
-
-      // Test round-trip serialization
-      const deserialized = PayoutCurvePiece.deserialize(
-        serialized,
-      ) as PolynomialPayoutCurvePiece;
-      expect(deserialized).to.be.instanceof(PolynomialPayoutCurvePiece);
-      expect(deserialized.points.length).to.equal(2);
-      expect(deserialized.points[0].eventOutcome).to.equal(BigInt(0));
-      expect(deserialized.points[0].outcomePayout).to.equal(BigInt(0));
-      expect(deserialized.points[1].eventOutcome).to.equal(BigInt(1));
-      expect(deserialized.points[1].outcomePayout).to.equal(BigInt(1));
-    });
-
-    it('handles large BigInt values correctly', () => {
-      const instance = new PolynomialPayoutCurvePiece();
-      const largeBigInt = BigInt('18446744073709551615'); // Max uint64
-
-      instance.points = [
-        {
-          eventOutcome: largeBigInt,
-          outcomePayout: largeBigInt,
-          extraPrecision: 0,
-        },
-      ];
-
-      const serialized = instance.serialize();
-      const deserialized = PayoutCurvePiece.deserialize(
-        serialized,
-      ) as PolynomialPayoutCurvePiece;
-
-      expect(deserialized.points[0].eventOutcome).to.equal(largeBigInt);
-      expect(deserialized.points[0].outcomePayout).to.equal(largeBigInt);
-    });
-  });
-
-  describe('HyperbolaPayoutCurvePiece', () => {
-    it('serializes and deserializes correctly with normal values', () => {
-      const instance = new HyperbolaPayoutCurvePiece();
-      instance.usePositivePiece = true;
-      instance.translateOutcome = F64.fromNumber(100.5);
-      instance.translatePayout = F64.fromNumber(50.25);
-      instance.a = F64.fromNumber(1.0);
-      instance.b = F64.fromNumber(0.0);
-      instance.c = F64.fromNumber(0.0);
-      instance.d = F64.fromNumber(200.0);
-
-      const serialized = instance.serialize();
-      expect(serialized).to.be.instanceof(Buffer);
-      expect(serialized.length).to.be.greaterThan(0);
-
-      // Test round-trip
-      const deserialized = PayoutCurvePiece.deserialize(
-        serialized,
-      ) as HyperbolaPayoutCurvePiece;
-      expect(deserialized.usePositivePiece).to.equal(true);
-      expect(deserialized.translateOutcome.toNumber()).to.equal(100.5);
-    });
-
-    it('handles very large f64 values without precision loss', () => {
-      // Test values that exceed JavaScript MAX_SAFE_INTEGER
-      const testCases = [
-        {
-          name: 'Large positive number',
-          value: 1.7976931348623157e100, // Very large but valid f64
-        },
-        {
-          name: 'Very small number',
-          value: 5e-324, // Smallest positive denormalized f64
-        },
-        {
-          name: 'Beyond safe integer',
-          value: 9007199254740992, // MAX_SAFE_INTEGER + 1
-        },
-        {
-          name: 'Scientific notation',
-          value: 1.23456789e50,
-        },
-      ];
-
-      testCases.forEach(({ value }) => {
-        const instance = new HyperbolaPayoutCurvePiece();
-        instance.usePositivePiece = false;
-        instance.translateOutcome = F64.fromNumber(value);
-        instance.translatePayout = F64.fromNumber(123.456);
-        instance.a = F64.fromNumber(1.0);
-        instance.b = F64.fromNumber(0.0);
-        instance.c = F64.fromNumber(0.0);
-        instance.d = F64.fromNumber(value * 2);
-
-        // Test round-trip serialization preserves exact binary representation
-        const serialized = instance.serialize();
-        const deserialized = PayoutCurvePiece.deserialize(
-          serialized,
-        ) as HyperbolaPayoutCurvePiece;
-
-        // The F64 should maintain exact binary representation
-        expect(deserialized.translateOutcome.equals(instance.translateOutcome))
-          .to.be.true;
-        expect(deserialized.d.equals(instance.d)).to.be.true;
-      });
-    });
-
-    it('handles JSON with string values (for very large numbers)', () => {
-      // Test JSON with string values for large numbers
-      const jsonWithStrings = {
-        usePositivePiece: true,
-        translateOutcome: '1.7976931348623157e+100', // String representation
-        translatePayout: 50000.0, // Regular number
-        a: '9007199254740992', // String for large integer
-        b: 0.0,
-        c: 0.0,
-        d: 1.5,
-      };
-
-      const instance = HyperbolaPayoutCurvePiece.fromJSON(jsonWithStrings);
-
-      // Should handle both string and number inputs correctly
-      expect(instance.usePositivePiece).to.be.true;
-      expect(instance.translateOutcome.toNumber()).to.equal(
-        1.7976931348623157e100,
-      );
-      expect(instance.translatePayout.toNumber()).to.equal(50000.0);
-      expect(instance.a.toNumber()).to.equal(9007199254740992);
-    });
-
-    it('JSON round-trip maintains values within JavaScript precision limits', () => {
-      const instance = new HyperbolaPayoutCurvePiece();
-      instance.usePositivePiece = true;
-      instance.translateOutcome = F64.fromNumber(50000.5);
-      instance.translatePayout = F64.fromNumber(25000.25);
-      instance.a = F64.fromNumber(1.5);
-      instance.b = F64.fromNumber(0.0);
-      instance.c = F64.fromNumber(0.0);
-      instance.d = F64.fromNumber(10000.0);
-
-      // Test JSON round-trip
-      const json = instance.toJSON();
-      const restored = HyperbolaPayoutCurvePiece.fromJSON(
-        json.hyperbolaPayoutCurvePiece,
-      );
-
-      expect(restored.usePositivePiece).to.equal(instance.usePositivePiece);
-      expect(restored.translateOutcome.toNumber()).to.equal(
-        instance.translateOutcome.toNumber(),
-      );
-      expect(restored.translatePayout.toNumber()).to.equal(
-        instance.translatePayout.toNumber(),
-      );
-      expect(restored.a.toNumber()).to.equal(instance.a.toNumber());
-      expect(restored.d.toNumber()).to.equal(instance.d.toNumber());
-    });
-
-    it('demonstrates precision limits with very large numbers in JSON', () => {
-      // This test demonstrates the precision tradeoff we're making
-      const veryLargeNumber = 1.2345678901234567e100;
-
-      const instance = new HyperbolaPayoutCurvePiece();
-      instance.usePositivePiece = false;
-      instance.translateOutcome = F64.fromNumber(veryLargeNumber);
-      instance.translatePayout = F64.fromNumber(0);
-      instance.a = F64.fromNumber(0);
-      instance.b = F64.fromNumber(0);
-      instance.c = F64.fromNumber(0);
-      instance.d = F64.fromNumber(0);
-
-      // Binary serialization preserves exact representation
-      const binarySerialized = instance.serialize();
-      const binaryDeserialized = PayoutCurvePiece.deserialize(
-        binarySerialized,
-      ) as HyperbolaPayoutCurvePiece;
-
-      expect(
-        binaryDeserialized.translateOutcome.equals(instance.translateOutcome),
-      ).to.be.true;
-
-      // JSON serialization may lose precision for very large numbers
-      const json = instance.toJSON();
-      const jsonRestored = HyperbolaPayoutCurvePiece.fromJSON(
-        json.hyperbolaPayoutCurvePiece,
-      );
-
-      // This may not be exactly equal due to JSON number precision limits
-      const jsonValue = jsonRestored.translateOutcome.toNumber();
-
-      // The important thing is that both are very large numbers in the same ballpark
-      expect(jsonValue).to.be.greaterThan(1e99);
-    });
-  });
-});

package/.yalc/@node-dlc/messaging/__tests__/messages/PayoutFunction.spec.ts

@@ -1,101 +0,0 @@
-import { expect } from 'chai';
-
-import { HyperbolaPayoutCurvePiece } from '../../lib/messages/PayoutCurvePiece';
-import { PayoutFunction } from '../../lib/messages/PayoutFunction';
-import { F64 } from '../../lib/serialize/F64';
-
-describe('PayoutFunction', () => {
-  describe('serialize', () => {
-    it('serializes', () => {
-      const instance = new PayoutFunction();
-
-      // Create PayoutCurvePiece programmatically instead of using legacy hex data
-      const payoutCurvePiece = new HyperbolaPayoutCurvePiece();
-      payoutCurvePiece.usePositivePiece = true;
-      payoutCurvePiece.translateOutcome = F64.fromNumber(5000);
-      payoutCurvePiece.translatePayout = F64.fromNumber(1);
-      payoutCurvePiece.a = F64.fromNumber(1);
-      payoutCurvePiece.b = F64.fromNumber(1);
-      payoutCurvePiece.c = F64.fromNumber(1);
-      payoutCurvePiece.d = F64.fromNumber(312000000);
-
-      instance.payoutFunctionPieces = [
-        {
-          endPoint: {
-            eventOutcome: BigInt(999999),
-            outcomePayout: BigInt(0),
-            extraPrecision: 0,
-          },
-          payoutCurvePiece,
-        },
-      ];
-
-      instance.lastEndpoint = {
-        eventOutcome: BigInt(50000),
-        outcomePayout: BigInt(100000),
-        extraPrecision: 0,
-      };
-
-      // Test that it serializes without errors (new dlcspecs PR #163 format)
-      const serialized = instance.serialize();
-      expect(serialized).to.be.instanceof(Buffer);
-      expect(serialized.length).to.be.greaterThan(0);
-    });
-  });
-
-  describe('deserialize', () => {
-    it('deserializes', () => {
-      // Create a test instance and serialize it first for round-trip testing
-      const originalInstance = new PayoutFunction();
-
-      // Create PayoutCurvePiece programmatically
-      const payoutCurvePiece = new HyperbolaPayoutCurvePiece();
-      payoutCurvePiece.usePositivePiece = true;
-      payoutCurvePiece.translateOutcome = F64.fromNumber(5000);
-      payoutCurvePiece.translatePayout = F64.fromNumber(1);
-      payoutCurvePiece.a = F64.fromNumber(1);
-      payoutCurvePiece.b = F64.fromNumber(1);
-      payoutCurvePiece.c = F64.fromNumber(1);
-      payoutCurvePiece.d = F64.fromNumber(312000000);
-
-      originalInstance.payoutFunctionPieces = [
-        {
-          endPoint: {
-            eventOutcome: BigInt(999999),
-            outcomePayout: BigInt(0),
-            extraPrecision: 0,
-          },
-          payoutCurvePiece,
-        },
-      ];
-
-      originalInstance.lastEndpoint = {
-        eventOutcome: BigInt(50000),
-        outcomePayout: BigInt(100000),
-        extraPrecision: 0,
-      };
-
-      // Serialize and then deserialize to ensure round-trip consistency
-      const serialized = originalInstance.serialize();
-      const instance = PayoutFunction.deserialize(serialized);
-
-      expect(instance.lastEndpoint.eventOutcome).to.equal(BigInt(50000));
-      expect(instance.lastEndpoint.outcomePayout).to.equal(BigInt(100000));
-      expect(instance.lastEndpoint.extraPrecision).to.equal(0);
-
-      expect(instance.payoutFunctionPieces.length).to.equal(1);
-      expect(
-        instance.payoutFunctionPieces[0].payoutCurvePiece,
-      ).to.be.instanceof(HyperbolaPayoutCurvePiece);
-      expect(instance.payoutFunctionPieces[0].endPoint.eventOutcome).to.equal(
-        BigInt(999999),
-      );
-      expect(instance.payoutFunctionPieces[0].endPoint.outcomePayout).to.equal(
-        BigInt(0),
-      );
-      expect(instance.payoutFunctionPieces[0].endPoint.extraPrecision).to.equal(
-        0,
-      );
-    });
-  });
-});

package/.yalc/@node-dlc/messaging/__tests__/messages/RoundingIntervals.spec.ts

@@ -1,75 +0,0 @@
-import { expect } from 'chai';
-
-import { RoundingIntervals } from '../../lib';
-
-describe('RoundingIntervals', () => {
-  describe('serialize', () => {
-    it('serializes', () => {
-      const instance = new RoundingIntervals();
-
-      const intervals = [
-        { beginInterval: 1n, roundingMod: 2n },
-        { beginInterval: 3n, roundingMod: 4n },
-      ];
-      instance.intervals = intervals;
-
-      expect(instance.serialize().toString("hex")).to.equal(
-        '02' + // number of intervals (bigsize)
-        '0000000000000001' + // begin_interval (u64)
-        '0000000000000002' + // rounding_mod (u64)
-        '0000000000000003' + // begin_interval (u64)
-        '0000000000000004'   // rounding_mod (u64)
-      ); // prettier-ignore
-    });
-  });
-
-  describe('deserialize', () => {
-    it('deserializes', () => {
-      const buf = Buffer.from(
-        '02' + // number of intervals (bigsize)
-        '0000000000000001' + // begin_interval (u64)
-        '0000000000000002' + // rounding_mod (u64)
-        '0000000000000003' + // begin_interval (u64)
-        '0000000000000004'   // rounding_mod (u64)
-      , 'hex'); // prettier-ignore
-
-      const instance = RoundingIntervals.deserialize(buf);
-
-      expect(instance.intervals.length).to.eq(2); // Check number of intervals instead of instance.length
-      expect(instance.intervals[0].beginInterval).to.eq(1n);
-      expect(instance.intervals[0].roundingMod).to.eq(2n);
-      expect(instance.intervals[1].beginInterval).to.eq(3n);
-      expect(instance.intervals[1].roundingMod).to.eq(4n);
-    });
-  });
-
-  describe('validate', () => {
-    const instance = new RoundingIntervals();
-
-    beforeEach(() => {
-      const intervals = [
-        { beginInterval: 1n, roundingMod: 2n },
-        { beginInterval: 3n, roundingMod: 4n },
-      ];
-      instance.intervals = intervals;
-    });
-
-    it('should not throw error', () => {
-      expect(() => instance.validate()).to.not.throw();
-    });
-
-    it('should throw error if negative intervals', () => {
-      instance.intervals[0].beginInterval = -1n;
-      expect(() => instance.validate()).to.throw(
-        'beginInterval must be non-negative',
-      );
-    });
-
-    it('should throw error if non-increasing intervals', () => {
-      instance.intervals[1].beginInterval = 0n;
-      expect(() => instance.validate()).to.throw(
-        'Intervals must be strictly increasing',
-      );
-    });
-  });
-});

package/.yalc/@node-dlc/messaging/__tests__/serialize/F64.spec.ts

@@ -1,261 +0,0 @@
-import { expect } from 'chai';
-
-import { F64 } from '../../lib/serialize/F64';
-
-describe('F64', () => {
-  describe('Construction and basic operations', () => {
-    it('should create F64 from number', () => {
-      const f64 = F64.fromNumber(123.456);
-      expect(f64.toNumber()).to.equal(123.456);
-    });
-
-    it('should create F64 from string', () => {
-      const f64 = F64.fromString('123.456');
-      expect(f64.toNumber()).to.equal(123.456);
-    });
-
-    it('should create F64 from bigint', () => {
-      const f64 = F64.fromBigInt(BigInt(123456789));
-      expect(f64.toNumber()).to.equal(123456789);
-    });
-
-    it('should create zero F64', () => {
-      const f64 = F64.zero();
-      expect(f64.toNumber()).to.equal(0);
-      expect(f64.isZero()).to.be.true;
-    });
-  });
-
-  describe('Large number handling', () => {
-    it('should handle very large integers within safe range', () => {
-      const largeNum = Number.MAX_SAFE_INTEGER; // 9,007,199,254,740,991
-      const f64 = F64.fromNumber(largeNum);
-      expect(f64.toNumber()).to.equal(largeNum);
-    });
-
-    it('should handle numbers beyond JavaScript safe integer range', () => {
-      // This is beyond MAX_SAFE_INTEGER, where JavaScript loses precision
-      const veryLargeNum = 9007199254740992; // MAX_SAFE_INTEGER + 1
-      const f64 = F64.fromNumber(veryLargeNum);
-
-      // The F64 should maintain the IEEE 754 representation
-      expect(f64.toNumber()).to.equal(veryLargeNum);
-    });
-
-    it('should handle maximum finite f64 value', () => {
-      const maxFinite = 1.7976931348623157e308;
-      const f64 = F64.fromNumber(maxFinite);
-      expect(f64.toNumber()).to.equal(maxFinite);
-      expect(f64.isFinite()).to.be.true;
-    });
-
-    it('should handle minimum positive normal f64 value', () => {
-      const minNormal = 2.2250738585072014e-308;
-      const f64 = F64.fromNumber(minNormal);
-      expect(f64.toNumber()).to.equal(minNormal);
-    });
-
-    it('should handle very small denormalized numbers', () => {
-      const denormal = 5e-324; // Smallest positive denormalized number
-      const f64 = F64.fromNumber(denormal);
-      expect(f64.toNumber()).to.equal(denormal);
-    });
-  });
-
-  describe('Special values', () => {
-    it('should handle positive infinity', () => {
-      const f64 = F64.fromNumber(Number.POSITIVE_INFINITY);
-      expect(f64.isInfinite()).to.be.true;
-      expect(f64.isFinite()).to.be.false;
-      expect(f64.toNumber()).to.equal(Number.POSITIVE_INFINITY);
-    });
-
-    it('should handle negative infinity', () => {
-      const f64 = F64.fromNumber(Number.NEGATIVE_INFINITY);
-      expect(f64.isInfinite()).to.be.true;
-      expect(f64.isFinite()).to.be.false;
-      expect(f64.toNumber()).to.equal(Number.NEGATIVE_INFINITY);
-    });
-
-    it('should handle NaN', () => {
-      const f64 = F64.fromNumber(Number.NaN);
-      expect(f64.isNaN()).to.be.true;
-      expect(f64.isFinite()).to.be.false;
-      expect(Number.isNaN(f64.toNumber())).to.be.true;
-    });
-
-    it('should handle negative zero', () => {
-      const f64 = F64.fromNumber(-0);
-      expect(f64.toNumber()).to.equal(-0);
-      expect(Object.is(f64.toNumber(), -0)).to.be.true;
-    });
-  });
-
-  describe('Serialization and deserialization', () => {
-    it('should serialize and deserialize correctly', () => {
-      const original = 123.456789;
-      const f64 = F64.fromNumber(original);
-      const serialized = f64.serialize();
-      const deserialized = F64.deserialize(serialized);
-
-      expect(deserialized.toNumber()).to.equal(original);
-      expect(deserialized.equals(f64)).to.be.true;
-    });
-
-    it('should maintain exact binary representation for large numbers', () => {
-      const largeNum = 1.2345678901234567e100;
-      const f64 = F64.fromNumber(largeNum);
-      const serialized = f64.serialize();
-      const deserialized = F64.deserialize(serialized);
-
-      expect(deserialized.equals(f64)).to.be.true;
-      expect(deserialized.toHex()).to.equal(f64.toHex());
-    });
-
-    it('should handle round-trip with buffer', () => {
-      const testValues = [
-        0,
-        -0,
-        1,
-        -1,
-        Math.PI,
-        Math.E,
-        Number.MAX_SAFE_INTEGER,
-        Number.MIN_SAFE_INTEGER,
-        1.7976931348623157e308, // MAX_VALUE
-        2.2250738585072014e-308, // MIN_VALUE
-      ];
-
-      testValues.forEach((value) => {
-        const f64 = F64.fromNumber(value);
-        const buffer = f64.getBuffer();
-        const restored = new F64(buffer);
-        expect(restored.equals(f64)).to.be.true;
-      });
-    });
-  });
-
-  describe('Hex representation', () => {
-    it('should convert to and from hex correctly', () => {
-      const f64 = F64.fromNumber(123.456);
-      const hex = f64.toHex();
-      const restored = F64.fromHex(hex);
-
-      expect(restored.equals(f64)).to.be.true;
-      expect(hex).to.be.a('string');
-      expect(hex.length).to.equal(16); // 8 bytes = 16 hex chars
-    });
-
-    it('should handle special values in hex', () => {
-      const testValues = [
-        { value: 0, expectedHex: '0000000000000000' },
-        { value: 1, expectedHex: '3ff0000000000000' },
-        { value: -1, expectedHex: 'bff0000000000000' },
-        { value: Number.POSITIVE_INFINITY, expectedHex: '7ff0000000000000' },
-        { value: Number.NEGATIVE_INFINITY, expectedHex: 'fff0000000000000' },
-      ];
-
-      testValues.forEach(({ value, expectedHex }) => {
-        const f64 = F64.fromNumber(value);
-        expect(f64.toHex()).to.equal(expectedHex);
-      });
-    });
-  });
-
-  describe('Comparison operations', () => {
-    it('should compare F64 instances correctly', () => {
-      const a = F64.fromNumber(123.456);
-      const b = F64.fromNumber(123.456);
-      const c = F64.fromNumber(123.457);
-
-      expect(a.equals(b)).to.be.true;
-      expect(a.equals(c)).to.be.false;
-      expect(a.eq(123.456)).to.be.true;
-      expect(a.eq(123.457)).to.be.false;
-    });
-
-    it('should handle greater than comparisons', () => {
-      const a = F64.fromNumber(10);
-      const b = F64.fromNumber(5);
-
-      expect(a.gt(b)).to.be.true;
-      expect(b.gt(a)).to.be.false;
-      expect(a.gt(5)).to.be.true;
-      expect(a.gt(15)).to.be.false;
-    });
-
-    it('should handle less than comparisons', () => {
-      const a = F64.fromNumber(5);
-      const b = F64.fromNumber(10);
-
-      expect(a.lt(b)).to.be.true;
-      expect(b.lt(a)).to.be.false;
-      expect(a.lt(10)).to.be.true;
-      expect(a.lt(3)).to.be.false;
-    });
-  });
-
-  describe('Constants', () => {
-    it('should provide correct constant values', () => {
-      expect(F64.ZERO.toNumber()).to.equal(0);
-      expect(F64.ONE.toNumber()).to.equal(1);
-      expect(F64.NEGATIVE_ONE.toNumber()).to.equal(-1);
-      expect(F64.INFINITY.isInfinite()).to.be.true;
-      expect(F64.NEGATIVE_INFINITY.isInfinite()).to.be.true;
-      expect(F64.NaN.isNaN()).to.be.true;
-    });
-  });
-
-  describe('Precision test cases for DLC usage', () => {
-    it('should handle typical DLC payout curve parameters', () => {
-      // These are typical values that might appear in DLC payout curves
-      const testValues = [
-        1000000.0, // 1 million
-        50000.0, // Strike price
-        0.00000001, // Very small precision
-        1.7976931348623157e100, // Very large number
-        -50000.0, // Negative strike
-        0.0, // Zero
-        Math.PI * 1000000, // Irrational number scaled up
-      ];
-
-      testValues.forEach((value) => {
-        const f64 = F64.fromNumber(value);
-        const serialized = f64.serialize();
-        const deserialized = F64.deserialize(serialized);
-
-        expect(deserialized.equals(f64)).to.be.true;
-        expect(deserialized.toNumber()).to.equal(value);
-      });
-    });
-
-    it('should handle edge cases for financial calculations', () => {
-      // Test satoshi-level precision scaled to different units
-      const satoshi = 0.00000001; // 1 satoshi in BTC
-      const f64 = F64.fromNumber(satoshi);
-
-      expect(f64.toNumber()).to.equal(satoshi);
-      expect(f64.serialize().length).to.equal(8);
-    });
-  });
-
-  describe('Error handling', () => {
-    it('should throw error for invalid buffer size', () => {
-      expect(() => new F64(Buffer.alloc(4))).to.throw(
-        'F64 buffer must be exactly 8 bytes',
-      );
-      expect(() => new F64(Buffer.alloc(10))).to.throw(
-        'F64 buffer must be exactly 8 bytes',
-      );
-    });
-
-    it('should throw error for invalid hex string', () => {
-      expect(() => F64.fromHex('invalid')).to.throw(
-        'Hex string must represent exactly 8 bytes',
-      );
-      expect(() => F64.fromHex('1234')).to.throw(
-        'Hex string must represent exactly 8 bytes',
-      );
-    });
-  });
-});

package/.yalc/@node-dlc/messaging/__tests__/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "noEmit": true
-  },
-  "include": ["**/*.ts"],
-  "exclude": []
-}