@atomicfinance/types 3.6.0 → 4.0.0

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

@@ -0,0 +1,302 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+
+import { MessageType, PROTOCOL_VERSION } from '../MessageType';
+import { deserializeTlv } from '../serialize/deserializeTlv';
+import { getTlv } from '../serialize/getTlv';
+import { bigIntToNumber, toBigInt } from '../util';
+import { IDlcMessage } from './DlcMessage';
+import { FundingInput, IFundingInputJSON } from './FundingInput';
+import { FundingSignatures, IFundingSignaturesJSON } from './FundingSignatures';
+import { ScriptWitnessV0 } from './ScriptWitnessV0';
+
+/**
+ * DlcClose message contains information about a node and indicates its
+ * desire to close an existing contract.
+ * Updated to follow DlcOffer architectural patterns.
+ */
+export class DlcClose implements IDlcMessage {
+  public static type = MessageType.DlcClose;
+
+  /**
+   * Creates a DlcClose from JSON data (e.g., from test vectors)
+   * Handles both our internal format and external test vector formats
+   * @param json JSON object representing a DLC close message
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  public static fromJSON(json: any): DlcClose {
+    const instance = new DlcClose();
+
+    // Basic fields with field name variations
+    instance.protocolVersion =
+      json.protocolVersion || json.protocol_version || PROTOCOL_VERSION;
+
+    // Basic fields with field name variations
+    instance.contractId = Buffer.from(
+      json.contractId || json.contract_id,
+      'hex',
+    );
+    instance.closeSignature = Buffer.from(
+      json.closeSignature || json.close_signature,
+      'hex',
+    );
+
+    // Use toBigInt helper to handle BigInt values from json-bigint
+    instance.offerPayoutSatoshis = toBigInt(
+      json.offerPayoutSatoshis || json.offer_payout_satoshis,
+    );
+    instance.acceptPayoutSatoshis = toBigInt(
+      json.acceptPayoutSatoshis || json.accept_payout_satoshis,
+    );
+    instance.fundInputSerialId = toBigInt(
+      json.fundInputSerialId || json.fund_input_serial_id,
+    );
+
+    // Use FundingInput.fromJSON() for each funding input - proper delegation
+    instance.fundingInputs = (json.fundingInputs || json.funding_inputs || [])
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .map((inputJson: any) => FundingInput.fromJSON(inputJson));
+
+    // Create FundingSignatures manually since it doesn't have fromJSON
+    if (json.fundingSignatures || json.funding_signatures) {
+      instance.fundingSignatures = new FundingSignatures();
+      const sigData = json.fundingSignatures || json.funding_signatures;
+
+      // Handle different possible structures
+      if (sigData.fundingSignatures) {
+        // Standard format
+        instance.fundingSignatures.witnessElements = sigData.fundingSignatures.map(
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (sig: any) =>
+            sig.witnessElements?.map((elem: any) => {
+              const witness = new ScriptWitnessV0();
+              witness.length =
+                elem.length || Buffer.from(elem.witness || '', 'hex').length;
+              witness.witness = Buffer.from(elem.witness || '', 'hex');
+              return witness;
+            }) || [],
+        );
+      } else if (Array.isArray(sigData)) {
+        // Array format
+        instance.fundingSignatures.witnessElements = sigData.map(
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (sig: any) =>
+            sig.witnessElements?.map((elem: any) => {
+              const witness = new ScriptWitnessV0();
+              witness.length =
+                elem.length || Buffer.from(elem.witness || '', 'hex').length;
+              witness.witness = Buffer.from(elem.witness || '', 'hex');
+              return witness;
+            }) || [],
+        );
+      }
+    }
+
+    return instance;
+  }
+
+  /**
+   * Deserializes a close_dlc message with backward compatibility
+   * Detects old format (without protocol_version) vs new format (with protocol_version)
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): DlcClose {
+    const instance = new DlcClose();
+    const reader = new BufferReader(buf);
+
+    const type = reader.readUInt16BE(); // read type
+
+    // Validate type matches expected DlcClose type
+    if (type !== MessageType.DlcClose) {
+      throw new Error(
+        `Invalid message type. Expected ${MessageType.DlcClose}, got ${type}`,
+      );
+    }
+
+    // Read protocol version
+    instance.protocolVersion = reader.readUInt32BE();
+    instance.contractId = reader.readBytes(32);
+    instance.closeSignature = reader.readBytes(64);
+    instance.offerPayoutSatoshis = reader.readUInt64BE();
+    instance.acceptPayoutSatoshis = reader.readUInt64BE();
+    instance.fundInputSerialId = reader.readUInt64BE();
+
+    // Changed from u16 to bigsize for consistency with DlcOffer
+    const fundingInputsLen = Number(reader.readBigSize());
+
+    for (let i = 0; i < fundingInputsLen; i++) {
+      // FundingInput body is serialized directly without TLV wrapper in rust-dlc format
+      const fundingInput = FundingInput.deserializeBody(
+        reader.buffer.subarray(reader.position),
+      );
+      instance.fundingInputs.push(fundingInput);
+
+      // Skip past the FundingInput we just read
+      const fundingInputLength = fundingInput.serializeBody().length;
+      reader.position += fundingInputLength;
+    }
+
+    // Handle FundingSignatures - deserialize raw data (no TLV wrapper) like DlcSign
+    instance.fundingSignatures = FundingSignatures.deserialize(
+      reader.buffer.subarray(reader.position),
+    );
+
+    // Skip past the funding signatures we just read
+    const fundingLength = instance.fundingSignatures.serialize().length;
+    reader.position += fundingLength;
+
+    // Parse any additional TLV stream (for future extensibility)
+    while (!reader.eof) {
+      const buf = getTlv(reader);
+      const tlvReader = new BufferReader(buf);
+      const { type } = deserializeTlv(tlvReader);
+
+      // Store unknown TLVs for future compatibility
+      if (!instance.unknownTlvs) {
+        instance.unknownTlvs = [];
+      }
+      instance.unknownTlvs.push({ type: Number(type), data: buf });
+    }
+
+    return instance;
+  }
+
+  /**
+   * The type for close_dlc message. close_dlc = 52170
+   */
+  public type = DlcClose.type;
+
+  // New fields as per dlcspecs PR #163
+  public protocolVersion: number = PROTOCOL_VERSION; // Default to current protocol version
+
+  public contractId: Buffer;
+
+  public closeSignature: Buffer;
+
+  public offerPayoutSatoshis: bigint;
+
+  public acceptPayoutSatoshis: bigint;
+
+  public fundInputSerialId: bigint;
+
+  public fundingInputs: FundingInput[] = [];
+
+  public fundingSignatures: FundingSignatures;
+
+  // Store unknown TLVs for forward compatibility
+  public unknownTlvs?: Array<{ type: number; data: Buffer }>;
+
+  /**
+   * Validates correctness of all fields
+   * @throws Will throw an error if validation fails
+   */
+  public validate(): void {
+    // Type is set automatically in class
+
+    // protocol_version validation
+    if (this.protocolVersion !== PROTOCOL_VERSION) {
+      throw new Error(
+        `Unsupported protocol version: ${this.protocolVersion}, expected: ${PROTOCOL_VERSION}`,
+      );
+    }
+
+    // contractId validation
+    if (!this.contractId || this.contractId.length !== 32) {
+      throw new Error('contractId must be 32 bytes');
+    }
+
+    // closeSignature validation
+    if (!this.closeSignature || this.closeSignature.length !== 64) {
+      throw new Error('closeSignature must be 64 bytes');
+    }
+
+    // Ensure input serial ids are unique
+    const inputSerialIds = this.fundingInputs.map(
+      (input: FundingInput) => input.inputSerialId,
+    );
+
+    if (new Set(inputSerialIds).size !== inputSerialIds.length) {
+      throw new Error('inputSerialIds must be unique');
+    }
+
+    // Ensure funding inputs are segwit
+    this.fundingInputs.forEach((input: FundingInput) => input.validate());
+
+    // Note: FundingSignatures doesn't have a validate method, so we skip validation
+  }
+
+  /**
+   * Converts dlc_close to JSON (canonical rust-dlc format)
+   */
+  public toJSON(): IDlcCloseJSON {
+    // Include unknown TLVs for debugging
+    const tlvs = [];
+    if (this.unknownTlvs) {
+      this.unknownTlvs.forEach((tlv) =>
+        tlvs.push({ type: tlv.type, data: tlv.data.toString('hex') }),
+      );
+    }
+
+    // Return canonical rust-dlc format
+    return {
+      protocolVersion: this.protocolVersion,
+      contractId: this.contractId.toString('hex'),
+      closeSignature: this.closeSignature.toString('hex'),
+      offerPayoutSatoshis: bigIntToNumber(this.offerPayoutSatoshis),
+      acceptPayoutSatoshis: bigIntToNumber(this.acceptPayoutSatoshis),
+      fundInputSerialId: bigIntToNumber(this.fundInputSerialId),
+      fundingInputs: this.fundingInputs.map((input) => input.toJSON()),
+      fundingSignatures: this.fundingSignatures.toJSON(),
+    } as any; // Allow different field names from interface
+  }
+
+  /**
+   * Serializes the close_dlc message into a Buffer
+   * Updated serialization format to match DlcOffer patterns
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeUInt16BE(this.type);
+
+    // New fields as per dlcspecs PR #163
+    writer.writeUInt32BE(this.protocolVersion);
+    writer.writeBytes(this.contractId);
+    writer.writeBytes(this.closeSignature);
+    writer.writeUInt64BE(this.offerPayoutSatoshis);
+    writer.writeUInt64BE(this.acceptPayoutSatoshis);
+    writer.writeUInt64BE(this.fundInputSerialId);
+
+    // Changed from u16 to bigsize for consistency with DlcOffer
+    writer.writeBigSize(this.fundingInputs.length);
+
+    for (const fundingInput of this.fundingInputs) {
+      // Use serializeBody() to match rust-dlc behavior - funding inputs in vec are serialized without TLV wrapper
+      writer.writeBytes(fundingInput.serializeBody());
+    }
+
+    // Serialize FundingSignatures directly (no TLV wrapper) like DlcSign
+    writer.writeBytes(this.fundingSignatures.serialize());
+
+    // Write unknown TLVs for forward compatibility
+    if (this.unknownTlvs) {
+      this.unknownTlvs.forEach((tlv) => {
+        writer.writeBytes(tlv.data);
+      });
+    }
+
+    return writer.toBuffer();
+  }
+}
+
+export interface IDlcCloseJSON {
+  type?: number; // Made optional for rust-dlc compatibility
+  protocolVersion: number;
+  contractId: string;
+  closeSignature: string;
+  offerPayoutSatoshis: number;
+  acceptPayoutSatoshis: number;
+  fundInputSerialId: number;
+  fundingInputs: IFundingInputJSON[];
+  fundingSignatures: IFundingSignaturesJSON;
+  serialized?: string; // Made optional - hex serialization for compatibility testing
+  tlvs?: any[]; // Made optional - for unknown TLVs
+}

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

@@ -0,0 +1,121 @@
+import { Tx } from '@node-dlc/bitcoin';
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+
+import { DlcAccept, DlcOffer, DlcTransactions } from '..';
+import { MessageType } from '../MessageType';
+import { IDlcMessage } from './DlcMessage';
+
+/**
+ * DlcClose Metadata object contains information required for verifying DlcClose
+ * message.
+ */
+export class DlcCloseMetadata {
+  /**
+   * Convert JSON to DlcCloseMetadata
+   * @param json
+   */
+  public static fromJSON(json: IDlcCloseMetadataJSON): DlcCloseMetadata {
+    const instance = new DlcCloseMetadata();
+
+    instance.offerFundingPubKey = Buffer.from(json.offerFundingPubKey, 'hex');
+    instance.acceptFundingPubKey = Buffer.from(json.acceptFundingPubKey, 'hex');
+    instance.offerPayoutSPK = Buffer.from(json.offerPayoutSPK, 'hex');
+    instance.acceptPayoutSPK = Buffer.from(json.acceptPayoutSPK, 'hex');
+    instance.offerPayoutSerialId = BigInt(json.offerPayoutSerialId);
+    instance.acceptPayoutSerialId = BigInt(json.acceptPayoutSerialId);
+    instance.feeRatePerVb = BigInt(json.feeRatePerVb);
+    instance.fundTx = Tx.fromHex(json.fundTx);
+    instance.fundTxVout = json.fundTxVout;
+
+    return instance;
+  }
+
+  public static fromDlcMessages(
+    dlcOffer: DlcOffer,
+    dlcAccept: DlcAccept,
+    dlcTxs: DlcTransactions,
+  ): DlcCloseMetadata {
+    const instance = new DlcCloseMetadata();
+
+    instance.offerFundingPubKey = dlcOffer.fundingPubkey;
+    instance.acceptFundingPubKey = dlcAccept.fundingPubkey;
+    instance.offerPayoutSPK = dlcOffer.payoutSpk;
+    instance.acceptPayoutSPK = dlcAccept.payoutSpk;
+    instance.offerPayoutSerialId = dlcOffer.payoutSerialId;
+    instance.acceptPayoutSerialId = dlcAccept.payoutSerialId;
+    instance.feeRatePerVb = dlcOffer.feeRatePerVb;
+    instance.fundTx = dlcTxs.fundTx;
+    instance.fundTxVout = dlcTxs.fundTxVout;
+
+    return instance;
+  }
+
+  public offerFundingPubKey: Buffer;
+
+  public acceptFundingPubKey: Buffer;
+
+  public offerPayoutSPK: Buffer;
+
+  public acceptPayoutSPK: Buffer;
+
+  public offerPayoutSerialId: bigint;
+
+  public acceptPayoutSerialId: bigint;
+
+  public feeRatePerVb: bigint;
+
+  public fundTx: Tx;
+
+  public fundTxVout: number;
+
+  /**
+   * Converts dlc_close_metadata to JSON
+   */
+  public toJSON(): IDlcCloseMetadataJSON {
+    return {
+      offerFundingPubKey: this.offerFundingPubKey.toString('hex'),
+      acceptFundingPubKey: this.acceptFundingPubKey.toString('hex'),
+      offerPayoutSPK: this.offerPayoutSPK.toString('hex'),
+      acceptPayoutSPK: this.acceptPayoutSPK.toString('hex'),
+      offerPayoutSerialId: Number(this.offerPayoutSerialId),
+      acceptPayoutSerialId: Number(this.acceptPayoutSerialId),
+      feeRatePerVb: Number(this.feeRatePerVb),
+      fundTx: this.fundTx.serialize().toString('hex'),
+      fundTxVout: this.fundTxVout,
+    };
+  }
+
+  public toDlcMessages(): {
+    dlcOffer: DlcOffer;
+    dlcAccept: DlcAccept;
+    dlcTxs: DlcTransactions;
+  } {
+    const dlcOffer = new DlcOffer();
+    const dlcAccept = new DlcAccept();
+    const dlcTxs = new DlcTransactions();
+
+    dlcOffer.fundingPubkey = this.offerFundingPubKey;
+    dlcAccept.fundingPubkey = this.acceptFundingPubKey;
+    dlcOffer.payoutSpk = this.offerPayoutSPK;
+    dlcAccept.payoutSpk = this.acceptPayoutSPK;
+    dlcOffer.payoutSerialId = this.offerPayoutSerialId;
+    dlcAccept.payoutSerialId = this.acceptPayoutSerialId;
+    dlcOffer.feeRatePerVb = this.feeRatePerVb;
+    dlcTxs.fundTx = this.fundTx;
+    dlcTxs.fundTxVout = this.fundTxVout;
+
+    return { dlcOffer, dlcAccept, dlcTxs };
+  }
+}
+
+export interface IDlcCloseMetadataJSON {
+  offerFundingPubKey: string;
+  acceptFundingPubKey: string;
+  offerPayoutSPK: string;
+  acceptPayoutSPK: string;
+  offerPayoutSerialId: number;
+  acceptPayoutSerialId: number;
+  feeRatePerVb: number;
+  fundTx: string;
+  fundTxVout: number;
+}

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

@@ -0,0 +1,67 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+
+import { MessageType } from '../MessageType';
+import { IDlcMessage } from './DlcMessage';
+
+/**
+ * DlcIds message contains list of buffers
+ */
+export class DlcIds implements IDlcMessage {
+  public static type = MessageType.DlcIds;
+
+  public static deserialize(buf: Buffer): DlcIds {
+    const reader = new BufferReader(buf);
+
+    const type = Number(reader.readUInt16BE());
+
+    switch (type) {
+      case MessageType.DlcIdsV0:
+        return DlcIds.deserializeV0(buf);
+      default:
+        throw new Error(`DLC IDs message type must be DlcIdsV0`);
+    }
+  }
+
+  /**
+   * Deserializes an dlc_ids message
+   * @param buf
+   */
+  private static deserializeV0(buf: Buffer): DlcIds {
+    const instance = new DlcIds();
+    const reader = new BufferReader(buf);
+
+    reader.readUInt16BE(); // read type
+    const idsLen = reader.readBigSize(); // ids length
+
+    for (let i = 0; i < idsLen; i++) {
+      instance.ids.push(reader.readBytes(32));
+    }
+
+    return instance;
+  }
+
+  /**
+   * The type for dlc_ids message
+   */
+  public type = DlcIds.type;
+
+  public ids: Buffer[] = [];
+
+  /**
+   * Serializes the dlc_ids message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeUInt16BE(this.type);
+    writer.writeBigSize(this.ids.length);
+    for (const id of this.ids) {
+      writer.writeBytes(id);
+    }
+
+    return writer.toBuffer();
+  }
+}
+
+// Legacy support - keeping old class name as alias
+export const DlcIdsV0 = DlcIds;
+export type DlcIdsV0 = DlcIds;

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

@@ -0,0 +1,81 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+
+import { MessageType } from '../MessageType';
+import { IDlcMessage } from './DlcMessage';
+
+/**
+ * DlcInfo message contains list of buffers
+ */
+export class DlcInfo implements IDlcMessage {
+  public static type = MessageType.DlcInfo;
+
+  public static deserialize(buf: Buffer): DlcInfo {
+    const reader = new BufferReader(buf);
+
+    const type = Number(reader.readUInt16BE());
+
+    switch (type) {
+      case MessageType.DlcInfoV0:
+        return DlcInfo.deserializeV0(buf);
+      default:
+        throw new Error(`DLC Info message type must be DlcInfoV0`);
+    }
+  }
+
+  /**
+   * Deserializes an dlc_info message
+   * @param buf
+   */
+  private static deserializeV0(buf: Buffer): DlcInfo {
+    const instance = new DlcInfo();
+    const reader = new BufferReader(buf);
+
+    reader.readUInt16BE(); // read type
+
+    instance.numDlcOffers = reader.readUInt32BE();
+    instance.numDlcAccepts = reader.readUInt32BE();
+    instance.numDlcSigns = reader.readUInt32BE();
+    instance.numDlcCancels = reader.readUInt32BE();
+    instance.numDlcCloses = reader.readUInt32BE();
+    instance.numDlcTransactions = reader.readUInt32BE();
+
+    return instance;
+  }
+
+  /**
+   * The type for dlc_info message
+   */
+  public type = DlcInfo.type;
+
+  public numDlcOffers: number;
+
+  public numDlcAccepts: number;
+
+  public numDlcSigns: number;
+
+  public numDlcCancels: number;
+
+  public numDlcCloses: number;
+
+  public numDlcTransactions: number;
+
+  /**
+   * Serializes the dlc_info message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeUInt16BE(this.type);
+    writer.writeUInt32BE(this.numDlcOffers);
+    writer.writeUInt32BE(this.numDlcAccepts);
+    writer.writeUInt32BE(this.numDlcSigns);
+    writer.writeUInt32BE(this.numDlcCancels);
+    writer.writeUInt32BE(this.numDlcCloses);
+    writer.writeUInt32BE(this.numDlcTransactions);
+
+    return writer.toBuffer();
+  }
+}
+
+// Legacy support - keeping old class name as alias
+export const DlcInfoV0 = DlcInfo;
+export type DlcInfoV0 = DlcInfo;

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

@@ -0,0 +1,87 @@
+import { BufferReader } from '@node-dlc/bufio';
+
+import { MessageType } from '../MessageType';
+import {
+  EnumeratedDescriptor,
+  NumericalDescriptor,
+} from './ContractDescriptor';
+import {
+  DisjointContractInfo,
+  IContractInfoV0JSON,
+  IContractInfoV1JSON,
+  SingleContractInfo,
+} from './ContractInfo';
+import { DlcAccept } from './DlcAccept';
+import { DlcClose } from './DlcClose';
+import { DlcOffer } from './DlcOffer';
+import { DlcSign } from './DlcSign';
+import { NodeAnnouncementMessage } from './NodeAnnouncementMessage';
+import { OracleAnnouncement } from './OracleAnnouncement';
+import { OracleAttestation } from './OracleAttestation';
+import { OrderAccept } from './OrderAccept';
+import { OrderOffer } from './OrderOffer';
+
+export interface IDlcMessage {
+  type: number;
+  serialize(): Buffer;
+}
+
+export type ContractInfoV0JSON = IContractInfoV0JSON;
+export type ContractInfoV1JSON = IContractInfoV1JSON;
+
+export abstract class DlcMessage {
+  public static deserialize(
+    buf: Buffer,
+  ):
+    | EnumeratedDescriptor
+    | NumericalDescriptor
+    | SingleContractInfo
+    | DisjointContractInfo
+    | OrderOffer
+    | OrderAccept
+    | DlcOffer
+    | DlcAccept
+    | DlcSign
+    | DlcClose
+    | OracleAttestation
+    | OracleAnnouncement
+    | NodeAnnouncementMessage {
+    const reader = new BufferReader(buf);
+    const type = reader.readUInt16BE();
+
+    switch (type) {
+      case MessageType.ContractDescriptorV0:
+        return EnumeratedDescriptor.deserialize(buf);
+      case MessageType.ContractDescriptorV1:
+        return NumericalDescriptor.deserialize(buf);
+      case MessageType.SingleContractInfo:
+        return SingleContractInfo.deserialize(buf);
+      case MessageType.DisjointContractInfo:
+        return DisjointContractInfo.deserialize(buf);
+      case MessageType.OrderOffer:
+        return OrderOffer.deserialize(buf);
+      case MessageType.OrderAccept:
+        return OrderAccept.deserialize(buf);
+      case MessageType.DlcOffer:
+        return DlcOffer.deserialize(buf);
+      case MessageType.DlcAccept:
+        return DlcAccept.deserialize(buf);
+      case MessageType.DlcSign:
+        return DlcSign.deserialize(buf);
+      case MessageType.DlcClose:
+        return DlcClose.deserialize(buf);
+      case MessageType.OracleAttestation:
+        return OracleAttestation.deserialize(buf);
+      case MessageType.OracleAnnouncement:
+        return OracleAnnouncement.deserialize(buf);
+      case MessageType.NodeAnnouncement:
+        return NodeAnnouncementMessage.deserialize(buf);
+      default:
+        throw new Error(`DlcMessage type ${type} not supported`);
+    }
+  }
+
+  public abstract type: number;
+
+  public abstract serialize(): Buffer;
+}