@atomicfinance/bitcoin-dlc-provider 3.6.1 → 4.0.0

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

@@ -0,0 +1,449 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+
+import { MessageType, PayoutCurvePieceType } from '../MessageType';
+import { F64 } from '../serialize/F64';
+import { bigIntToNumber, toBigInt } from '../util';
+import { IDlcMessage } from './DlcMessage';
+
+export abstract class PayoutCurvePiece {
+  public static deserialize(
+    buf: Buffer,
+  ): PolynomialPayoutCurvePiece | HyperbolaPayoutCurvePiece {
+    const reader = new BufferReader(buf);
+    const typeId = Number(reader.readBigSize());
+
+    switch (typeId) {
+      case PayoutCurvePieceType.Polynomial:
+        return PolynomialPayoutCurvePiece.deserialize(buf);
+      case PayoutCurvePieceType.Hyperbola:
+        return HyperbolaPayoutCurvePiece.deserialize(buf);
+      default:
+        throw new Error(
+          `Payout curve piece type must be Polynomial (0) or Hyperbola (1), got ${typeId}`,
+        );
+    }
+  }
+
+  /**
+   * Creates a PayoutCurvePiece from JSON data
+   * @param json JSON object representing a payout curve piece
+   */
+  public static fromJSON(json: any): PayoutCurvePiece {
+    if (!json) {
+      throw new Error('payoutCurvePiece is required');
+    }
+
+    // Handle test vector format with nested types
+    if (json.polynomialPayoutCurvePiece) {
+      return PolynomialPayoutCurvePiece.fromJSON(
+        json.polynomialPayoutCurvePiece,
+      );
+    } else if (json.hyperbolaPayoutCurvePiece) {
+      return HyperbolaPayoutCurvePiece.fromJSON(json.hyperbolaPayoutCurvePiece);
+    }
+    // Handle direct format
+    else if (json.points !== undefined || json.payoutPoints !== undefined) {
+      return PolynomialPayoutCurvePiece.fromJSON(json);
+    } else if (json.usePositivePiece !== undefined) {
+      return HyperbolaPayoutCurvePiece.fromJSON(json);
+    } else {
+      throw new Error(
+        'payoutCurvePiece must be either polynomial (with points) or hyperbola (with usePositivePiece)',
+      );
+    }
+  }
+
+  public abstract payoutCurvePieceType: PayoutCurvePieceType;
+  public abstract type: number; // For backward compatibility
+  public abstract toJSON():
+    | PolynomialPayoutCurvePieceJSON
+    | HyperbolaPayoutCurvePieceJSON;
+  public abstract serialize(): Buffer;
+}
+
+/**
+ * PolynomialPayoutCurvePiece defines a polynomial curve piece for payout functions.
+ * This corresponds to type 0 in the sibling sub-type format.
+ */
+export class PolynomialPayoutCurvePiece
+  extends PayoutCurvePiece
+  implements IDlcMessage {
+  public static payoutCurvePieceType = PayoutCurvePieceType.Polynomial;
+
+  /**
+   * Creates a PolynomialPayoutCurvePiece from JSON data
+   * @param json JSON object representing a polynomial payout curve piece
+   */
+  public static fromJSON(json: any): PolynomialPayoutCurvePiece {
+    const instance = new PolynomialPayoutCurvePiece();
+
+    const points = json.payoutPoints || json.points || [];
+    instance.points = points.map((point: any) => ({
+      eventOutcome: toBigInt(point.eventOutcome || point.event_outcome),
+      outcomePayout: toBigInt(point.outcomePayout || point.outcome_payout),
+      extraPrecision: point.extraPrecision || point.extra_precision || 0,
+    }));
+
+    return instance;
+  }
+
+  /**
+   * Deserializes a polynomial_payout_curve_piece message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): PolynomialPayoutCurvePiece {
+    const instance = new PolynomialPayoutCurvePiece();
+    const reader = new BufferReader(buf);
+
+    reader.readBigSize(); // read type (0)
+    const numPts = Number(reader.readBigSize());
+
+    for (let i = 0; i < numPts; i++) {
+      const eventOutcome = reader.readUInt64BE();
+      const outcomePayout = reader.readUInt64BE();
+      const extraPrecision = reader.readUInt16BE();
+
+      instance.points.push({
+        eventOutcome,
+        outcomePayout,
+        extraPrecision,
+      });
+    }
+
+    return instance;
+  }
+
+  /**
+   * The type for polynomial_payout_curve_piece message - Note: this is a sub-component, not a standalone wire message
+   */
+  public type = MessageType.PolynomialPayoutCurvePiece;
+
+  /**
+   * The payout curve piece type for new format
+   */
+  public payoutCurvePieceType = PayoutCurvePieceType.Polynomial;
+
+  public points: IPoint[] = [];
+
+  /**
+   * Converts polynomial_payout_curve_piece to JSON
+   */
+  public toJSON(): PolynomialPayoutCurvePieceJSON {
+    return {
+      polynomialPayoutCurvePiece: {
+        payoutPoints: this.points.map((point) => {
+          return {
+            eventOutcome: bigIntToNumber(point.eventOutcome),
+            outcomePayout: bigIntToNumber(point.outcomePayout),
+            extraPrecision: Number(point.extraPrecision),
+          };
+        }),
+      },
+    };
+  }
+
+  /**
+   * Serializes the polynomial_payout_curve_piece message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+
+    writer.writeBigSize(this.payoutCurvePieceType);
+    writer.writeBigSize(this.points.length);
+
+    for (const point of this.points) {
+      writer.writeUInt64BE(point.eventOutcome);
+      writer.writeUInt64BE(point.outcomePayout);
+      writer.writeUInt16BE(point.extraPrecision);
+    }
+
+    return writer.toBuffer();
+  }
+}
+
+/**
+ * HyperbolaPayoutCurvePiece defines a hyperbola curve piece for payout functions.
+ * This corresponds to type 1 in the sibling sub-type format.
+ * Updated to use F64 for precise f64 parameter handling.
+ */
+export class HyperbolaPayoutCurvePiece
+  extends PayoutCurvePiece
+  implements IDlcMessage {
+  public static payoutCurvePieceType = PayoutCurvePieceType.Hyperbola;
+
+  /**
+   * Helper function to safely parse F64 values from JSON
+   * Handles both number and string inputs for maximum precision
+   */
+  private static parseF64Value(value: any): F64 | null {
+    // Check for basic null/undefined
+    if (value === null || value === undefined) {
+      return null;
+    }
+
+    try {
+      if (typeof value === 'string') {
+        // Parse string directly to preserve precision
+        try {
+          return F64.fromString(value);
+        } catch (error) {
+          // If fromString fails, try parsing as number
+          const numValue = parseFloat(value);
+          if (!isNaN(numValue) && isFinite(numValue)) {
+            return F64.fromNumber(numValue);
+          }
+        }
+      } else if (typeof value === 'number') {
+        // Parse number - handle special cases
+        if (!isFinite(value)) {
+          return null; // Reject NaN, Infinity, -Infinity
+        }
+        return F64.fromNumber(value);
+      }
+
+      // Try to convert other types to number as fallback
+      const numValue = Number(value);
+      if (!isNaN(numValue) && isFinite(numValue)) {
+        return F64.fromNumber(numValue);
+      }
+
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Creates a HyperbolaPayoutCurvePiece from JSON data
+   * @param json JSON object representing a hyperbola payout curve piece
+   */
+  public static fromJSON(json: any): HyperbolaPayoutCurvePiece | null {
+    if (!json || typeof json !== 'object') return null;
+
+    // Handle both wrapped format and direct format
+    let data =
+      json.hyperbolaPayoutCurvePiece || json.hyperbola_payout_curve_piece;
+
+    // If no wrapper found, assume direct format if it has the expected properties
+    if (
+      !data &&
+      (json.usePositivePiece !== undefined ||
+        json.use_positive_piece !== undefined)
+    ) {
+      data = json;
+    }
+
+    if (!data) return null;
+
+    try {
+      const usePositivePiece =
+        data.usePositivePiece || data.use_positive_piece || false;
+
+      // Parse each F64 value with null check
+      const translateOutcome = this.parseF64Value(
+        data.translateOutcome !== undefined
+          ? data.translateOutcome
+          : data.translate_outcome,
+      );
+      const translatePayout = this.parseF64Value(
+        data.translatePayout !== undefined
+          ? data.translatePayout
+          : data.translate_payout,
+      );
+      const a = this.parseF64Value(data.a);
+      const b = this.parseF64Value(data.b);
+      const c = this.parseF64Value(data.c);
+      const d = this.parseF64Value(data.d);
+
+      // Check that all required values were parsed successfully
+      if (!translateOutcome || !translatePayout || !a || !b || !c || !d) {
+        throw new Error('Failed to parse one or more F64 values');
+      }
+
+      return new HyperbolaPayoutCurvePiece(
+        usePositivePiece,
+        translateOutcome,
+        translatePayout,
+        a,
+        b,
+        c,
+        d,
+      );
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Deserializes a hyperbola_payout_curve_piece message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): HyperbolaPayoutCurvePiece {
+    const instance = new HyperbolaPayoutCurvePiece();
+    const reader = new BufferReader(buf);
+
+    reader.readBigSize(); // read type (1)
+    instance.usePositivePiece = reader.readUInt8() === 1;
+
+    // Read f64 values using F64 for precise handling - read raw 8-byte buffers
+    instance.translateOutcome = F64.deserialize(reader.readBytes(8));
+    instance.translatePayout = F64.deserialize(reader.readBytes(8));
+    instance.a = F64.deserialize(reader.readBytes(8));
+    instance.b = F64.deserialize(reader.readBytes(8));
+    instance.c = F64.deserialize(reader.readBytes(8));
+    instance.d = F64.deserialize(reader.readBytes(8));
+
+    // Note: leftEndPoint and rightEndPoint are not part of the serialization
+    // They will be set by PayoutFunction when creating from JSON
+    instance.leftEndPoint = {
+      eventOutcome: BigInt(0),
+      outcomePayout: BigInt(0),
+      extraPrecision: 0,
+    };
+
+    instance.rightEndPoint = {
+      eventOutcome: BigInt(0),
+      outcomePayout: BigInt(0),
+      extraPrecision: 0,
+    };
+
+    return instance;
+  }
+
+  /**
+   * The type for hyperbola_payout_curve_piece message - Note: this is a sub-component, not a standalone wire message
+   */
+  public type = MessageType.HyperbolaPayoutCurvePiece;
+
+  public payoutCurvePieceType = HyperbolaPayoutCurvePiece.payoutCurvePieceType;
+
+  // Use F64 for precise f64 parameter handling to avoid JavaScript precision issues
+  public leftEndPoint: IPayoutPoint;
+  public rightEndPoint: IPayoutPoint;
+  public usePositivePiece: boolean;
+  public translateOutcome: F64; // f64 - precise handling with F64
+  public translatePayout: F64; // f64 - precise handling with F64
+  public a: F64; // f64 - precise handling with F64
+  public b: F64; // f64 - precise handling with F64
+  public c: F64; // f64 - precise handling with F64
+  public d: F64; // f64 - precise handling with F64
+
+  constructor(
+    usePositivePiece = false,
+    translateOutcome?: string | F64,
+    translatePayout?: string | F64,
+    a?: string | F64,
+    b?: string | F64,
+    c?: string | F64,
+    d?: string | F64,
+  ) {
+    super();
+    this.usePositivePiece = usePositivePiece;
+
+    // Convert string inputs to F64 objects, or use existing F64 objects
+    this.translateOutcome = translateOutcome
+      ? typeof translateOutcome === 'string'
+        ? F64.fromString(translateOutcome)
+        : translateOutcome
+      : F64.fromNumber(0);
+    this.translatePayout = translatePayout
+      ? typeof translatePayout === 'string'
+        ? F64.fromString(translatePayout)
+        : translatePayout
+      : F64.fromNumber(0);
+    this.a = a
+      ? typeof a === 'string'
+        ? F64.fromString(a)
+        : a
+      : F64.fromNumber(0);
+    this.b = b
+      ? typeof b === 'string'
+        ? F64.fromString(b)
+        : b
+      : F64.fromNumber(0);
+    this.c = c
+      ? typeof c === 'string'
+        ? F64.fromString(c)
+        : c
+      : F64.fromNumber(0);
+    this.d = d
+      ? typeof d === 'string'
+        ? F64.fromString(d)
+        : d
+      : F64.fromNumber(0);
+  }
+
+  /**
+   * Converts hyperbola_payout_curve_piece to JSON
+   * Uses F64.toJSONValue() which preserves precision by using strings for very large numbers
+   */
+  public toJSON(): HyperbolaPayoutCurvePieceJSON {
+    return {
+      hyperbolaPayoutCurvePiece: {
+        usePositivePiece: this.usePositivePiece,
+        translateOutcome: this.translateOutcome.toJSONValue(), // Smart conversion: number if safe, string if large
+        translatePayout: this.translatePayout.toJSONValue(), // Preserves precision automatically
+        a: this.a.toJSONValue(),
+        b: this.b.toJSONValue(),
+        c: this.c.toJSONValue(),
+        d: this.d.toJSONValue(),
+      },
+    };
+  }
+
+  /**
+   * Serializes the hyperbola_payout_curve_piece message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+
+    writer.writeBigSize(this.payoutCurvePieceType);
+    writer.writeUInt8(this.usePositivePiece ? 1 : 0);
+
+    // Write f64 values using F64 for precise handling - write raw 8-byte buffers
+    writer.writeBytes(this.translateOutcome.serialize());
+    writer.writeBytes(this.translatePayout.serialize());
+    writer.writeBytes(this.a.serialize());
+    writer.writeBytes(this.b.serialize());
+    writer.writeBytes(this.c.serialize());
+    writer.writeBytes(this.d.serialize());
+
+    return writer.toBuffer();
+  }
+}
+
+interface IPoint {
+  eventOutcome: bigint;
+  outcomePayout: bigint;
+  extraPrecision: number;
+}
+
+interface IPointJSON {
+  eventOutcome: number;
+  outcomePayout: number;
+  extraPrecision: number;
+}
+
+interface IPayoutPoint {
+  eventOutcome: bigint;
+  outcomePayout: bigint;
+  extraPrecision: number;
+}
+
+export interface PolynomialPayoutCurvePieceJSON {
+  polynomialPayoutCurvePiece: {
+    payoutPoints: IPointJSON[];
+  };
+}
+
+export interface HyperbolaPayoutCurvePieceJSON {
+  hyperbolaPayoutCurvePiece: {
+    usePositivePiece: boolean;
+    translateOutcome: number | string;
+    translatePayout: number | string;
+    a: number | string;
+    b: number | string;
+    c: number | string;
+    d: number | string;
+  };
+}

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

@@ -0,0 +1,240 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+
+import { MessageType } from '../MessageType';
+import { bigIntToNumber, toBigInt } from '../util';
+import { IDlcMessage } from './DlcMessage';
+import {
+  HyperbolaPayoutCurvePiece,
+  HyperbolaPayoutCurvePieceJSON,
+  PayoutCurvePiece,
+  PolynomialPayoutCurvePieceJSON,
+} from './PayoutCurvePiece';
+
+/**
+ * PayoutFunction contains the payout curve definition for numeric outcome contracts.
+ * Updated to match rust-dlc format exactly.
+ */
+export class PayoutFunction implements IDlcMessage {
+  public static type = MessageType.PayoutFunction;
+
+  /**
+   * Creates a PayoutFunction from JSON data
+   * @param json JSON object representing a payout function
+   */
+  public static fromJSON(json: any): PayoutFunction {
+    const instance = new PayoutFunction();
+
+    // Parse payout function pieces
+    const pieces =
+      json.payoutFunctionPieces || json.payout_function_pieces || [];
+    instance.payoutFunctionPieces = pieces.map(
+      (pieceJson: any, index: number) => {
+        const piece = {
+          endPoint: {
+            eventOutcome: toBigInt(pieceJson.endPoint?.eventOutcome),
+            outcomePayout: toBigInt(pieceJson.endPoint?.outcomePayout),
+            extraPrecision: pieceJson.endPoint?.extraPrecision || 0,
+          },
+          payoutCurvePiece: PayoutCurvePiece.fromJSON(
+            pieceJson.payoutCurvePiece || pieceJson.payout_curve_piece,
+          ),
+        };
+
+        // For HyperbolaPayoutCurvePiece, set the left and right end points
+        if (piece.payoutCurvePiece instanceof HyperbolaPayoutCurvePiece) {
+          const hyperbola = piece.payoutCurvePiece as HyperbolaPayoutCurvePiece;
+
+          // Left end point is this piece's endPoint
+          hyperbola.leftEndPoint = piece.endPoint;
+
+          // Right end point is the next piece's endPoint, or lastEndpoint if this is the last piece
+          if (index < pieces.length - 1) {
+            const nextPiece = pieces[index + 1];
+            hyperbola.rightEndPoint = {
+              eventOutcome: toBigInt(nextPiece.endPoint?.eventOutcome),
+              outcomePayout: toBigInt(nextPiece.endPoint?.outcomePayout),
+              extraPrecision: nextPiece.endPoint?.extraPrecision || 0,
+            };
+          } else {
+            // Use lastEndpoint for the final piece
+            const lastEndpoint = json.lastEndpoint || json.last_endpoint || {};
+            hyperbola.rightEndPoint = {
+              eventOutcome: toBigInt(lastEndpoint.eventOutcome),
+              outcomePayout: toBigInt(lastEndpoint.outcomePayout),
+              extraPrecision: lastEndpoint.extraPrecision || 0,
+            };
+          }
+        }
+
+        return piece;
+      },
+    );
+
+    // Parse last endpoint
+    const lastEndpoint = json.lastEndpoint || json.last_endpoint;
+    if (lastEndpoint) {
+      instance.lastEndpoint = {
+        eventOutcome: toBigInt(lastEndpoint.eventOutcome),
+        outcomePayout: toBigInt(lastEndpoint.outcomePayout),
+        extraPrecision: lastEndpoint.extraPrecision || 0,
+      };
+    } else {
+      // Default last endpoint if not provided
+      instance.lastEndpoint = {
+        eventOutcome: BigInt(0),
+        outcomePayout: BigInt(0),
+        extraPrecision: 0,
+      };
+    }
+
+    return instance;
+  }
+
+  /**
+   * Deserializes a payout_function message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): PayoutFunction {
+    const instance = new PayoutFunction();
+    const reader = new BufferReader(buf);
+
+    // Read payout function pieces (as vec)
+    const numPieces = Number(reader.readBigSize());
+
+    for (let i = 0; i < numPieces; i++) {
+      // Read end_point first
+      const eventOutcome = reader.readUInt64BE();
+      const outcomePayout = reader.readUInt64BE();
+      const extraPrecision = reader.readUInt16BE();
+
+      // Read payout curve piece
+      const payoutCurvePieceStartPos = reader.position;
+      const payoutCurvePiece = PayoutCurvePiece.deserialize(
+        reader.buffer.subarray(reader.position),
+      );
+
+      // Skip past the payout curve piece bytes
+      const payoutCurvePieceSize = payoutCurvePiece.serialize().length;
+      reader.position = payoutCurvePieceStartPos + payoutCurvePieceSize;
+
+      instance.payoutFunctionPieces.push({
+        endPoint: {
+          eventOutcome,
+          outcomePayout,
+          extraPrecision,
+        },
+        payoutCurvePiece,
+      });
+    }
+
+    // Read last_endpoint
+    instance.lastEndpoint = {
+      eventOutcome: reader.readUInt64BE(),
+      outcomePayout: reader.readUInt64BE(),
+      extraPrecision: reader.readUInt16BE(),
+    };
+
+    return instance;
+  }
+
+  /**
+   * The type for payout_function message. payout_function = 42790
+   */
+  public type = PayoutFunction.type;
+
+  public payoutFunctionPieces: IPayoutFunctionPiece[] = [];
+  public lastEndpoint: IPayoutPoint;
+
+  /**
+   * Constructor that ensures proper initialization
+   */
+  constructor() {
+    // Explicitly initialize arrays to handle file-linking issues
+    this.payoutFunctionPieces = [];
+  }
+
+  /**
+   * Converts payout_function to JSON
+   */
+  public toJSON(): PayoutFunctionJSON {
+    return {
+      payoutFunctionPieces: this.payoutFunctionPieces.map((piece) => ({
+        endPoint: {
+          eventOutcome: bigIntToNumber(piece.endPoint.eventOutcome),
+          outcomePayout: bigIntToNumber(piece.endPoint.outcomePayout),
+          extraPrecision: piece.endPoint.extraPrecision,
+        },
+        payoutCurvePiece: piece.payoutCurvePiece.toJSON(),
+      })),
+      lastEndpoint: {
+        eventOutcome: bigIntToNumber(this.lastEndpoint.eventOutcome),
+        outcomePayout: bigIntToNumber(this.lastEndpoint.outcomePayout),
+        extraPrecision: this.lastEndpoint.extraPrecision,
+      },
+    };
+  }
+
+  /**
+   * Serializes the payout_function message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+
+    // Write payout_function_pieces as vec (length + elements)
+    writer.writeBigSize(this.payoutFunctionPieces.length);
+
+    for (const piece of this.payoutFunctionPieces) {
+      // Write end_point first (matches rust order)
+      writer.writeUInt64BE(piece.endPoint.eventOutcome);
+      writer.writeUInt64BE(piece.endPoint.outcomePayout);
+      writer.writeUInt16BE(piece.endPoint.extraPrecision);
+
+      // Write payout_curve_piece second
+      writer.writeBytes(piece.payoutCurvePiece.serialize());
+    }
+
+    // Write last_endpoint
+    writer.writeUInt64BE(this.lastEndpoint.eventOutcome);
+    writer.writeUInt64BE(this.lastEndpoint.outcomePayout);
+    writer.writeUInt16BE(this.lastEndpoint.extraPrecision);
+
+    return writer.toBuffer();
+  }
+}
+
+// Legacy support
+export const PayoutFunctionV0 = PayoutFunction;
+export type PayoutFunctionV0 = PayoutFunction;
+
+interface IPayoutPoint {
+  eventOutcome: bigint;
+  outcomePayout: bigint;
+  extraPrecision: number;
+}
+
+interface IPayoutPointJSON {
+  eventOutcome: number;
+  outcomePayout: number;
+  extraPrecision: number;
+}
+
+interface IPayoutFunctionPiece {
+  endPoint: IPayoutPoint;
+  payoutCurvePiece: PayoutCurvePiece;
+}
+
+interface IPayoutFunctionPieceJSON {
+  endPoint: IPayoutPointJSON;
+  payoutCurvePiece:
+    | PolynomialPayoutCurvePieceJSON
+    | HyperbolaPayoutCurvePieceJSON;
+}
+
+export interface PayoutFunctionJSON {
+  type?: number; // Optional for rust-dlc compatibility
+  payoutFunctionPieces: IPayoutFunctionPieceJSON[];
+  lastEndpoint: IPayoutPointJSON;
+}
+
+// Legacy interface
+export type PayoutFunctionV0JSON = PayoutFunctionJSON;