@reyaxyz/common 0.332.0 → 0.333.2

package/src/utils/calculate.ts

@@ -63,31 +63,136 @@ export const calculateMaxExposure = ({
   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 = ({
-  poolPrice,
   oraclePrice,
-  tradeBaseSize,
-  poolMaxExposure,
-  marketDepthFactor,
-  marketSpread,
+  currentLogF,
+  tradeExposure,
+  poolNetExposure,
+  depthFactor,
+  maxExposure,
+  priceSpread,
 }: {
-  poolPrice: number;
   oraclePrice: number;
-  tradeBaseSize: number;
-  poolMaxExposure: number;
-  marketDepthFactor: number;
-  marketSpread: number;
+  currentLogF: number;
+  tradeExposure: number;
+  poolNetExposure: number;
+  depthFactor: number;
+  maxExposure: number;
+  priceSpread: number;
 }): number => {
-  if (tradeBaseSize === 0) {
-    return poolPrice;
+  if (tradeExposure === 0) {
+    return oraclePrice * Math.exp(currentLogF);
   }
 
-  const poolDeviation =
-    (tradeBaseSize * oraclePrice) / (marketDepthFactor * poolMaxExposure);
-  const appliedSpread = tradeBaseSize > 0 ? marketSpread : -marketSpread;
-  const estExecutionPrice = poolPrice * (1 + poolDeviation + appliedSpread);
+  // 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);
 
-  return Math.max(0, estExecutionPrice);
+  // 3. Apply signed spread
+  const signedSpread = tradeExposure > 0 ? priceSpread : -priceSpread;
+  return Math.max(0, ammPrice * (1 + signedSpread));
 };
 
 export const calculateTradeFee = ({

package/src/utils/token/token-info.ts

@@ -122,7 +122,9 @@ export const TOKEN_INFO: Record<ReyaChainId | MoneyInOutChainId, TokenInfo[]> =
         address: '0xa6cf523f856f4a0aab78848e251c1b042e6406d5',
         decimals: 8,
         isRUSDUnderlying: false,
-        ...defaultTokenThresholds,
+        minDepositAmount: 0.0001,
+        minWithdrawAmount: 0.0001,
+        minTransferAmount: 0.0001,
       },
     ],
     [MoneyInOutChainId.ethereumMainnet]: [