@paraswap/dex-lib 2.42.3 → 2.42.4-baseswap

package/src/dex/baseswap-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/baseswap-v3/contract-math/Tick.ts

@@ -0,0 +1,82 @@
+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,
+    tickCurrent: bigint,
+    liquidityDelta: bigint,
+    secondsPerLiquidityCumulativeX128: bigint,
+    tickCumulative: bigint,
+    time: 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) {
+      if (tick <= tickCurrent) {
+        info.secondsPerLiquidityOutsideX128 = secondsPerLiquidityCumulativeX128;
+        info.tickCumulativeOutside = tickCumulative;
+        info.secondsOutside = time;
+      }
+      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,
+    secondsPerLiquidityCumulativeX128: bigint,
+    tickCumulative: bigint,
+    time: bigint,
+  ): bigint {
+    const info = ticks[Number(tick)];
+    info.secondsPerLiquidityOutsideX128 =
+      secondsPerLiquidityCumulativeX128 - info.secondsPerLiquidityOutsideX128;
+    info.tickCumulativeOutside = tickCumulative - info.tickCumulativeOutside;
+    info.secondsOutside = time - info.secondsOutside;
+    return info.liquidityNet;
+  }
+}

package/src/dex/baseswap-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];
+  }
+}

package/src/dex/baseswap-v3/contract-math/TickMath.ts

@@ -0,0 +1,211 @@
+import { gt } from 'lodash';
+import { BI_MAX_UINT256 } from '../../../bigint-constants';
+import { _gt } from './utils';
+import { _require } from '../../../utils';
+
+export class TickMath {
+  static readonly MIN_TICK = -887272n;
+  static readonly MAX_TICK = -TickMath.MIN_TICK;
+  static readonly MIN_SQRT_RATIO = 4295128739n;
+  static readonly MAX_SQRT_RATIO =
+    1461446703485210103287273052203988822378723970342n;
+
+  static getSqrtRatioAtTick(tick: bigint): bigint {
+    const absTick =
+      tick < 0n
+        ? BigInt.asUintN(256, -BigInt.asIntN(256, tick))
+        : BigInt.asUintN(256, BigInt.asIntN(256, tick));
+    _require(
+      absTick <= BigInt.asUintN(256, TickMath.MAX_TICK),
+      'T',
+      { absTick },
+      'absTick <= BigInt.asUintN(256, TickMath.MAX_TICK)',
+    );
+
+    let ratio =
+      (absTick & 0x1n) !== 0n
+        ? 0xfffcb933bd6fad37aa2d162d1a594001n
+        : 0x100000000000000000000000000000000n;
+    if ((absTick & 0x2n) !== 0n)
+      ratio = (ratio * 0xfff97272373d413259a46990580e213an) >> 128n;
+    if ((absTick & 0x4n) !== 0n)
+      ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdccn) >> 128n;
+    if ((absTick & 0x8n) !== 0n)
+      ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0n) >> 128n;
+    if ((absTick & 0x10n) !== 0n)
+      ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644n) >> 128n;
+    if ((absTick & 0x20n) !== 0n)
+      ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0n) >> 128n;
+    if ((absTick & 0x40n) !== 0n)
+      ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861n) >> 128n;
+    if ((absTick & 0x80n) !== 0n)
+      ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053n) >> 128n;
+    if ((absTick & 0x100n) !== 0n)
+      ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4n) >> 128n;
+    if ((absTick & 0x200n) !== 0n)
+      ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54n) >> 128n;
+    if ((absTick & 0x400n) !== 0n)
+      ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3n) >> 128n;
+    if ((absTick & 0x800n) !== 0n)
+      ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9n) >> 128n;
+    if ((absTick & 0x1000n) !== 0n)
+      ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825n) >> 128n;
+    if ((absTick & 0x2000n) !== 0n)
+      ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5n) >> 128n;
+    if ((absTick & 0x4000n) !== 0n)
+      ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7n) >> 128n;
+    if ((absTick & 0x8000n) !== 0n)
+      ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6n) >> 128n;
+    if ((absTick & 0x10000n) !== 0n)
+      ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9n) >> 128n;
+    if ((absTick & 0x20000n) !== 0n)
+      ratio = (ratio * 0x5d6af8dedb81196699c329225ee604n) >> 128n;
+    if ((absTick & 0x40000n) !== 0n)
+      ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98n) >> 128n;
+    if ((absTick & 0x80000n) !== 0n)
+      ratio = (ratio * 0x48a170391f7dc42444e8fa2n) >> 128n;
+
+    if (tick > 0) ratio = BI_MAX_UINT256 / ratio;
+    return BigInt.asUintN(
+      160,
+      (ratio >> 32n) + (ratio % (1n << 32n) == 0n ? 0n : 1n),
+    );
+  }
+
+  static getTickAtSqrtRatio(sqrtPriceX96: bigint): bigint {
+    _require(
+      sqrtPriceX96 >= TickMath.MIN_SQRT_RATIO &&
+        sqrtPriceX96 < TickMath.MAX_SQRT_RATIO,
+      'R',
+      { sqrtPriceX96 },
+      'sqrtPriceX96 >= TickMath.MIN_SQRT_RATIO && sqrtPriceX96 < TickMath.MAX_SQRT_RATIO',
+    );
+
+    let ratio = BigInt.asUintN(256, sqrtPriceX96) << 32n;
+
+    let r = ratio;
+    let msb = 0n;
+
+    let f = _gt(r, 0xffffffffffffffffffffffffffffffffn) << 7n;
+    msb = msb | f;
+    r = r >> f;
+
+    f = _gt(r, 0xffffffffffffffffn) << 6n;
+    msb = msb | f;
+    r = r >> f;
+
+    f = _gt(r, 0xffffffffn) << 5n;
+    msb = msb | f;
+    r = r >> f;
+
+    f = _gt(r, 0xffffn) << 4n;
+    msb = msb | f;
+    r = r >> f;
+
+    f = _gt(r, 0xffn) << 3n;
+    msb = msb | f;
+    r = r >> f;
+
+    f = _gt(r, 0xfn) << 2n;
+    msb = msb | f;
+    r = r >> f;
+
+    f = _gt(r, 0x3n) << 1n;
+    msb = msb | f;
+    r = r >> f;
+
+    f = _gt(r, 0x1n);
+    msb = msb | f;
+
+    if (msb >= 128n) r = ratio >> (msb - 127n);
+    else r = ratio << (127n - msb);
+
+    let log_2 = (BigInt.asIntN(256, msb) - 128n) << 64n;
+
+    r = (r * r) >> 127n;
+    f = r >> 128n;
+    log_2 = log_2 | (f << 63n);
+    r = r >> f;
+
+    r = (r * r) >> 127n;
+    f = r >> 128n;
+    log_2 = log_2 | (f << 62n);
+    r = r >> f;
+
+    r = (r * r) >> 127n;
+    f = r >> 128n;
+    log_2 = log_2 | (f << 61n);
+    r = r >> f;
+
+    r = (r * r) >> 127n;
+    f = r >> 128n;
+    log_2 = log_2 | (f << 60n);
+    r = r >> f;
+
+    r = (r * r) >> 127n;
+    f = r >> 128n;
+    log_2 = log_2 | (f << 59n);
+    r = r >> f;
+
+    r = (r * r) >> 127n;
+    f = r >> 128n;
+    log_2 = log_2 | (f << 58n);
+    r = r >> f;
+
+    r = (r * r) >> 127n;
+    f = r >> 128n;
+    log_2 = log_2 | (f << 57n);
+    r = r >> f;
+
+    r = (r * r) >> 127n;
+    f = r >> 128n;
+    log_2 = log_2 | (f << 56n);
+    r = r >> f;
+
+    r = (r * r) >> 127n;
+    f = r >> 128n;
+    log_2 = log_2 | (f << 55n);
+    r = r >> f;
+
+    r = (r * r) >> 127n;
+    f = r >> 128n;
+    log_2 = log_2 | (f << 54n);
+    r = r >> f;
+
+    r = (r * r) >> 127n;
+    f = r >> 128n;
+    log_2 = log_2 | (f << 53n);
+    r = r >> f;
+
+    r = (r * r) >> 127n;
+    f = r >> 128n;
+    log_2 = log_2 | (f << 52n);
+    r = r >> f;
+
+    r = (r * r) >> 127n;
+    f = r >> 128n;
+    log_2 = log_2 | (f << 51n);
+    r = r >> f;
+
+    r = (r * r) >> 127n;
+    f = r >> 128n;
+    log_2 = log_2 | (f << 50n);
+
+    const log_sqrt10001 = log_2 * 255738958999603826347141n; // 128.128 number
+
+    const tickLow = BigInt.asIntN(
+      24,
+      (log_sqrt10001 - 3402992956809132418596140100660247210n) >> 128n,
+    );
+    const tickHi = BigInt.asIntN(
+      24,
+      (log_sqrt10001 + 291339464771989622907027621153398088495n) >> 128n,
+    );
+
+    return tickLow === tickHi
+      ? tickLow
+      : TickMath.getSqrtRatioAtTick(tickHi) <= sqrtPriceX96
+      ? tickHi
+      : tickLow;
+  }
+}

package/src/dex/baseswap-v3/contract-math/UnsafeMath.ts

@@ -0,0 +1,5 @@
+export class UnsafeMath {
+  static divRoundingUp(x: bigint, y: bigint) {
+    return (x + y - 1n) / y;
+  }
+}