@atomicfinance/types 4.2.8 → 4.3.1

package/.yalc/@node-dlc/messaging/lib/messages/NegotiationFields.ts

@@ -0,0 +1,256 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+
+import { RoundingIntervals } from './RoundingIntervals';
+import { IRoundingIntervalsJSON } from './RoundingIntervals';
+
+/**
+ * Negotiation fields for DLC contract negotiation.
+ * Follows the Rust enum pattern with Single and Disjoint variants.
+ */
+export abstract class NegotiationFields {
+  public static deserialize(buf: Buffer): NegotiationFields {
+    const reader = new BufferReader(buf);
+    const discriminator = Number(reader.readBigSize());
+
+    switch (discriminator) {
+      case 0:
+        return SingleNegotiationFields.deserialize(buf);
+      case 1:
+        return DisjointNegotiationFields.deserialize(buf);
+      default:
+        throw new Error(
+          `Invalid NegotiationFields discriminator: ${discriminator}. Must be 0 (Single) or 1 (Disjoint)`,
+        );
+    }
+  }
+
+  /**
+   * Creates a NegotiationFields from JSON data
+   * @param json JSON object representing negotiation fields
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  public static fromJSON(json: any): NegotiationFields {
+    if (!json || typeof json !== 'object') {
+      throw new Error('Invalid JSON input for NegotiationFields');
+    }
+
+    const variant = json.variant;
+
+    switch (variant) {
+      case 'Single':
+        return SingleNegotiationFields.fromJSON(json);
+      case 'Disjoint':
+        return DisjointNegotiationFields.fromJSON(json);
+      default:
+        throw new Error(
+          `Unknown negotiation fields variant: ${variant}. Must be 'Single' or 'Disjoint'`,
+        );
+    }
+  }
+
+  public abstract variant: 'Single' | 'Disjoint';
+  public abstract discriminator: number;
+  public abstract serialize(): Buffer;
+  public abstract toJSON(): INegotiationFieldsJSON;
+}
+
+/**
+ * Negotiation fields for contract based on a single event.
+ */
+export class SingleNegotiationFields extends NegotiationFields {
+  /**
+   * Creates a SingleNegotiationFields from JSON data
+   * @param json JSON object representing single negotiation fields
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  public static fromJSON(json: any): SingleNegotiationFields {
+    const instance = new SingleNegotiationFields();
+
+    if (json.variant !== 'Single') {
+      throw new Error(
+        `Invalid variant for SingleNegotiationFields: expected 'Single', got ${json.variant}`,
+      );
+    }
+
+    if (!json.roundingIntervals) {
+      throw new Error(
+        'SingleNegotiationFields requires roundingIntervals field',
+      );
+    }
+
+    instance.roundingIntervals = RoundingIntervals.fromJSON(
+      json.roundingIntervals,
+    );
+
+    return instance;
+  }
+
+  /**
+   * Deserializes single negotiation fields
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): SingleNegotiationFields {
+    const instance = new SingleNegotiationFields();
+    const reader = new BufferReader(buf);
+
+    reader.readBigSize(); // read discriminator (0)
+
+    // Read remaining bytes as raw RoundingIntervals data
+    const remainingBytes = reader.readBytes();
+    instance.roundingIntervals = RoundingIntervals.deserialize(remainingBytes);
+
+    return instance;
+  }
+
+  public variant = 'Single' as const;
+  public discriminator = 0;
+  public roundingIntervals: RoundingIntervals;
+
+  /**
+   * Converts single negotiation fields to JSON
+   */
+  public toJSON(): ISingleNegotiationFieldsJSON {
+    return {
+      variant: this.variant,
+      roundingIntervals: this.roundingIntervals.toJSON(),
+    };
+  }
+
+  /**
+   * Serializes the single negotiation fields into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeBigSize(this.discriminator);
+    writer.writeBytes(this.roundingIntervals.serialize());
+
+    return writer.toBuffer();
+  }
+}
+
+/**
+ * Negotiation fields for contract based on multiple events.
+ */
+export class DisjointNegotiationFields extends NegotiationFields {
+  /**
+   * Creates a DisjointNegotiationFields from JSON data
+   * @param json JSON object representing disjoint negotiation fields
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  public static fromJSON(json: any): DisjointNegotiationFields {
+    const instance = new DisjointNegotiationFields();
+
+    if (json.variant !== 'Disjoint') {
+      throw new Error(
+        `Invalid variant for DisjointNegotiationFields: expected 'Disjoint', got ${json.variant}`,
+      );
+    }
+
+    if (!json.negotiationFields || !Array.isArray(json.negotiationFields)) {
+      throw new Error(
+        'DisjointNegotiationFields requires negotiationFields array',
+      );
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    instance.negotiationFields = json.negotiationFields.map((fieldJson: any) =>
+      NegotiationFields.fromJSON(fieldJson),
+    );
+
+    return instance;
+  }
+
+  /**
+   * Deserializes disjoint negotiation fields
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): DisjointNegotiationFields {
+    const instance = new DisjointNegotiationFields();
+    const reader = new BufferReader(buf);
+
+    reader.readBigSize(); // read discriminator (1)
+    const numFields = Number(reader.readBigSize());
+
+    for (let i = 0; i < numFields; i++) {
+      // For simplicity, let's read the nested field by looking ahead
+      // to determine its length based on its discriminator
+      const startPos = reader.position;
+      const discriminator = Number(reader.readBigSize());
+
+      if (discriminator === 0) {
+        // Single field: discriminator + RoundingIntervals data
+        // RoundingIntervals has its own length, so we need to parse it
+        const roundingIntervals = RoundingIntervals.deserialize(
+          reader.readBytes(),
+        );
+
+        // Reset and read the complete field
+        reader.position = startPos;
+        const fieldLength = 1 + roundingIntervals.serialize().length; // discriminator + data length
+        const fieldData = reader.readBytes(fieldLength);
+
+        instance.negotiationFields.push(
+          NegotiationFields.deserialize(fieldData),
+        );
+      } else if (discriminator === 1) {
+        throw new Error('Nested disjoint fields not yet supported');
+      } else {
+        throw new Error(`Unknown discriminator: ${discriminator}`);
+      }
+    }
+
+    return instance;
+  }
+
+  public variant = 'Disjoint' as const;
+  public discriminator = 1;
+  public negotiationFields: NegotiationFields[] = [];
+
+  /**
+   * Converts disjoint negotiation fields to JSON
+   */
+  public toJSON(): IDisjointNegotiationFieldsJSON {
+    return {
+      variant: this.variant,
+      negotiationFields: this.negotiationFields.map((field) => field.toJSON()),
+    };
+  }
+
+  /**
+   * Serializes the disjoint negotiation fields into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeBigSize(this.discriminator);
+    writer.writeBigSize(this.negotiationFields.length);
+
+    for (const negotiationField of this.negotiationFields) {
+      writer.writeBytes(negotiationField.serialize());
+    }
+
+    return writer.toBuffer();
+  }
+}
+
+export type INegotiationFieldsJSON =
+  | ISingleNegotiationFieldsJSON
+  | IDisjointNegotiationFieldsJSON;
+
+export interface ISingleNegotiationFieldsJSON {
+  variant: 'Single';
+  roundingIntervals: IRoundingIntervalsJSON;
+}
+
+export interface IDisjointNegotiationFieldsJSON {
+  variant: 'Disjoint';
+  negotiationFields: INegotiationFieldsJSON[];
+}
+
+// Legacy exports for backward compatibility - map to new structure
+export const NegotiationFieldsV0 = SingleNegotiationFields; // V0 was empty, now maps to Single
+export const NegotiationFieldsV1 = SingleNegotiationFields; // V1 had rounding intervals
+export const NegotiationFieldsV2 = DisjointNegotiationFields; // V2 had list of fields
+
+export type INegotiationFieldsV0JSON = ISingleNegotiationFieldsJSON;
+export type INegotiationFieldsV1JSON = ISingleNegotiationFieldsJSON;
+export type INegotiationFieldsV2JSON = IDisjointNegotiationFieldsJSON;

package/.yalc/@node-dlc/messaging/lib/messages/NodeAnnouncementMessage.ts

@@ -0,0 +1,145 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+import { BitField } from '@node-dlc/common';
+import * as crypto from '@node-dlc/crypto';
+import { NodeFeatureFlags } from '@node-dlc/wire';
+
+import { Address } from '../domain/Address';
+import { MessageType } from '../MessageType';
+import { getTlv } from '../serialize/getTlv';
+import { IWireMessage } from './IWireMessage';
+
+/**
+ * This gossip message allows a node to indicate extra data associated with it,
+ * in addition to its public key. To avoid trivial denial of service attacks,
+ * nodes not associated with an already known channel are ignored.
+ */
+export class NodeAnnouncementMessage implements IWireMessage {
+  public static type = MessageType.NodeAnnouncement;
+
+  public static deserialize(payload: Buffer): NodeAnnouncementMessage {
+    const instance = new NodeAnnouncementMessage();
+    const reader = new BufferReader(payload);
+    reader.readUInt16BE(); // read off type
+
+    instance.signature = reader.readBytes(64);
+
+    const flen = reader.readUInt16BE();
+    instance.features = BitField.fromBuffer(reader.readBytes(flen));
+
+    instance.timestamp = reader.readUInt32BE();
+    instance.nodeId = reader.readBytes(33);
+    instance.rgbColor = reader.readBytes(3);
+    instance.alias = reader.readBytes(32);
+    instance.addresses = [];
+
+    reader.readUInt16BE(); // addr_len
+
+    while (!reader.eof) {
+      const address = Address.deserialize(getTlv(reader));
+
+      instance.addresses.push(address);
+    }
+
+    return instance;
+  }
+
+  /**
+   * Message hashing is after the first 66 bytes of the message
+   * and excludes the type and signature. It performs a double
+   * sha-256 hash of the remaining bytes.
+   */
+  public static hash(msg: NodeAnnouncementMessage): Buffer {
+    const bytes = msg.serialize().slice(66); // type + signature
+    return crypto.hash256(bytes);
+  }
+
+  /**
+   * Verifies the message signature
+   */
+  public static verifySignatures(msg: NodeAnnouncementMessage): boolean {
+    const hash = NodeAnnouncementMessage.hash(msg);
+    return crypto.verifySig(hash, msg.signature, msg.nodeId);
+  }
+
+  /**
+   * Type 257
+   */
+  public type: MessageType = MessageType.NodeAnnouncement;
+
+  /**
+   * Signature of the announcement message by the node's public key
+   * returned as a 64-byte Buffer.
+   */
+  public signature: Buffer;
+
+  public features: BitField<NodeFeatureFlags>;
+
+  public timestamp: number;
+
+  /**
+   * Compressed public key of the node that is a 33-byte
+   * buffer.
+   */
+  public nodeId: Buffer;
+
+  /**
+   * Color of the node returned as a 3-byte Buffer.
+   */
+  public rgbColor: Buffer;
+
+  /**
+   * Alias of the node returned as a 32-byte Buffer.
+   */
+  public alias: Buffer;
+
+  /**
+   * Addresses that the node allow public network connections
+   * on. The type indicates how the address is encoded. Addresses
+   * are in order of connectivity preference. Currently
+   * supported addresses formats are IPv4, IPv6, Tor2 and Tor3
+   */
+  public addresses: Address[] = [];
+
+  public serialize(): Buffer {
+    const featuresBuffer = this.features.toBuffer();
+    const featuresLen = featuresBuffer.length;
+
+    // serialize addresses into buffers so we can obtain the length
+    const addressBuffers = [];
+    for (const address of this.addresses) {
+      addressBuffers.push(address.serialize());
+    }
+
+    // obtain total address length
+    // eslint-disable-next-line
+    const addressBytes: number = addressBuffers.map(b => b.length).reduce((sum, val) => sum + val, 0); // prettier-ignore
+
+    const len =
+      2 + // type
+      64 + // signature
+      2 + // flen
+      featuresLen + // features length
+      4 + // timestamp
+      33 + // node_id
+      3 + // rgb_color
+      32 + // alias
+      2 + // addresses
+      addressBytes; // cumulative addr bytes
+    const writer = new BufferWriter(Buffer.alloc(len));
+
+    writer.writeUInt16BE(this.type);
+    writer.writeBytes(this.signature);
+    writer.writeUInt16BE(featuresLen);
+    if (featuresLen > 0) writer.writeBytes(featuresBuffer);
+    writer.writeUInt32BE(this.timestamp);
+    writer.writeBytes(this.nodeId);
+    writer.writeBytes(this.rgbColor);
+    writer.writeBytes(this.alias);
+    writer.writeUInt16BE(addressBytes);
+    for (const addressBuffer of addressBuffers) {
+      writer.writeBytes(addressBuffer);
+    }
+
+    return writer.toBuffer();
+  }
+}

package/.yalc/@node-dlc/messaging/lib/messages/OracleAnnouncement.ts

@@ -0,0 +1,176 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+import { math, verify } from 'bip-schnorr';
+
+import { MessageType } from '../MessageType';
+import { getTlv } from '../serialize/getTlv';
+import { IDlcMessage } from './DlcMessage';
+import { IOracleEventJSON, OracleEvent } from './OracleEvent';
+
+/**
+ * Oracle announcement that describe an event and the way that an oracle will
+ * attest to it. Updated to be rust-dlc compliant.
+ *
+ * In order to make it possible to hold oracles accountable in cases where
+ * they do not release a signature for an event outcome, there needs to be
+ * a proof that an oracle has committed to a given outcome. This proof is
+ * given in a so-called oracle announcement, which contains an oracle event
+ * together with the oracle public key and a signature over its serialization,
+ * which must be valid with respect to the specified public key.
+ *
+ * This also makes it possible for users to obtain oracle event information
+ * from an un-trusted peer while being guaranteed that it originates from a
+ * given oracle.
+ */
+export class OracleAnnouncement implements IDlcMessage {
+  public static type = MessageType.OracleAnnouncement;
+
+  /**
+   * Creates an OracleAnnouncement from JSON data
+   * @param json JSON object representing oracle announcement
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  public static fromJSON(json: any): OracleAnnouncement {
+    const instance = new OracleAnnouncement();
+
+    // Handle different field name variations
+    instance.announcementSig = Buffer.from(
+      json.announcementSignature ||
+        json.announcementSig ||
+        json.announcement_signature,
+      'hex',
+    );
+    instance.oraclePubkey = Buffer.from(
+      json.oraclePublicKey || json.oraclePubkey || json.oracle_public_key,
+      'hex',
+    );
+    instance.oracleEvent = OracleEvent.fromJSON(
+      json.oracleEvent || json.oracle_event,
+    );
+
+    return instance;
+  }
+
+  /**
+   * Deserializes an oracle_announcement message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): OracleAnnouncement {
+    const instance = new OracleAnnouncement();
+    const reader = new BufferReader(buf);
+
+    reader.readBigSize(); // read type
+    instance.length = reader.readBigSize();
+    instance.announcementSig = reader.readBytes(64);
+    instance.oraclePubkey = reader.readBytes(32);
+    instance.oracleEvent = OracleEvent.deserialize(getTlv(reader));
+
+    return instance;
+  }
+
+  /**
+   * The type for oracle_announcement message. oracle_announcement = 55332
+   */
+  public type = OracleAnnouncement.type;
+
+  public length: bigint;
+
+  /** The signature enabling verifying the origin of the announcement. */
+  public announcementSig: Buffer;
+
+  /** The public key of the oracle (32 bytes, x-only). */
+  public oraclePubkey: Buffer;
+
+  /** The description of the event and attesting. */
+  public oracleEvent: OracleEvent;
+
+  /**
+   * Validates the oracle announcement according to rust-dlc specification.
+   * This includes validating the oracle event and verifying the announcement signature.
+   * @throws Will throw an error if validation fails
+   */
+  public validate(): void {
+    // Validate oracle event first
+    this.oracleEvent.validate();
+
+    // Validate oracle public key format (32 bytes for x-only)
+    if (!this.oraclePubkey || this.oraclePubkey.length !== 32) {
+      throw new Error('Oracle public key must be 32 bytes (x-only format)');
+    }
+
+    // Validate announcement signature format (64 bytes for Schnorr)
+    if (!this.announcementSig || this.announcementSig.length !== 64) {
+      throw new Error(
+        'Announcement signature must be 64 bytes (Schnorr format)',
+      );
+    }
+
+    // Verify announcement signature over the oracle event
+    try {
+      const msg = math.taggedHash(
+        'DLC/oracle/announcement/v0',
+        this.oracleEvent.serialize(),
+      );
+      verify(this.oraclePubkey, msg, this.announcementSig);
+    } catch (error) {
+      throw new Error(`Invalid announcement signature: ${error.message}`);
+    }
+  }
+
+  /**
+   * Returns the nonces from the oracle event.
+   * This is useful for finding matching oracle announcements.
+   */
+  public getNonces(): Buffer[] {
+    return this.oracleEvent.oracleNonces;
+  }
+
+  /**
+   * Returns the event maturity epoch from the oracle event.
+   */
+  public getEventMaturityEpoch(): number {
+    return this.oracleEvent.eventMaturityEpoch;
+  }
+
+  /**
+   * Returns the event ID from the oracle event.
+   */
+  public getEventId(): string {
+    return this.oracleEvent.eventId;
+  }
+
+  /**
+   * Converts oracle_announcement to JSON (canonical rust-dlc format)
+   */
+  public toJSON(): OracleAnnouncementJSON {
+    return {
+      announcementSignature: this.announcementSig.toString('hex'),
+      oraclePublicKey: this.oraclePubkey.toString('hex'),
+      oracleEvent: this.oracleEvent.toJSON(),
+    };
+  }
+
+  /**
+   * Serializes the oracle_announcement message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeBigSize(this.type);
+
+    const dataWriter = new BufferWriter();
+    dataWriter.writeBytes(this.announcementSig);
+    dataWriter.writeBytes(this.oraclePubkey);
+    dataWriter.writeBytes(this.oracleEvent.serialize());
+
+    writer.writeBigSize(dataWriter.size);
+    writer.writeBytes(dataWriter.toBuffer());
+
+    return writer.toBuffer();
+  }
+}
+
+export interface OracleAnnouncementJSON {
+  type?: number; // Made optional for rust-dlc compatibility
+  announcementSignature: string; // Canonical field name
+  oraclePublicKey: string; // Canonical field name
+  oracleEvent: IOracleEventJSON;
+}