@atomicfinance/bitcoin-dlc-provider 3.6.0 → 4.0.0

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,84 @@
+import { Sequence, Tx } from '@node-dlc/bitcoin';
+import { StreamReader } from '@node-dlc/bufio';
+import { expect } from 'chai';
+
+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('serialize', () => {
+    it('serializes', () => {
+      expect(instance.serialize().toString('hex')).to.equal(
+        fundingInputHex.toString('hex'),
+      );
+    });
+  });
+
+  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'));
+    });
+  });
+
+  describe('validate', () => {
+    it('should ensure inputs are segwit', () => {
+      instance.prevTx = Tx.decode(
+        StreamReader.fromBuffer(
+          Buffer.from(
+            '02000000000100c2eb0b00000000160014e70dcc9ffa7ff84c889c9e79b218708bae3bc95800000000', // has no inputs
+            'hex',
+          ),
+        ),
+      );
+      expect(function () {
+        instance.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',
+      );
+    });
+  });
+});