@atomicfinance/types 4.2.8 → 4.3.1

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

@@ -0,0 +1,118 @@
+import { expect } from 'chai';
+
+import { CetAdaptorSignatures } from '../../lib/messages/CetAdaptorSignatures';
+import { DlcSign, DlcSignContainer } from '../../lib/messages/DlcSign';
+import { FundingSignatures } from '../../lib/messages/FundingSignatures';
+import { ScriptWitnessV0 } from '../../lib/messages/ScriptWitnessV0';
+
+describe('DlcSign', () => {
+  let instance: DlcSign;
+
+  const contractId = Buffer.from(
+    'c1c79e1e9e2fa2840b2514902ea244f39eb3001a4037a52ea43c797d4f841269',
+    'hex',
+  );
+
+  const contractId2 = Buffer.from(
+    '4946fe172de3778fa660b9858d0624044f4494667757f50388abe6fe523376e8',
+    'hex',
+  );
+
+  const refundSignature = Buffer.alloc(64, 0x01); // Simple test signature
+
+  beforeEach(() => {
+    instance = new DlcSign();
+
+    instance.protocolVersion = 1; // Set protocol version
+    instance.contractId = contractId;
+
+    // Create test CET adaptor signatures
+    instance.cetAdaptorSignatures = new CetAdaptorSignatures();
+    instance.cetAdaptorSignatures.sigs = [
+      {
+        encryptedSig: Buffer.alloc(65),
+        dleqProof: Buffer.alloc(97),
+      },
+    ];
+
+    instance.refundSignature = refundSignature;
+
+    // Create test funding signatures using proper ScriptWitnessV0 objects
+    instance.fundingSignatures = new FundingSignatures();
+
+    const witness1 = new ScriptWitnessV0();
+    witness1.length = 71;
+    witness1.witness = Buffer.alloc(71);
+
+    const witness2 = new ScriptWitnessV0();
+    witness2.length = 33;
+    witness2.witness = Buffer.alloc(33);
+
+    instance.fundingSignatures.witnessElements = [[witness1, witness2]];
+  });
+
+  describe('deserialize', () => {
+    it('has correct type', () => {
+      expect(DlcSign.deserialize(instance.serialize()).type).to.equal(
+        instance.type,
+      );
+    });
+  });
+
+  describe('DlcSign', () => {
+    describe('serialize', () => {
+      it('serializes', () => {
+        // Test round-trip consistency instead of exact hex match
+        const serialized = instance.serialize();
+        const deserialized = DlcSign.deserialize(serialized);
+
+        expect(deserialized.contractId).to.deep.equal(instance.contractId);
+        expect(deserialized.refundSignature).to.deep.equal(
+          instance.refundSignature,
+        );
+        expect(deserialized.cetAdaptorSignatures.sigs.length).to.equal(
+          instance.cetAdaptorSignatures.sigs.length,
+        );
+      });
+    });
+
+    describe('deserialize', () => {
+      it('deserializes', () => {
+        // Test round-trip consistency
+        const serialized = instance.serialize();
+        const deserialized = DlcSign.deserialize(serialized);
+
+        expect(deserialized.contractId).to.deep.equal(contractId);
+        expect(deserialized.refundSignature).to.deep.equal(refundSignature);
+      });
+    });
+
+    describe('toJSON', () => {
+      it('convert 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.contractId).to.be.a('string');
+        expect(json.refundSignature).to.be.a('string');
+      });
+    });
+  });
+
+  describe('DlcSignContainer', () => {
+    it('should serialize and deserialize', () => {
+      // Create two distinct signs
+      const dlcSign = instance;
+      const dlcSign2 = new DlcSign();
+      Object.assign(dlcSign2, dlcSign);
+      dlcSign2.contractId = contractId2;
+
+      const container = new DlcSignContainer();
+      container.addSign(dlcSign);
+      container.addSign(dlcSign2);
+
+      const deserialized = DlcSignContainer.deserialize(container.serialize());
+
+      expect(container.serialize()).to.deep.equal(deserialized.serialize());
+    });
+  });
+});

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

@@ -0,0 +1,157 @@
+import { Tx } from '@node-dlc/bitcoin';
+import { StreamReader } from '@node-dlc/bufio';
+import { expect } from 'chai';
+
+import { DlcTransactions } from '../../lib/messages/DlcTransactions';
+import { MessageType } from '../../lib/MessageType';
+
+describe('DlcTransactions', () => {
+  const contractId = Buffer.from(
+    '6010a7e779c5079493ad06abbcaca06b8a04d501890cd724104d1df6e20968e8',
+    'hex',
+  );
+
+  const fundTx = Tx.decode(
+    StreamReader.fromBuffer(
+      Buffer.from(
+        '02000000022f76d0509ca3ad7559e0f45489aa2efea70f8657e3cdfce6b8194019012370a10100000000ffffffffd295f485f2d181eb06ae6d5e62007db4bfe52ad31e6e1a5c576e2f396bbda9470100000000ffffffff03aed10e000000000022002034e21059bdd0c5d1d3f2d03075b33ec89c9a018a855158a6c605d921e41db8fd88f6dc0b00000000160014ccd5d5d8249b94c4381c478907c2ad81f0c35227f2b1eb0b000000001600149212ec2ed940f3cd93bfbd16c5f817ee079243bb00000000',
+        'hex',
+      ),
+    ),
+  );
+
+  const fundTxVout = 0;
+
+  const refundTx = Tx.decode(
+    StreamReader.fromBuffer(
+      Buffer.from(
+        '02000000017f19d63285e628c1b0702cd1a11df6fe4d2acc75595dc52fb8d2842b13aa56220000000000feffffff023ac30e000000000016001442795b177d2bd1d538d379af766a979e4056d43cd007000000000000160014f9e38ab4d13bc36fd4df0381e355d9f7b50d69808c106460',
+        'hex',
+      ),
+    ),
+  );
+
+  const cet0 = Tx.decode(
+    StreamReader.fromBuffer(
+      Buffer.from(
+        '02000000017f19d63285e628c1b0702cd1a11df6fe4d2acc75595dc52fb8d2842b13aa56220000000000ffffffff010acb0e000000000016001442795b177d2bd1d538d379af766a979e4056d43c00000000',
+        'hex',
+      ),
+    ),
+  );
+
+  const cet1 = Tx.decode(
+    StreamReader.fromBuffer(
+      Buffer.from(
+        '02000000017f19d63285e628c1b0702cd1a11df6fe4d2acc75595dc52fb8d2842b13aa56220000000000ffffffff010acb0e000000000016001442795b177d2bd1d538d379af766a979e4056d43c00000000',
+        'hex',
+      ),
+    ),
+  );
+
+  describe('serialize', () => {
+    it('serializes', () => {
+      const instance = new DlcTransactions();
+
+      instance.contractId = contractId;
+      instance.fundTx = fundTx;
+      instance.fundTxVout = fundTxVout;
+      instance.refundTx = refundTx;
+      instance.cets.push(cet0);
+      instance.cets.push(cet1);
+
+      expect(instance.serialize().toString("hex")).to.equal(
+        "ef2e" + // type
+        "6010a7e779c5079493ad06abbcaca06b8a04d501890cd724104d1df6e20968e8" + // contract_id
+        "00c5" + // fund_tx_len
+        "02000000022f76d0509ca3ad7559e0f45489aa2efea70f8657e3cdfce6b8194019012370a10100000000ffffffffd295f485f2d181eb06ae6d5e62007db4bfe52ad31e6e1a5c576e2f396bbda9470100000000ffffffff03aed10e000000000022002034e21059bdd0c5d1d3f2d03075b33ec89c9a018a855158a6c605d921e41db8fd88f6dc0b00000000160014ccd5d5d8249b94c4381c478907c2ad81f0c35227f2b1eb0b000000001600149212ec2ed940f3cd93bfbd16c5f817ee079243bb00000000" +
+        "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
+        "0071" + // refund_tx_len
+        "02000000017f19d63285e628c1b0702cd1a11df6fe4d2acc75595dc52fb8d2842b13aa56220000000000feffffff023ac30e000000000016001442795b177d2bd1d538d379af766a979e4056d43cd007000000000000160014f9e38ab4d13bc36fd4df0381e355d9f7b50d69808c106460" +
+        "02" + // num_cets
+        "0052" + // cet_0_len
+        "02000000017f19d63285e628c1b0702cd1a11df6fe4d2acc75595dc52fb8d2842b13aa56220000000000ffffffff010acb0e000000000016001442795b177d2bd1d538d379af766a979e4056d43c00000000" +
+        "0052" + // cet_1_len
+        "02000000017f19d63285e628c1b0702cd1a11df6fe4d2acc75595dc52fb8d2842b13aa56220000000000ffffffff010acb0e000000000016001442795b177d2bd1d538d379af766a979e4056d43c00000000" +
+        "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+      ); // prettier-ignore
+    });
+  });
+
+  describe('deserialize', () => {
+    const buf = Buffer.from(
+      "ef2e" + // type
+      "6010a7e779c5079493ad06abbcaca06b8a04d501890cd724104d1df6e20968e8" + // contract_id
+      "00c5" + // fund_tx_len
+      "02000000022f76d0509ca3ad7559e0f45489aa2efea70f8657e3cdfce6b8194019012370a10100000000ffffffffd295f485f2d181eb06ae6d5e62007db4bfe52ad31e6e1a5c576e2f396bbda9470100000000ffffffff03aed10e000000000022002034e21059bdd0c5d1d3f2d03075b33ec89c9a018a855158a6c605d921e41db8fd88f6dc0b00000000160014ccd5d5d8249b94c4381c478907c2ad81f0c35227f2b1eb0b000000001600149212ec2ed940f3cd93bfbd16c5f817ee079243bb00000000" +
+      "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
+      "0071" + // refund_tx_len
+      "02000000017f19d63285e628c1b0702cd1a11df6fe4d2acc75595dc52fb8d2842b13aa56220000000000feffffff023ac30e000000000016001442795b177d2bd1d538d379af766a979e4056d43cd007000000000000160014f9e38ab4d13bc36fd4df0381e355d9f7b50d69808c106460" +
+      "02" + // num_cets
+      "0052" + // cet_0_len
+      "02000000017f19d63285e628c1b0702cd1a11df6fe4d2acc75595dc52fb8d2842b13aa56220000000000ffffffff010acb0e000000000016001442795b177d2bd1d538d379af766a979e4056d43c00000000" +
+      "0052" + // cet_1_len
+      "02000000017f19d63285e628c1b0702cd1a11df6fe4d2acc75595dc52fb8d2842b13aa56220000000000ffffffff010acb0e000000000016001442795b177d2bd1d538d379af766a979e4056d43c00000000" +
+      "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+      , "hex"
+    ); // prettier-ignore
+
+    it('deserializes', () => {
+      const unknownInstance = DlcTransactions.deserialize(buf);
+
+      if (unknownInstance.type === MessageType.DlcTransactions) {
+        const instance = unknownInstance as DlcTransactions;
+
+        expect(instance.fundTx.serialize()).to.deep.equal(fundTx.serialize());
+        expect(Number(instance.fundTxVout)).to.deep.equal(Number(fundTxVout));
+        expect(instance.refundTx.serialize()).to.deep.equal(
+          refundTx.serialize(),
+        );
+        expect(instance.cets[0].serialize()).to.deep.equal(cet0.serialize());
+        expect(instance.cets[1].serialize()).to.deep.equal(cet1.serialize());
+      } else {
+        throw Error('DlcTransactions Incorrect type');
+      }
+    });
+
+    it('deserializes without cets', () => {
+      // Set parseCets to false
+      const unknownInstance = DlcTransactions.deserialize(buf, false);
+
+      if (unknownInstance.type === MessageType.DlcTransactions) {
+        const instance = unknownInstance as DlcTransactions;
+
+        expect(instance.fundTx.serialize()).to.deep.equal(fundTx.serialize());
+        expect(Number(instance.fundTxVout)).to.deep.equal(Number(fundTxVout));
+        expect(instance.refundTx.serialize()).to.deep.equal(
+          refundTx.serialize(),
+        );
+        expect(instance.cets.length).to.equal(1);
+      } else {
+        throw Error('DlcTransactions Incorrect type');
+      }
+    });
+  });
+
+  describe('toJSON', () => {
+    it('convert to JSON', async () => {
+      const instance = new DlcTransactions();
+
+      instance.contractId = contractId;
+      instance.fundTx = fundTx;
+      instance.fundTxVout = fundTxVout;
+      instance.refundTx = refundTx;
+      instance.cets.push(cet0);
+      instance.cets.push(cet1);
+
+      const jsonInstance = instance.toJSON();
+
+      expect(jsonInstance.contractId).to.equal(contractId.toString('hex'));
+      expect(jsonInstance.fundTx).to.equal(fundTx.serialize().toString('hex'));
+      expect(jsonInstance.refundTx).to.equal(
+        refundTx.serialize().toString('hex'),
+      );
+      expect(jsonInstance.cets[0]).to.equal(cet0.serialize().toString('hex'));
+    });
+  });
+});

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

@@ -0,0 +1,50 @@
+import { expect } from 'chai';
+
+import { EnumEventDescriptor } from '../../lib/messages/EventDescriptor';
+
+describe('EnumEventDescriptorV0', () => {
+  const outcomeOne = Buffer.from('64756d6d7931', 'hex').toString();
+
+  const outcomeTwo = Buffer.from('64756d6d7932', 'hex').toString();
+
+  describe('serialize', () => {
+    it('serializes', () => {
+      const instance = new EnumEventDescriptor();
+
+      instance.length = BigInt(16);
+      instance.outcomes = [outcomeOne, outcomeTwo];
+
+      expect(instance.serialize().toString("hex")).to.equal(
+        "fdd806" + // type
+        "10" + // length
+        "0002" + // num_outcomes
+        "06" + // outcome_1_len
+        "64756d6d7931" + // outcome_1
+        "06" + // outcome_2_len
+        "64756d6d7932" // outcome_2
+      ); // prettier-ignore
+    });
+  });
+
+  describe('deserialize', () => {
+    it('deserializes', () => {
+      const buf = Buffer.from(
+        "fdd806" + // type
+        "10" + // length
+        "0002" + // num_outcomes
+        "06" + // outcome_1_len
+        "64756d6d7931" + // outcome_1
+        "06" + // outcome_2_len
+        "64756d6d7932" // outcome_2
+        , "hex"
+      ); // prettier-ignore
+
+      const instance = EnumEventDescriptor.deserialize(buf);
+
+      expect(Number(instance.outcomes[0].length)).to.equal(outcomeOne.length);
+      expect(instance.outcomes[0]).to.deep.equal(outcomeOne);
+      expect(Number(instance.outcomes[1].length)).to.equal(outcomeTwo.length);
+      expect(instance.outcomes[1]).to.deep.equal(outcomeTwo);
+    });
+  });
+});

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

@@ -0,0 +1,93 @@
+import { expect } from 'chai';
+
+import {
+  DigitDecompositionEventDescriptor,
+  EventDescriptor,
+  MessageType,
+} from '../../lib';
+
+describe('EventDescriptorV0', () => {
+  const instance = new DigitDecompositionEventDescriptor();
+  instance.base = 2;
+  instance.isSigned = false;
+  instance.unit = 'BTC-USD';
+  instance.precision = 0;
+  instance.nbDigits = 17;
+
+  describe('serialize', () => {
+    it('serializes', () => {
+      expect(instance.serialize().toString("hex")).to.equal(
+        "fdd80a" + // type event_descriptor
+        "11" + // length
+        "0002" + // base
+        "00" + // isSigned
+        "07" + // unitLen
+        "4254432d555344" + // unit
+        "00000000" + // precision
+        "0011" // nbDigits
+      ); // prettier-ignore
+    });
+  });
+
+  describe('deserialize', () => {
+    it('deserializes', () => {
+      const unknownInstance = EventDescriptor.deserialize(
+        Buffer.from(
+          'fdd80a' + // type contract_descriptor
+            '11' + // length
+            '0002' + // base
+            '00' + // isSigned
+            '07' + // unitLen
+            '4254432d555344' + // unit
+            '00000000' + // precision
+            '0011', // nbDigits
+          'hex',
+        ),
+      ); // prettier-ignore
+
+      if (
+        unknownInstance.type === MessageType.DigitDecompositionEventDescriptorV0
+      ) {
+        const instance = unknownInstance as DigitDecompositionEventDescriptor;
+
+        expect(instance.length).to.equal(17n);
+        expect(instance.base).to.equal(2);
+        expect(instance.isSigned).to.equal(false);
+        expect(instance.unit).to.equal('BTC-USD');
+        expect(instance.precision).to.equal(0);
+        expect(instance.nbDigits).to.equal(17);
+      }
+    });
+  });
+
+  describe('validate', () => {
+    const instance = new DigitDecompositionEventDescriptor();
+
+    beforeEach(() => {
+      instance.base = 2;
+      instance.isSigned = false;
+      instance.unit = 'BTC-USD';
+      instance.precision = 0;
+      instance.nbDigits = 17;
+    });
+
+    it('should not throw error', () => {
+      expect(() => instance.validate()).to.not.throw();
+    });
+
+    it('should throw if base <= 0', () => {
+      instance.base = 0;
+      expect(() => instance.validate()).to.throw('base must be greater than 0');
+
+      instance.base = -1;
+      expect(() => instance.validate()).to.throw('base must be greater than 0');
+    });
+
+    it('should throw if isSigned is true', () => {
+      instance.isSigned = true;
+      expect(() => instance.validate()).to.throw(
+        'node-dlc does not support isSigned',
+      );
+    });
+  });
+});

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

@@ -0,0 +1,169 @@
+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', () => {
+  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);
+
+      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,
+      );
+    });
+
+    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', () => {
+      const fundingInput = FundingInput.fromJSON({
+        inputSerialId: 1,
+        prevTx:
+          '02000000000100c2eb0b00000000160014e70dcc9ffa7ff84c889c9e79b218708bae3bc95800000000', // has no inputs
+        prevTxVout: 0,
+        sequence: 4294967295,
+        maxWitnessLen: 108,
+        redeemScript: '',
+      });
+
+      expect(function () {
+        fundingInput.validate();
+      }).to.throw(Error);
+    });
+  });
+});

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

@@ -0,0 +1,83 @@
+import { expect } from 'chai';
+
+import { FundingSignatures } from '../../lib/messages/FundingSignatures';
+import { ScriptWitnessV0 } from '../../lib/messages/ScriptWitnessV0';
+
+describe('FundingSignatures', () => {
+  let instance: FundingSignatures;
+
+  beforeEach(() => {
+    instance = new FundingSignatures();
+
+    // Create test witness elements
+    const witness1 = new ScriptWitnessV0();
+    witness1.length = 71;
+    witness1.witness = Buffer.alloc(71, 0x01);
+
+    const witness2 = new ScriptWitnessV0();
+    witness2.length = 33;
+    witness2.witness = Buffer.alloc(33, 0x02);
+
+    const witness3 = new ScriptWitnessV0();
+    witness3.length = 65;
+    witness3.witness = Buffer.alloc(65, 0x03);
+
+    // Set up witness elements for two funding inputs
+    instance.witnessElements = [
+      [witness1, witness2], // First funding input
+      [witness3], // Second funding input
+    ];
+  });
+
+  describe('serialize and deserialize', () => {
+    it('should round-trip correctly', () => {
+      const serialized = instance.serialize();
+      expect(serialized).to.be.instanceof(Buffer);
+      expect(serialized.length).to.be.greaterThan(0);
+
+      const deserialized = FundingSignatures.deserialize(serialized);
+      expect(deserialized.witnessElements).to.have.length(2);
+
+      // Check first funding input witnesses
+      expect(deserialized.witnessElements[0]).to.have.length(2);
+      expect(deserialized.witnessElements[0][0].length).to.equal(71);
+      expect(deserialized.witnessElements[0][0].witness).to.deep.equal(
+        Buffer.alloc(71, 0x01),
+      );
+      expect(deserialized.witnessElements[0][1].length).to.equal(33);
+      expect(deserialized.witnessElements[0][1].witness).to.deep.equal(
+        Buffer.alloc(33, 0x02),
+      );
+
+      // Check second funding input witnesses
+      expect(deserialized.witnessElements[1]).to.have.length(1);
+      expect(deserialized.witnessElements[1][0].length).to.equal(65);
+      expect(deserialized.witnessElements[1][0].witness).to.deep.equal(
+        Buffer.alloc(65, 0x03),
+      );
+    });
+  });
+
+  describe('toJSON', () => {
+    it('should convert to canonical rust-dlc JSON format', () => {
+      const json = instance.toJSON();
+      expect(json.fundingSignatures).to.be.an('array');
+      expect(json.fundingSignatures).to.have.length(2);
+
+      // Check first funding input
+      expect(json.fundingSignatures[0].witnessElements).to.have.length(2);
+      expect(json.fundingSignatures[0].witnessElements[0].witness).to.be.a(
+        'string',
+      );
+      expect(json.fundingSignatures[0].witnessElements[1].witness).to.be.a(
+        'string',
+      );
+
+      // Check second funding input
+      expect(json.fundingSignatures[1].witnessElements).to.have.length(1);
+      expect(json.fundingSignatures[1].witnessElements[0].witness).to.be.a(
+        'string',
+      );
+    });
+  });
+});