@atomicfinance/bitcoin-wallet-provider 4.2.8 → 4.3.1

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

@@ -0,0 +1,188 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,266 @@
+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);
+  }
+}