@paraswap/dex-lib 4.1.20 → 4.1.21

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

@@ -1,226 +0,0 @@
-import {
-  OracleObservation,
-  OracleObservationCandidates,
-  PoolState,
-} from '../types';
-import { _require } from '../../../utils';
-import { DeepReadonly } from 'ts-essentials';
-import { ZERO_ORACLE_OBSERVATION } from '../constants';
-
-function replaceUndefinedObservationWithZero(state: PoolState, index: number) {
-  if (state.observations[index] === undefined) {
-    state.observations[index] = { ...ZERO_ORACLE_OBSERVATION };
-  }
-}
-
-export class Oracle {
-  static transform(
-    state: DeepReadonly<PoolState>,
-    last: OracleObservation,
-    blockTimestamp: bigint,
-    tick: bigint,
-    liquidity: bigint,
-  ): OracleObservation {
-    const delta = blockTimestamp - last.blockTimestamp;
-    return {
-      blockTimestamp: state.blockTimestamp,
-      tickCumulative: last.tickCumulative + BigInt.asIntN(56, tick) * delta,
-      secondsPerLiquidityCumulativeX128:
-        last.secondsPerLiquidityCumulativeX128 +
-        (BigInt.asUintN(160, delta) << 128n) /
-          (liquidity > 0n ? liquidity : 1n),
-      initialized: true,
-    };
-  }
-
-  static write(
-    state: PoolState,
-    index: number,
-    blockTimestamp: bigint,
-    tick: bigint,
-    liquidity: bigint,
-    cardinality: number,
-    cardinalityNext: number,
-  ): [number, number] {
-    const last = state.observations[index];
-
-    if (last.blockTimestamp == state.blockTimestamp)
-      return [index, cardinality];
-
-    let indexUpdated = 0;
-    let cardinalityUpdated = 0;
-
-    if (cardinalityNext > cardinality && index == cardinality - 1) {
-      cardinalityUpdated = cardinalityNext;
-    } else {
-      cardinalityUpdated = cardinality;
-    }
-
-    indexUpdated = (index + 1) % cardinalityUpdated;
-
-    state.observations[indexUpdated] = Oracle.transform(
-      state,
-      last,
-      blockTimestamp,
-      tick,
-      liquidity,
-    );
-    if (indexUpdated !== index) {
-      delete state.observations[index];
-    }
-    return [indexUpdated, cardinalityUpdated];
-  }
-
-  static lte(time: bigint, a: bigint, b: bigint): boolean {
-    if (a <= time && b <= time) return a <= b;
-
-    const aAdjusted = a > time ? a : a + 2n ** 32n;
-    const bAdjusted = b > time ? b : b + 2n ** 32n;
-    return aAdjusted <= bAdjusted;
-  }
-
-  static binarySearch(
-    state: DeepReadonly<PoolState>,
-    time: bigint,
-    target: bigint,
-    index: number,
-    cardinality: number,
-  ): OracleObservationCandidates {
-    let l = (index + 1) % cardinality;
-    let r = l + cardinality - 1;
-    let i;
-
-    let beforeOrAt;
-    let atOrAfter;
-    while (true) {
-      i = (l + r) / 2;
-
-      beforeOrAt = state.observations[i % cardinality];
-
-      // we've landed on an uninitialized tick, keep searching higher (more recently)
-      if (!beforeOrAt.initialized) {
-        l = i + 1;
-        continue;
-      }
-
-      atOrAfter = state.observations[(i + 1) % cardinality];
-
-      const targetAtOrAfter = Oracle.lte(
-        time,
-        beforeOrAt.blockTimestamp,
-        target,
-      );
-
-      // check if we've found the answer!
-      if (targetAtOrAfter && Oracle.lte(time, target, atOrAfter.blockTimestamp))
-        break;
-
-      if (!targetAtOrAfter) r = i - 1;
-      else l = i + 1;
-    }
-    return { beforeOrAt, atOrAfter };
-  }
-
-  static getSurroundingObservations(
-    state: DeepReadonly<PoolState>,
-    time: bigint,
-    target: bigint,
-    tick: bigint,
-    index: number,
-    liquidity: bigint,
-    cardinality: number,
-  ): OracleObservationCandidates {
-    let beforeOrAt = state.observations[index];
-
-    if (Oracle.lte(time, beforeOrAt.blockTimestamp, target)) {
-      if (beforeOrAt.blockTimestamp === target) {
-        return { beforeOrAt, atOrAfter: beforeOrAt };
-      } else {
-        return {
-          beforeOrAt,
-          atOrAfter: Oracle.transform(
-            state,
-            beforeOrAt,
-            target,
-            tick,
-            liquidity,
-          ),
-        };
-      }
-    }
-
-    beforeOrAt = state.observations[(index + 1) % cardinality];
-    if (!beforeOrAt.initialized) beforeOrAt = state.observations[0];
-
-    _require(
-      Oracle.lte(time, beforeOrAt.blockTimestamp, target),
-      'OLD',
-      { time, beforeOrAtBlockTimestamp: beforeOrAt.blockTimestamp, target },
-      'Oracle.lte(time, beforeOrAt.blockTimestamp, target)',
-    );
-
-    return Oracle.binarySearch(state, time, target, index, cardinality);
-  }
-
-  static observeSingle(
-    state: DeepReadonly<PoolState>,
-    time: bigint,
-    secondsAgo: bigint,
-    tick: bigint,
-    index: number,
-    liquidity: bigint,
-    cardinality: number,
-  ): [bigint, bigint] {
-    if (secondsAgo == 0n) {
-      let last = state.observations[index];
-      if (last.blockTimestamp != time)
-        last = Oracle.transform(state, last, time, tick, liquidity);
-      return [last.tickCumulative, last.secondsPerLiquidityCumulativeX128];
-    }
-
-    const target = time - secondsAgo;
-
-    const { beforeOrAt, atOrAfter } = Oracle.getSurroundingObservations(
-      state,
-      time,
-      target,
-      tick,
-      index,
-      liquidity,
-      cardinality,
-    );
-
-    if (target === beforeOrAt.blockTimestamp) {
-      return [
-        beforeOrAt.tickCumulative,
-        beforeOrAt.secondsPerLiquidityCumulativeX128,
-      ];
-    } else if (target === atOrAfter.blockTimestamp) {
-      return [
-        atOrAfter.tickCumulative,
-        atOrAfter.secondsPerLiquidityCumulativeX128,
-      ];
-    } else {
-      const observationTimeDelta =
-        atOrAfter.blockTimestamp - beforeOrAt.blockTimestamp;
-      const targetDelta = target - beforeOrAt.blockTimestamp;
-      return [
-        beforeOrAt.tickCumulative +
-          ((atOrAfter.tickCumulative - beforeOrAt.tickCumulative) /
-            observationTimeDelta) *
-            targetDelta,
-        beforeOrAt.secondsPerLiquidityCumulativeX128 +
-          BigInt.asUintN(
-            160,
-            (BigInt.asUintN(
-              256,
-              atOrAfter.secondsPerLiquidityCumulativeX128 -
-                beforeOrAt.secondsPerLiquidityCumulativeX128,
-            ) *
-              targetDelta) /
-              observationTimeDelta,
-          ),
-      ];
-    }
-  }
-}

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

@@ -1,226 +0,0 @@
-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/uniswap-v3/contract-math/SwapMath.ts

@@ -1,139 +0,0 @@
-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/uniswap-v3/contract-math/Tick.ts

@@ -1,82 +0,0 @@
-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;
-  }
-}