@atomicfinance/types 3.6.1 → 4.0.0

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

@@ -0,0 +1,326 @@
+import { expect } from 'chai';
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { OracleAnnouncement } from '../../lib/messages/OracleAnnouncement';
+import { OracleAttestation } from '../../lib/messages/OracleAttestation';
+
+// Load test vectors
+const testVectorsPath = path.join(
+  __dirname,
+  '../../test_vectors/oracle/oracle_message_test_vectors.json',
+);
+const testVectors = JSON.parse(fs.readFileSync(testVectorsPath, 'utf8'));
+
+describe('OracleAttestation', () => {
+  const attestationSig = Buffer.from(
+    '424c11a44c2e522f90bbe4abab6ec1bc8ab44c9b29316ce6e1d0d7d08385a474' +
+      'de6b75f1da183a2a4f9ad144b48bf1026cee9687221df58f04128db79ca17e2a',
+    'hex',
+  );
+
+  const oraclePubkey = Buffer.from(
+    '1d5dcdba2e64cb116cc0c375a0856298f0058b778f46bfe625ac6576204889e4',
+    'hex',
+  );
+
+  const invalidOraclePubkey = Buffer.from(
+    '5d1bcfab252c6dd9edd7aea4c5eeeef138f7ff7346061ea40143a9f5ae80baa9',
+    'hex',
+  );
+
+  describe('serialize', () => {
+    it('serializes', () => {
+      const instance = new OracleAttestation();
+
+      instance.eventId = 'BTC-USD-OVER-50K-COINBASE';
+      instance.oraclePubkey = oraclePubkey;
+      instance.signatures.push(attestationSig);
+      instance.outcomes.push('NO');
+
+      // 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', () => {
+      // Create a test instance and serialize it first for round-trip testing
+      const originalInstance = new OracleAttestation();
+      originalInstance.eventId = 'BTC-USD-OVER-50K-COINBASE';
+      originalInstance.oraclePubkey = oraclePubkey;
+      originalInstance.signatures.push(attestationSig);
+      originalInstance.outcomes.push('NO');
+
+      // Serialize and then deserialize to ensure round-trip consistency
+      const serialized = originalInstance.serialize();
+      const instance = OracleAttestation.deserialize(serialized);
+
+      expect(Number(instance.length)).to.be.greaterThan(0); // Length is calculated automatically
+      expect(instance.eventId).to.equal('BTC-USD-OVER-50K-COINBASE');
+      expect(instance.oraclePubkey).to.deep.equal(oraclePubkey);
+      expect(instance.signatures[0]).to.deep.equal(attestationSig);
+      expect(instance.outcomes[0]).to.equal('NO');
+    });
+  });
+
+  describe('validate', () => {
+    it('should validate when correct outcome signatures', () => {
+      const instance = new OracleAttestation();
+
+      instance.eventId = 'BTC-USD-OVER-50K-COINBASE';
+      instance.oraclePubkey = oraclePubkey;
+      instance.signatures.push(attestationSig);
+      instance.outcomes.push('NO');
+
+      expect(function () {
+        instance.validate();
+      }).to.not.throw(Error);
+    });
+
+    it('should invalidate when incorrect outcome signatures', () => {
+      const instance = new OracleAttestation();
+
+      instance.eventId = 'BTC-USD-OVER-50K-COINBASE';
+      instance.oraclePubkey = invalidOraclePubkey;
+      instance.signatures.push(attestationSig);
+      instance.outcomes.push('NO');
+
+      expect(function () {
+        instance.validate();
+      }).to.throw(Error);
+    });
+  });
+
+  /**
+   * Comprehensive Test Vectors
+   * Tests oracle attestations from various implementations and oracle providers
+   */
+  describe('comprehensive attestation test vectors', () => {
+    describe('Atomic Finance attestation', () => {
+      let announcement: OracleAnnouncement;
+      let instance: OracleAttestation;
+
+      before(() => {
+        const announcementBuf = Buffer.from(
+          testVectors.atomic.announcement,
+          'hex',
+        );
+        announcement = OracleAnnouncement.deserialize(announcementBuf);
+        const attestationBuf = Buffer.from(
+          testVectors.atomic.attestation,
+          'hex',
+        );
+        instance = OracleAttestation.deserialize(attestationBuf);
+      });
+
+      it('deserializes Atomic oracle attestation', () => {
+        expect(Number(instance.length)).to.be.greaterThan(0);
+        expect(instance.eventId).to.equal(testVectors.atomic.metadata.eventId);
+        expect(instance.oraclePubkey).to.be.instanceOf(Buffer);
+        expect(instance.oraclePubkey.length).to.equal(32);
+        expect(instance.signatures).to.be.an('array');
+        expect(instance.outcomes).to.be.an('array');
+        expect(instance.signatures.length).to.equal(instance.outcomes.length);
+      });
+
+      it('validates Atomic oracle attestation', () => {
+        expect(() => instance.validate()).to.not.throw();
+      });
+
+      it('validates against corresponding announcement', () => {
+        expect(() => instance.validate(announcement)).to.not.throw();
+      });
+
+      it('has correct number of signatures for digit decomposition', () => {
+        expect(instance.signatures).to.have.length(18); // 18-digit binary decomposition
+        expect(instance.outcomes).to.have.length(18);
+      });
+
+      it('has binary outcomes (0 or 1)', () => {
+        instance.outcomes.forEach((outcome) => {
+          expect(['0', '1']).to.include(outcome);
+        });
+      });
+
+      it('round-trip serialization works', () => {
+        const serialized = instance.serialize();
+        const deserialized = OracleAttestation.deserialize(serialized);
+        expect(deserialized.eventId).to.equal(instance.eventId);
+        expect(deserialized.oraclePubkey).to.deep.equal(instance.oraclePubkey);
+        expect(deserialized.outcomes).to.deep.equal(instance.outcomes);
+      });
+    });
+
+    describe('Lava attestation', () => {
+      let announcement: OracleAnnouncement;
+      let instance: OracleAttestation;
+
+      before(() => {
+        const announcementBuf = Buffer.from(
+          testVectors.lava.announcement,
+          'hex',
+        );
+        announcement = OracleAnnouncement.deserialize(announcementBuf);
+        const attestationBuf = Buffer.from(testVectors.lava.attestation, 'hex');
+        instance = OracleAttestation.deserialize(attestationBuf);
+      });
+
+      it('deserializes Lava oracle attestation', () => {
+        expect(Number(instance.length)).to.be.greaterThan(0);
+        expect(instance.eventId).to.be.a('string');
+        expect(instance.oraclePubkey).to.be.instanceOf(Buffer);
+        expect(instance.oraclePubkey.length).to.equal(32);
+        expect(instance.signatures).to.be.an('array');
+        expect(instance.outcomes).to.be.an('array');
+        expect(instance.signatures.length).to.equal(instance.outcomes.length);
+      });
+
+      it('has correct number of signatures for digit decomposition', () => {
+        expect(instance.signatures).to.have.length(18); // 18-digit binary decomposition
+        expect(instance.outcomes).to.have.length(18);
+      });
+
+      it('has binary outcomes (0 or 1)', () => {
+        instance.outcomes.forEach((outcome) => {
+          expect(['0', '1']).to.include(outcome);
+        });
+      });
+
+      it('round-trip serialization works', () => {
+        const serialized = instance.serialize();
+        const deserialized = OracleAttestation.deserialize(serialized);
+        expect(deserialized.eventId).to.equal(instance.eventId);
+        expect(deserialized.oraclePubkey).to.deep.equal(instance.oraclePubkey);
+        expect(deserialized.outcomes).to.deep.equal(instance.outcomes);
+      });
+    });
+
+    describe('rust-dlc enum oracle', () => {
+      let announcement: OracleAnnouncement;
+      let instance: OracleAttestation;
+
+      before(() => {
+        const announcementBuf = Buffer.from(
+          testVectors.rust_dlc_enum.announcement,
+          'hex',
+        );
+        announcement = OracleAnnouncement.deserialize(announcementBuf);
+        const attestationBuf = Buffer.from(
+          testVectors.rust_dlc_enum.attestation,
+          'hex',
+        );
+        instance = OracleAttestation.deserialize(attestationBuf);
+      });
+
+      it('deserializes rust-dlc enum oracle attestation', () => {
+        expect(Number(instance.length)).to.be.greaterThan(0);
+        expect(instance.eventId).to.equal('sports-match-001');
+        expect(instance.oraclePubkey).to.be.instanceOf(Buffer);
+        expect(instance.oraclePubkey.length).to.equal(32);
+        expect(instance.signatures).to.be.an('array');
+        expect(instance.outcomes).to.be.an('array');
+        expect(instance.signatures.length).to.equal(instance.outcomes.length);
+      });
+
+      it('has single signature for enum event', () => {
+        expect(instance.signatures).to.have.length(1);
+        expect(instance.outcomes).to.have.length(1);
+      });
+
+      it('has valid enum outcome', () => {
+        expect(instance.outcomes[0]).to.equal('win');
+        expect(['win', 'lose', 'draw']).to.include(instance.outcomes[0]);
+      });
+
+      it('round-trip serialization works', () => {
+        const serialized = instance.serialize();
+        const deserialized = OracleAttestation.deserialize(serialized);
+        expect(deserialized.eventId).to.equal(instance.eventId);
+        expect(deserialized.oraclePubkey).to.deep.equal(instance.oraclePubkey);
+        expect(deserialized.outcomes).to.deep.equal(instance.outcomes);
+      });
+    });
+
+    describe('rust-dlc numeric oracle', () => {
+      let instance: OracleAttestation;
+
+      before(() => {
+        const attestationBuf = Buffer.from(
+          testVectors.rust_dlc_numeric.attestation,
+          'hex',
+        );
+        instance = OracleAttestation.deserialize(attestationBuf);
+      });
+
+      it('deserializes rust-dlc numeric oracle attestation', () => {
+        expect(Number(instance.length)).to.be.greaterThan(0);
+        expect(instance.eventId).to.equal('btc-price-test');
+        expect(instance.oraclePubkey).to.be.instanceOf(Buffer);
+        expect(instance.oraclePubkey.length).to.equal(32);
+        expect(instance.signatures).to.be.an('array');
+        expect(instance.outcomes).to.be.an('array');
+        expect(instance.signatures.length).to.equal(instance.outcomes.length);
+      });
+
+      it('has correct number of signatures for 8-digit decomposition', () => {
+        expect(instance.signatures).to.have.length(8); // 8-digit binary decomposition
+        expect(instance.outcomes).to.have.length(8);
+      });
+
+      it('has binary outcomes (0 or 1)', () => {
+        instance.outcomes.forEach((outcome) => {
+          expect(['0', '1']).to.include(outcome);
+        });
+      });
+
+      it('represents number 42 in binary (00101010)', () => {
+        // Outcomes are in little-endian order (LSB first)
+        const expectedBinary = ['0', '1', '0', '1', '0', '1', '0', '0'];
+        expect(instance.outcomes).to.deep.equal(expectedBinary);
+      });
+
+      it('round-trip serialization works', () => {
+        const serialized = instance.serialize();
+        const deserialized = OracleAttestation.deserialize(serialized);
+        expect(deserialized.eventId).to.equal(instance.eventId);
+        expect(deserialized.oraclePubkey).to.deep.equal(instance.oraclePubkey);
+        expect(deserialized.outcomes).to.deep.equal(instance.outcomes);
+      });
+    });
+
+    describe('cross-validation tests', () => {
+      it('attestations have consistent event IDs with announcements', () => {
+        const testCases = [
+          {
+            announcement: testVectors.atomic.announcement,
+            attestation: testVectors.atomic.attestation,
+          },
+          {
+            announcement: testVectors.lava.announcement,
+            attestation: testVectors.lava.attestation,
+          },
+          {
+            announcement: testVectors.rust_dlc_enum.announcement,
+            attestation: testVectors.rust_dlc_enum.attestation,
+          },
+          {
+            announcement: testVectors.rust_dlc_numeric.announcement,
+            attestation: testVectors.rust_dlc_numeric.attestation,
+          },
+        ];
+        testCases.forEach((testCase) => {
+          const announcement = OracleAnnouncement.deserialize(
+            Buffer.from(testCase.announcement, 'hex'),
+          );
+          const attestation = OracleAttestation.deserialize(
+            Buffer.from(testCase.attestation, 'hex'),
+          );
+          expect(attestation.eventId).to.equal(announcement.getEventId());
+        });
+      });
+    });
+  });
+});

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

@@ -0,0 +1,143 @@
+import { expect } from 'chai';
+
+import {
+  DigitDecompositionEventDescriptor,
+  EnumEventDescriptor,
+} from '../../lib/messages/EventDescriptor';
+import { OracleEvent } from '../../lib/messages/OracleEvent';
+
+describe('OracleEvent', () => {
+  const oracleNonce = Buffer.from(
+    '3cfba011378411b20a5ab773cb95daab93e9bcd1e4cce44986a7dda84e01841b',
+    'hex',
+  );
+
+  const eventId = Buffer.from('64756d6d79', 'hex');
+
+  describe('serialize', () => {
+    it('serializes', () => {
+      const instance = new OracleEvent();
+
+      instance.length = BigInt(64);
+      instance.oracleNonces.push(oracleNonce);
+      instance.eventMaturityEpoch = 0;
+      instance.eventDescriptor = EnumEventDescriptor.deserialize(
+        Buffer.from(
+          'fdd806' + // type enum_event_descriptor
+            '10' + // length
+            '0002' + // num_outcomes
+            '06' + // outcome_1_len
+            '64756d6d7931' + // outcome_1
+            '06' + // outcome_2_len
+            '64756d6d7932', // outcome_2
+          'hex',
+        ),
+      );
+      instance.eventId = eventId.toString();
+
+      expect(instance.serialize().toString("hex")).to.equal(
+        "fdd822" + // type oracle_event
+        "40" + // length
+        "0001" + // nb_nonces
+        "3cfba011378411b20a5ab773cb95daab93e9bcd1e4cce44986a7dda84e01841b" + // oracle_nonces
+        "00000000" + // event_maturity_epoch
+        "fdd806" + // type enum_event_descriptor
+        "10" + // length
+        "0002" + // num_outcomes
+        "06" + // outcome_1_len
+        "64756d6d7931" + // outcome_1
+        "06" + // outcome_2_len
+        "64756d6d7932" + // outcome_2
+        "05" + // event_id_length
+        "64756d6d79" // event_id
+      ); // prettier-ignore
+    });
+  });
+
+  describe('deserialize', () => {
+    it('deserializes', () => {
+      const buf = Buffer.from(
+        "fdd822" + // type oracle_event
+        "40" + // length
+        "0001" + // nb_nonces
+        "3cfba011378411b20a5ab773cb95daab93e9bcd1e4cce44986a7dda84e01841b" + // oracle_nonces
+        "00000000" + // event_maturity_epoch
+        "fdd806" + // type enum_event_descriptor
+        "10" + // length
+        "0002" + // num_outcomes
+        "06" + // outcome_1_len
+        "64756d6d7931" + // outcome_1
+        "06" + // outcome_2_len
+        "64756d6d7932" + // outcome_2
+        "05" + // event_id_length
+        "64756d6d79" // event_id
+        , "hex"
+      ); // prettier-ignore
+
+      const instance = OracleEvent.deserialize(buf);
+
+      expect(instance.oracleNonces[0]).to.deep.equal(oracleNonce);
+      expect(instance.eventMaturityEpoch).to.equal(0);
+      expect(instance.eventDescriptor.serialize().toString('hex')).to.equal(
+        'fdd806' + // type enum_event_descriptor
+          '10' + // length
+          '0002' + // num_outcomes
+          '06' + // outcome_1_len
+          '64756d6d7931' + // outcome_1
+          '06' + // outcome_2_len
+          '64756d6d7932', // outcome_2
+      );
+      expect(instance.eventId).to.equal(eventId.toString());
+    });
+  });
+
+  describe('validate', () => {
+    const instance = new OracleEvent();
+
+    beforeEach(() => {
+      instance.length = BigInt(64);
+      instance.oracleNonces.push(oracleNonce);
+      instance.eventMaturityEpoch = 0;
+      instance.eventDescriptor = EnumEventDescriptor.deserialize(
+        Buffer.from(
+          'fdd806' + // type enum_event_descriptor
+            '10' + // length
+            '0002' + // num_outcomes
+            '06' + // outcome_1_len
+            '64756d6d7931' + // outcome_1
+            '06' + // outcome_2_len
+            '64756d6d7932', // outcome_2
+          'hex',
+        ),
+      );
+      instance.eventId = eventId.toString();
+    });
+
+    it('should not throw error', () => {
+      expect(() => instance.validate()).to.not.throw();
+    });
+
+    it('should throw if eventMaturityEpoch is less than 0', () => {
+      instance.eventMaturityEpoch = -1;
+      expect(() => instance.validate()).to.throw();
+    });
+
+    it('should throw if oracleNonces.length !== eventDescriptor.nbDigits', () => {
+      instance.eventDescriptor = DigitDecompositionEventDescriptor.deserialize(
+        Buffer.from(
+          'fdd80a' + // type
+            '11' + // length
+            '0002' + // base (Switch to '02' with oracle_announcement_v1)
+            '00' + // isSigned
+            '07' + // unit_Len
+            '6274632f757364' + // btc/usd (unit)
+            '00000000' + // precision
+            '0011', // nb_digits
+          'hex',
+        ),
+      ); // prettier-ignore);
+      instance.oracleNonces = [];
+      expect(() => instance.validate()).to.throw();
+    });
+  });
+});

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

@@ -0,0 +1,95 @@
+import { expect } from 'chai';
+
+import { EnumEventDescriptorV0 } from '../../lib/messages/EventDescriptor';
+import { OracleAnnouncement } from '../../lib/messages/OracleAnnouncement';
+import { OracleAttestation } from '../../lib/messages/OracleAttestation';
+import { OracleEvent } from '../../lib/messages/OracleEvent';
+import { OracleEventContainer } from '../../lib/messages/OracleEventContainer';
+
+describe('OracleEventContainer', () => {
+  function createTestOracleAnnouncement(): OracleAnnouncement {
+    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;
+
+    const eventDescriptor = new EnumEventDescriptorV0();
+    eventDescriptor.outcomes = ['dummy1', 'dummy2'];
+    oracleEvent.eventDescriptor = eventDescriptor;
+    oracleEvent.eventId = 'dummy';
+
+    announcement.oracleEvent = oracleEvent;
+    return announcement;
+  }
+
+  function createTestOracleAttestation(): OracleAttestation {
+    const attestation = new OracleAttestation();
+    attestation.eventId = 'BTC-USD-OVER-50K-COINBASE';
+    attestation.oraclePubkey = Buffer.from(
+      '1d5dcdba2e64cb116cc0c375a0856298f0058b778f46bfe625ac6576204889e4',
+      'hex',
+    );
+    attestation.signatures.push(
+      Buffer.from(
+        '424c11a44c2e522f90bbe4abab6ec1bc8ab44c9b29316ce6e1d0d7d08385a474de6b75f1da183a2a4f9ad144b48bf1026cee9687221df58f04128db79ca17e2a',
+        'hex',
+      ),
+    );
+    attestation.outcomes.push('NO');
+    return attestation;
+  }
+
+  describe('serialize', () => {
+    it('serializes', () => {
+      const instance = new OracleEventContainer();
+
+      instance.oracleName = 'Atomic';
+      instance.uri = '';
+      instance.announcement = createTestOracleAnnouncement();
+      instance.attestation = createTestOracleAttestation();
+      instance.outcome = '45354';
+
+      // 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', () => {
+      // Create a test instance and serialize it first for round-trip testing
+      const originalInstance = new OracleEventContainer();
+      originalInstance.oracleName = 'Atomic';
+      originalInstance.uri = '';
+      originalInstance.announcement = createTestOracleAnnouncement();
+      originalInstance.attestation = createTestOracleAttestation();
+      originalInstance.outcome = '45354';
+
+      // Serialize and then deserialize to ensure round-trip consistency
+      const serialized = originalInstance.serialize();
+      const instance = OracleEventContainer.deserialize(serialized);
+
+      expect(Number(instance.length)).to.be.greaterThan(0); // Length is calculated automatically
+      expect(instance.oracleName).to.equal('Atomic');
+      expect(instance.uri).to.equal('');
+      expect(instance.announcement).to.be.instanceof(OracleAnnouncement);
+      expect(instance.attestation).to.be.instanceof(OracleAttestation);
+      expect(instance.outcome).to.equal('45354');
+    });
+  });
+});

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

@@ -0,0 +1,48 @@
+import { expect } from 'chai';
+
+import { OracleIdentifier } from '../../lib/messages/OracleIdentifier';
+
+describe('OracleIdentifierV0', () => {
+  const oraclePubkey = Buffer.from(
+    '5d1bcfab252c6dd9edd7aea4c5eeeef138f7ff7346061ea40143a9f5ae80baa9',
+    'hex',
+  );
+
+  const oracleName = 'atomic';
+
+  describe('serialize', () => {
+    it('serializes', () => {
+      const instance = new OracleIdentifier();
+
+      instance.length = BigInt(64);
+      instance.oracleName = oracleName;
+      instance.oraclePubkey = oraclePubkey;
+
+      expect(instance.serialize().toString("hex")).to.equal(
+        "fdf020" + // type oracle_identifier
+        "27" + // length
+        "06" + // oracle_name length
+        "61746f6d6963" + // oracle_name
+        "5d1bcfab252c6dd9edd7aea4c5eeeef138f7ff7346061ea40143a9f5ae80baa9" // oracle_pubkey
+      ); // prettier-ignore
+    });
+  });
+
+  describe('deserialize', () => {
+    it('deserializes', () => {
+      const buf = Buffer.from(
+        "fdf020" + // type oracle_identifier
+        "27" + // length
+        "06" + // oracle_name length
+        "61746f6d6963" + // oracle_name
+        "5d1bcfab252c6dd9edd7aea4c5eeeef138f7ff7346061ea40143a9f5ae80baa9" // oracle_pubkey
+        , "hex"
+      ); // prettier-ignore
+
+      const instance = OracleIdentifier.deserialize(buf);
+
+      expect(instance.oracleName).to.equal(oracleName);
+      expect(instance.oraclePubkey).to.deep.equal(oraclePubkey);
+    });
+  });
+});