@atomicfinance/bitcoin-dlc-provider 4.2.7 → 4.2.8

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

@@ -1,111 +0,0 @@
-import { expect } from 'chai';
-
-import { DlcInput } from '../../lib/messages/DlcInput';
-
-describe('DlcInput', () => {
-  let dlcInput: DlcInput;
-
-  const testData = {
-    localFundPubkey:
-      '023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb',
-    remoteFundPubkey:
-      '025476c2e83188368da1ff3e292e7acafcdb3566bb0ad253f62fc70f07aeee6357',
-    contractId:
-      '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef', // 32-byte contract ID
-  };
-
-  beforeEach(() => {
-    dlcInput = DlcInput.fromJSON(testData);
-  });
-
-  describe('fromJSON', () => {
-    it('should create DlcInput from JSON with camelCase', () => {
-      const input = DlcInput.fromJSON({
-        localFundPubkey: testData.localFundPubkey,
-        remoteFundPubkey: testData.remoteFundPubkey,
-        contractId: testData.contractId,
-      });
-
-      expect(input.localFundPubkey).to.be.instanceOf(Buffer);
-      expect(input.remoteFundPubkey).to.be.instanceOf(Buffer);
-      expect(input.contractId).to.be.instanceOf(Buffer);
-      expect(input.contractId.toString('hex')).to.equal(testData.contractId);
-    });
-
-    it('should create DlcInput from JSON with snake_case', () => {
-      const input = DlcInput.fromJSON({
-        local_fund_pubkey: testData.localFundPubkey,
-        remote_fund_pubkey: testData.remoteFundPubkey,
-        contract_id: testData.contractId,
-      });
-
-      expect(input.localFundPubkey).to.be.instanceOf(Buffer);
-      expect(input.remoteFundPubkey).to.be.instanceOf(Buffer);
-      expect(input.contractId).to.be.instanceOf(Buffer);
-      expect(input.contractId.toString('hex')).to.equal(testData.contractId);
-    });
-  });
-
-  describe('toJSON', () => {
-    it('should convert DlcInput to JSON', () => {
-      const json = dlcInput.toJSON();
-
-      expect(json.localFundPubkey).to.equal(testData.localFundPubkey);
-      expect(json.remoteFundPubkey).to.equal(testData.remoteFundPubkey);
-      expect(json.contractId).to.equal(testData.contractId);
-    });
-  });
-
-  describe('serialize/deserialize', () => {
-    it('should serialize and deserialize correctly', () => {
-      const serialized = dlcInput.serialize();
-      const deserialized = DlcInput.deserialize(serialized);
-
-      expect(deserialized.localFundPubkey).to.deep.equal(
-        dlcInput.localFundPubkey,
-      );
-      expect(deserialized.remoteFundPubkey).to.deep.equal(
-        dlcInput.remoteFundPubkey,
-      );
-      expect(deserialized.contractId).to.deep.equal(dlcInput.contractId);
-    });
-
-    it('should serialize and deserialize body correctly', () => {
-      const serialized = dlcInput.serializeBody();
-      const deserialized = DlcInput.deserializeBody(serialized);
-
-      expect(deserialized.localFundPubkey).to.deep.equal(
-        dlcInput.localFundPubkey,
-      );
-      expect(deserialized.remoteFundPubkey).to.deep.equal(
-        dlcInput.remoteFundPubkey,
-      );
-      expect(deserialized.contractId).to.deep.equal(dlcInput.contractId);
-    });
-  });
-
-  describe('validate', () => {
-    it('should validate correct DlcInput', () => {
-      expect(() => dlcInput.validate()).to.not.throw();
-    });
-
-    it('should throw error for missing localFundPubkey', () => {
-      dlcInput.localFundPubkey = null as any;
-      expect(() => dlcInput.validate()).to.throw('localFundPubkey is required');
-    });
-
-    it('should throw error for missing remoteFundPubkey', () => {
-      dlcInput.remoteFundPubkey = null as any;
-      expect(() => dlcInput.validate()).to.throw(
-        'remoteFundPubkey is required',
-      );
-    });
-
-    it('should throw error for invalid contractId', () => {
-      dlcInput.contractId = Buffer.alloc(16); // Wrong size - should be 32 bytes
-      expect(() => dlcInput.validate()).to.throw(
-        'contractId must be a 32-byte buffer',
-      );
-    });
-  });
-});

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

@@ -1,589 +0,0 @@
-import { Value } from '@node-dlc/bitcoin';
-import { BitcoinNetworks } from 'bitcoin-networks';
-import { expect } from 'chai';
-
-import {
-  BatchFundingGroup,
-  OrderIrcInfoV0,
-  OrderMetadataV0,
-  OrderPositionInfo,
-} from '../../lib';
-import { EnumeratedDescriptor } from '../../lib/messages/ContractDescriptor';
-import { SingleContractInfo } from '../../lib/messages/ContractInfo';
-import {
-  DlcOffer,
-  DlcOfferContainer,
-  LOCKTIME_THRESHOLD,
-} from '../../lib/messages/DlcOffer';
-import { EnumEventDescriptorV0 } from '../../lib/messages/EventDescriptor';
-import { FundingInput } from '../../lib/messages/FundingInput';
-import { OracleAnnouncement } from '../../lib/messages/OracleAnnouncement';
-import { OracleEvent } from '../../lib/messages/OracleEvent';
-import { SingleOracleInfo } from '../../lib/messages/OracleInfo';
-import { MessageType, PROTOCOL_VERSION } from '../../lib/MessageType';
-
-describe('DlcOffer', () => {
-  const bitcoinNetwork = BitcoinNetworks.bitcoin_regtest;
-
-  let instance: DlcOffer;
-  const contractFlags = Buffer.from('00', 'hex');
-  const chainHash = Buffer.from(
-    '06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f',
-    'hex',
-  );
-  const temporaryContractId = Buffer.from(
-    '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef', // 32 bytes
-    'hex',
-  );
-
-  // Create ContractInfo programmatically for new dlcspecs PR #163 format
-  function createTestContractInfo(): SingleContractInfo {
-    const contractInfo = new SingleContractInfo();
-    contractInfo.totalCollateral = BigInt(200000000);
-
-    // Create enumerated contract descriptor
-    const contractDescriptor = new EnumeratedDescriptor();
-    contractDescriptor.outcomes = [
-      { outcome: 'win', localPayout: BigInt(0) },
-      { outcome: 'draw', localPayout: BigInt(153666723) },
-      { outcome: 'lose', localPayout: BigInt(200000000) },
-    ];
-
-    // Create oracle info (simplified)
-    const oracleInfo = new SingleOracleInfo();
-    const announcement = new OracleAnnouncement();
-    announcement.announcementSig = Buffer.from(
-      'fab22628f6e2602e1671c286a2f63a9246794008627a1749639217f4214cb4a9494c93d1a852221080f44f697adb4355df59eb339f6ba0f9b01ba661a8b108d4',
-      'hex',
-    );
-    announcement.oraclePubkey = Buffer.from(
-      'da078bbb1d34e7729e38e2ae34236e776da121af442626fa31e31ae55a279a0b',
-      'hex',
-    );
-
-    const oracleEvent = new OracleEvent();
-    oracleEvent.oracleNonces = [
-      Buffer.from(
-        '3cfba011378411b20a5ab773cb95daab93e9bcd1e4cce44986a7dda84e01841b',
-        'hex',
-      ),
-    ];
-    oracleEvent.eventMaturityEpoch = 0;
-    // Use proper EnumEventDescriptorV0 for new dlcspecs PR #163 format
-    const eventDescriptor = new EnumEventDescriptorV0();
-    eventDescriptor.outcomes = ['dummy1', 'dummy2'];
-    oracleEvent.eventDescriptor = eventDescriptor;
-    oracleEvent.eventId = 'dummy';
-
-    announcement.oracleEvent = oracleEvent;
-    oracleInfo.announcement = announcement;
-
-    contractInfo.contractDescriptor = contractDescriptor;
-    contractInfo.oracleInfo = oracleInfo;
-
-    return contractInfo;
-  }
-
-  const fundingPubkey = Buffer.from(
-    '0327efea09ff4dfb13230e887cbab8821d5cc249c7ff28668c6633ff9f4b4c08e3',
-    'hex',
-  );
-
-  const payoutSpk = Buffer.from(
-    '00142bbdec425007dc360523b0294d2c64d2213af498',
-    'hex',
-  );
-
-  const fundingInput = Buffer.from(
-    'fda714' +
-      '3f' + // length
-      '000000000000fa51' + // input_serial_id
-      '0029' + // prevtx_len
-      '02000000000100c2eb0b00000000160014369d63a82ed846f4d47ad55045e594ab95539d6000000000' + // prevtx
-      '00000000' + // prevtx_vout
-      'ffffffff' + // sequence
-      '006b' + // max_witness_len
-      '0000', // redeemscript_len
-    'hex',
-  );
-
-  const changeSpk = Buffer.from(
-    '0014afa16f949f3055f38bd3a73312bed00b61558884',
-    'hex',
-  );
-
-  beforeEach(() => {
-    instance = new DlcOffer();
-    instance.protocolVersion = PROTOCOL_VERSION; // New field
-    instance.contractFlags = contractFlags;
-    instance.chainHash = chainHash;
-    instance.temporaryContractId = temporaryContractId; // New field
-    instance.contractInfo = createTestContractInfo();
-    instance.fundingPubkey = fundingPubkey;
-    instance.payoutSpk = payoutSpk;
-    instance.payoutSerialId = BigInt(11555292);
-    instance.offerCollateral = BigInt(99999999);
-    instance.fundingInputs = [FundingInput.deserialize(fundingInput)];
-    instance.changeSpk = changeSpk;
-    instance.changeSerialId = BigInt(2008045);
-    instance.fundOutputSerialId = BigInt(5411962);
-    instance.feeRatePerVb = BigInt(1);
-    instance.cetLocktime = 100;
-    instance.refundLocktime = 200;
-  });
-
-  describe('deserialize', () => {
-    it('should throw if incorrect type', () => {
-      // Create buffer with incorrect type (0x123 instead of 42778)
-      const incorrectTypeBuffer = Buffer.concat([
-        Buffer.from([0x01, 0x23]), // incorrect type
-        instance.serialize().slice(2), // rest of the data
-      ]);
-      expect(function () {
-        DlcOffer.deserialize(incorrectTypeBuffer);
-      }).to.throw(Error);
-    });
-
-    it('has correct type', () => {
-      expect(DlcOffer.deserialize(instance.serialize()).type).to.equal(
-        instance.type,
-      );
-    });
-  });
-
-  describe('DlcOffer', () => {
-    describe('serialize', () => {
-      it('serializes', () => {
-        // 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);
-      });
-
-      it('serializes with positioninfo', () => {
-        const positionInfo = new OrderPositionInfo();
-        positionInfo.shiftForFees = 'acceptor';
-        positionInfo.fees = BigInt(1000);
-
-        instance.positionInfo = positionInfo;
-
-        // 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', () => {
-        // Use round-trip testing approach for consistency
-        const serialized = instance.serialize();
-        const deserialized = DlcOffer.deserialize(serialized);
-
-        expect(deserialized.protocolVersion).to.equal(PROTOCOL_VERSION);
-        expect(deserialized.contractFlags).to.deep.equal(contractFlags);
-        expect(deserialized.chainHash).to.deep.equal(chainHash);
-        expect(deserialized.temporaryContractId).to.deep.equal(
-          temporaryContractId,
-        );
-        expect(deserialized.fundingPubkey).to.deep.equal(fundingPubkey);
-        expect(deserialized.payoutSpk).to.deep.equal(payoutSpk);
-        expect(Number(deserialized.payoutSerialId)).to.equal(11555292);
-        expect(Number(deserialized.offerCollateral)).to.equal(99999999);
-        expect(deserialized.changeSpk).to.deep.equal(changeSpk);
-        expect(Number(deserialized.changeSerialId)).to.equal(2008045);
-        expect(Number(deserialized.fundOutputSerialId)).to.equal(5411962);
-        expect(Number(deserialized.feeRatePerVb)).to.equal(1);
-        expect(deserialized.cetLocktime).to.equal(100);
-        expect(deserialized.refundLocktime).to.equal(200);
-      });
-
-      it('has correct type', () => {
-        const serialized = instance.serialize();
-        expect(DlcOffer.deserialize(serialized).type).to.equal(
-          MessageType.DlcOffer,
-        );
-      });
-
-      it('deserializes with positioninfo', () => {
-        const positionInfo = new OrderPositionInfo();
-        positionInfo.shiftForFees = 'acceptor';
-        positionInfo.fees = BigInt(1000);
-
-        instance.positionInfo = positionInfo;
-
-        const serialized = instance.serialize();
-        const deserialized = DlcOffer.deserialize(serialized);
-
-        expect(deserialized.positionInfo).to.be.instanceof(OrderPositionInfo);
-        expect(deserialized.positionInfo?.serialize()).to.deep.equal(
-          positionInfo.serialize(),
-        );
-      });
-    });
-
-    describe('toJSON', () => {
-      it('converts to JSON', async () => {
-        const json = instance.toJSON();
-        // Basic structure validation - detailed field testing is done in cross-language tests
-        expect(json).to.be.an('object');
-        expect(json.protocolVersion).to.be.a('number');
-        expect(json.temporaryContractId).to.be.a('string');
-        expect(json.contractFlags).to.be.a('number');
-        expect(json.chainHash).to.be.a('string');
-        expect(json.contractInfo).to.be.an('object');
-      });
-    });
-
-    describe('getAddresses', () => {
-      it('should get addresses', () => {
-        const expectedFundingAddress =
-          'bcrt1qayylp95g2tzq2a60x2l7f8mclnx5y2jxm0yt09';
-        const expectedChangeAddress =
-          'bcrt1q47skl9ylxp2l8z7n5ue390kspds4tzyy5jdxs8';
-        const expectedPayoutAddress =
-          'bcrt1q9w77csjsqlwrvpfrkq556try6gsn4ayc2kn0kl';
-
-        // Use round-trip approach for consistency
-        const serialized = instance.serialize();
-        const deserialized = DlcOffer.deserialize(serialized);
-
-        const {
-          fundingAddress,
-          changeAddress,
-          payoutAddress,
-        } = deserialized.getAddresses(bitcoinNetwork);
-
-        expect(fundingAddress).to.equal(expectedFundingAddress);
-        expect(changeAddress).to.equal(expectedChangeAddress);
-        expect(payoutAddress).to.equal(expectedPayoutAddress);
-      });
-    });
-
-    describe('validate', () => {
-      it('should throw if protocol version is invalid', () => {
-        instance.protocolVersion = 999;
-        expect(function () {
-          instance.validate();
-        }).to.throw('Unsupported protocol version: 999, expected: 1');
-      });
-
-      it('should throw if temporaryContractId is invalid', () => {
-        instance.temporaryContractId = Buffer.from('invalid', 'hex');
-        expect(function () {
-          instance.validate();
-        }).to.throw('temporaryContractId must be 32 bytes');
-      });
-
-      it('should throw if payout_spk is invalid', () => {
-        instance.payoutSpk = Buffer.from('fff', 'hex');
-        expect(function () {
-          instance.validate();
-        }).to.throw(Error);
-      });
-      it('should throw if change_spk is invalid', () => {
-        instance.changeSpk = Buffer.from('fff', 'hex');
-        expect(function () {
-          instance.validate();
-        }).to.throw(Error);
-      });
-      it('should throw if fundingpubkey is not a valid pubkey', () => {
-        instance.fundingPubkey = Buffer.from(
-          '00f003aa11f2a97b6be755a86b9fd798a7451c670196a5245b7bae971306b7c87e',
-          'hex',
-        );
-        expect(function () {
-          instance.validate();
-        }).to.throw(Error);
-      });
-      it('should throw if fundingpubkey is not in compressed secp256k1 format', () => {
-        instance.fundingPubkey = Buffer.from(
-          '045162991c7299223973cabc99ef5087d7bab2dafe61f78e5388b2f9492f7978123f51fd05ef0693790c0b2d4f30848363a3f3fbcf2bd53a05ba0fd5bb708c3184',
-          'hex',
-        );
-        expect(function () {
-          instance.validate();
-        }).to.throw(Error);
-      });
-      it('should throw if offerCollateral is less than 1000', () => {
-        instance.offerCollateral = BigInt(999);
-        expect(function () {
-          instance.validate();
-        }).to.throw(Error);
-
-        // boundary check
-        instance.offerCollateral = BigInt(1000);
-        expect(function () {
-          instance.validate();
-        }).to.not.throw(Error);
-      });
-
-      it('should throw if cet_locktime is less than 0', () => {
-        instance.cetLocktime = -1;
-        expect(() => {
-          instance.validate();
-        }).to.throw('cet_locktime must be greater than or equal to 0');
-      });
-
-      it('should throw if refund_locktime is less than 0', () => {
-        instance.refundLocktime = -1;
-        expect(() => {
-          instance.validate();
-        }).to.throw('refund_locktime must be greater than or equal to 0');
-      });
-
-      it('should throw if cet_locktime and refund_locktime are not in same units', () => {
-        instance.cetLocktime = 100;
-        instance.refundLocktime = LOCKTIME_THRESHOLD + 200;
-        expect(function () {
-          instance.validate();
-        }).to.throw(Error);
-      });
-
-      it('should not throw if cet_locktime and refund_locktime are in same units', () => {
-        instance.cetLocktime = 100;
-        instance.refundLocktime = 200;
-        expect(function () {
-          instance.validate();
-        }).to.not.throw(Error);
-
-        instance.cetLocktime = LOCKTIME_THRESHOLD + 100;
-        instance.refundLocktime = LOCKTIME_THRESHOLD + 200;
-        expect(function () {
-          instance.validate();
-        }).to.not.throw(Error);
-      });
-
-      it('should throw if cet_locktime >= refund_locktime', () => {
-        instance.cetLocktime = 200;
-        instance.refundLocktime = 100;
-        expect(function () {
-          instance.validate();
-        }).to.throw(Error);
-
-        instance.cetLocktime = 100;
-        instance.refundLocktime = 100;
-        expect(function () {
-          instance.validate();
-        }).to.throw(Error);
-      });
-
-      it('should throw if inputSerialIds arent unique', () => {
-        instance.fundingInputs = [
-          FundingInput.deserialize(fundingInput),
-          FundingInput.deserialize(fundingInput),
-        ];
-        expect(function () {
-          instance.validate();
-        }).to.throw(Error);
-      });
-
-      it('should throw if changeSerialId  == fundOutputSerialId', () => {
-        instance.changeSerialId = instance.fundOutputSerialId;
-        expect(function () {
-          instance.validate();
-        }).to.throw(Error);
-      });
-
-      it('should throw if funding amount less than offer collateral', () => {
-        instance.offerCollateral = BigInt(3e8);
-        expect(function () {
-          instance.validate();
-        }).to.throw(Error);
-      });
-
-      it('should allow single funded DLCs when totalCollateral equals offerCollateral', () => {
-        // Set up single funded DLC
-        instance.contractInfo.totalCollateral = BigInt(99999999);
-        instance.offerCollateral = BigInt(99999999);
-        instance.markAsSingleFunded();
-
-        expect(function () {
-          instance.validate();
-        }).to.not.throw(Error);
-      });
-
-      it('should throw if marked as single funded but collateral amounts do not match', () => {
-        instance.contractInfo.totalCollateral = BigInt(200000000);
-        instance.offerCollateral = BigInt(99999999);
-
-        expect(function () {
-          instance.markAsSingleFunded();
-        }).to.throw(
-          'Cannot mark as single funded: totalCollateral (200000000) must equal offerCollateral (99999999)',
-        );
-      });
-
-      it('should validate single funded DLC funding amount correctly', () => {
-        // Set up single funded DLC
-        instance.contractInfo.totalCollateral = BigInt(99999999);
-        instance.offerCollateral = BigInt(99999999);
-        instance.markAsSingleFunded();
-
-        // Funding amount should be at least totalCollateral for single funded DLCs
-        expect(function () {
-          instance.validate();
-        }).to.not.throw(Error);
-      });
-
-      it('should throw if single funded DLC funding amount is insufficient', () => {
-        // Set up single funded DLC with insufficient funding
-        instance.contractInfo.totalCollateral = BigInt(300000000);
-        instance.offerCollateral = BigInt(300000000);
-        instance.markAsSingleFunded();
-
-        expect(function () {
-          instance.validate();
-        }).to.throw(
-          'For single funded DLCs, fundingAmount must be at least totalCollateral',
-        );
-      });
-    });
-
-    describe('Single Funded DLC Methods', () => {
-      it('should correctly identify single funded DLCs', () => {
-        // Initially not single funded
-        expect(instance.isSingleFunded()).to.be.false;
-
-        // Mark as single funded
-        instance.contractInfo.totalCollateral = BigInt(99999999);
-        instance.offerCollateral = BigInt(99999999);
-        instance.markAsSingleFunded();
-
-        expect(instance.isSingleFunded()).to.be.true;
-      });
-
-      it('should auto-detect single funded DLCs based on collateral amounts', () => {
-        // Set equal collateral amounts
-        instance.contractInfo.totalCollateral = BigInt(99999999);
-        instance.offerCollateral = BigInt(99999999);
-
-        // Should be detected as single funded even without explicit flag
-        expect(instance.isSingleFunded()).to.be.true;
-      });
-
-      it('should not identify regular DLCs as single funded', () => {
-        // Default test setup has different collateral amounts
-        expect(instance.isSingleFunded()).to.be.false;
-      });
-
-      it('should mark DLC as single funded when collateral amounts are equal', () => {
-        instance.contractInfo.totalCollateral = BigInt(99999999);
-        instance.offerCollateral = BigInt(99999999);
-
-        expect(function () {
-          instance.markAsSingleFunded();
-        }).to.not.throw(Error);
-
-        expect(instance.singleFunded).to.be.true;
-      });
-
-      it('should auto-detect single funded DLCs during deserialization', () => {
-        // Set up single funded DLC
-        instance.contractInfo.totalCollateral = BigInt(99999999);
-        instance.offerCollateral = BigInt(99999999);
-
-        // Serialize and deserialize
-        const serialized = instance.serialize();
-        const deserialized = DlcOffer.deserialize(serialized);
-
-        // Should auto-detect as single funded
-        expect(deserialized.singleFunded).to.be.true;
-        expect(deserialized.isSingleFunded()).to.be.true;
-      });
-    });
-  });
-
-  describe('DlcOfferContainer', () => {
-    it('should serialize and deserialize', () => {
-      // Create test offers using round-trip approach
-      const dlcOffer = createTestDlcOffer();
-      const dlcOffer2 = createTestDlcOffer();
-      // swap payout and change spk to differentiate between dlcoffers
-      dlcOffer2.payoutSpk = dlcOffer.changeSpk;
-      dlcOffer2.changeSpk = dlcOffer.payoutSpk;
-
-      const container = new DlcOfferContainer();
-      container.addOffer(dlcOffer);
-      container.addOffer(dlcOffer2);
-
-      const serialized = container.serialize();
-      const deserialized = DlcOfferContainer.deserialize(serialized);
-
-      expect(deserialized.serialize()).to.deep.equal(container.serialize());
-    });
-
-    function createTestDlcOffer(): DlcOffer {
-      const testOffer = new DlcOffer();
-      testOffer.protocolVersion = PROTOCOL_VERSION;
-      testOffer.contractFlags = contractFlags;
-      testOffer.chainHash = chainHash;
-      testOffer.temporaryContractId = temporaryContractId;
-      testOffer.contractInfo = createTestContractInfo();
-      testOffer.fundingPubkey = fundingPubkey;
-      testOffer.payoutSpk = payoutSpk;
-      testOffer.payoutSerialId = BigInt(11555292);
-      testOffer.offerCollateral = BigInt(99999999);
-      testOffer.fundingInputs = [FundingInput.deserialize(fundingInput)];
-      testOffer.changeSpk = changeSpk;
-      testOffer.changeSerialId = BigInt(2008045);
-      testOffer.fundOutputSerialId = BigInt(5411962);
-      testOffer.feeRatePerVb = BigInt(1);
-      testOffer.cetLocktime = 100;
-      testOffer.refundLocktime = 200;
-      return testOffer;
-    }
-  });
-
-  describe('TLVs', () => {
-    it('should deserialize with all TLV types present', () => {
-      const dlcOffer = new DlcOffer();
-
-      dlcOffer.protocolVersion = PROTOCOL_VERSION;
-      dlcOffer.contractFlags = contractFlags;
-      dlcOffer.chainHash = chainHash;
-      dlcOffer.temporaryContractId = temporaryContractId;
-      dlcOffer.contractInfo = createTestContractInfo();
-      dlcOffer.fundingPubkey = fundingPubkey;
-      dlcOffer.payoutSpk = payoutSpk;
-      dlcOffer.payoutSerialId = BigInt(29829);
-      dlcOffer.offerCollateral = BigInt(16649967);
-      dlcOffer.fundingInputs = [FundingInput.deserialize(fundingInput)];
-      dlcOffer.changeSpk = changeSpk;
-      dlcOffer.changeSerialId = BigInt(94880);
-      dlcOffer.fundOutputSerialId = BigInt(44394);
-      dlcOffer.feeRatePerVb = BigInt(45);
-      dlcOffer.cetLocktime = 1712689645;
-      dlcOffer.refundLocktime = 1719255498;
-
-      // Create TLV components programmatically for new dlcspecs PR #163 format
-      const metadata = new OrderMetadataV0();
-      metadata.offerId = 'test-offer-id'; // Required property
-      metadata.createdAt = 1640995200; // Optional but set for consistency
-      metadata.goodTill = 1640995260; // Optional but set for consistency
-
-      const ircInfo = new OrderIrcInfoV0();
-      ircInfo.nick = 'test-nick'; // Required property
-      ircInfo.pubKey = Buffer.alloc(33); // Required property
-
-      const positionInfo = new OrderPositionInfo();
-      positionInfo.shiftForFees = 'acceptor';
-      positionInfo.fees = BigInt(6930);
-
-      const batchFundingGroup = new BatchFundingGroup();
-      batchFundingGroup.eventIds = ['test-event']; // Required property
-      batchFundingGroup.allocatedCollateral = Value.fromSats(BigInt(1000)); // Required property
-
-      dlcOffer.metadata = metadata;
-      dlcOffer.ircInfo = ircInfo;
-      dlcOffer.positionInfo = positionInfo;
-      dlcOffer.batchFundingGroups = [batchFundingGroup];
-
-      // Test round-trip consistency with TLVs
-      const serialized = dlcOffer.serialize();
-      const deserialized = DlcOffer.deserialize(serialized);
-
-      expect(deserialized.toJSON()).to.deep.equal(dlcOffer.toJSON());
-    });
-  });
-});