@atomicfinance/types 4.1.3 → 4.1.4

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

@@ -0,0 +1,294 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+
+import { MessageType } from '../MessageType';
+import { IDlcMessage } from './DlcMessage';
+
+export abstract class EventDescriptor {
+  public static deserialize(
+    buf: Buffer,
+  ): EnumEventDescriptor | DigitDecompositionEventDescriptor {
+    const reader = new BufferReader(buf);
+
+    const type = Number(reader.readBigSize());
+
+    switch (type) {
+      case MessageType.EnumEventDescriptor:
+        return EnumEventDescriptor.deserialize(buf);
+      case MessageType.DigitDecompositionEventDescriptor:
+        return DigitDecompositionEventDescriptor.deserialize(buf);
+      default:
+        throw new Error(
+          `Payout function TLV type must be EnumEventDescriptorV0 or DigitDecompositionEventDescriptor`,
+        );
+    }
+  }
+
+  /**
+   * Creates an EventDescriptor from JSON data
+   * @param json JSON object representing event descriptor
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  public static fromJSON(json: any): EventDescriptor {
+    if (!json) {
+      throw new Error('eventDescriptor is required');
+    }
+
+    // Check if it's an enum event or digit decomposition event
+    if (json.enumEvent || json.enum_event) {
+      return EnumEventDescriptor.fromJSON(json.enumEvent || json.enum_event);
+    } else if (json.digitDecompositionEvent || json.digit_decomposition_event) {
+      return DigitDecompositionEventDescriptor.fromJSON(
+        json.digitDecompositionEvent || json.digit_decomposition_event,
+      );
+    } else {
+      throw new Error(
+        'eventDescriptor must have either enumEvent or digitDecompositionEvent',
+      );
+    }
+  }
+
+  public abstract type: number;
+
+  public abstract length: bigint;
+
+  public abstract toJSON():
+    | IEnumEventDescriptorJSON
+    | IDigitDecompositionEventDescriptorJSON;
+
+  public abstract serialize(): Buffer;
+}
+
+/**
+ * EnumEventDescriptor message contains the event outcomes for enumerated events.
+ * Simplified class name (removed V0 suffix).
+ */
+export class EnumEventDescriptor
+  extends EventDescriptor
+  implements IDlcMessage {
+  public static type = MessageType.EnumEventDescriptorV0;
+
+  /**
+   * Creates an EnumEventDescriptor from JSON data
+   * @param json JSON object representing an enum event descriptor
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  public static fromJSON(json: any): EnumEventDescriptor {
+    const instance = new EnumEventDescriptor();
+    instance.outcomes = json.outcomes || [];
+    return instance;
+  }
+
+  /**
+   * Deserializes an enum_event_descriptor_v0 message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): EnumEventDescriptor {
+    const instance = new EnumEventDescriptor();
+    const reader = new BufferReader(buf);
+
+    reader.readBigSize(); // read type
+    instance.length = reader.readBigSize(); // need to fix this
+    reader.readUInt16BE(); // num_outcomes
+
+    while (!reader.eof) {
+      const outcomeLen = reader.readBigSize();
+      const outcomeBuf = reader.readBytes(Number(outcomeLen));
+      instance.outcomes.push(outcomeBuf.toString());
+    }
+
+    return instance;
+  }
+
+  /**
+   * The type for enum_event_descriptor_v0 message. enum_event_descriptor_v0 = 55302
+   */
+  public type = EnumEventDescriptor.type;
+
+  public length = BigInt(0); // Required by EventDescriptor parent class
+
+  public outcomes: string[] = [];
+
+  /**
+   * Converts enum_event_descriptor to JSON
+   */
+  public toJSON(): IEnumEventDescriptorJSON {
+    return {
+      enumEvent: {
+        outcomes: this.outcomes,
+      },
+    };
+  }
+
+  /**
+   * Serializes the enum_event_descriptor_v0 message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeBigSize(this.type);
+
+    const dataWriter = new BufferWriter();
+    dataWriter.writeUInt16BE(this.outcomes.length);
+
+    for (const outcome of this.outcomes) {
+      dataWriter.writeBigSize(outcome.length);
+      dataWriter.writeBytes(Buffer.from(outcome));
+    }
+
+    writer.writeBigSize(dataWriter.size);
+    writer.writeBytes(dataWriter.toBuffer());
+
+    return writer.toBuffer();
+  }
+}
+
+// Legacy support - keep V0 alias for backward compatibility
+export const EnumEventDescriptorV0 = EnumEventDescriptor;
+export type EnumEventDescriptorV0 = EnumEventDescriptor;
+
+/**
+ * DigitDecompositionEventDescriptor is a simple enumeration of outcomes.
+ * Simplified class name (removed V0 suffix).
+ */
+export class DigitDecompositionEventDescriptor
+  extends EventDescriptor
+  implements IDlcMessage {
+  public static type = MessageType.DigitDecompositionEventDescriptor;
+
+  /**
+   * Creates a DigitDecompositionEventDescriptor from JSON data
+   * @param json JSON object representing digit decomposition event descriptor
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  public static fromJSON(json: any): DigitDecompositionEventDescriptor {
+    const instance = new DigitDecompositionEventDescriptor();
+    instance.base = json.base || 10;
+    instance.isSigned = json.isSigned || json.is_signed || false;
+    instance.unit = json.unit || '';
+    instance.precision = json.precision || 0;
+    instance.nbDigits = json.nbDigits || json.nb_digits || 0;
+    return instance;
+  }
+
+  /**
+   * Deserializes an digit_decomposition_event_descriptor message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): DigitDecompositionEventDescriptor {
+    const instance = new DigitDecompositionEventDescriptor();
+    const reader = new BufferReader(buf);
+
+    reader.readBigSize(); // read type
+    instance.length = reader.readBigSize(); // need to fix this
+
+    /**
+     * NOTE: BASE IS INCORRECT FORMAT FOR DLC SPEC (SHOULD BE BIGSIZE)
+     * Will be fixed in oracle_announcement_v1
+     * https://github.com/discreetlogcontracts/dlcspecs/blob/master/Oracle.md#version-0-digit_decomposition_event_descriptor
+     */
+    instance.base = reader.readUInt16BE();
+    instance.isSigned = reader.readUInt8() === 1;
+    const unitLen = reader.readBigSize();
+    const unitBuf = reader.readBytes(Number(unitLen));
+    instance.unit = unitBuf.toString();
+    instance.precision = reader.readUInt32BE();
+    instance.nbDigits = reader.readUInt16BE();
+
+    return instance;
+  }
+
+  /**
+   * The type for digit_decomposition_event_descriptor message. digit_decomposition_event_descriptor = 55306
+   */
+  public type = DigitDecompositionEventDescriptor.type;
+
+  public length: bigint;
+
+  public base: number; // Switch to bigint in oracle_announcement_v1
+
+  public isSigned: boolean;
+
+  public unit: string;
+
+  public precision: number;
+
+  public nbDigits: number;
+
+  /**
+   * Validates correctness of all fields in the message
+   * https://github.com/discreetlogcontracts/dlcspecs/blob/master/Oracle.md
+   * @throws Will throw an error if validation fails
+   */
+  public validate(): void {
+    if (this.base <= 0) {
+      throw new Error('base must be greater than 0');
+    }
+
+    // TODO: support isSigned according to specifications
+    if (this.isSigned) {
+      throw new Error('node-dlc does not support isSigned');
+    }
+  }
+
+  /**
+   * Converts digit_decomposition_event_descriptor to JSON (canonical rust-dlc format)
+   */
+  public toJSON(): IDigitDecompositionEventDescriptorJSON {
+    return {
+      digitDecompositionEvent: {
+        base: this.base,
+        isSigned: this.isSigned,
+        unit: this.unit,
+        precision: this.precision,
+        nbDigits: this.nbDigits,
+      },
+    };
+  }
+
+  /**
+   * Serializes the digit_decomposition_event_descriptor message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeBigSize(this.type);
+
+    const dataWriter = new BufferWriter();
+    dataWriter.writeUInt16BE(this.base); // Switch to BigSize in oracle_announcement_v1
+    dataWriter.writeUInt8(this.isSigned ? 1 : 0);
+    dataWriter.writeBigSize(this.unit.length);
+    dataWriter.writeBytes(Buffer.from(this.unit));
+    dataWriter.writeUInt32BE(this.precision);
+    dataWriter.writeUInt16BE(this.nbDigits);
+
+    writer.writeBigSize(dataWriter.size);
+    writer.writeBytes(dataWriter.toBuffer());
+
+    return writer.toBuffer();
+  }
+}
+
+// Legacy support - keep V0 alias for backward compatibility
+export const DigitDecompositionEventDescriptorV0 = DigitDecompositionEventDescriptor;
+export type DigitDecompositionEventDescriptorV0 = DigitDecompositionEventDescriptor;
+
+export interface IEnumEventDescriptorJSON {
+  enumEvent: {
+    outcomes: string[];
+  };
+}
+
+// Rust-dlc enum variant format for DigitDecompositionEventDescriptor
+export interface IDigitDecompositionEventDescriptorJSON {
+  digitDecompositionEvent: {
+    base: number;
+    isSigned: boolean;
+    unit: string;
+    precision: number;
+    nbDigits: number;
+  };
+}
+
+// Legacy interface
+export type IEnumEventDescriptorV0JSON = IEnumEventDescriptorJSON;
+
+// Legacy interface
+export type IDigitDecompositionEventDescriptorV0JSON = IDigitDecompositionEventDescriptorJSON;

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

@@ -0,0 +1,260 @@
+import { Sequence, Tx } from '@node-dlc/bitcoin';
+import { BufferReader, BufferWriter, StreamReader } from '@node-dlc/bufio';
+
+import { MessageType } from '../MessageType';
+import { bigIntToNumber, toBigInt } from '../util';
+import { DlcInput } from './DlcInput';
+import { IDlcMessage } from './DlcMessage';
+
+/**
+ * FundingInput contains information about a specific input to be used
+ * in a funding transaction, as well as its corresponding on-chain UTXO.
+ * Matches rust-dlc FundingInput struct.
+ */
+export class FundingInput implements IDlcMessage {
+  public static type = MessageType.FundingInput;
+
+  /**
+   * Creates a FundingInput from JSON data (e.g., from test vectors)
+   * @param json JSON object representing funding input
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  public static fromJSON(json: any): FundingInput {
+    const instance = new FundingInput();
+
+    instance.inputSerialId = toBigInt(
+      json.inputSerialId || json.input_serial_id,
+    );
+
+    // Parse previous transaction
+    const prevTxHex = json.prevTx || json.prev_tx;
+    if (prevTxHex) {
+      instance.prevTx = Tx.decode(
+        StreamReader.fromBuffer(Buffer.from(prevTxHex, 'hex')),
+      );
+    } else {
+      // Create a minimal transaction for test purposes
+      // TODO: This should be properly implemented when full test vector support is needed
+      const writer = new BufferWriter();
+      writer.writeUInt32BE(2); // version
+      writer.writeUInt8(0); // input count
+      writer.writeUInt8(1); // output count
+      writer.writeUInt64BE(BigInt(100000000)); // output value
+      writer.writeUInt8(25); // script length
+      writer.writeBytes(Buffer.alloc(25)); // script
+      writer.writeUInt32BE(0); // locktime
+
+      const txBytes = writer.toBuffer();
+      instance.prevTx = Tx.decode(StreamReader.fromBuffer(txBytes));
+    }
+
+    instance.prevTxVout = json.prevTxVout || json.prev_tx_vout || 0;
+    instance.sequence = new Sequence(json.sequence || 0xffffffff);
+    instance.maxWitnessLen = json.maxWitnessLen || json.max_witness_len || 108;
+
+    const redeemScript = json.redeemScript || json.redeem_script || '';
+    instance.redeemScript = Buffer.from(redeemScript, 'hex');
+
+    // Parse optional DLC input
+    const dlcInput = json.dlcInput || json.dlc_input;
+    if (dlcInput) {
+      instance.dlcInput = DlcInput.fromJSON(dlcInput);
+    }
+
+    return instance;
+  }
+
+  /**
+   * Deserializes a funding_input message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): FundingInput {
+    const instance = new FundingInput();
+    const reader = new BufferReader(buf);
+
+    reader.readBigSize(); // read type
+    instance.length = reader.readBigSize();
+    instance.inputSerialId = reader.readUInt64BE();
+    const prevTxLen = reader.readUInt16BE();
+    instance.prevTx = Tx.decode(
+      StreamReader.fromBuffer(reader.readBytes(prevTxLen)),
+    );
+    instance.prevTxVout = reader.readUInt32BE();
+    instance.sequence = new Sequence(reader.readUInt32BE());
+    instance.maxWitnessLen = reader.readUInt16BE();
+    const redeemScriptLen = reader.readUInt16BE();
+    instance.redeemScript = reader.readBytes(redeemScriptLen);
+
+    // Read optional DLC input using rust-dlc Optional format (0x00/0x01 prefix)
+    if (reader.position < reader.buffer.length) {
+      const dlcInputData = reader.readOptional();
+      if (dlcInputData) {
+        instance.dlcInput = DlcInput.deserializeBody(dlcInputData);
+      }
+    }
+
+    return instance;
+  }
+
+  /**
+   * Deserializes a funding_input message without TLV wrapper (for use in DlcOffer)
+   * This matches rust-dlc behavior where FundingInput is in a vector without individual TLV wrappers
+   * @param buf
+   */
+  public static deserializeBody(buf: Buffer): FundingInput {
+    const instance = new FundingInput();
+    const reader = new BufferReader(buf);
+
+    // No TLV type/length to read - funding input body is serialized directly
+    instance.inputSerialId = reader.readUInt64BE();
+
+    // Read prev_tx with BigSize length (to match rust-dlc)
+    const prevTxLen = Number(reader.readBigSize());
+    instance.prevTx = Tx.decode(
+      StreamReader.fromBuffer(reader.readBytes(prevTxLen)),
+    );
+
+    instance.prevTxVout = reader.readUInt32BE();
+    instance.sequence = new Sequence(reader.readUInt32BE());
+    instance.maxWitnessLen = reader.readUInt16BE();
+
+    // Test: Read redeem_script with simple u16 length (to match rust-bitcoin ScriptBuf)
+    const redeemScriptLen = reader.readUInt16BE();
+    instance.redeemScript = reader.readBytes(redeemScriptLen);
+
+    // Read optional DLC input using rust-dlc Optional format (0x00/0x01 prefix)
+    if (reader.position < reader.buffer.length) {
+      const dlcInputData = reader.readOptional();
+      if (dlcInputData) {
+        instance.dlcInput = DlcInput.deserializeBody(dlcInputData);
+      }
+    }
+
+    return instance;
+  }
+
+  /**
+   * The type for funding_input message. funding_input = 42772
+   */
+  public type = FundingInput.type;
+
+  public length: bigint;
+
+  public inputSerialId: bigint;
+
+  public prevTx: Tx;
+
+  public prevTxVout: number;
+
+  public sequence: Sequence;
+
+  public maxWitnessLen: number;
+
+  public redeemScript: Buffer;
+
+  public dlcInput?: DlcInput;
+
+  public scriptSigLength(): number {
+    if (this.redeemScript.length > 0) {
+      return 1 + this.redeemScript.length;
+    } else {
+      return 0;
+    }
+  }
+
+  /**
+   * Validates correctness of all fields
+   * @throws Will throw an error if validation fails
+   */
+  public validate(): void {
+    // 1. Type is set automatically in class
+    // 2. Ensure inputs are segwit
+    if (!this.prevTx.isSegWit) throw new Error('fundingInput must be segwit');
+  }
+
+  /**
+   * Converts funding_input to JSON (canonical rust-dlc format)
+   */
+  public toJSON(): IFundingInputJSON {
+    const result: IFundingInputJSON = {
+      inputSerialId: bigIntToNumber(this.inputSerialId),
+      prevTx: this.prevTx.serialize().toString('hex'),
+      prevTxVout: this.prevTxVout,
+      sequence: this.sequence.value,
+      maxWitnessLen: this.maxWitnessLen,
+      redeemScript: this.redeemScript.toString('hex'),
+    };
+
+    if (this.dlcInput) {
+      result.dlcInput = this.dlcInput.toJSON();
+    }
+
+    return result;
+  }
+
+  /**
+   * Serializes the funding_input message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeBigSize(this.type);
+
+    const dataWriter = new BufferWriter();
+    dataWriter.writeUInt64BE(this.inputSerialId);
+    dataWriter.writeUInt16BE(this.prevTx.serialize().length);
+    dataWriter.writeBytes(this.prevTx.serialize());
+    dataWriter.writeUInt32BE(this.prevTxVout);
+    dataWriter.writeUInt32BE(this.sequence.value);
+    dataWriter.writeUInt16BE(this.maxWitnessLen);
+    dataWriter.writeUInt16BE(this.redeemScript.length);
+    dataWriter.writeBytes(this.redeemScript);
+
+    // Write optional DLC input using rust-dlc Optional format (0x00/0x01 prefix)
+    const dlcInputData = this.dlcInput ? this.dlcInput.serializeBody() : null;
+    dataWriter.writeOptional(dlcInputData);
+
+    writer.writeBigSize(dataWriter.size);
+    writer.writeBytes(dataWriter.toBuffer());
+
+    return writer.toBuffer();
+  }
+
+  public serializeBody(): Buffer {
+    // Serialize funding input body without TLV wrapper (for embedding in DlcOffer)
+    // This matches rust-dlc behavior where FundingInput.write() doesn't add type_id
+    const writer = new BufferWriter();
+    writer.writeUInt64BE(this.inputSerialId);
+
+    // Use BigSize for prev_tx length to match rust-dlc (prev_tx, vec)
+    writer.writeBigSize(this.prevTx.serialize().length);
+    writer.writeBytes(this.prevTx.serialize());
+
+    writer.writeUInt32BE(this.prevTxVout);
+    writer.writeUInt32BE(this.sequence.value);
+    writer.writeUInt16BE(this.maxWitnessLen);
+
+    // Test: Use simple u16 length for redeem_script to match rust-bitcoin ScriptBuf
+    writer.writeUInt16BE(this.redeemScript.length);
+    writer.writeBytes(this.redeemScript);
+
+    // Write optional DLC input using rust-dlc Optional format (0x00/0x01 prefix)
+    const dlcInputData = this.dlcInput ? this.dlcInput.serializeBody() : null;
+    writer.writeOptional(dlcInputData);
+
+    return writer.toBuffer();
+  }
+}
+
+export interface IFundingInputJSON {
+  inputSerialId: number;
+  prevTx: string;
+  prevTxVout: number;
+  sequence: number;
+  maxWitnessLen: number;
+  redeemScript: string;
+  dlcInput?: {
+    localFundPubkey: string;
+    remoteFundPubkey: string;
+    contractId: string;
+  };
+}

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

@@ -0,0 +1,98 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+
+import { MessageType } from '../MessageType';
+import { IDlcMessage } from './DlcMessage';
+import { IScriptWitnessV0JSON, ScriptWitnessV0 } from './ScriptWitnessV0';
+
+/**
+ * FundingSignatures contains signatures of the funding transaction
+ * and any necessary information linking the signatures to their inputs.
+ */
+export class FundingSignatures implements IDlcMessage {
+  public static type = MessageType.FundingSignatures;
+
+  /**
+   * Deserializes a funding_signatures message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): FundingSignatures {
+    const instance = new FundingSignatures();
+    const reader = new BufferReader(buf);
+
+    // reader.readBigSize(); // read type
+    // instance.length = reader.readBigSize();
+    const numWitnesses = Number(reader.readBigSize());
+
+    for (let i = 0; i < numWitnesses; i++) {
+      const numWitnessElements = Number(reader.readBigSize());
+      const witnessElements: ScriptWitnessV0[] = [];
+      for (let j = 0; j < numWitnessElements; j++) {
+        // Read witness element directly: [bigsize:len][len*byte:witness]
+        const witnessLength = Number(reader.readBigSize());
+        const witnessBytes = reader.readBytes(witnessLength);
+
+        const witness = new ScriptWitnessV0();
+        witness.length = witnessLength;
+        witness.witness = witnessBytes;
+        witnessElements.push(witness);
+      }
+      instance.witnessElements.push(witnessElements);
+    }
+
+    return instance;
+  }
+
+  /**
+   * The type for funding_signatures message. funding_signatures = 42776
+   */
+  public type = FundingSignatures.type;
+
+  public length: bigint;
+
+  public witnessElements: ScriptWitnessV0[][] = [];
+
+  /**
+   * Converts funding_signatures to JSON (canonical rust-dlc format)
+   */
+  public toJSON(): IFundingSignaturesJSON {
+    return {
+      fundingSignatures: this.witnessElements.map((witnessElement) => {
+        return {
+          witnessElements: witnessElement.map((witness) => witness.toJSON()),
+        };
+      }),
+    };
+  }
+
+  /**
+   * Serializes the funding_signatures message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    // writer.writeBigSize(this.type);
+
+    const dataWriter = new BufferWriter();
+
+    dataWriter.writeBigSize(this.witnessElements.length);
+
+    for (const witnessElements of this.witnessElements) {
+      dataWriter.writeBigSize(witnessElements.length);
+      for (const witnessElement of witnessElements) {
+        dataWriter.writeBytes(witnessElement.serialize());
+      }
+    }
+
+    // writer.writeBigSize(dataWriter.size);
+    writer.writeBytes(dataWriter.toBuffer());
+
+    return writer.toBuffer();
+  }
+}
+
+export interface IFundingSignaturesJSON {
+  fundingSignatures: IFundingSignatureJSON[];
+}
+
+export interface IFundingSignatureJSON {
+  witnessElements: IScriptWitnessV0JSON[];
+}

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

@@ -0,0 +1,6 @@
+import { MessageType } from '../MessageType';
+
+export interface IWireMessage {
+  type: MessageType;
+  serialize(): Buffer;
+}