@atomicfinance/bitcoin-dlc-provider 4.2.6 → 4.2.8

package/.yalc/@node-dlc/core/lib/dlc/HyperbolaPayoutCurve.ts

@@ -1,188 +0,0 @@
-import {
-  HyperbolaPayoutCurvePiece,
-  MessageType,
-  PayoutCurvePieceType,
-  PayoutFunctionV0,
-  RoundingIntervals,
-} from '@node-dlc/messaging';
-import BigNumber from 'bignumber.js';
-
-import { CETPayout } from '..';
-import { splitIntoRanges } from './CETCalculator';
-import PayoutCurve from './PayoutCurve';
-
-export class HyperbolaPayoutCurve implements PayoutCurve {
-  constructor(
-    private a: BigNumber,
-    private b: BigNumber,
-    private c: BigNumber,
-    private d: BigNumber,
-    private translateOutcome: BigNumber,
-    private translatePayout: BigNumber,
-    private positive: boolean = true, // TODO: support negative pieces
-  ) {}
-
-  getPayout(_x: bigint): BigNumber {
-    const { a, b, c, d, translateOutcome, translatePayout } = this;
-    const x = new BigNumber(Number(_x));
-
-    const payout = c
-      .times(
-        x
-          .minus(translateOutcome)
-          .plus(
-            x
-              .minus(translateOutcome)
-              .exponentiatedBy(2)
-              .minus(a.times(b).times(4))
-              .squareRoot(),
-          )
-          .div(a.times(2)),
-      )
-      .plus(
-        a
-          .times(d)
-          .times(2)
-          .div(
-            x
-              .minus(translateOutcome)
-              .plus(
-                x
-                  .minus(translateOutcome)
-                  .exponentiatedBy(2)
-                  .minus(a.times(b).times(4))
-                  .squareRoot(),
-              ),
-          ),
-      )
-      .plus(translatePayout);
-
-    return payout;
-  }
-
-  getOutcomeForPayout(payout: BigNumber): bigint {
-    const { a, b, c, d, translateOutcome, translatePayout } = this;
-
-    // Inverse function
-    // y=(-ad^{2}-bf_{2}^{2}+2bf_{2}x-bx^{2}+df_{1}f_{2}-df_{1}x)/(d(f_{2}-x))
-    if (c.eq(0)) {
-      const denominator = d.times(translatePayout.minus(payout));
-
-      if (denominator.eq(0)) {
-        return BigInt(-1);
-      }
-
-      const outcome = a
-        .negated()
-        .times(d.exponentiatedBy(2))
-        .minus(b.times(translatePayout.exponentiatedBy(2)))
-        .plus(b.times(translatePayout).times(payout).times(2))
-        .minus(b.times(payout.exponentiatedBy(2)))
-        .plus(d.times(translateOutcome).times(translatePayout))
-        .minus(d.times(translateOutcome).times(payout))
-        .dividedBy(denominator)
-        .integerValue();
-
-      if (outcome.isFinite()) return BigInt(outcome.toString());
-      return BigInt(-1);
-    } else {
-      // y=\left((\sqrt{((adf_{2}-adx+bcf_{2}-bcx-2c\cdot d\cdot f_{1})^{2}-4cd(a^{2}d^{2}-2abcd+abf_{2}^{2}-2abf_{2}x+abx^{2}-adf_{1}f_{2}+adf_{1}x+b^{2}c^{2}-bcf_{1}f_{2}+bcf_{1}x+c\cdot d\cdot f_{1}^{2}))}-adf_{2}+adx-bcf_{2}+bcx+2c\cdot d\cdot f_{1})\right)/(2cd)
-      throw new Error('Not supported');
-    }
-  }
-
-  toPayoutCurvePiece(): HyperbolaPayoutCurvePiece {
-    const { a, b, c, d, translateOutcome, translatePayout, positive } = this;
-
-    // Use the constructor with string values to avoid F64 dependency issues
-    const piece = new HyperbolaPayoutCurvePiece(
-      positive,
-      translateOutcome.toString(),
-      translatePayout.toString(),
-      a.toString(),
-      b.toString(),
-      c.toString(),
-      d.toString(),
-    );
-
-    return piece;
-  }
-
-  equals(curve: HyperbolaPayoutCurve): boolean {
-    return (
-      this.a.eq(curve.a) &&
-      this.b.eq(curve.b) &&
-      this.c.eq(curve.c) &&
-      this.d.eq(curve.d) &&
-      this.translateOutcome.eq(curve.translateOutcome) &&
-      this.translatePayout.eq(curve.translatePayout) &&
-      this.positive === curve.positive
-    );
-  }
-
-  static fromPayoutCurvePiece(
-    piece: HyperbolaPayoutCurvePiece,
-  ): HyperbolaPayoutCurve {
-    // Convert F64 values to BigNumber using toDecimal().toString() to preserve precision
-    const a = new BigNumber(piece.a.toDecimal().toString());
-    const b = new BigNumber(piece.b.toDecimal().toString());
-    const c = new BigNumber(piece.c.toDecimal().toString());
-    const d = new BigNumber(piece.d.toDecimal().toString());
-    const translateOutcome = new BigNumber(
-      piece.translateOutcome.toDecimal().toString(),
-    );
-    const translatePayout = new BigNumber(
-      piece.translatePayout.toDecimal().toString(),
-    );
-
-    return new HyperbolaPayoutCurve(
-      a,
-      b,
-      c,
-      d,
-      translateOutcome,
-      translatePayout,
-      piece.usePositivePiece,
-    );
-  }
-
-  static computePayouts(
-    payoutFunction: PayoutFunctionV0,
-    totalCollateral: bigint,
-    roundingIntervals: RoundingIntervals,
-  ): CETPayout[] {
-    if (payoutFunction.payoutFunctionPieces.length !== 1)
-      throw new Error('Must have at least one piece');
-    const {
-      endPoint,
-      payoutCurvePiece,
-    } = payoutFunction.payoutFunctionPieces[0];
-
-    if (
-      payoutCurvePiece.payoutCurvePieceType !==
-        PayoutCurvePieceType.Hyperbola &&
-      payoutCurvePiece.type !== MessageType.HyperbolaPayoutCurvePiece &&
-      payoutCurvePiece.type !== MessageType.OldHyperbolaPayoutCurvePiece
-    )
-      throw new Error('Payout curve piece must be a hyperbola');
-
-    const _payoutCurvePiece = payoutCurvePiece as HyperbolaPayoutCurvePiece;
-    const curve = this.fromPayoutCurvePiece(_payoutCurvePiece);
-
-    // For the new PayoutFunction structure, get the starting point from the hyperbola piece's leftEndPoint
-    // This matches the rust-dlc implementation where get_first_outcome() returns left_end_point.event_outcome
-    const initialEventOutcome =
-      _payoutCurvePiece.leftEndPoint?.eventOutcome || BigInt(0);
-    const initialOutcomePayout =
-      _payoutCurvePiece.leftEndPoint?.outcomePayout || BigInt(0);
-    return splitIntoRanges(
-      initialEventOutcome,
-      endPoint.eventOutcome,
-      initialOutcomePayout,
-      endPoint.outcomePayout,
-      totalCollateral,
-      curve,
-      roundingIntervals.intervals,
-    );
-  }
-}

package/.yalc/@node-dlc/core/lib/dlc/PayoutCurve.ts

@@ -1,6 +0,0 @@
-import BigNumber from 'bignumber.js';
-
-export default interface PayoutCurve {
-  getPayout(x: bigint): BigNumber;
-  getOutcomeForPayout(y: BigNumber): bigint;
-}

package/.yalc/@node-dlc/core/lib/dlc/PolynomialPayoutCurve.ts

@@ -1,266 +0,0 @@
-import {
-  MessageType,
-  PayoutCurvePieceType,
-  PayoutFunction,
-  PolynomialPayoutCurvePiece,
-  RoundingIntervals,
-} from '@node-dlc/messaging';
-import BigNumber from 'bignumber.js';
-
-import { fromPrecision, getPrecision } from '../utils/Precision';
-import { CETPayout, mergePayouts, splitIntoRanges } from './CETCalculator';
-
-interface DlcPoint {
-  outcome: BigNumber;
-  payout: BigNumber;
-}
-
-export class PolynomialPayoutCurve {
-  private readonly points: DlcPoint[];
-  private readonly slope: BigNumber;
-  private readonly left: DlcPoint;
-  private readonly right: DlcPoint;
-
-  constructor(points: DlcPoint[]) {
-    if (points.length !== 2) throw new Error('Must have two points');
-    this.points = points;
-    this.left = points[0];
-    this.right = points[points.length - 1];
-
-    // m = (y2 - y1) / (x2 - x1)
-    this.slope = this.right.payout
-      .minus(this.left.payout)
-      .dividedBy(this.right.outcome.minus(this.left.outcome));
-  }
-
-  /**
-   * Get the payout for a given outcome
-   * @param outcome The outcome to get the payout for
-   * @returns The payout for the outcome
-   */
-  getPayout(outcome: bigint): BigNumber {
-    const { left, slope } = this;
-
-    const x = new BigNumber(Number(outcome));
-
-    // y = mx + b
-    const payout = slope.times(x.minus(left.outcome)).plus(left.payout);
-
-    return payout;
-  }
-
-  /**
-   * Get the outcome for a given payout
-   * @param payout The payout to get the outcome for
-   * @returns The outcome for the payout
-   */
-  getOutcomeForPayout(payout: BigNumber): bigint {
-    const { left, right, slope } = this;
-    const y = new BigNumber(Number(payout));
-
-    // Handle constant payout curve (slope = 0)
-    if (slope.isZero()) {
-      // For constant curves, if the payout matches, return any outcome in the range
-      // If it doesn't match, this is an invalid request
-      if (y.eq(left.payout)) {
-        return BigInt(left.outcome.toString());
-      } else {
-        // For constant curves, if payout doesn't match, return left outcome
-        // This prevents Infinity errors in calculations
-        return BigInt(left.outcome.toString());
-      }
-    }
-
-    // Find the x value for the given y
-    // slope = (y2 - y1) / (x2 - x1)
-    // x1 = (y2 - y1) / slope + x2
-    const outcome = y
-      .minus(left.payout)
-      .dividedBy(slope)
-      .plus(left.outcome)
-      .integerValue();
-
-    // Clamp the outcome to the valid range
-    const clampedOutcome = BigNumber.max(
-      left.outcome,
-      BigNumber.min(outcome, right.outcome),
-    );
-
-    return BigInt(clampedOutcome.toString());
-  }
-
-  /**
-   * Serializes PolynomialPayoutCurve to a PolynomialPayoutCurvePiece (for transport)
-   * @returns A PolynomialPayoutCurvePiece
-   */
-  toPayoutCurvePiece(): PolynomialPayoutCurvePiece {
-    const { points } = this;
-
-    const piece = new PolynomialPayoutCurvePiece();
-
-    piece.points = points.map((point) => {
-      const eventOutcome = BigInt(point.outcome.toString());
-      const outcomePayout = BigInt(point.payout.toString());
-      const extraPrecision = getPrecision(point.payout);
-      return { eventOutcome, outcomePayout, extraPrecision };
-    });
-
-    return piece;
-  }
-
-  /**
-   * Determine if the payout curve is equal to another
-   * @param curve A PolynomialPayoutCurve
-   * @returns True if the curves are the same
-   */
-  equals(curve: PolynomialPayoutCurve): boolean {
-    return this.points.every((point, i) => {
-      const otherPoint = curve.points[i];
-      return (
-        point.outcome.eq(otherPoint.outcome) &&
-        point.payout.eq(otherPoint.payout)
-      );
-    });
-  }
-
-  /**
-   * Creates a PolynomialPayoutCurve from a PolynomialPayoutCurvePiece
-   * @param piece
-   * @returns A PolynomialPayoutCurve
-   */
-  static fromPayoutCurvePiece(
-    piece: PolynomialPayoutCurvePiece,
-  ): PolynomialPayoutCurve {
-    const points = piece.points.map((point) => {
-      const outcome = new BigNumber(point.eventOutcome.toString());
-      const payout = new BigNumber(point.outcomePayout.toString()).plus(
-        fromPrecision(point.extraPrecision),
-      );
-      return { outcome, payout };
-    });
-    return new PolynomialPayoutCurve(points);
-  }
-
-  /**
-   * Computes all CETs for a given payout curve
-   * @param payoutFunction The payout function
-   * @param totalCollateral The total collateral
-   * @param roundingIntervals The rounding intervals
-   * @returns A list of CETs
-   */
-  static computePayouts(
-    payoutFunction: PayoutFunction,
-    totalCollateral: bigint,
-    roundingIntervals: RoundingIntervals,
-  ): CETPayout[] {
-    if (payoutFunction.payoutFunctionPieces.length < 1)
-      throw new Error('Must have at least one piece');
-
-    payoutFunction.payoutFunctionPieces.forEach((piece) => {
-      if (
-        piece.payoutCurvePiece.payoutCurvePieceType !==
-          PayoutCurvePieceType.Polynomial &&
-        piece.payoutCurvePiece.type !== MessageType.PolynomialPayoutCurvePiece
-      )
-        throw new Error('Payout curve piece must be a polynomial');
-    });
-
-    const CETS: CETPayout[] = [];
-
-    // 1. Add the first piece to the list
-    const { payoutCurvePiece } = payoutFunction.payoutFunctionPieces[0];
-
-    const curve = this.fromPayoutCurvePiece(
-      payoutCurvePiece as PolynomialPayoutCurvePiece,
-    );
-
-    // For the first piece, start from 0 and go to the first endpoint
-    const firstPiece = payoutFunction.payoutFunctionPieces[0];
-
-    // Calculate the start payout by evaluating the curve at outcome 0
-    const startPayout = curve.getPayout(BigInt(0));
-    const startPayoutBigInt = BigInt(startPayout.integerValue().toString());
-
-    // Only add ranges if there's actually a range to cover
-    if (firstPiece.endPoint.eventOutcome > 0) {
-      CETS.push(
-        ...splitIntoRanges(
-          BigInt(0), // Start from 0
-          firstPiece.endPoint.eventOutcome,
-          startPayoutBigInt, // Start payout calculated from curve
-          firstPiece.endPoint.outcomePayout, // End payout from endpoint
-          totalCollateral,
-          curve,
-          roundingIntervals.intervals,
-        ),
-      );
-    }
-
-    // 2. If there are subsequent pieces, add them to the list
-    for (let i = 1; i < payoutFunction.payoutFunctionPieces.length; i++) {
-      const { payoutCurvePiece } = payoutFunction.payoutFunctionPieces[i];
-
-      const curve = this.fromPayoutCurvePiece(
-        payoutCurvePiece as PolynomialPayoutCurvePiece,
-      );
-
-      CETS.push(
-        ...splitIntoRanges(
-          payoutFunction.payoutFunctionPieces[i - 1].endPoint.eventOutcome,
-          payoutFunction.payoutFunctionPieces[i].endPoint.eventOutcome,
-          payoutFunction.payoutFunctionPieces[i - 1].endPoint.outcomePayout,
-          payoutFunction.payoutFunctionPieces[i].endPoint.outcomePayout,
-          totalCollateral,
-          curve,
-          roundingIntervals.intervals,
-        ),
-      );
-    }
-
-    // 3. Handle the final range from the last piece to lastEndpoint if it exists
-    if (
-      payoutFunction.lastEndpoint &&
-      payoutFunction.payoutFunctionPieces.length > 0
-    ) {
-      const lastPieceIndex = payoutFunction.payoutFunctionPieces.length - 1;
-      const lastPiece = payoutFunction.payoutFunctionPieces[lastPieceIndex];
-
-      // Check if there's a range to cover
-      if (
-        payoutFunction.lastEndpoint.eventOutcome >
-        lastPiece.endPoint.eventOutcome
-      ) {
-        // For the final range, we'll assume a constant payout from the last piece endpoint to lastEndpoint
-        // This is a common pattern for DLC payout functions
-        const finalCurve = new PolynomialPayoutCurve([
-          {
-            outcome: new BigNumber(lastPiece.endPoint.eventOutcome.toString()),
-            payout: new BigNumber(lastPiece.endPoint.outcomePayout.toString()),
-          },
-          {
-            outcome: new BigNumber(
-              payoutFunction.lastEndpoint.eventOutcome.toString(),
-            ),
-            payout: new BigNumber(
-              payoutFunction.lastEndpoint.outcomePayout.toString(),
-            ),
-          },
-        ]);
-
-        CETS.push(
-          ...splitIntoRanges(
-            lastPiece.endPoint.eventOutcome,
-            payoutFunction.lastEndpoint.eventOutcome,
-            lastPiece.endPoint.outcomePayout,
-            payoutFunction.lastEndpoint.outcomePayout,
-            totalCollateral,
-            finalCurve,
-            roundingIntervals.intervals,
-          ),
-        );
-      }
-    }
-
-    return mergePayouts(CETS);
-  }
-}