@atomicfinance/bitcoin-dlc-provider 4.1.2 → 4.1.3

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

@@ -1,454 +0,0 @@
-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
-   */
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
-  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
-   */
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
-  public static fromJSON(json: any): PolynomialPayoutCurvePiece {
-    const instance = new PolynomialPayoutCurvePiece();
-
-    const points = json.payoutPoints || json.points || [];
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    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
-   */
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
-  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
-   */
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
-  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

@@ -1,242 +0,0 @@
-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
-   */
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
-  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(
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      (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;