@atomicfinance/bitcoin-dlc-provider 3.6.1 → 4.0.0

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

@@ -0,0 +1,127 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+
+import { MessageType } from '../MessageType';
+import { toBigInt } from '../util';
+import { IDlcMessage } from './DlcMessage';
+
+/**
+ * RoundingIntervals defines rounding intervals for numeric outcome contracts.
+ * Updated to match dlcspecs format (no longer uses TLV).
+ */
+export class RoundingIntervals implements IDlcMessage {
+  public static type = MessageType.RoundingIntervals;
+
+  /**
+   * Creates a RoundingIntervals from JSON data
+   * @param json JSON object representing rounding intervals
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  public static fromJSON(json: any): RoundingIntervals {
+    const instance = new RoundingIntervals();
+
+    const intervals = json.intervals || [];
+    instance.intervals = intervals.map((interval: any) => ({
+      beginInterval: toBigInt(
+        interval.beginInterval || interval.begin_interval,
+      ),
+      roundingMod: toBigInt(interval.roundingMod || interval.rounding_mod),
+    }));
+
+    return instance;
+  }
+
+  /**
+   * Deserializes a rounding_intervals message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): RoundingIntervals {
+    const instance = new RoundingIntervals();
+    const reader = new BufferReader(buf);
+
+    const numRoundingIntervals = Number(reader.readBigSize());
+
+    for (let i = 0; i < numRoundingIntervals; i++) {
+      const beginInterval = reader.readUInt64BE();
+      const roundingMod = reader.readUInt64BE();
+
+      instance.intervals.push({ beginInterval, roundingMod });
+    }
+
+    return instance;
+  }
+
+  /**
+   * The type for rounding_intervals message. rounding_intervals = 42788
+   */
+  public type = RoundingIntervals.type;
+
+  public intervals: IInterval[] = [];
+
+  /**
+   * Validates correctness of all fields in the message
+   * https://github.com/discreetlogcontracts/dlcspecs/blob/master/NumericOutcome.md#requirements
+   * @throws Will throw an error if validation fails
+   */
+  public validate(): void {
+    // 1. Intervals must be non-negative
+    for (const interval of this.intervals) {
+      if (interval.beginInterval < 0) {
+        throw new Error('beginInterval must be non-negative');
+      }
+    }
+
+    // 2. Intervals must be strictly increasing
+    for (let i = 1; i < this.intervals.length; ++i) {
+      if (
+        this.intervals[i - 1].beginInterval >= this.intervals[i].beginInterval
+      ) {
+        throw new Error(`Intervals must be strictly increasing`);
+      }
+    }
+  }
+
+  /**
+   * Converts rounding_intervals to JSON
+   */
+  public toJSON(): IRoundingIntervalsJSON {
+    return {
+      intervals: this.intervals.map((interval) => {
+        return {
+          beginInterval: Number(interval.beginInterval),
+          roundingMod: Number(interval.roundingMod),
+        };
+      }),
+    };
+  }
+
+  /**
+   * Serializes the rounding_intervals message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+
+    writer.writeBigSize(this.intervals.length);
+
+    for (const interval of this.intervals) {
+      writer.writeUInt64BE(interval.beginInterval);
+      writer.writeUInt64BE(interval.roundingMod);
+    }
+
+    return writer.toBuffer();
+  }
+}
+
+interface IInterval {
+  beginInterval: bigint;
+  roundingMod: bigint;
+}
+
+interface IIntervalJSON {
+  beginInterval: number;
+  roundingMod: number;
+}
+
+export interface IRoundingIntervalsJSON {
+  type?: number; // Optional for rust-dlc compatibility
+  intervals: IIntervalJSON[];
+}

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

@@ -0,0 +1,63 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+
+/**
+ * ScriptWitness is the data for a witness element in a witness stack.
+ * An empty witness_stack is an error, as every input must be Segwit.
+ * Witness elements should not include their length as part of the witness
+ * data.
+ */
+export class ScriptWitnessV0 {
+  /**
+   * Deserializes an script_witness_v0 message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): ScriptWitnessV0 {
+    const instance = new ScriptWitnessV0();
+    const reader = new BufferReader(buf);
+
+    instance.length = Number(reader.readBigSize());
+    instance.witness = reader.readBytes(instance.length);
+
+    return instance;
+  }
+
+  public static getWitness(reader: BufferReader): Buffer {
+    const length = Number(reader.readBigSize());
+    const body = reader.readBytes(Number(length));
+
+    const writer = new BufferWriter();
+    writer.writeBigSize(length);
+    writer.writeBytes(body);
+
+    return writer.toBuffer();
+  }
+
+  public length: number;
+
+  public witness: Buffer;
+
+  /**
+   * Converts script_witness_v0 to JSON
+   */
+  public toJSON(): IScriptWitnessV0JSON {
+    return {
+      witness: this.witness.toString('hex'),
+    };
+  }
+
+  /**
+   * Serializes the script_witness_v0 message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+
+    writer.writeBigSize(this.witness.length);
+    writer.writeBytes(this.witness);
+
+    return writer.toBuffer();
+  }
+}
+
+export interface IScriptWitnessV0JSON {
+  witness: string;
+}

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

@@ -0,0 +1,40 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+
+export class Tlv {
+  /**
+   * Deserializes an tlv message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): Tlv {
+    const instance = new Tlv();
+    const reader = new BufferReader(buf);
+
+    instance.type = Number(reader.readBigSize()); // read type
+    instance.length = reader.readBigSize();
+    instance.body = reader.readBytes(Number(instance.length));
+
+    return instance;
+  }
+
+  public type: number;
+
+  public length: bigint;
+
+  public body: Buffer;
+
+  /**
+   * Serializes the tlv message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeBigSize(this.type);
+    const dataWriter = new BufferWriter();
+
+    dataWriter.writeBytes(this.body);
+
+    writer.writeBigSize(dataWriter.size);
+    writer.writeBytes(dataWriter.toBuffer());
+
+    return writer.toBuffer();
+  }
+}

package/.yalc/@node-dlc/messaging/lib/serialize/F64.ts

@@ -0,0 +1,352 @@
+import Decimal from 'decimal.js';
+
+/**
+ * IEEE 754 double-precision floating-point number implementation
+ *
+ * Format: 1 bit sign + 11 bits exponent + 52 bits mantissa
+ *
+ * This class works directly with the binary representation to avoid
+ * precision loss when serializing/deserializing f64 values to/from buffers.
+ */
+export class F64 {
+  private _buffer: Buffer; // 8 bytes storing the IEEE 754 representation
+
+  /**
+   * Create an F64 from raw bytes (IEEE 754 format)
+   */
+  constructor(buffer?: Buffer) {
+    if (buffer) {
+      if (buffer.length !== 8) {
+        throw new Error('F64 buffer must be exactly 8 bytes');
+      }
+      this._buffer = Buffer.from(buffer);
+    } else {
+      this._buffer = Buffer.alloc(8);
+    }
+  }
+
+  /**
+   * Create F64 from JavaScript number
+   */
+  static fromNumber(num: number): F64 {
+    const buffer = Buffer.alloc(8);
+    buffer.writeDoubleBE(num, 0);
+    return new F64(buffer);
+  }
+
+  /**
+   * Create F64 from Decimal.js value
+   * Uses the most precise conversion possible
+   */
+  static fromDecimal(decimal: Decimal): F64 {
+    // Convert to number and let IEEE 754 handle the precision
+    const num = decimal.toNumber();
+    return F64.fromNumber(num);
+  }
+
+  /**
+   * Create F64 from string representation
+   * Uses Decimal.js to parse the string without precision loss from JavaScript Number
+   */
+  static fromString(str: string): F64 {
+    // Parse string using Decimal.js to avoid JavaScript Number precision loss
+    const decimal = new Decimal(str);
+    return F64.fromDecimal(decimal);
+  }
+
+  /**
+   * Create F64 from bigint (treating as integer value)
+   */
+  static fromBigInt(bigint: bigint): F64 {
+    const num = Number(bigint);
+    return F64.fromNumber(num);
+  }
+
+  /**
+   * Create F64 representing zero (static method for API compatibility)
+   */
+  static zero(): F64 {
+    return F64.fromNumber(0);
+  }
+
+  /**
+   * Create F64 with specific IEEE 754 components
+   */
+  static fromComponents(
+    sign: boolean,
+    exponent: number,
+    mantissa: bigint,
+  ): F64 {
+    if (exponent < 0 || exponent > 2047) {
+      throw new Error('Exponent must be between 0 and 2047');
+    }
+    if (mantissa < BigInt(0) || mantissa >= BigInt(1) << BigInt(52)) {
+      throw new Error('Mantissa must be between 0 and 2^52-1');
+    }
+
+    const buffer = Buffer.alloc(8);
+
+    // Pack into 64-bit big-endian format
+    // Bit layout: SEEEEEEE EEEEMMMM MMMMMMMM MMMMMMMM MMMMMMMM MMMMMMMM MMMMMMMM MMMMMMMM
+    const signBit = sign ? BigInt(1) : BigInt(0);
+    const expBits = BigInt(exponent);
+    const mantissaBits = mantissa;
+
+    const ieee754Bits =
+      (signBit << BigInt(63)) | (expBits << BigInt(52)) | mantissaBits;
+
+    // Write as big-endian bytes
+    for (let i = 0; i < 8; i++) {
+      const byteValue = Number(
+        (ieee754Bits >> BigInt(56 - i * 8)) & BigInt(0xff),
+      );
+      buffer.writeUInt8(byteValue, i);
+    }
+
+    return new F64(buffer);
+  }
+
+  /**
+   * Get the raw buffer containing IEEE 754 representation
+   */
+  getBuffer(): Buffer {
+    return Buffer.from(this._buffer);
+  }
+
+  /**
+   * Serialize to buffer (big-endian)
+   */
+  serialize(): Buffer {
+    return this.getBuffer();
+  }
+
+  /**
+   * Deserialize from buffer (big-endian)
+   */
+  static deserialize(buffer: Buffer): F64 {
+    return new F64(buffer);
+  }
+
+  /**
+   * Write to BufferWriter
+   */
+  writeTo(writer: any): void {
+    writer.writeBytes(this._buffer);
+  }
+
+  /**
+   * Read from BufferReader
+   */
+  static readFrom(reader: any): F64 {
+    const buffer = reader.readBytes(8);
+    return new F64(buffer);
+  }
+
+  /**
+   * Convert to JavaScript number
+   * This may lose precision for very large or very precise values
+   */
+  toNumber(): number {
+    return this._buffer.readDoubleBE(0);
+  }
+
+  /**
+   * Convert to Decimal.js for arbitrary precision
+   */
+  toDecimal(): Decimal {
+    return new Decimal(this.toNumber());
+  }
+
+  /**
+   * Extract IEEE 754 components
+   */
+  getComponents(): { sign: boolean; exponent: number; mantissa: bigint } {
+    // Read as big-endian 64-bit integer
+    let ieee754Bits = BigInt(0);
+    for (let i = 0; i < 8; i++) {
+      ieee754Bits =
+        (ieee754Bits << BigInt(8)) | BigInt(this._buffer.readUInt8(i));
+    }
+
+    const sign = (ieee754Bits & (BigInt(1) << BigInt(63))) !== BigInt(0);
+    const exponent = Number((ieee754Bits >> BigInt(52)) & BigInt(0x7ff));
+    const mantissa = ieee754Bits & ((BigInt(1) << BigInt(52)) - BigInt(1));
+
+    return { sign, exponent, mantissa };
+  }
+
+  /**
+   * Check if the value is finite
+   */
+  isFinite(): boolean {
+    const { exponent } = this.getComponents();
+    return exponent !== 2047; // NaN and Infinity have exponent = 2047
+  }
+
+  /**
+   * Check if the value is NaN
+   */
+  isNaN(): boolean {
+    const { exponent, mantissa } = this.getComponents();
+    return exponent === 2047 && mantissa !== BigInt(0);
+  }
+
+  /**
+   * Check if the value is infinite
+   */
+  isInfinite(): boolean {
+    const { exponent, mantissa } = this.getComponents();
+    return exponent === 2047 && mantissa === BigInt(0);
+  }
+
+  /**
+   * Check if the value is zero
+   */
+  isZero(): boolean {
+    const { exponent, mantissa } = this.getComponents();
+    return exponent === 0 && mantissa === BigInt(0);
+  }
+
+  /**
+   * Get string representation
+   */
+  toString(): string {
+    return this.toNumber().toString();
+  }
+
+  /**
+   * Convert to JSON-safe value: number if within safe range, string if too large
+   * This preserves precision for very large numbers that exceed JavaScript's MAX_SAFE_INTEGER
+   */
+  toJSONValue(): number | string {
+    const num = this.toNumber();
+
+    // Check if the number is within JavaScript's safe integer range
+    if (num <= Number.MAX_SAFE_INTEGER && num >= Number.MIN_SAFE_INTEGER) {
+      return num;
+    }
+
+    // For very large numbers, return as string to preserve precision
+    return num.toString();
+  }
+
+  /**
+   * Create F64 from JSON value (handles both number and string inputs)
+   */
+  static fromJSONValue(value: number | string): F64 {
+    if (typeof value === 'string') {
+      return F64.fromString(value);
+    } else {
+      return F64.fromNumber(value);
+    }
+  }
+
+  /**
+   * Get hex representation of the raw bytes
+   */
+  toHex(): string {
+    return this._buffer.toString('hex');
+  }
+
+  /**
+   * Create F64 from hex string
+   */
+  static fromHex(hex: string): F64 {
+    const buffer = Buffer.from(hex, 'hex');
+    if (buffer.length !== 8) {
+      throw new Error('Hex string must represent exactly 8 bytes');
+    }
+    return new F64(buffer);
+  }
+
+  /**
+   * Compare with another F64
+   */
+  equals(other: F64): boolean {
+    return this._buffer.equals(other._buffer);
+  }
+
+  /**
+   * Equality comparison (alias for equals, for API compatibility)
+   */
+  eq(other: F64 | number): boolean {
+    if (typeof other === 'number') {
+      return this.toNumber() === other;
+    }
+    return this.equals(other);
+  }
+
+  /**
+   * Greater than comparison
+   */
+  gt(other: F64 | number): boolean {
+    if (typeof other === 'number') {
+      return this.toNumber() > other;
+    }
+    return this.toNumber() > other.toNumber();
+  }
+
+  /**
+   * Less than comparison
+   */
+  lt(other: F64 | number): boolean {
+    if (typeof other === 'number') {
+      return this.toNumber() < other;
+    }
+    return this.toNumber() < other.toNumber();
+  }
+
+  /**
+   * Greater than or equal comparison
+   */
+  gte(other: F64 | number): boolean {
+    if (typeof other === 'number') {
+      return this.toNumber() >= other;
+    }
+    return this.toNumber() >= other.toNumber();
+  }
+
+  /**
+   * Less than or equal comparison
+   */
+  lte(other: F64 | number): boolean {
+    if (typeof other === 'number') {
+      return this.toNumber() <= other;
+    }
+    return this.toNumber() <= other.toNumber();
+  }
+
+  /**
+   * Create a copy
+   */
+  clone(): F64 {
+    return new F64(this._buffer);
+  }
+
+  /**
+   * Constants
+   */
+  static get ZERO(): F64 {
+    return F64.fromNumber(0);
+  }
+
+  static get ONE(): F64 {
+    return F64.fromNumber(1);
+  }
+
+  static get NEGATIVE_ONE(): F64 {
+    return F64.fromNumber(-1);
+  }
+
+  static get INFINITY(): F64 {
+    return F64.fromNumber(Number.POSITIVE_INFINITY);
+  }
+
+  static get NEGATIVE_INFINITY(): F64 {
+    return F64.fromNumber(Number.NEGATIVE_INFINITY);
+  }
+
+  static get NaN(): F64 {
+    return F64.fromNumber(Number.NaN);
+  }
+}

package/.yalc/@node-dlc/messaging/lib/serialize/deserializeTlv.ts

@@ -0,0 +1,15 @@
+import { BufferReader } from '@node-dlc/bufio';
+
+export function deserializeTlv(reader: BufferReader): ITlv {
+  const type = reader.readBigSize();
+  const length = reader.readBigSize();
+  const body = reader.readBytes(Number(length));
+
+  return { type, length, body };
+}
+
+interface ITlv {
+  type: bigint;
+  length: bigint;
+  body: Buffer;
+}

package/.yalc/@node-dlc/messaging/lib/serialize/getTlv.ts

@@ -0,0 +1,21 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+
+// TODO: add unit tests
+export function getTlv(reader: BufferReader): Buffer {
+  const type = reader.readBigSize();
+  const length = reader.readBigSize();
+  const body = reader.readBytes(Number(length));
+
+  const writer = new BufferWriter();
+  writer.writeBigSize(type);
+  writer.writeBigSize(length);
+  writer.writeBytes(body);
+
+  return writer.toBuffer();
+}
+
+export function skipTlv(reader: BufferReader): void {
+  reader.readBigSize();
+  const length = reader.readBigSize();
+  reader.readBytes(Number(length));
+}

package/.yalc/@node-dlc/messaging/lib/serialize/readTlvs.ts

@@ -0,0 +1,37 @@
+import { BufferReader } from '@node-dlc/bufio';
+
+/**
+ * Reads TLVs from a reader until the entire stream is processed. The handler is
+ * responsible for doing something with the data bytes.
+ * @param reader
+ * @param handler
+ */
+export function readTlvs(
+  reader: BufferReader,
+  handler: (type: bigint, value: BufferReader) => boolean,
+) {
+  let lastType: bigint;
+  while (!reader.eof) {
+    const type = reader.readBigSize();
+    const len = reader.readBigSize();
+    const value = reader.readBytes(Number(len));
+    const valueReader = new BufferReader(value);
+
+    if (type <= lastType) {
+      throw new Error('Invalid TLV stream');
+    }
+
+    const isEven = type % BigInt(2) === BigInt(0);
+    const wasHandled = handler(type, valueReader);
+
+    if (!wasHandled && isEven) {
+      throw new Error('Unknown even type');
+    }
+
+    if (wasHandled && !valueReader.eof) {
+      throw new Error('Non-canonical length');
+    }
+
+    lastType = type;
+  }
+}

package/.yalc/@node-dlc/messaging/lib/util.ts

@@ -0,0 +1,33 @@
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Safely converts various input types to BigInt
+ * @param value Value to convert to BigInt
+ * @returns BigInt representation of the value, or BigInt(0) for null/undefined
+ */
+export function toBigInt(value: any): bigint {
+  if (value === null || value === undefined) return BigInt(0);
+  if (typeof value === 'bigint') return value;
+  if (typeof value === 'string') return BigInt(value);
+  if (typeof value === 'number') return BigInt(value);
+  return BigInt(0);
+}
+
+/**
+ * Safely converts BigInt to number, preserving precision for safe integers
+ * @param value BigInt value to convert
+ * @returns Number if within safe range, otherwise returns the BigInt as-is for JSON serialization
+ */
+export function bigIntToNumber(value: bigint): number | any {
+  // For values within safe integer range, convert to number
+  if (
+    value <= BigInt(Number.MAX_SAFE_INTEGER) &&
+    value >= BigInt(Number.MIN_SAFE_INTEGER)
+  ) {
+    return Number(value);
+  }
+  // For larger values, preserve as BigInt (json-bigint will handle serialization)
+  return value as any;
+}