@paraswap/dex-lib 2.42.28 → 2.42.29

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

@@ -0,0 +1,570 @@
+import _ from 'lodash';
+import { OutputResult, PoolState, Slot0, TickInfo } from '../types';
+import { LiquidityMath } from './LiquidityMath';
+import { SqrtPriceMath } from './SqrtPriceMath';
+import { SwapMath } from './SwapMath';
+import { Tick } from './Tick';
+import { TickBitMap } from './TickBitMap';
+import { TickMath } from './TickMath';
+import { _require } from '../../../utils';
+import { DeepReadonly } from 'ts-essentials';
+import { NumberAsString, SwapSide } from '@paraswap/core';
+import { BI_MAX_INT } from '../../../bigint-constants';
+import {
+  MAX_PRICING_COMPUTATION_STEPS_ALLOWED,
+  OUT_OF_RANGE_ERROR_POSTFIX,
+} from '../constants';
+
+type ModifyPositionParams = {
+  tickLower: bigint;
+  tickUpper: bigint;
+  liquidityDelta: bigint;
+};
+
+export type PriceComputationState = {
+  amountSpecifiedRemaining: bigint;
+  amountCalculated: bigint;
+  sqrtPriceX96: bigint;
+  tick: bigint;
+  protocolFee: bigint;
+  liquidity: bigint;
+  isFirstCycleState: boolean;
+};
+
+export type PriceComputationCache = {
+  tickCount: number;
+};
+
+export function _updatePriceComputationObjects<
+  T extends PriceComputationState | PriceComputationCache,
+>(toUpdate: T, updateBy: T) {
+  for (const k of Object.keys(updateBy) as (keyof T)[]) {
+    toUpdate[k] = updateBy[k];
+  }
+}
+
+function _priceComputationCycles(
+  poolState: DeepReadonly<PoolState>,
+  ticksCopy: Record<NumberAsString, TickInfo>,
+  slot0Start: Slot0,
+  state: PriceComputationState,
+  cache: PriceComputationCache,
+  sqrtPriceLimitX96: bigint,
+  zeroForOne: boolean,
+  exactInput: boolean,
+): [
+  // result
+  PriceComputationState,
+  // Latest calculated full cycle state we can use for bigger amounts
+  {
+    latestFullCycleState: PriceComputationState;
+    latestFullCycleCache: PriceComputationCache;
+  },
+] {
+  const latestFullCycleState: PriceComputationState = { ...state };
+
+  if (cache.tickCount == 0) {
+    cache.tickCount = 1;
+  }
+  const latestFullCycleCache: PriceComputationCache = { ...cache };
+
+  // We save tick before any change. Later we use this to restore
+  // state before last step
+  let lastTicksCopy: { index: number; tick: TickInfo } | undefined;
+
+  let i = 0;
+  for (
+    ;
+    state.amountSpecifiedRemaining !== 0n &&
+    state.sqrtPriceX96 !== sqrtPriceLimitX96;
+    ++i
+  ) {
+    if (
+      latestFullCycleCache.tickCount + i >
+      MAX_PRICING_COMPUTATION_STEPS_ALLOWED
+    ) {
+      state.amountSpecifiedRemaining = 0n;
+      state.amountCalculated = 0n;
+      break;
+    }
+
+    const step = {
+      sqrtPriceStartX96: 0n,
+      tickNext: 0n,
+      initialized: false,
+      sqrtPriceNextX96: 0n,
+      amountIn: 0n,
+      amountOut: 0n,
+      feeAmount: 0n,
+    };
+
+    step.sqrtPriceStartX96 = state.sqrtPriceX96;
+
+    try {
+      [step.tickNext, step.initialized] =
+        TickBitMap.nextInitializedTickWithinOneWord(
+          poolState,
+          state.tick,
+          poolState.tickSpacing,
+          zeroForOne,
+          true,
+        );
+    } catch (e) {
+      if (
+        e instanceof Error &&
+        e.message.endsWith(OUT_OF_RANGE_ERROR_POSTFIX)
+      ) {
+        state.amountSpecifiedRemaining = 0n;
+        state.amountCalculated = 0n;
+        break;
+      }
+      throw e;
+    }
+
+    if (step.tickNext < TickMath.MIN_TICK) {
+      step.tickNext = TickMath.MIN_TICK;
+    } else if (step.tickNext > TickMath.MAX_TICK) {
+      step.tickNext = TickMath.MAX_TICK;
+    }
+
+    step.sqrtPriceNextX96 = TickMath.getSqrtRatioAtTick(step.tickNext);
+
+    const swapStepResult = SwapMath.computeSwapStep(
+      state.sqrtPriceX96,
+      (
+        zeroForOne
+          ? step.sqrtPriceNextX96 < sqrtPriceLimitX96
+          : step.sqrtPriceNextX96 > sqrtPriceLimitX96
+      )
+        ? sqrtPriceLimitX96
+        : step.sqrtPriceNextX96,
+      state.liquidity,
+      state.amountSpecifiedRemaining,
+      poolState.slot0.fee,
+    );
+
+    state.sqrtPriceX96 = swapStepResult.sqrtRatioNextX96;
+    step.amountIn = swapStepResult.amountIn;
+    step.amountOut = swapStepResult.amountOut;
+    step.feeAmount = swapStepResult.feeAmount;
+
+    if (exactInput) {
+      state.amountSpecifiedRemaining -= step.amountIn + step.feeAmount;
+      state.amountCalculated = state.amountCalculated - step.amountOut;
+    } else {
+      state.amountSpecifiedRemaining += step.amountOut;
+      state.amountCalculated =
+        state.amountCalculated + step.amountIn + step.feeAmount;
+    }
+
+    if (state.sqrtPriceX96 === step.sqrtPriceNextX96) {
+      if (step.initialized) {
+
+        if (state.amountSpecifiedRemaining === 0n) {
+          const castTickNext = Number(step.tickNext);
+          lastTicksCopy = {
+            index: castTickNext,
+            tick: { ...ticksCopy[castTickNext] },
+          };
+        }
+
+        let liquidityNet = Tick.cross(
+          ticksCopy,
+          step.tickNext,
+        );
+        if (zeroForOne) liquidityNet = -liquidityNet;
+
+        state.liquidity = LiquidityMath.addDelta(state.liquidity, liquidityNet);
+      }
+
+      state.tick = zeroForOne ? step.tickNext - 1n : step.tickNext;
+    } else if (state.sqrtPriceX96 != step.sqrtPriceStartX96) {
+      state.tick = TickMath.getTickAtSqrtRatio(state.sqrtPriceX96);
+    }
+
+    if (state.amountSpecifiedRemaining !== 0n) {
+      _updatePriceComputationObjects(latestFullCycleState, state);
+      _updatePriceComputationObjects(latestFullCycleCache, cache);
+      // If it last cycle, check if ticks were changed and then restore previous state
+      // for next calculations
+    } else if (lastTicksCopy !== undefined) {
+      ticksCopy[lastTicksCopy.index] = lastTicksCopy.tick;
+    }
+  }
+
+  if (i > 1) {
+    latestFullCycleCache.tickCount += i - 1;
+  }
+
+  if (state.amountSpecifiedRemaining !== 0n) {
+    state.amountSpecifiedRemaining = 0n;
+    state.amountCalculated = 0n;
+  }
+
+  return [state, { latestFullCycleState, latestFullCycleCache }];
+}
+
+class UniswapV3Math {
+  queryOutputs(
+    poolState: DeepReadonly<PoolState>,
+    // Amounts must increase
+    amounts: bigint[],
+    zeroForOne: boolean,
+    side: SwapSide,
+  ): OutputResult {
+    const slot0Start = poolState.slot0;
+
+    const isSell = side === SwapSide.SELL;
+
+    // While calculating, ticks are changing, so to not change the actual state,
+    // we use copy
+    const ticksCopy = _.cloneDeep(poolState.ticks);
+
+    const sqrtPriceLimitX96 = zeroForOne
+      ? TickMath.MIN_SQRT_RATIO + 1n
+      : TickMath.MAX_SQRT_RATIO - 1n;
+
+    const cache: PriceComputationCache = {
+      tickCount: 0,
+    };
+
+    const state: PriceComputationState = {
+      // Will be overwritten later
+      amountSpecifiedRemaining: 0n,
+      amountCalculated: 0n,
+      sqrtPriceX96: slot0Start.sqrtPriceX96,
+      tick: slot0Start.tick,
+      protocolFee: 0n,
+      liquidity: poolState.liquidity,
+      isFirstCycleState: true,
+    };
+
+    let isOutOfRange = false;
+    let previousAmount = 0n;
+
+    const outputs = new Array(amounts.length);
+    const tickCounts = new Array(amounts.length);
+    for (const [i, amount] of amounts.entries()) {
+      if (amount === 0n) {
+        outputs[i] = 0n;
+        tickCounts[i] = 0;
+        continue;
+      }
+
+      const amountSpecified = isSell
+        ? BigInt.asIntN(256, amount)
+        : -BigInt.asIntN(256, amount);
+
+      if (state.isFirstCycleState) {
+        // Set first non zero amount
+        state.amountSpecifiedRemaining = amountSpecified;
+        state.isFirstCycleState = false;
+      } else {
+        state.amountSpecifiedRemaining =
+          amountSpecified - (previousAmount - state.amountSpecifiedRemaining);
+      }
+
+      const exactInput = amountSpecified > 0n;
+
+      _require(
+        zeroForOne
+          ? sqrtPriceLimitX96 < slot0Start.sqrtPriceX96 &&
+              sqrtPriceLimitX96 > TickMath.MIN_SQRT_RATIO
+          : sqrtPriceLimitX96 > slot0Start.sqrtPriceX96 &&
+              sqrtPriceLimitX96 < TickMath.MAX_SQRT_RATIO,
+        'SPL',
+        { zeroForOne, sqrtPriceLimitX96, slot0Start },
+        'zeroForOne ? sqrtPriceLimitX96 < slot0Start.sqrtPriceX96 && sqrtPriceLimitX96 > TickMath.MIN_SQRT_RATIO : sqrtPriceLimitX96 > slot0Start.sqrtPriceX96 && sqrtPriceLimitX96 < TickMath.MAX_SQRT_RATIO',
+      );
+
+      if (!isOutOfRange) {
+        const [finalState, { latestFullCycleState, latestFullCycleCache }] =
+          _priceComputationCycles(
+            poolState,
+            ticksCopy,
+            slot0Start,
+            state,
+            cache,
+            sqrtPriceLimitX96,
+            zeroForOne,
+            exactInput,
+          );
+        if (
+          finalState.amountSpecifiedRemaining === 0n &&
+          finalState.amountCalculated === 0n
+        ) {
+          isOutOfRange = true;
+          outputs[i] = 0n;
+          tickCounts[i] = 0;
+          continue;
+        }
+
+        // We use it on next step to correct state.amountSpecifiedRemaining
+        previousAmount = amountSpecified;
+
+        // First extract calculated values
+        const [amount0, amount1] =
+          zeroForOne === exactInput
+            ? [
+                amountSpecified - finalState.amountSpecifiedRemaining,
+                finalState.amountCalculated,
+              ]
+            : [
+                finalState.amountCalculated,
+                amountSpecified - finalState.amountSpecifiedRemaining,
+              ];
+
+        // Update for next amount
+        _updatePriceComputationObjects(state, latestFullCycleState);
+        _updatePriceComputationObjects(cache, latestFullCycleCache);
+
+        if (isSell) {
+          outputs[i] = BigInt.asUintN(256, -(zeroForOne ? amount1 : amount0));
+          tickCounts[i] = latestFullCycleCache.tickCount;
+          continue;
+        } else {
+          outputs[i] = zeroForOne
+            ? BigInt.asUintN(256, amount0)
+            : BigInt.asUintN(256, amount1);
+          tickCounts[i] = latestFullCycleCache.tickCount;
+          continue;
+        }
+      } else {
+        outputs[i] = 0n;
+        tickCounts[i] = 0;
+      }
+    }
+
+    return {
+      outputs,
+      tickCounts,
+    };
+  }
+
+  swapFromEvent(
+    poolState: PoolState,
+    newSqrtPriceX96: bigint,
+    newTick: bigint,
+    newLiquidity: bigint,
+    zeroForOne: boolean,
+  ): void {
+    const slot0Start = poolState.slot0;
+
+    const cache = {
+      liquidityStart: poolState.liquidity,
+      blockTimestamp: this._blockTimestamp(poolState),
+      feeProtocol: 0n,
+      secondsPerLiquidityCumulativeX128: 0n,
+      tickCumulative: 0n,
+      computedLatestObservation: false,
+    };
+
+    const state = {
+      // Because I don't have the exact amount user used, set this number to MAX_NUMBER to proceed
+      // with calculations. I think it is not a problem since in loop I don't rely on this value
+      amountSpecifiedRemaining: BI_MAX_INT,
+      amountCalculated: 0n,
+      sqrtPriceX96: slot0Start.sqrtPriceX96,
+      tick: slot0Start.tick,
+      protocolFee: 0n,
+      liquidity: cache.liquidityStart,
+    };
+
+    // Because I didn't have all variables, adapted loop stop with state.tick !== newTick
+    // condition. This cycle need only to calculate Tick.cross() function values
+    // It means that we are interested in cycling only if state.tick !== newTick
+    // When they become equivalent, we proceed with state updating part as normal
+    // And if assumptions regarding this cycle are correct, we don't need to process
+    // the last cycle when state.tick === newTick
+    while (state.tick !== newTick && state.sqrtPriceX96 !== newSqrtPriceX96) {
+      const step = {
+        sqrtPriceStartX96: 0n,
+        tickNext: 0n,
+        initialized: false,
+        sqrtPriceNextX96: 0n,
+        amountIn: 0n,
+        amountOut: 0n,
+        feeAmount: 0n,
+      };
+
+      step.sqrtPriceStartX96 = state.sqrtPriceX96;
+
+      [step.tickNext, step.initialized] =
+        TickBitMap.nextInitializedTickWithinOneWord(
+          poolState,
+          state.tick,
+          poolState.tickSpacing,
+          zeroForOne,
+          false,
+        );
+
+      if (step.tickNext < TickMath.MIN_TICK) {
+        step.tickNext = TickMath.MIN_TICK;
+      } else if (step.tickNext > TickMath.MAX_TICK) {
+        step.tickNext = TickMath.MAX_TICK;
+      }
+
+      step.sqrtPriceNextX96 = TickMath.getSqrtRatioAtTick(step.tickNext);
+
+      const swapStepResult = SwapMath.computeSwapStep(
+        state.sqrtPriceX96,
+        (
+          zeroForOne
+            ? step.sqrtPriceNextX96 < newSqrtPriceX96
+            : step.sqrtPriceNextX96 > newSqrtPriceX96
+        )
+          ? newSqrtPriceX96
+          : step.sqrtPriceNextX96,
+        state.liquidity,
+        state.amountSpecifiedRemaining,
+        poolState.slot0.fee,
+      );
+
+      state.sqrtPriceX96 = swapStepResult.sqrtRatioNextX96;
+
+      if (state.sqrtPriceX96 == step.sqrtPriceNextX96) {
+        if (step.initialized) {
+
+          let liquidityNet = Tick.cross(
+            poolState.ticks,
+            step.tickNext,
+          );
+
+          if (zeroForOne) liquidityNet = -liquidityNet;
+
+          state.liquidity = LiquidityMath.addDelta(
+            state.liquidity,
+            liquidityNet,
+          );
+        }
+
+        state.tick = zeroForOne ? step.tickNext - 1n : step.tickNext;
+      } else if (state.sqrtPriceX96 != step.sqrtPriceStartX96) {
+        state.tick = TickMath.getTickAtSqrtRatio(state.sqrtPriceX96);
+      }
+    }
+
+    if (slot0Start.tick !== newTick) {
+      [
+        poolState.slot0.sqrtPriceX96,
+        poolState.slot0.tick,
+      ] = [newSqrtPriceX96, newTick];
+    } else {
+      poolState.slot0.sqrtPriceX96 = newSqrtPriceX96;
+    }
+
+    if (poolState.liquidity !== newLiquidity)
+      poolState.liquidity = newLiquidity;
+  }
+
+  _modifyPosition(
+    state: PoolState,
+    params: ModifyPositionParams,
+  ): [bigint, bigint] {
+    const _slot0 = state.slot0;
+
+    this._updatePosition(
+      state,
+      params.tickLower,
+      params.tickUpper,
+      params.liquidityDelta,
+    );
+
+    let amount0 = 0n;
+    let amount1 = 0n;
+    if (params.liquidityDelta !== 0n) {
+      if (_slot0.tick < params.tickLower) {
+        amount0 = SqrtPriceMath._getAmount0DeltaO(
+          TickMath.getSqrtRatioAtTick(params.tickLower),
+          TickMath.getSqrtRatioAtTick(params.tickUpper),
+          params.liquidityDelta,
+        );
+      } else if (_slot0.tick < params.tickUpper) {
+        const liquidityBefore = state.liquidity;
+
+        amount0 = SqrtPriceMath._getAmount0DeltaO(
+          _slot0.sqrtPriceX96,
+          TickMath.getSqrtRatioAtTick(params.tickUpper),
+          params.liquidityDelta,
+        );
+        amount1 = SqrtPriceMath._getAmount1DeltaO(
+          TickMath.getSqrtRatioAtTick(params.tickLower),
+          _slot0.sqrtPriceX96,
+          params.liquidityDelta,
+        );
+
+        state.liquidity = LiquidityMath.addDelta(
+          liquidityBefore,
+          params.liquidityDelta,
+        );
+      } else {
+        amount1 = SqrtPriceMath._getAmount1DeltaO(
+          TickMath.getSqrtRatioAtTick(params.tickLower),
+          TickMath.getSqrtRatioAtTick(params.tickUpper),
+          params.liquidityDelta,
+        );
+      }
+    }
+    return [amount0, amount1];
+  }
+
+  private _isTickToProcess(state: PoolState, tick: bigint): boolean {
+    return tick >= state.lowestKnownTick && tick <= state.highestKnownTick;
+  }
+
+  private _updatePosition(
+    state: PoolState,
+    tickLower: bigint,
+    tickUpper: bigint,
+    liquidityDelta: bigint,
+  ): void {
+    // if we need to update the ticks, do it
+    let flippedLower = false;
+    let flippedUpper = false;
+    if (liquidityDelta !== 0n) {
+      const time = this._blockTimestamp(state);
+
+      if (this._isTickToProcess(state, tickLower)) {
+        flippedLower = Tick.update(
+          state,
+          tickLower,
+          liquidityDelta,
+          false,
+          state.maxLiquidityPerTick,
+        );
+      }
+      if (this._isTickToProcess(state, tickUpper)) {
+        flippedUpper = Tick.update(
+          state,
+          tickUpper,
+          liquidityDelta,
+          true,
+          state.maxLiquidityPerTick,
+        );
+      }
+
+      if (flippedLower) {
+        TickBitMap.flipTick(state, tickLower, state.tickSpacing);
+      }
+      if (flippedUpper) {
+        TickBitMap.flipTick(state, tickUpper, state.tickSpacing);
+      }
+    }
+
+    // clear any tick data that is no longer needed
+    if (liquidityDelta < 0n) {
+      if (flippedLower) {
+        Tick.clear(state, tickLower);
+      }
+      if (flippedUpper) {
+        Tick.clear(state, tickUpper);
+      }
+    }
+  }
+
+  private _blockTimestamp(state: DeepReadonly<PoolState>) {
+    return BigInt.asUintN(32, state.blockTimestamp);
+  }
+}
+
+export const uniswapV3Math = new UniswapV3Math();

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

@@ -0,0 +1,50 @@
+import { NumberAsString } from '@paraswap/core';
+import {
+  TickBitMapMappingsWithBigNumber,
+  TickInfo,
+  TickInfoMappingsWithBigNumber,
+} from '../types';
+import { bigIntify } from '../../../utils';
+
+export function _mulmod(x: bigint, y: bigint, m: bigint): bigint {
+  return m === 0n ? 0n : (x * y) % m;
+}
+
+export function _lt(x: bigint, y: bigint) {
+  return x < y ? 1n : 0n;
+}
+
+export function _gt(x: bigint, y: bigint) {
+  return x > y ? 1n : 0n;
+}
+
+export function _reduceTickBitmap(
+  tickBitmap: Record<NumberAsString, bigint>,
+  tickBitmapToReduce: TickBitMapMappingsWithBigNumber[],
+) {
+  return tickBitmapToReduce.reduce<Record<NumberAsString, bigint>>(
+    (acc, curr) => {
+      const { index, value } = curr;
+      acc[index] = bigIntify(value);
+      return acc;
+    },
+    tickBitmap,
+  );
+}
+
+export function _reduceTicks(
+  ticks: Record<NumberAsString, TickInfo>,
+  ticksToReduce: TickInfoMappingsWithBigNumber[],
+) {
+  return ticksToReduce.reduce<Record<string, TickInfo>>((acc, curr) => {
+    const { index, value } = curr;
+    if (value.initialized) {
+      acc[index] = {
+        liquidityGross: bigIntify(value.liquidityGross),
+        liquidityNet: bigIntify(value.liquidityNet),
+        initialized: value.initialized,
+      };
+    }
+    return acc;
+  }, ticks);
+}