@reyaxyz/common 0.364.0 → 0.364.2

package/src/utils/calculate.ts

@@ -1,8 +1,6 @@
 import { mergeMap } from './struct';
 import BigNumber from 'bignumber.js';
 
-export const POOL_IMR = 9.1;
-
 type MarketId = string;
 type Address = string;
 
@@ -53,148 +51,6 @@ export const calculateMaxWithdraw = ({
   return Math.max(0, Math.min(realBalance, maxFromMargin));
 };
 
-export const calculateMaxExposure = ({
-  poolBalance,
-  riskFactor,
-  poolIMR = POOL_IMR,
-}: {
-  poolBalance: number;
-  poolIMR?: number;
-  riskFactor: number;
-}) => poolBalance / (poolIMR * Math.sqrt(riskFactor));
-
-/**
- * Splits a trade exposure into rebalancing and unbalancing portions relative to pool net exposure.
- * Rebalancing reduces pool's absolute exposure; unbalancing increases it.
- */
-export const splitTradeExposure = (
-  tradeExposure: number,
-  poolNetExposure: number,
-): { rebalancing: number; unbalancing: number } => {
-  if (tradeExposure === 0) {
-    return { rebalancing: 0, unbalancing: 0 };
-  }
-
-  // If pool has no exposure, entire trade is unbalancing
-  if (poolNetExposure === 0) {
-    return { rebalancing: 0, unbalancing: tradeExposure };
-  }
-
-  // Opposite sign means trade increases pool exposure → pure unbalancing
-  const sameSign =
-    (poolNetExposure > 0 && tradeExposure > 0) ||
-    (poolNetExposure < 0 && tradeExposure < 0);
-  if (!sameSign) {
-    return { rebalancing: 0, unbalancing: tradeExposure };
-  }
-
-  // Same sign: trade reduces pool exposure (pool takes opposite side)
-  const absPool = Math.abs(poolNetExposure);
-  const absTrade = Math.abs(tradeExposure);
-
-  if (absTrade <= absPool) {
-    // Pure rebalancing — trade doesn't cross zero
-    return { rebalancing: tradeExposure, unbalancing: 0 };
-  }
-
-  // Mixed: rebalance up to pool exposure, then unbalance the rest
-  const rebalancing = poolNetExposure;
-  const unbalancing = tradeExposure - rebalancing;
-  return { rebalancing, unbalancing };
-};
-
-/**
- * Computes the new log price multiplier (logF) after a trade, handling both
- * rebalancing and unbalancing portions.
- *
- * Mirrors on-chain logic in PriceMultiplier.sol:computeNewLogPriceMultiplier.
- */
-export const computeNewLogF = ({
-  currentLogF,
-  tradeExposure,
-  poolNetExposure,
-  depthFactor,
-  maxExposure,
-}: {
-  currentLogF: number;
-  tradeExposure: number;
-  poolNetExposure: number;
-  depthFactor: number;
-  maxExposure: number;
-}): number => {
-  if (tradeExposure === 0) return currentLogF;
-
-  const { rebalancing, unbalancing } = splitTradeExposure(
-    tradeExposure,
-    poolNetExposure,
-  );
-
-  // Case 1: Has unbalancing portion (includes mixed trades)
-  if (unbalancing !== 0) {
-    // If also rebalancing, it brings logF to 0 by definition (trade crosses zero)
-    const startLogF = rebalancing === 0 ? currentLogF : 0;
-    return startLogF + unbalancing / (depthFactor * maxExposure);
-  }
-
-  // Case 2: Only rebalancing
-  // Both rebalancing and poolNetExposure have the same sign, so ratio is in [0, 1]
-  if (rebalancing !== 0 && poolNetExposure !== 0) {
-    const ratio = rebalancing / poolNetExposure;
-    return currentLogF * (1 - ratio);
-  }
-
-  return currentLogF;
-};
-
-/**
- * Estimates the execution price for a trade using the exponential logPriceMultiplier formula.
- *
- * Mirrors on-chain logic:
- * 1. computeNewLogPriceMultiplier (PriceMultiplier.sol)
- * 2. computeAmmPrice: ammPrice = oraclePrice * exp(logF)
- * 3. computeSignedSpread: executionPrice = ammPrice * (1 + signedSpread)
- *
- * @audit spreadDiscount not applied — known limitation, to be addressed later
- * @audit priceSpacing rounding not applied
- */
-export const calculateEstimatedExecutionPrice = ({
-  oraclePrice,
-  currentLogF,
-  tradeExposure,
-  poolNetExposure,
-  depthFactor,
-  maxExposure,
-  priceSpread,
-}: {
-  oraclePrice: number;
-  currentLogF: number;
-  tradeExposure: number;
-  poolNetExposure: number;
-  depthFactor: number;
-  maxExposure: number;
-  priceSpread: number;
-}): number => {
-  if (tradeExposure === 0) {
-    return oraclePrice * Math.exp(currentLogF);
-  }
-
-  // 1. Compute new logF after trade impact
-  const newLogF = computeNewLogF({
-    currentLogF,
-    tradeExposure,
-    poolNetExposure,
-    depthFactor,
-    maxExposure,
-  });
-
-  // 2. Compute AMM price: oraclePrice * exp(newLogF)
-  const ammPrice = oraclePrice * Math.exp(newLogF);
-
-  // 3. Apply signed spread
-  const signedSpread = tradeExposure > 0 ? priceSpread : -priceSpread;
-  return Math.max(0, ammPrice * (1 + signedSpread));
-};
-
 export const calculateTradeFee = ({
   feeRate,
   tradeNotional,
@@ -203,42 +59,6 @@ export const calculateTradeFee = ({
   tradeNotional: number;
 }) => feeRate * Math.abs(tradeNotional);
 
-export const calculateSpread = ({
-  depthFactor,
-  maxExposure,
-  oraclePrice,
-  poolPrice,
-  tradeNotional,
-}: {
-  depthFactor: number;
-  maxExposure: number;
-  oraclePrice: number;
-  poolPrice: number;
-  tradeNotional: number;
-}) =>
-  (poolPrice / oraclePrice) *
-  (1 + tradeNotional / (depthFactor * maxExposure) - 1) *
-  tradeNotional;
-
-export const calculateEstimatedLiquidationPrice = ({
-  LMR,
-  accountBalance,
-  isShort,
-  notional,
-  oraclePrice,
-}: {
-  LMR: number;
-  accountBalance: number;
-  isShort: boolean;
-  notional: number;
-  oraclePrice: number;
-}) =>
-  Math.max(
-    0,
-    oraclePrice *
-      (1 - ((accountBalance - LMR) / notional) * (isShort ? -1 : 1)),
-  );
-
 export const calculateLeverage = ({
   imrMultiplier,
   riskFactor,
@@ -262,212 +82,6 @@ export const calculateRequiredMargin = ({
   (Math.abs(currentNotional + tradeNotional) - Math.abs(currentNotional)) /
     leverage;
 
-/**
- * Calculates the maximum notional trade size (unsigned, always ≥ 0).
- *
- * Implements the UI quant spec v2 ("Maximum trade") with two cases:
- *   Case 1 — Extending: trade same direction as existing position.
- *   Case 2 — Reverting: decompose into (a) close position exactly, then
- *            (b) extend from zero in the opposite direction.
- *
- * All quadratics use the unsigned convention (t = |tradeNotional|) so the
- * positive root always corresponds to the correct direction.
- */
-export const calculateMaxOrderSize = ({
-  currIMR,
-  currNodeBalance,
-  currNotional,
-  depthFactor,
-  feeRate,
-  isShortTrade,
-  leverage,
-  maxExposure,
-  oraclePrice,
-  poolPrice,
-  currentLogF,
-  netExposure,
-}: {
-  currIMR: number;
-  currNodeBalance: number;
-  currNotional: number;
-  depthFactor: number;
-  feeRate: number;
-  isShortTrade: boolean;
-  leverage: number;
-  maxExposure: number;
-  oraclePrice: number;
-  poolPrice: number;
-  currentLogF: number;
-  netExposure: number;
-}): number => {
-  const D = depthFactor * maxExposure;
-  const rho = poolPrice / oraclePrice;
-  const tradeSign = isShortTrade ? -1 : 1;
-  const s0 = currNotional > 0 ? 1 : currNotional < 0 ? -1 : tradeSign;
-  const absN0 = Math.abs(currNotional);
-
-  /**
-   * Solve the extending quadratic (spec §Case 1) for max trade size.
-   * a·t² + b·t + c = 0  where a = ρ·γ, b = s₀·(1/lev + fee) + (ρ−1), c = −surplus.
-   * Root selection: pick the root whose sign matches s₀ (dir).
-   * For rebalancing (a < 0), caps at |NE| (beyond which γ switches to unbalancing).
-   */
-  const solveExtending = (
-    dir: number,
-    surplus: number, // aka, IMRDelta
-    rho_: number,
-    gamma_: number,
-    isRebal: boolean,
-    absNE: number,
-  ): number => {
-    if (surplus <= 0) return 0;
-    const a = rho_ * gamma_;
-    const b = dir * (1 / leverage + feeRate) + (rho_ - 1);
-    const c = -surplus;
-    // Degenerate: γ = 0 → linear equation b·t + c = 0 (rebalancing with f = 0)
-    if (a === 0) {
-      if (b === 0) return isRebal ? absNE : 0;
-      const t = -c / b;
-      if (t * dir <= 0) return isRebal ? absNE : 0;
-      return isRebal ? Math.min(Math.abs(t), absNE) : Math.abs(t);
-    }
-    const disc = b * b - 4 * a * c;
-    if (isRebal) {
-      if (disc < 0) return absNE;
-      const t = (-b + dir * Math.sqrt(disc)) / (2 * a);
-      return t * dir <= 0 ? absNE : Math.min(Math.abs(t), absNE);
-    }
-    if (disc < 0)
-      throw new Error(`calculateMaxOrderSize: negative discriminant (${disc})`);
-    const t = (-b + dir * Math.sqrt(disc)) / (2 * a);
-    if (t * dir <= 0)
-      throw new Error(`calculateMaxOrderSize: no valid root (${t})`);
-    return Math.abs(t);
-  };
-
-  // Determine γ for a trade of given direction against the current pool state
-  const getGamma = (dir: number, logF: number, ne: number) => {
-    const isRebal = ne !== 0 && dir === Math.sign(ne);
-    const gamma = isRebal ? -logF / ne : 1 / D;
-    return { gamma, isRebal };
-  };
-
-  /**
-   * Like solveExtending, but when the rebalancing leg is capped at |NE|
-   * (pool-flip), continues with the unbalancing leg from NE = 0.
-   *
-   * For the exact rebalancing trade to NE = 0:
-   *   execRatio = ρ·exp(γ·dir·|NE|) = exp(f)·exp(−f) = 1
-   * so only fee and IMR consume margin. Then extend with γ = 1/D and ρ' = 1.
-   */
-  const extendWithFlip = (
-    dir: number,
-    surplus: number,
-    rho_: number,
-    gamma_: number,
-    isRebal: boolean,
-    absNE: number,
-  ): number => {
-    const result = solveExtending(dir, surplus, rho_, gamma_, isRebal, absNE);
-    if (!isRebal || result < absNE || absNE === 0) return result;
-
-    // Pool-flip: rebalancing consumed absNE, continue unbalancing from NE = 0
-    const surplusAfter = surplus - absNE * (1 / leverage + feeRate);
-    if (surplusAfter <= 0) return absNE;
-    return absNE + solveExtending(dir, surplusAfter, 1, 1 / D, false, 0);
-  };
-
-  // ── Case 1: Extending ──────────────────────────────────────────────────
-  if (tradeSign === s0) {
-    const { gamma, isRebal } = getGamma(tradeSign, currentLogF, netExposure);
-    return extendWithFlip(
-      s0,
-      currNodeBalance - currIMR,
-      rho,
-      gamma,
-      isRebal,
-      Math.abs(netExposure),
-    );
-  }
-
-  // ── Case 2: Reverting — close N₀, then re-extend ──────────────────────
-
-  // Step 1: Close N₀ entirely (spec §Case 2, Step 1)
-  const closeTrade = -currNotional;
-  const closeDir = -s0;
-  const { gamma: gammaC, isRebal: closeIsRebal } = getGamma(
-    closeDir,
-    currentLogF,
-    netExposure,
-  );
-  const closeFlipsPool = closeIsRebal && absN0 > Math.abs(netExposure);
-
-  // Exec price ratio: ρ·exp(γ_c·closeTrade) for non-flip, dedicated formula for flip
-  const closeExecRatio = closeFlipsPool
-    ? Math.exp((closeTrade - netExposure) / D)
-    : rho * Math.exp(gammaC * closeTrade);
-
-  const balClose =
-    currNodeBalance - feeRate * absN0 + closeTrade * (1 - closeExecRatio);
-  const imrClose = currIMR - absN0 / leverage;
-  const surplusClose = balClose - imrClose;
-
-  // Insolvency: can't fully close without going under margin.
-  // Solve partial-close quadratic (spec appendix): b has flipped feeRate sign.
-  // Falls back to full close (|N₀|) when no valid partial-close root exists.
-  if (surplusClose <= 0) {
-    const IMRDelta = currNodeBalance - currIMR;
-    const { gamma: gammaP } = getGamma(closeDir, currentLogF, netExposure);
-    const a = rho * gammaP;
-    const b = s0 * (1 / leverage - feeRate) + (rho - 1);
-    const c = -IMRDelta;
-
-    if (a === 0) {
-      if (b === 0) return absN0;
-      const t = -c / b;
-      if (t * closeDir <= 0) return absN0;
-      return Math.min(Math.abs(t), absN0);
-    }
-
-    const disc = b * b - 4 * a * c;
-    if (disc < 0) return absN0;
-    const t = (-b + closeDir * Math.sqrt(disc)) / (2 * a);
-    if (t * closeDir <= 0) return absN0;
-    return Math.min(Math.abs(t), absN0);
-  }
-
-  // Step 2: Extend from zero in -s₀ direction with post-close pool state
-  const neAfter = netExposure + currNotional;
-  let fPrime: number;
-  if (closeFlipsPool) {
-    fPrime = (closeTrade - netExposure) / D;
-  } else if (closeIsRebal) {
-    fPrime = currentLogF * (1 + currNotional / netExposure);
-  } else {
-    fPrime = currentLogF + closeTrade / D;
-  }
-  const rhoPrime = Math.exp(fPrime);
-
-  const extDir = -s0;
-  const { gamma: gammaPrime, isRebal: isExtRebal } = getGamma(
-    extDir,
-    fPrime,
-    neAfter,
-  );
-
-  return (
-    absN0 +
-    extendWithFlip(
-      extDir,
-      surplusClose,
-      rhoPrime,
-      gammaPrime,
-      isExtRebal,
-      Math.abs(neAfter),
-    )
-  );
-};
-
 export const calculateIMR = ({
   marketLeverages,
   marketPrices,
@@ -520,29 +134,6 @@ export const calculateLMR = ({
       : sum;
   }, 0);
 
-// if account balance is below LMR position is liquidable
-
-export const calculateMarginRatio = ({
-  LMR,
-  totalBalance,
-  tradeCost,
-}: {
-  LMR: number;
-  totalBalance: number;
-  tradeCost: number;
-}) => {
-  if (LMR === 0) {
-    return 0;
-  }
-  if (tradeCost > totalBalance) {
-    return 1;
-  }
-  if (totalBalance === tradeCost) {
-    return Infinity;
-  }
-  return Math.min(1, LMR / (totalBalance - tradeCost));
-};
-
 export const calculateTotalMargin = ({
   marketsTrackers,
   accountBalances,
@@ -703,94 +294,6 @@ export const calculatePositionAdjustedQty = (
   return origQty.times(marketBaseMultiplier).div(positionBaseMultiplier);
 };
 
-/**
- * Linearly interpolate a depth ratio from a (thresholds, ratios) curve.
- * The curve implicitly starts at (exposure=0, ratio=1.0).
- * - Between thresholds: linear interpolation
- * - Above last threshold: last ratio (flat extrapolation)
- *
- * @param thresholds - Sorted ascending exposure thresholds in notional USD (must be non-empty)
- * @param ratios - Depth ratio at each threshold (same length as thresholds, must be non-empty)
- * @param exposure - Absolute exposure notional (must be >= 0)
- * @throws if thresholds or ratios are empty, or if they have different lengths
- */
-export const interpolateDepthRatio = (
-  thresholds: number[],
-  ratios: number[],
-  exposure: number,
-): number => {
-  if (exposure < 0) {
-    throw new Error('interpolateDepthRatio: exposure must be >= 0');
-  }
-  if (thresholds.length === 0 || ratios.length === 0) {
-    throw new Error(
-      'interpolateDepthRatio: thresholds and ratios must be non-empty',
-    );
-  }
-  if (thresholds.length !== ratios.length) {
-    throw new Error(
-      'interpolateDepthRatio: thresholds and ratios must have equal length',
-    );
-  }
-
-  const allThresholds = [0, ...thresholds];
-  const allRatios = [1.0, ...ratios];
-
-  if (exposure === 0) return 1.0;
-  if (exposure >= allThresholds[allThresholds.length - 1]) {
-    return allRatios[allRatios.length - 1];
-  }
-
-  for (let i = 0; i < allThresholds.length - 1; i++) {
-    if (exposure <= allThresholds[i + 1]) {
-      const t =
-        (exposure - allThresholds[i]) /
-        (allThresholds[i + 1] - allThresholds[i]);
-      return allRatios[i] + t * (allRatios[i + 1] - allRatios[i]);
-    }
-  }
-
-  throw new Error('interpolateDepthRatio: unreachable');
-};
-
-/**
- * Calculate the dynamic depth factor for a trade given pool state and config.
- *
- * The pool takes the opposite side of the trade, so:
- *   poolNotionalAfterTrade = currentPoolNotional - signedTradeNotional
- *
- * The depth ratio is interpolated from the exposure curve, then multiplied
- * by baseDepth to produce the final depth factor.
- *
- * @param baseDepth - Base depth multiplier for this market
- * @param thresholds - Sorted ascending exposure thresholds (notional USD)
- * @param ratios - Depth ratio at each threshold
- * @param currentPoolNotional - Pool's current notional in this market (signed)
- * @param signedTradeNotional - Trade notional (positive=buy, negative=sell)
- */
-export const calculateDynamicDepthFactor = ({
-  baseDepth,
-  thresholds,
-  ratios,
-  currentPoolNotional,
-  signedTradeNotional,
-}: {
-  baseDepth: number;
-  thresholds: number[];
-  ratios: number[];
-  currentPoolNotional: number;
-  signedTradeNotional: number;
-}): number => {
-  const poolNotionalAfterTrade = currentPoolNotional - signedTradeNotional;
-  const absExposureNotional = Math.abs(poolNotionalAfterTrade);
-  const depthRatio = interpolateDepthRatio(
-    thresholds,
-    ratios,
-    absExposureNotional,
-  );
-  return depthRatio * baseDepth;
-};
-
 export const calculatePositionAdlPnL = ({
   marketTrackerAdlUnwindPrice,
   marketTrackerBaseMultiplier,