@atomicfinance/bitcoin-dlc-provider 4.0.0 → 4.0.2

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

@@ -1,4 +1,3 @@
-import { F64 } from '../../lib/serialize/F64';
 import { expect } from 'chai';
 
 import {
@@ -9,6 +8,7 @@ import {
 import { HyperbolaPayoutCurvePiece } from '../../lib/messages/PayoutCurvePiece';
 import { PayoutFunction } from '../../lib/messages/PayoutFunction';
 import { RoundingIntervals } from '../../lib/messages/RoundingIntervals';
+import { F64 } from '../../lib/serialize/F64';
 
 describe('ContractDescriptor', () => {
   describe('EnumeratedDescriptor', () => {
@@ -93,6 +93,7 @@ describe('ContractDescriptor', () => {
           { outcome: outcomeThree, localPayout: payoutThree },
         ];
 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const json = instance.toJSON() as any; // Cast to any to access the wrapped structure
 
         // Check that the JSON has the proper enum format structure
@@ -238,6 +239,7 @@ describe('ContractDescriptor', () => {
         ];
         instance.roundingIntervals = roundingIntervals;
 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const json = instance.toJSON() as any; // Cast to any to access the wrapped structure
 
         // Check that the JSON has the proper structure

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

@@ -1,4 +1,3 @@
-import { F64 } from '../../lib/serialize/F64';
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 
@@ -20,6 +19,7 @@ import { SingleOracleInfo } from '../../lib/messages/OracleInfo';
 import { HyperbolaPayoutCurvePiece } from '../../lib/messages/PayoutCurvePiece';
 import { PayoutFunction } from '../../lib/messages/PayoutFunction';
 import { RoundingIntervals } from '../../lib/messages/RoundingIntervals';
+import { F64 } from '../../lib/serialize/F64';
 
 chai.use(chaiAsPromised);
 const expect = chai.expect;

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

@@ -216,6 +216,78 @@ describe('DlcAccept', () => {
           instance.validate();
         }).to.throw(Error);
       });
+
+      it('should allow single funded DLCs with zero acceptCollateral', () => {
+        // Set up single funded DLC with zero collateral
+        instance.acceptCollateral = BigInt(0);
+        instance.fundingInputs = [];
+        instance.markAsSingleFunded();
+
+        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.acceptCollateral = BigInt(300000000);
+        instance.fundingInputs = [];
+        instance.markAsSingleFunded();
+
+        expect(function () {
+          instance.validate();
+        }).to.throw(
+          'For single funded DLCs, fundingAmount must be at least acceptCollateral',
+        );
+      });
+    });
+
+    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.markAsSingleFunded();
+
+        expect(instance.isSingleFunded()).to.be.true;
+      });
+
+      it('should not identify regular DLCs as single funded', () => {
+        // Default test setup has non-zero acceptCollateral
+        expect(instance.isSingleFunded()).to.be.false;
+      });
+
+      it('should mark DLC as single funded', () => {
+        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 with zero collateral
+        instance.acceptCollateral = BigInt(0);
+
+        // Serialize and deserialize
+        const serialized = instance.serialize();
+        const deserialized = DlcAccept.deserialize(serialized);
+
+        // Should auto-detect as single funded
+        expect(deserialized.singleFunded).to.be.true;
+        expect(deserialized.isSingleFunded()).to.be.true;
+      });
+
+      it('should not auto-detect regular DLCs as single funded', () => {
+        // Default test setup has non-zero acceptCollateral
+        const serialized = instance.serialize();
+        const deserialized = DlcAccept.deserialize(serialized);
+
+        // Should not be detected as single funded
+        expect(deserialized.singleFunded).to.be.false;
+        expect(deserialized.isSingleFunded()).to.be.false;
+      });
     });
   });
 

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

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

@@ -6,7 +6,7 @@ import {
   BatchFundingGroup,
   OrderIrcInfoV0,
   OrderMetadataV0,
-  OrderPositionInfoV0,
+  OrderPositionInfo,
 } from '../../lib';
 import { EnumeratedDescriptor } from '../../lib/messages/ContractDescriptor';
 import { SingleContractInfo } from '../../lib/messages/ContractInfo';
@@ -112,30 +112,6 @@ describe('DlcOffer', () => {
     'hex',
   );
 
-  // Use round-trip testing approach for new dlcspecs PR #163 format
-  function createTestDlcOfferHex(): Buffer {
-    const testInstance = new DlcOffer();
-    testInstance.protocolVersion = PROTOCOL_VERSION;
-    testInstance.contractFlags = contractFlags;
-    testInstance.chainHash = chainHash;
-    testInstance.temporaryContractId = temporaryContractId;
-    testInstance.contractInfo = createTestContractInfo();
-    testInstance.fundingPubkey = fundingPubkey;
-    testInstance.payoutSpk = payoutSpk;
-    testInstance.payoutSerialId = BigInt(11555292);
-    testInstance.offerCollateral = BigInt(99999999);
-    testInstance.fundingInputs = [FundingInput.deserialize(fundingInput)];
-    testInstance.changeSpk = changeSpk;
-    testInstance.changeSerialId = BigInt(2008045);
-    testInstance.fundOutputSerialId = BigInt(5411962);
-    testInstance.feeRatePerVb = BigInt(1);
-    testInstance.cetLocktime = 100;
-    testInstance.refundLocktime = 200;
-    return testInstance.serialize();
-  }
-
-  const dlcOfferHex = createTestDlcOfferHex();
-
   beforeEach(() => {
     instance = new DlcOffer();
     instance.protocolVersion = PROTOCOL_VERSION; // New field
@@ -185,7 +161,7 @@ describe('DlcOffer', () => {
       });
 
       it('serializes with positioninfo', () => {
-        const positionInfo = new OrderPositionInfoV0();
+        const positionInfo = new OrderPositionInfo();
         positionInfo.shiftForFees = 'acceptor';
         positionInfo.fees = BigInt(1000);
 
@@ -230,7 +206,7 @@ describe('DlcOffer', () => {
       });
 
       it('deserializes with positioninfo', () => {
-        const positionInfo = new OrderPositionInfoV0();
+        const positionInfo = new OrderPositionInfo();
         positionInfo.shiftForFees = 'acceptor';
         positionInfo.fees = BigInt(1000);
 
@@ -239,7 +215,7 @@ describe('DlcOffer', () => {
         const serialized = instance.serialize();
         const deserialized = DlcOffer.deserialize(serialized);
 
-        expect(deserialized.positionInfo).to.be.instanceof(OrderPositionInfoV0);
+        expect(deserialized.positionInfo).to.be.instanceof(OrderPositionInfo);
         expect(deserialized.positionInfo?.serialize()).to.deep.equal(
           positionInfo.serialize(),
         );
@@ -409,25 +385,111 @@ describe('DlcOffer', () => {
         }).to.throw(Error);
       });
 
-      it('should throw if totalCollateral <= offerCollateral', () => {
-        instance.contractInfo.totalCollateral = BigInt(200000000);
-        instance.offerCollateral = BigInt(200000000);
+      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(200000001);
+        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.throw(Error);
+        }).to.not.throw(Error);
       });
 
-      it('should throw if funding amount less than offer collateral', () => {
-        instance.offerCollateral = BigInt(3e8);
+      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(Error);
+        }).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;
       });
     });
   });
@@ -504,7 +566,7 @@ describe('DlcOffer', () => {
       ircInfo.nick = 'test-nick'; // Required property
       ircInfo.pubKey = Buffer.alloc(33); // Required property
 
-      const positionInfo = new OrderPositionInfoV0();
+      const positionInfo = new OrderPositionInfo();
       positionInfo.shiftForFees = 'acceptor';
       positionInfo.fees = BigInt(6930);
 

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

@@ -2,82 +2,167 @@ import { Sequence, Tx } from '@node-dlc/bitcoin';
 import { StreamReader } from '@node-dlc/bufio';
 import { expect } from 'chai';
 
+import { DlcInput } from '../../lib/messages/DlcInput';
 import { FundingInput } from '../../lib/messages/FundingInput';
 
 describe('FundingInput', () => {
-  let instance: FundingInput;
-
-  const type = Buffer.from('fda714', 'hex');
-  const length = Buffer.from('3f', 'hex');
-  const inputSerialID = Buffer.from('000000000000dae8', 'hex');
-  const prevTxLen = Buffer.from('0029', 'hex');
-  const prevTx = Buffer.from(
-    '02000000000100c2eb0b00000000160014e70dcc9ffa7ff84c889c9e79b218708bae3bc95800000000',
-    'hex',
-  );
-  const prevTxVout = Buffer.from('00000000', 'hex');
-  const sequence = Buffer.from('ffffffff', 'hex');
-  const maxWitnessLen = Buffer.from('006b', 'hex');
-  const redeemScriptLen = Buffer.from('0000', 'hex');
-
-  const fundingInputHex = Buffer.concat([
-    type,
-    length,
-    inputSerialID,
-    prevTxLen,
-    prevTx,
-    prevTxVout,
-    sequence,
-    maxWitnessLen,
-    redeemScriptLen,
-  ]);
-
-  beforeEach(() => {
-    instance = new FundingInput();
-
-    instance.length = BigInt(63);
-    instance.inputSerialId = BigInt(56040);
-    instance.prevTx = Tx.decode(StreamReader.fromBuffer(prevTx));
-    instance.prevTxVout = 0;
-    instance.sequence = Sequence.default();
-    instance.maxWitnessLen = 107;
-    instance.redeemScript = Buffer.from('', 'hex');
-  });
+  describe('serialization/deserialization', () => {
+    it('should deserialize and serialize FundingInput message', () => {
+      const fundingInput = FundingInput.fromJSON({
+        inputSerialId: 1,
+        prevTx:
+          '0200000001f58f85b356ad5bb5b6d0ef3eb863be8a6cb95e08e1e9e92885b4b22e7e51eb9d0000000000ffffffff01008c8647000000002200201234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef00000000',
+        prevTxVout: 0,
+        sequence: 4294967295,
+        maxWitnessLen: 108,
+        redeemScript: '',
+      });
+
+      const serialized = fundingInput.serialize();
+      const deserialized = FundingInput.deserialize(serialized);
 
-  describe('serialize', () => {
-    it('serializes', () => {
-      expect(instance.serialize().toString('hex')).to.equal(
-        fundingInputHex.toString('hex'),
+      expect(deserialized.inputSerialId).to.equal(fundingInput.inputSerialId);
+      expect(deserialized.prevTxVout).to.equal(fundingInput.prevTxVout);
+      expect(deserialized.sequence.value).to.equal(fundingInput.sequence.value);
+      expect(deserialized.maxWitnessLen).to.equal(fundingInput.maxWitnessLen);
+      expect(deserialized.redeemScript).to.deep.equal(
+        fundingInput.redeemScript,
       );
     });
-  });
 
-  describe('deserialize', () => {
-    it('deserializes', () => {
-      const instance = FundingInput.deserialize(fundingInputHex);
-
-      expect(Number(instance.length)).to.equal(63);
-      expect(Number(instance.inputSerialId)).to.equal(56040);
-      expect(instance.prevTx.serialize()).to.deep.equal(prevTx);
-      expect(instance.prevTxVout).to.equal(0);
-      expect(instance.sequence.value).to.equal(4294967295);
-      expect(instance.maxWitnessLen).to.equal(107);
-      expect(instance.redeemScript).to.deep.equal(Buffer.from('', 'hex'));
+    it('should handle FundingInput with optional DlcInput', () => {
+      const fundingInputWithDlc = FundingInput.fromJSON({
+        inputSerialId: 1,
+        prevTx:
+          '0200000001f58f85b356ad5bb5b6d0ef3eb863be8a6cb95e08e1e9e92885b4b22e7e51eb9d0000000000ffffffff01008c8647000000002200201234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef00000000',
+        prevTxVout: 0,
+        sequence: 4294967295,
+        maxWitnessLen: 108,
+        redeemScript: '',
+        dlcInput: {
+          localFundPubkey:
+            '023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb',
+          remoteFundPubkey:
+            '025476c2e83188368da1ff3e292e7acafcdb3566bb0ad253f62fc70f07aeee6357',
+          contractId:
+            '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+        },
+      });
+
+      // Test full serialize/deserialize
+      const serialized = fundingInputWithDlc.serialize();
+      const deserialized = FundingInput.deserialize(serialized);
+
+      expect(deserialized.dlcInput).to.not.be.undefined;
+      expect(deserialized.dlcInput!.localFundPubkey).to.deep.equal(
+        fundingInputWithDlc.dlcInput!.localFundPubkey,
+      );
+      expect(deserialized.dlcInput!.remoteFundPubkey).to.deep.equal(
+        fundingInputWithDlc.dlcInput!.remoteFundPubkey,
+      );
+      expect(deserialized.dlcInput!.contractId).to.deep.equal(
+        fundingInputWithDlc.dlcInput!.contractId,
+      );
+
+      // Test body serialize/deserialize (used in DlcOffer)
+      const serializedBody = fundingInputWithDlc.serializeBody();
+      const deserializedBody = FundingInput.deserializeBody(serializedBody);
+
+      expect(deserializedBody.dlcInput).to.not.be.undefined;
+      expect(deserializedBody.dlcInput!.localFundPubkey).to.deep.equal(
+        fundingInputWithDlc.dlcInput!.localFundPubkey,
+      );
+      expect(deserializedBody.dlcInput!.remoteFundPubkey).to.deep.equal(
+        fundingInputWithDlc.dlcInput!.remoteFundPubkey,
+      );
+      expect(deserializedBody.dlcInput!.contractId).to.deep.equal(
+        fundingInputWithDlc.dlcInput!.contractId,
+      );
+    });
+
+    it('should handle FundingInput without DlcInput', () => {
+      const fundingInputWithoutDlc = FundingInput.fromJSON({
+        inputSerialId: 1,
+        prevTx:
+          '0200000001f58f85b356ad5bb5b6d0ef3eb863be8a6cb95e08e1e9e92885b4b22e7e51eb9d0000000000ffffffff01008c8647000000002200201234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef00000000',
+        prevTxVout: 0,
+        sequence: 4294967295,
+        maxWitnessLen: 108,
+        redeemScript: '',
+      });
+
+      // Test full serialize/deserialize
+      const serialized = fundingInputWithoutDlc.serialize();
+      const deserialized = FundingInput.deserialize(serialized);
+
+      expect(deserialized.dlcInput).to.be.undefined;
+
+      // Test body serialize/deserialize (used in DlcOffer)
+      const serializedBody = fundingInputWithoutDlc.serializeBody();
+      const deserializedBody = FundingInput.deserializeBody(serializedBody);
+
+      expect(deserializedBody.dlcInput).to.be.undefined;
+    });
+
+    it('should use rust-dlc optional format (0x00/0x01 prefix)', () => {
+      // Test without DlcInput - should have 0x00 byte at the end
+      const fundingInputWithoutDlc = FundingInput.fromJSON({
+        inputSerialId: 1,
+        prevTx:
+          '0200000001f58f85b356ad5bb5b6d0ef3eb863be8a6cb95e08e1e9e92885b4b22e7e51eb9d0000000000ffffffff01008c8647000000002200201234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef00000000',
+        prevTxVout: 0,
+        sequence: 4294967295,
+        maxWitnessLen: 108,
+        redeemScript: '',
+      });
+
+      const serializedBody = fundingInputWithoutDlc.serializeBody();
+      // Last byte should be 0x00 indicating no DLC input
+      expect(serializedBody[serializedBody.length - 1]).to.equal(0x00);
+
+      // Test with DlcInput - should have 0x01 byte followed by DLC input data
+      const fundingInputWithDlc = FundingInput.fromJSON({
+        inputSerialId: 1,
+        prevTx:
+          '0200000001f58f85b356ad5bb5b6d0ef3eb863be8a6cb95e08e1e9e92885b4b22e7e51eb9d0000000000ffffffff01008c8647000000002200201234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef00000000',
+        prevTxVout: 0,
+        sequence: 4294967295,
+        maxWitnessLen: 108,
+        redeemScript: '',
+        dlcInput: {
+          localFundPubkey:
+            '023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb',
+          remoteFundPubkey:
+            '025476c2e83188368da1ff3e292e7acafcdb3566bb0ad253f62fc70f07aeee6357',
+          contractId:
+            '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+        },
+      });
+
+      const serializedBodyWithDlc = fundingInputWithDlc.serializeBody();
+
+      // Find where the DLC input optional marker should be
+      // It should be at: 8 (inputSerialId) + 1-9 (prevTx length) + prevTx.length + 4 (prevTxVout) + 4 (sequence) + 2 (maxWitnessLen) + 2 (redeemScript.length) + redeemScript.length
+      const dlcInputMarkerIndex =
+        serializedBodyWithDlc.length - (33 + 33 + 32 + 1); // DLC input data + marker (contractId is 32 bytes)
+      expect(serializedBodyWithDlc[dlcInputMarkerIndex]).to.equal(0x01);
     });
   });
 
   describe('validate', () => {
     it('should ensure inputs are segwit', () => {
-      instance.prevTx = Tx.decode(
-        StreamReader.fromBuffer(
-          Buffer.from(
-            '02000000000100c2eb0b00000000160014e70dcc9ffa7ff84c889c9e79b218708bae3bc95800000000', // has no inputs
-            'hex',
-          ),
-        ),
-      );
+      const fundingInput = FundingInput.fromJSON({
+        inputSerialId: 1,
+        prevTx:
+          '02000000000100c2eb0b00000000160014e70dcc9ffa7ff84c889c9e79b218708bae3bc95800000000', // has no inputs
+        prevTxVout: 0,
+        sequence: 4294967295,
+        maxWitnessLen: 108,
+        redeemScript: '',
+      });
+
       expect(function () {
-        instance.validate();
+        fundingInput.validate();
       }).to.throw(Error);
     });
   });