@paraswap/dex-lib 2.42.28 → 2.42.29

package/src/dex/solidly-v3/contract-math/SqrtPriceMath.ts

@@ -0,0 +1,226 @@
+import { BI_MAX_UINT160 } from '../../../bigint-constants';
+import { FixedPoint96 } from './FixedPoint96';
+import { FullMath } from './FullMath';
+import { UnsafeMath } from './UnsafeMath';
+import { _require } from '../../../utils';
+
+export class SqrtPriceMath {
+  static getNextSqrtPriceFromAmount0RoundingUp(
+    sqrtPX96: bigint,
+    liquidity: bigint,
+    amount: bigint,
+    add: boolean,
+  ): bigint {
+    if (amount === 0n) return sqrtPX96;
+    const numerator1 =
+      BigInt.asUintN(256, liquidity) << FixedPoint96.RESOLUTION;
+
+    const product = amount * sqrtPX96;
+    if (add) {
+      if (product / amount === sqrtPX96) {
+        const denominator = numerator1 + product;
+        if (denominator >= numerator1) {
+          return BigInt.asUintN(
+            160,
+            FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator),
+          );
+        }
+      }
+      return BigInt.asUintN(
+        160,
+        UnsafeMath.divRoundingUp(numerator1, numerator1 / sqrtPX96 + amount),
+      );
+    } else {
+      _require(
+        product / amount === sqrtPX96 && numerator1 > product,
+        '',
+        { product, amount, sqrtPX96, numerator1 },
+        'product / amount === sqrtPX96 && numerator1 > product',
+      );
+      const denominator = numerator1 - product;
+      return BigInt.asUintN(
+        160,
+        FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator),
+      );
+    }
+  }
+
+  static getNextSqrtPriceFromAmount1RoundingDown(
+    sqrtPX96: bigint,
+    liquidity: bigint,
+    amount: bigint,
+    add: boolean,
+  ): bigint {
+    if (add) {
+      const quotient =
+        amount <= BI_MAX_UINT160
+          ? (amount << FixedPoint96.RESOLUTION) / liquidity
+          : FullMath.mulDiv(amount, FixedPoint96.Q96, liquidity);
+      return BigInt.asUintN(160, BigInt.asUintN(256, sqrtPX96) + quotient);
+    } else {
+      const quotient =
+        amount <= BI_MAX_UINT160
+          ? UnsafeMath.divRoundingUp(
+              amount << FixedPoint96.RESOLUTION,
+              liquidity,
+            )
+          : FullMath.mulDivRoundingUp(amount, FixedPoint96.Q96, liquidity);
+
+      _require(
+        sqrtPX96 > quotient,
+        '',
+        { sqrtPX96, quotient },
+        'sqrtPX96 > quotient',
+      );
+      return BigInt.asUintN(160, sqrtPX96 - quotient);
+    }
+  }
+
+  static getNextSqrtPriceFromInput(
+    sqrtPX96: bigint,
+    liquidity: bigint,
+    amountIn: bigint,
+    zeroForOne: boolean,
+  ): bigint {
+    _require(sqrtPX96 > 0n, '', { sqrtPX96 }, 'sqrtPX96 > 0n');
+    _require(liquidity > 0n, '', { liquidity }, 'liquidity > 0n');
+
+    return zeroForOne
+      ? SqrtPriceMath.getNextSqrtPriceFromAmount0RoundingUp(
+          sqrtPX96,
+          liquidity,
+          amountIn,
+          true,
+        )
+      : SqrtPriceMath.getNextSqrtPriceFromAmount1RoundingDown(
+          sqrtPX96,
+          liquidity,
+          amountIn,
+          true,
+        );
+  }
+
+  static getNextSqrtPriceFromOutput(
+    sqrtPX96: bigint,
+    liquidity: bigint,
+    amountOut: bigint,
+    zeroForOne: boolean,
+  ): bigint {
+    _require(sqrtPX96 > 0n, '', { sqrtPX96 }, 'sqrtPX96 > 0n');
+    _require(liquidity > 0n, '', { liquidity }, 'liquidity > 0n');
+
+    return zeroForOne
+      ? SqrtPriceMath.getNextSqrtPriceFromAmount1RoundingDown(
+          sqrtPX96,
+          liquidity,
+          amountOut,
+          false,
+        )
+      : SqrtPriceMath.getNextSqrtPriceFromAmount0RoundingUp(
+          sqrtPX96,
+          liquidity,
+          amountOut,
+          false,
+        );
+  }
+
+  static getAmount0Delta(
+    sqrtRatioAX96: bigint,
+    sqrtRatioBX96: bigint,
+    liquidity: bigint,
+    roundUp: boolean,
+  ) {
+    if (sqrtRatioAX96 > sqrtRatioBX96) {
+      [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+    }
+
+    const numerator1 =
+      BigInt.asUintN(256, liquidity) << FixedPoint96.RESOLUTION;
+    const numerator2 = sqrtRatioBX96 - sqrtRatioAX96;
+
+    _require(sqrtRatioAX96 > 0, '', { sqrtRatioAX96 }, 'sqrtRatioAX96 > 0');
+
+    return roundUp
+      ? UnsafeMath.divRoundingUp(
+          FullMath.mulDivRoundingUp(numerator1, numerator2, sqrtRatioBX96),
+          sqrtRatioAX96,
+        )
+      : FullMath.mulDiv(numerator1, numerator2, sqrtRatioBX96) / sqrtRatioAX96;
+  }
+
+  static getAmount1Delta(
+    sqrtRatioAX96: bigint,
+    sqrtRatioBX96: bigint,
+    liquidity: bigint,
+    roundUp: boolean,
+  ) {
+    if (sqrtRatioAX96 > sqrtRatioBX96)
+      [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+
+    return roundUp
+      ? FullMath.mulDivRoundingUp(
+          liquidity,
+          sqrtRatioBX96 - sqrtRatioAX96,
+          FixedPoint96.Q96,
+        )
+      : FullMath.mulDiv(
+          liquidity,
+          sqrtRatioBX96 - sqrtRatioAX96,
+          FixedPoint96.Q96,
+        );
+  }
+
+  // Overloaded with different argument numbers
+  static _getAmount0DeltaO(
+    sqrtRatioAX96: bigint,
+    sqrtRatioBX96: bigint,
+    liquidity: bigint,
+  ) {
+    return liquidity < 0
+      ? -BigInt.asIntN(
+          256,
+          SqrtPriceMath.getAmount0Delta(
+            sqrtRatioAX96,
+            sqrtRatioBX96,
+            BigInt.asUintN(128, -liquidity),
+            false,
+          ),
+        )
+      : BigInt.asIntN(
+          256,
+          SqrtPriceMath.getAmount0Delta(
+            sqrtRatioAX96,
+            sqrtRatioBX96,
+            BigInt.asUintN(128, liquidity),
+            true,
+          ),
+        );
+  }
+
+  // Overloaded with different argument numbers
+  static _getAmount1DeltaO(
+    sqrtRatioAX96: bigint,
+    sqrtRatioBX96: bigint,
+    liquidity: bigint,
+  ) {
+    return liquidity < 0
+      ? -BigInt.asIntN(
+          256,
+          SqrtPriceMath.getAmount1Delta(
+            sqrtRatioAX96,
+            sqrtRatioBX96,
+            BigInt.asUintN(128, -liquidity),
+            false,
+          ),
+        )
+      : BigInt.asIntN(
+          256,
+          SqrtPriceMath.getAmount1Delta(
+            sqrtRatioAX96,
+            sqrtRatioBX96,
+            BigInt.asUintN(128, liquidity),
+            true,
+          ),
+        );
+  }
+}

package/src/dex/solidly-v3/contract-math/SwapMath.ts

@@ -0,0 +1,139 @@
+import { BI_POWS } from '../../../bigint-constants';
+import { FullMath } from './FullMath';
+import { SqrtPriceMath } from './SqrtPriceMath';
+
+export class SwapMath {
+  static computeSwapStep(
+    sqrtRatioCurrentX96: bigint,
+    sqrtRatioTargetX96: bigint,
+    liquidity: bigint,
+    amountRemaining: bigint,
+    feePips: bigint,
+  ): {
+    sqrtRatioNextX96: bigint;
+    amountIn: bigint;
+    amountOut: bigint;
+    feeAmount: bigint;
+  } {
+    const zeroForOne = sqrtRatioCurrentX96 >= sqrtRatioTargetX96;
+    const exactIn = amountRemaining >= 0n;
+
+    let sqrtRatioNextX96 = 0n;
+    let amountIn = 0n;
+    let amountOut = 0n;
+    let feeAmount = 0n;
+
+    if (exactIn) {
+      const amountRemainingLessFee = FullMath.mulDiv(
+        BigInt.asUintN(256, amountRemaining),
+        BI_POWS[6] - feePips,
+        BI_POWS[6],
+      );
+      amountIn = zeroForOne
+        ? SqrtPriceMath.getAmount0Delta(
+            sqrtRatioTargetX96,
+            sqrtRatioCurrentX96,
+            liquidity,
+            true,
+          )
+        : SqrtPriceMath.getAmount1Delta(
+            sqrtRatioCurrentX96,
+            sqrtRatioTargetX96,
+            liquidity,
+            true,
+          );
+      if (amountRemainingLessFee >= amountIn)
+        sqrtRatioNextX96 = sqrtRatioTargetX96;
+      else
+        sqrtRatioNextX96 = SqrtPriceMath.getNextSqrtPriceFromInput(
+          sqrtRatioCurrentX96,
+          liquidity,
+          amountRemainingLessFee,
+          zeroForOne,
+        );
+    } else {
+      amountOut = zeroForOne
+        ? SqrtPriceMath.getAmount1Delta(
+            sqrtRatioTargetX96,
+            sqrtRatioCurrentX96,
+            liquidity,
+            false,
+          )
+        : SqrtPriceMath.getAmount0Delta(
+            sqrtRatioCurrentX96,
+            sqrtRatioTargetX96,
+            liquidity,
+            false,
+          );
+      if (BigInt.asUintN(256, -amountRemaining) >= amountOut)
+        sqrtRatioNextX96 = sqrtRatioTargetX96;
+      else
+        sqrtRatioNextX96 = SqrtPriceMath.getNextSqrtPriceFromOutput(
+          sqrtRatioCurrentX96,
+          liquidity,
+          BigInt.asUintN(256, -amountRemaining),
+          zeroForOne,
+        );
+    }
+
+    const max = sqrtRatioTargetX96 == sqrtRatioNextX96;
+
+    if (zeroForOne) {
+      amountIn =
+        max && exactIn
+          ? amountIn
+          : SqrtPriceMath.getAmount0Delta(
+              sqrtRatioNextX96,
+              sqrtRatioCurrentX96,
+              liquidity,
+              true,
+            );
+      amountOut =
+        max && !exactIn
+          ? amountOut
+          : SqrtPriceMath.getAmount1Delta(
+              sqrtRatioNextX96,
+              sqrtRatioCurrentX96,
+              liquidity,
+              false,
+            );
+    } else {
+      amountIn =
+        max && exactIn
+          ? amountIn
+          : SqrtPriceMath.getAmount1Delta(
+              sqrtRatioCurrentX96,
+              sqrtRatioNextX96,
+              liquidity,
+              true,
+            );
+      amountOut =
+        max && !exactIn
+          ? amountOut
+          : SqrtPriceMath.getAmount0Delta(
+              sqrtRatioCurrentX96,
+              sqrtRatioNextX96,
+              liquidity,
+              false,
+            );
+    }
+
+    // cap the output amount to not exceed the remaining output amount
+    if (!exactIn && amountOut > BigInt.asUintN(256, -amountRemaining)) {
+      amountOut = BigInt.asUintN(256, -amountRemaining);
+    }
+
+    if (exactIn && sqrtRatioNextX96 != sqrtRatioTargetX96) {
+      // we didn't reach the target, so take the remainder of the maximum input as fee
+      feeAmount = BigInt.asUintN(256, amountRemaining) - amountIn;
+    } else {
+      feeAmount = FullMath.mulDivRoundingUp(
+        amountIn,
+        feePips,
+        BI_POWS[6] - feePips,
+      );
+    }
+
+    return { sqrtRatioNextX96, amountIn, amountOut, feeAmount };
+  }
+}

package/src/dex/solidly-v3/contract-math/Tick.ts

@@ -0,0 +1,66 @@
+import { PoolState, TickInfo } from '../types';
+import { LiquidityMath } from './LiquidityMath';
+import { _require } from '../../../utils';
+import { NumberAsString } from '@paraswap/core';
+import { ZERO_TICK_INFO } from '../constants';
+
+export class Tick {
+  static update(
+    state: Pick<PoolState, 'ticks'>,
+    tick: bigint,
+    liquidityDelta: bigint,
+    upper: boolean,
+    maxLiquidity: bigint,
+  ): boolean {
+    let info = state.ticks[Number(tick)];
+
+    if (info === undefined) {
+      info = { ...ZERO_TICK_INFO };
+      state.ticks[Number(tick)] = info;
+    }
+
+    const liquidityGrossBefore = info.liquidityGross;
+    const liquidityGrossAfter = LiquidityMath.addDelta(
+      liquidityGrossBefore,
+      liquidityDelta,
+    );
+
+    _require(
+      liquidityGrossAfter <= maxLiquidity,
+      'LO',
+      { liquidityGrossAfter, maxLiquidity },
+      'liquidityGrossAfter <= maxLiquidity',
+    );
+
+    const flipped = (liquidityGrossAfter == 0n) != (liquidityGrossBefore == 0n);
+
+    if (liquidityGrossBefore == 0n) {
+      info.initialized = true;
+    }
+
+    info.liquidityGross = liquidityGrossAfter;
+
+    info.liquidityNet = upper
+      ? BigInt.asIntN(
+          128,
+          BigInt.asIntN(256, info.liquidityNet) - liquidityDelta,
+        )
+      : BigInt.asIntN(
+          128,
+          BigInt.asIntN(256, info.liquidityNet) + liquidityDelta,
+        );
+    return flipped;
+  }
+
+  static clear(state: Pick<PoolState, 'ticks'>, tick: bigint) {
+    delete state.ticks[Number(tick)];
+  }
+
+  static cross(
+    ticks: Record<NumberAsString, TickInfo>,
+    tick: bigint,
+  ): bigint {
+    const info = ticks[Number(tick)];
+    return info.liquidityNet;
+  }
+}

package/src/dex/solidly-v3/contract-math/TickBitMap.ts

@@ -0,0 +1,123 @@
+import { BI_MAX_UINT8 } from '../../../bigint-constants';
+import { PoolState } from '../types';
+import { BitMath } from './BitMath';
+import { _require } from '../../../utils';
+import { DeepReadonly } from 'ts-essentials';
+import {
+  OUT_OF_RANGE_ERROR_POSTFIX,
+  TICK_BITMAP_BUFFER,
+  TICK_BITMAP_TO_USE,
+} from '../constants';
+
+function isWordPosOut(
+  wordPos: bigint,
+  startTickBitmap: bigint,
+  // For pricing we use wider range to check price impact. If function called from event
+  // it must always be within buffer
+  isPriceQuery: boolean,
+) {
+  let lowerTickBitmapLimit;
+  let upperTickBitmapLimit;
+
+  if (isPriceQuery) {
+    lowerTickBitmapLimit =
+      startTickBitmap - (TICK_BITMAP_BUFFER + TICK_BITMAP_TO_USE);
+    upperTickBitmapLimit =
+      startTickBitmap + (TICK_BITMAP_BUFFER + TICK_BITMAP_TO_USE);
+  } else {
+    lowerTickBitmapLimit = startTickBitmap - TICK_BITMAP_BUFFER;
+    upperTickBitmapLimit = startTickBitmap + TICK_BITMAP_BUFFER;
+  }
+
+  _require(
+    wordPos >= lowerTickBitmapLimit && wordPos <= upperTickBitmapLimit,
+    `wordPos is out of safe state tickBitmap request range: ${OUT_OF_RANGE_ERROR_POSTFIX}`,
+    { wordPos },
+    `wordPos >= LOWER_TICK_REQUEST_LIMIT && wordPos <= UPPER_TICK_REQUEST_LIMIT`,
+  );
+}
+
+export class TickBitMap {
+  static position(tick: bigint): [bigint, bigint] {
+    return [BigInt.asIntN(16, tick >> 8n), BigInt.asUintN(8, tick % 256n)];
+  }
+
+  static flipTick(
+    state: Pick<PoolState, 'startTickBitmap' | 'tickBitmap'>,
+    tick: bigint,
+    tickSpacing: bigint,
+  ) {
+    _require(
+      tick % tickSpacing === 0n,
+      '',
+      { tick, tickSpacing },
+      'tick % tickSpacing == 0n,',
+    );
+    const [wordPos, bitPos] = TickBitMap.position(tick / tickSpacing);
+    const mask = 1n << bitPos;
+
+    // flipTick is used only in _updatePosition which is always state changing event
+    // Therefore it is never used in price query
+    isWordPosOut(wordPos, state.startTickBitmap, false);
+
+    const stringWordPos = wordPos.toString();
+    if (state.tickBitmap[stringWordPos] === undefined) {
+      state.tickBitmap[stringWordPos] = 0n;
+    }
+
+    state.tickBitmap[stringWordPos] ^= mask;
+  }
+
+  static nextInitializedTickWithinOneWord(
+    state: DeepReadonly<Pick<PoolState, 'startTickBitmap' | 'tickBitmap'>>,
+    tick: bigint,
+    tickSpacing: bigint,
+    lte: boolean,
+    isPriceQuery: boolean,
+  ): [bigint, boolean] {
+    let compressed = tick / tickSpacing;
+    if (tick < 0n && tick % tickSpacing != 0n) compressed--;
+
+    let next = 0n;
+    let initialized = false;
+
+    if (lte) {
+      const [wordPos, bitPos] = TickBitMap.position(compressed);
+      const mask = (1n << bitPos) - 1n + (1n << bitPos);
+
+      isWordPosOut(wordPos, state.startTickBitmap, isPriceQuery);
+      let tickBitmapValue = state.tickBitmap[wordPos.toString()];
+      tickBitmapValue = tickBitmapValue === undefined ? 0n : tickBitmapValue;
+
+      const masked = tickBitmapValue & mask;
+
+      initialized = masked != 0n;
+      next = initialized
+        ? (compressed -
+            BigInt.asIntN(24, bitPos - BitMath.mostSignificantBit(masked))) *
+          tickSpacing
+        : (compressed - BigInt.asIntN(24, bitPos)) * tickSpacing;
+    } else {
+      // start from the word of the next tick, since the current tick state doesn't matter
+      const [wordPos, bitPos] = TickBitMap.position(compressed + 1n);
+      const mask = ~((1n << bitPos) - 1n);
+
+      isWordPosOut(wordPos, state.startTickBitmap, isPriceQuery);
+      let tickBitmapValue = state.tickBitmap[wordPos.toString()];
+      tickBitmapValue = tickBitmapValue === undefined ? 0n : tickBitmapValue;
+
+      const masked = tickBitmapValue & mask;
+
+      initialized = masked != 0n;
+      next = initialized
+        ? (compressed +
+            1n +
+            BigInt.asIntN(24, BitMath.leastSignificantBit(masked) - bitPos)) *
+          tickSpacing
+        : (compressed + 1n + BigInt.asIntN(24, BI_MAX_UINT8 - bitPos)) *
+          tickSpacing;
+    }
+
+    return [next, initialized];
+  }
+}