@atomicfinance/types 3.6.1 → 4.0.0

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

@@ -0,0 +1,220 @@
+import { F64 } from '../../lib/serialize/F64';
+import { expect } from 'chai';
+
+import {
+  HyperbolaPayoutCurvePiece,
+  PayoutCurvePiece,
+  PolynomialPayoutCurvePiece,
+} from '../../lib/messages/PayoutCurvePiece';
+
+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

@@ -0,0 +1,101 @@
+import { F64 } from '../../lib/serialize/F64';
+import { expect } from 'chai';
+
+import { HyperbolaPayoutCurvePiece } from '../../lib/messages/PayoutCurvePiece';
+import { PayoutFunction } from '../../lib/messages/PayoutFunction';
+
+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

@@ -0,0 +1,75 @@
+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

@@ -0,0 +1,260 @@
+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

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