@atomicfinance/types 4.1.3 → 4.1.5

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

@@ -0,0 +1,116 @@
+import { expect } from 'chai';
+
+import { OracleAnnouncement } from '../../lib/messages/OracleAnnouncement';
+import { SingleOracleInfo } from '../../lib/messages/OracleInfo';
+
+describe('SingleOracleInfo', () => {
+  describe('serialize', () => {
+    it('serializes', () => {
+      const instance = new SingleOracleInfo();
+
+      instance.length = BigInt(168);
+      instance.announcement = OracleAnnouncement.deserialize(
+        Buffer.from(
+          'fdd824' + // type oracle_announcement
+            'a4' + // length
+            'fab22628f6e2602e1671c286a2f63a9246794008627a1749639217f4214cb4a9' + // announcement_signature_r
+            '494c93d1a852221080f44f697adb4355df59eb339f6ba0f9b01ba661a8b108d4' + // announcement_signature_s
+            'da078bbb1d34e7729e38e2ae34236e776da121af442626fa31e31ae55a279a0b' + // oracle_public_key
+            'fdd822' + // type oracle_event
+            '40' + // length
+            '0001' + // nb_nonces
+            '3cfba011378411b20a5ab773cb95daab93e9bcd1e4cce44986a7dda84e01841b' + // oracle_nonces
+            '00000000' + // event_maturity_epoch
+            'fdd806' + // type enum_event_descriptor
+            '10' + // length
+            '0002' + // num_outcomes
+            '06' + // outcome_1_len
+            '64756d6d7931' + // outcome_1
+            '06' + // outcome_2_len
+            '64756d6d7932' + // outcome_2
+            '05' + // event_id_length
+            '64756d6d79', // event_id
+          'hex',
+        ),
+      );
+
+      expect(instance.serialize().toString("hex")).to.equal(
+        "fda712" + // type oracle_info
+        "a8" + // length
+        "fdd824" + // type oracle_announcement
+        "a4" + // length
+        "fab22628f6e2602e1671c286a2f63a9246794008627a1749639217f4214cb4a9" + // announcement_signature_r
+        "494c93d1a852221080f44f697adb4355df59eb339f6ba0f9b01ba661a8b108d4" + // announcement_signature_s
+        "da078bbb1d34e7729e38e2ae34236e776da121af442626fa31e31ae55a279a0b" + // oracle_public_key
+        "fdd822" + // type oracle_event
+        "40" + // length
+        "0001" + // nb_nonces
+        "3cfba011378411b20a5ab773cb95daab93e9bcd1e4cce44986a7dda84e01841b" + // oracle_nonces
+        "00000000" + // event_maturity_epoch
+        "fdd806" + // type enum_event_descriptor
+        "10" + // length
+        "0002" + // num_outcomes
+        "06" + // outcome_1_len
+        "64756d6d7931" + // outcome_1
+        "06" + // outcome_2_len
+        "64756d6d7932" + // outcome_2
+        "05" + // event_id_length
+        "64756d6d79" // event_id
+      ); // prettier-ignore
+    });
+  });
+
+  describe('deserialize', () => {
+    it('deserializes', () => {
+      const buf = Buffer.from(
+        "fda712" + // type oracle_info
+        "a8" + // length
+        "fdd824" + // type oracle_announcement
+        "a4" + // length
+        "fab22628f6e2602e1671c286a2f63a9246794008627a1749639217f4214cb4a9" + // announcement_signature_r
+        "494c93d1a852221080f44f697adb4355df59eb339f6ba0f9b01ba661a8b108d4" + // announcement_signature_s
+        "da078bbb1d34e7729e38e2ae34236e776da121af442626fa31e31ae55a279a0b" + // oracle_public_key
+        "fdd822" + // type oracle_event
+        "40" + // length
+        "0001" + // nb_nonces
+        "3cfba011378411b20a5ab773cb95daab93e9bcd1e4cce44986a7dda84e01841b" + // oracle_nonces
+        "00000000" + // event_maturity_epoch
+        "fdd806" + // type enum_event_descriptor
+        "10" + // length
+        "0002" + // num_outcomes
+        "06" + // outcome_1_len
+        "64756d6d7931" + // outcome_1
+        "06" + // outcome_2_len
+        "64756d6d7932" + // outcome_2
+        "05" + // event_id_length
+        "64756d6d79" // event_id
+        , "hex"
+      ); // prettier-ignore
+
+      const instance = SingleOracleInfo.deserialize(buf);
+
+      expect(instance.length).to.deep.equal(BigInt(168));
+      expect(instance.announcement.serialize().toString('hex')).to.equal(
+        'fdd824' + // type oracle_announcement
+          'a4' + // length
+          'fab22628f6e2602e1671c286a2f63a9246794008627a1749639217f4214cb4a9' + // announcement_signature_r
+          '494c93d1a852221080f44f697adb4355df59eb339f6ba0f9b01ba661a8b108d4' + // announcement_signature_s
+          'da078bbb1d34e7729e38e2ae34236e776da121af442626fa31e31ae55a279a0b' + // oracle_public_key
+          'fdd822' + // type oracle_event
+          '40' + // length
+          '0001' + // nb_nonces
+          '3cfba011378411b20a5ab773cb95daab93e9bcd1e4cce44986a7dda84e01841b' + // oracle_nonces
+          '00000000' + // event_maturity_epoch
+          'fdd806' + // type enum_event_descriptor
+          '10' + // length
+          '0002' + // num_outcomes
+          '06' + // outcome_1_len
+          '64756d6d7931' + // outcome_1
+          '06' + // outcome_2_len
+          '64756d6d7932' + // outcome_2
+          '05' + // event_id_length
+          '64756d6d79', // event_id
+      );
+    });
+  });
+});

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

@@ -0,0 +1,75 @@
+import { expect } from 'chai';
+
+import {
+  OrderAccept,
+  OrderAcceptContainer,
+} from '../../lib/messages/OrderAccept';
+import { OrderNegotiationFieldsV0 } from '../../lib/messages/OrderNegotiationFields';
+
+describe('OrderAccept', () => {
+  const tempOrderId = Buffer.from(
+    '960fb5f7960382ac7e76f3e24eb6b00059b1e68632a946843c22e1f65fdf216a',
+    'hex',
+  );
+
+  const tempOrderId2 = Buffer.from(
+    '0ef55fca0e3d0a95609ddce833d2f8ba6c2ee37bbe8583bc2068256c51a32914',
+    'hex',
+  );
+
+  describe('serialize', () => {
+    it('serializes', () => {
+      const instance = new OrderAccept();
+
+      instance.tempOrderId = tempOrderId;
+      instance.negotiationFields = new OrderNegotiationFieldsV0();
+
+      expect(instance.serialize().toString("hex")).to.equal(
+        "f534" + // type order_accept_v0
+        "960fb5f7960382ac7e76f3e24eb6b00059b1e68632a946843c22e1f65fdf216a" + // temp_order_id
+        "01" + // has negotiation fields (0x01)
+        "00" // SingleOrderNegotiationFields discriminator (0x00)
+      ); // prettier-ignore
+    });
+  });
+
+  describe('deserialize', () => {
+    it('deserializes', () => {
+      const buf = Buffer.from(
+        "f534" + // type order_accept_v0
+        "960fb5f7960382ac7e76f3e24eb6b00059b1e68632a946843c22e1f65fdf216a" + // temp_order_id
+        "01" + // has negotiation fields (0x01)
+        "00" // SingleOrderNegotiationFields discriminator (0x00)
+        , "hex"
+      ); // prettier-ignore
+
+      const instance = OrderAccept.deserialize(buf);
+
+      expect(instance.tempOrderId).to.deep.equal(tempOrderId);
+      expect(instance.negotiationFields.serialize().toString('hex')).to.equal(
+        '00',
+      );
+    });
+  });
+
+  describe('OrderAcceptContainer', () => {
+    it('should serialize and deserialize', () => {
+      const orderAccept = new OrderAccept();
+
+      orderAccept.tempOrderId = tempOrderId;
+      orderAccept.negotiationFields = new OrderNegotiationFieldsV0();
+
+      // swap payout and change spk to differentiate between dlcoffers
+      const orderAccept2 = OrderAccept.deserialize(orderAccept.serialize());
+      orderAccept2.tempOrderId = tempOrderId2;
+
+      const container = new OrderAcceptContainer();
+      container.addAccept(orderAccept);
+      container.addAccept(orderAccept2);
+
+      const instance = OrderAcceptContainer.deserialize(container.serialize());
+
+      expect(container.serialize()).to.deep.equal(instance.serialize());
+    });
+  });
+});

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

@@ -0,0 +1,299 @@
+import { expect } from 'chai';
+
+import { EnumeratedDescriptor } from '../../lib/messages/ContractDescriptor';
+import { SingleContractInfo } from '../../lib/messages/ContractInfo';
+import { EnumEventDescriptorV0 } from '../../lib/messages/EventDescriptor';
+import { OracleAnnouncement } from '../../lib/messages/OracleAnnouncement';
+import { OracleEvent } from '../../lib/messages/OracleEvent';
+import { SingleOracleInfo } from '../../lib/messages/OracleInfo';
+import {
+  DisjointOrderNegotiationFields,
+  OrderNegotiationFields,
+  SingleOrderNegotiationFields,
+} from '../../lib/messages/OrderNegotiationFields';
+import { OrderOffer } from '../../lib/messages/OrderOffer';
+
+describe('OrderNegotiationFields', () => {
+  describe('SingleOrderNegotiationFields', () => {
+    describe('serialize', () => {
+      it('serializes', () => {
+        const instance = new SingleOrderNegotiationFields();
+
+        expect(instance.serialize().toString('hex')).to.equal(
+          '00', // discriminator (0 for Single)
+        );
+      });
+    });
+
+    describe('deserialize', () => {
+      it('deserializes', () => {
+        const buf = Buffer.from(
+          "00" // discriminator (0 for Single)
+          , "hex"
+        ); // prettier-ignore
+
+        const instance = OrderNegotiationFields.deserialize(buf);
+
+        expect(instance).to.be.instanceof(SingleOrderNegotiationFields);
+        expect(instance.variant).to.equal('Single');
+        expect(instance.discriminator).to.equal(0);
+      });
+    });
+
+    describe('fromJSON', () => {
+      it('creates from JSON', () => {
+        const json = {
+          variant: 'Single',
+        };
+
+        const instance = OrderNegotiationFields.fromJSON(json);
+
+        expect(instance).to.be.instanceof(SingleOrderNegotiationFields);
+        expect(instance.variant).to.equal('Single');
+      });
+    });
+
+    describe('toJSON', () => {
+      it('converts to JSON', () => {
+        const instance = new SingleOrderNegotiationFields();
+        const json = instance.toJSON();
+
+        expect(json.variant).to.equal('Single');
+      });
+    });
+  });
+
+  describe('DisjointOrderNegotiationFields', () => {
+    describe('serialize', () => {
+      it('serializes', () => {
+        const instance = new DisjointOrderNegotiationFields();
+
+        // Create OrderOffer programmatically for simplified format
+        const orderOffer = new OrderOffer();
+
+        // Set required properties (simplified OrderOffer)
+        orderOffer.contractFlags = Buffer.from('00', 'hex');
+        orderOffer.chainHash = Buffer.from(
+          '06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f',
+          'hex',
+        );
+        orderOffer.temporaryContractId = Buffer.from(
+          '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+          'hex',
+        );
+
+        // Create a simple contract info with enumerated outcomes
+        const contractInfo = new SingleContractInfo();
+        contractInfo.totalCollateral = BigInt(200000000);
+
+        // Create enumerated contract descriptor
+        const contractDescriptor = new EnumeratedDescriptor();
+        contractDescriptor.outcomes = [
+          { outcome: 'win', localPayout: BigInt(0) },
+          { outcome: 'lose', localPayout: BigInt(200000000) },
+        ];
+
+        // Create oracle info (simplified)
+        const oracleInfo = new SingleOracleInfo();
+        const announcement = new OracleAnnouncement();
+        announcement.announcementSig = Buffer.alloc(64);
+        announcement.oraclePubkey = Buffer.alloc(32);
+
+        const oracleEvent = new OracleEvent();
+        oracleEvent.oracleNonces = [Buffer.alloc(32)];
+        oracleEvent.eventMaturityEpoch = 0;
+
+        // Use proper EnumEventDescriptorV0 for new dlcspecs PR #163 format
+        const eventDescriptor = new EnumEventDescriptorV0();
+        eventDescriptor.outcomes = ['win', 'lose'];
+        oracleEvent.eventDescriptor = eventDescriptor;
+        oracleEvent.eventId = 'test';
+
+        announcement.oracleEvent = oracleEvent;
+        oracleInfo.announcement = announcement;
+
+        contractInfo.contractDescriptor = contractDescriptor;
+        contractInfo.oracleInfo = oracleInfo;
+
+        orderOffer.contractInfo = contractInfo;
+        orderOffer.offerCollateralSatoshis = BigInt(100000000);
+        orderOffer.feeRatePerVb = BigInt(1);
+        orderOffer.cetLocktime = 100;
+        orderOffer.refundLocktime = 200;
+
+        instance.orderOffer = orderOffer;
+
+        // Test that it serializes without errors (simplified 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 DisjointOrderNegotiationFields();
+
+        // Create OrderOffer programmatically for simplified format
+        const orderOffer = new OrderOffer();
+
+        // Set required properties (simplified OrderOffer)
+        orderOffer.contractFlags = Buffer.from('00', 'hex');
+        orderOffer.chainHash = Buffer.from(
+          '06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f',
+          'hex',
+        );
+        orderOffer.temporaryContractId = Buffer.from(
+          '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+          'hex',
+        );
+
+        // Create a simple contract info with enumerated outcomes
+        const contractInfo = new SingleContractInfo();
+        contractInfo.totalCollateral = BigInt(200000000);
+
+        // Create enumerated contract descriptor
+        const contractDescriptor = new EnumeratedDescriptor();
+        contractDescriptor.outcomes = [
+          { outcome: 'win', localPayout: BigInt(0) },
+          { outcome: 'lose', localPayout: BigInt(200000000) },
+        ];
+
+        // Create oracle info (simplified)
+        const oracleInfo = new SingleOracleInfo();
+        const announcement = new OracleAnnouncement();
+        announcement.announcementSig = Buffer.alloc(64);
+        announcement.oraclePubkey = Buffer.alloc(32);
+
+        const oracleEvent = new OracleEvent();
+        oracleEvent.oracleNonces = [Buffer.alloc(32)];
+        oracleEvent.eventMaturityEpoch = 0;
+
+        // Use proper EnumEventDescriptorV0 for new dlcspecs PR #163 format
+        const eventDescriptor = new EnumEventDescriptorV0();
+        eventDescriptor.outcomes = ['win', 'lose'];
+        oracleEvent.eventDescriptor = eventDescriptor;
+        oracleEvent.eventId = 'test';
+
+        announcement.oracleEvent = oracleEvent;
+        oracleInfo.announcement = announcement;
+
+        contractInfo.contractDescriptor = contractDescriptor;
+        contractInfo.oracleInfo = oracleInfo;
+
+        orderOffer.contractInfo = contractInfo;
+        orderOffer.offerCollateralSatoshis = BigInt(100000000);
+        orderOffer.feeRatePerVb = BigInt(1);
+        orderOffer.cetLocktime = 100;
+        orderOffer.refundLocktime = 200;
+
+        originalInstance.orderOffer = orderOffer;
+
+        // Serialize and then deserialize to ensure round-trip consistency
+        const serialized = originalInstance.serialize();
+        const instance = OrderNegotiationFields.deserialize(serialized);
+
+        expect(instance).to.be.instanceof(DisjointOrderNegotiationFields);
+        expect(instance.variant).to.equal('Disjoint');
+        expect(instance.discriminator).to.equal(1);
+
+        const disjointInstance = instance as DisjointOrderNegotiationFields;
+        expect(disjointInstance.orderOffer).to.be.instanceof(OrderOffer);
+
+        // Test the simplified OrderOffer properties
+        const deserializedOffer = disjointInstance.orderOffer;
+        expect(deserializedOffer.chainHash).to.deep.equal(orderOffer.chainHash);
+        expect(deserializedOffer.temporaryContractId).to.deep.equal(
+          orderOffer.temporaryContractId,
+        );
+        expect(deserializedOffer.offerCollateralSatoshis).to.equal(
+          orderOffer.offerCollateralSatoshis,
+        );
+        expect(deserializedOffer.feeRatePerVb).to.equal(
+          orderOffer.feeRatePerVb,
+        );
+        expect(deserializedOffer.cetLocktime).to.equal(orderOffer.cetLocktime);
+        expect(deserializedOffer.refundLocktime).to.equal(
+          orderOffer.refundLocktime,
+        );
+      });
+    });
+
+    describe('fromJSON', () => {
+      it('throws error when orderOffer is missing', () => {
+        const json = {
+          variant: 'Disjoint',
+          // Missing orderOffer field
+        };
+
+        expect(() => OrderNegotiationFields.fromJSON(json)).to.throw(
+          'DisjointOrderNegotiationFields requires orderOffer field',
+        );
+      });
+    });
+
+    describe('toJSON', () => {
+      it('converts to JSON', () => {
+        const instance = new DisjointOrderNegotiationFields();
+
+        // Create a fully configured OrderOffer for testing
+        const orderOffer = new OrderOffer();
+        orderOffer.contractFlags = Buffer.from('00', 'hex');
+        orderOffer.chainHash = Buffer.from(
+          '06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f',
+          'hex',
+        );
+        orderOffer.temporaryContractId = Buffer.from(
+          '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+          'hex',
+        );
+
+        // Create a simple contract info with enumerated outcomes
+        const contractInfo = new SingleContractInfo();
+        contractInfo.totalCollateral = BigInt(200000000);
+
+        // Create enumerated contract descriptor
+        const contractDescriptor = new EnumeratedDescriptor();
+        contractDescriptor.outcomes = [
+          { outcome: 'win', localPayout: BigInt(0) },
+          { outcome: 'lose', localPayout: BigInt(200000000) },
+        ];
+
+        // Create oracle info (simplified)
+        const oracleInfo = new SingleOracleInfo();
+        const announcement = new OracleAnnouncement();
+        announcement.announcementSig = Buffer.alloc(64);
+        announcement.oraclePubkey = Buffer.alloc(32);
+
+        const oracleEvent = new OracleEvent();
+        oracleEvent.oracleNonces = [Buffer.alloc(32)];
+        oracleEvent.eventMaturityEpoch = 0;
+
+        // Use proper EnumEventDescriptorV0 for new dlcspecs PR #163 format
+        const eventDescriptor = new EnumEventDescriptorV0();
+        eventDescriptor.outcomes = ['win', 'lose'];
+        oracleEvent.eventDescriptor = eventDescriptor;
+        oracleEvent.eventId = 'test';
+
+        announcement.oracleEvent = oracleEvent;
+        oracleInfo.announcement = announcement;
+
+        contractInfo.contractDescriptor = contractDescriptor;
+        contractInfo.oracleInfo = oracleInfo;
+
+        orderOffer.contractInfo = contractInfo;
+        orderOffer.offerCollateralSatoshis = BigInt(100000000);
+        orderOffer.feeRatePerVb = BigInt(1);
+        orderOffer.cetLocktime = 100;
+        orderOffer.refundLocktime = 200;
+
+        instance.orderOffer = orderOffer;
+        const json = instance.toJSON();
+
+        expect(json.variant).to.equal('Disjoint');
+        expect(json.orderOffer).to.be.an('object');
+      });
+    });
+  });
+});

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

@@ -0,0 +1,121 @@
+import { expect } from 'chai';
+
+import { EnumeratedDescriptor } from '../../lib/messages/ContractDescriptor';
+import { SingleContractInfo } from '../../lib/messages/ContractInfo';
+import { EnumEventDescriptorV0 } from '../../lib/messages/EventDescriptor';
+import { OracleAnnouncement } from '../../lib/messages/OracleAnnouncement';
+import { OracleEvent } from '../../lib/messages/OracleEvent';
+import { SingleOracleInfo } from '../../lib/messages/OracleInfo';
+import { OrderOffer } from '../../lib/messages/OrderOffer';
+
+describe('OrderOffer', () => {
+  const chainHash = Buffer.from(
+    '06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f',
+    'hex',
+  );
+
+  describe('basic functionality', () => {
+    let instance: OrderOffer;
+
+    beforeEach(() => {
+      instance = new OrderOffer();
+
+      // Set required properties for simplified OrderOffer
+      instance.contractFlags = Buffer.from('00', 'hex');
+      instance.chainHash = chainHash;
+      instance.temporaryContractId = Buffer.from(
+        '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+        'hex',
+      );
+
+      // Create a simple contract info with enumerated outcomes
+      const contractInfo = new SingleContractInfo();
+      contractInfo.totalCollateral = BigInt(200000000);
+
+      // Create enumerated contract descriptor
+      const contractDescriptor = new EnumeratedDescriptor();
+      contractDescriptor.outcomes = [
+        { outcome: 'win', localPayout: BigInt(0) },
+        { outcome: 'lose', localPayout: BigInt(200000000) },
+      ];
+
+      // Create oracle info (simplified)
+      const oracleInfo = new SingleOracleInfo();
+      const announcement = new OracleAnnouncement();
+      announcement.announcementSig = Buffer.alloc(64);
+      announcement.oraclePubkey = Buffer.alloc(32);
+
+      const oracleEvent = new OracleEvent();
+      oracleEvent.oracleNonces = [Buffer.alloc(32)];
+      oracleEvent.eventMaturityEpoch = 0;
+
+      // Use proper EnumEventDescriptorV0 for new dlcspecs PR #163 format
+      const eventDescriptor = new EnumEventDescriptorV0();
+      eventDescriptor.outcomes = ['win', 'lose'];
+      oracleEvent.eventDescriptor = eventDescriptor;
+      oracleEvent.eventId = 'test';
+
+      announcement.oracleEvent = oracleEvent;
+      oracleInfo.announcement = announcement;
+
+      contractInfo.contractDescriptor = contractDescriptor;
+      contractInfo.oracleInfo = oracleInfo;
+
+      instance.contractInfo = contractInfo;
+      instance.offerCollateralSatoshis = BigInt(100000000);
+      instance.feeRatePerVb = BigInt(1);
+      instance.cetLocktime = 100;
+      instance.refundLocktime = 200;
+    });
+
+    it('creates and validates instance', () => {
+      expect(instance.chainHash).to.deep.equal(chainHash);
+      expect(instance.temporaryContractId).to.deep.equal(
+        Buffer.from(
+          '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+          'hex',
+        ),
+      );
+      expect(Number(instance.offerCollateralSatoshis)).to.equal(100000000);
+      expect(Number(instance.feeRatePerVb)).to.equal(1);
+      expect(instance.cetLocktime).to.equal(100);
+      expect(instance.refundLocktime).to.equal(200);
+    });
+
+    it('serializes and deserializes', () => {
+      const serialized = instance.serialize();
+      expect(serialized).to.be.instanceof(Buffer);
+      expect(serialized.length).to.be.greaterThan(0);
+
+      const deserialized = OrderOffer.deserialize(serialized);
+      expect(deserialized.chainHash).to.deep.equal(instance.chainHash);
+      expect(deserialized.temporaryContractId).to.deep.equal(
+        instance.temporaryContractId,
+      );
+      expect(deserialized.offerCollateralSatoshis).to.equal(
+        instance.offerCollateralSatoshis,
+      );
+      expect(deserialized.feeRatePerVb).to.equal(instance.feeRatePerVb);
+      expect(deserialized.cetLocktime).to.equal(instance.cetLocktime);
+      expect(deserialized.refundLocktime).to.equal(instance.refundLocktime);
+    });
+
+    it('converts to JSON', () => {
+      const json = instance.toJSON();
+      expect(json.type).to.equal(instance.type);
+      expect(json.chainHash).to.equal(instance.chainHash.toString('hex'));
+      expect(json.temporaryContractId).to.equal(
+        instance.temporaryContractId.toString('hex'),
+      );
+      expect(json.offerCollateralSatoshis).to.equal(
+        Number(instance.offerCollateralSatoshis),
+      );
+      expect(json.feeRatePerVb).to.equal(Number(instance.feeRatePerVb));
+      expect(json.cetLocktime).to.equal(instance.cetLocktime);
+      expect(json.refundLocktime).to.equal(instance.refundLocktime);
+    });
+  });
+
+  // TODO: Legacy tests need to be updated for dlcspecs PR #163 format
+  // The old hex test data uses the legacy TLV format and needs to be regenerated
+});

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

@@ -0,0 +1,75 @@
+import { expect } from 'chai';
+
+import { OrderPositionInfo } from '../../lib/messages/OrderPositionInfo';
+
+describe('OrderPositionInfo', () => {
+  let instance: OrderPositionInfo;
+
+  beforeEach(() => {
+    instance = new OrderPositionInfo();
+    instance.shiftForFees = 'offeror';
+    instance.fees = BigInt(10000);
+    instance.instrumentName = 'BTC-24SEP23-23500-P';
+    instance.contractSize = BigInt(1e8);
+    instance.direction = 'buy';
+    instance.price = BigInt(100000);
+  });
+
+  describe('deserialize', () => {
+    it('should correctly deserialize data', () => {
+      const buf = Buffer.from(
+        'fdf53a2e010000000000002710134254432d323453455032332d32333530302d500000000005f5e1000100000000000186a00000',
+        'hex',
+      );
+      const result = OrderPositionInfo.deserialize(buf);
+
+      expect(result.shiftForFees).to.equal('offeror');
+      expect(result.fees).to.equal(BigInt(10000));
+    });
+
+    it('should throw an error for invalid shiftForFees value', () => {
+      const buf = Buffer.from('fdf53a09030000000000002710', 'hex');
+      expect(() => OrderPositionInfo.deserialize(buf)).to.throw(
+        'Invalid shift for fees value: 3',
+      );
+    });
+
+    it('should deserialize with no instrument name or other parameters', () => {
+      const buf = Buffer.from('fdf53a2e010000000000002710', 'hex');
+      const result = OrderPositionInfo.deserialize(buf);
+
+      expect(result.shiftForFees).to.equal('offeror');
+      expect(result.fees).to.equal(BigInt(10000));
+    });
+  });
+
+  describe('serialize', () => {
+    it('should correctly serialize data', () => {
+      instance.shiftForFees = 'offeror';
+      instance.fees = BigInt(10000);
+
+      const result = instance.serialize();
+      expect(result.toString('hex')).to.equal(
+        'fdf53a30010000000000002710134254432d323453455032332d32333530302d500000000005f5e1000100000000000186a00000',
+      );
+    });
+  });
+
+  describe('toJSON', () => {
+    it('should correctly convert to JSON', () => {
+      instance.shiftForFees = 'offeror';
+      instance.fees = BigInt(10000);
+
+      const result = instance.toJSON();
+      expect(result).to.deep.equal({
+        type: instance.type,
+        shiftForFees: instance.shiftForFees,
+        fees: Number(instance.fees),
+        instrumentName: instance.instrumentName,
+        direction: instance.direction,
+        price: Number(instance.price),
+        extraPrecision: instance.extraPrecision,
+      });
+    });
+  });
+});