@paraswap/dex-lib 2.42.4-baseswap → 2.42.4

package/src/dex/baseswap-v3/config.ts

@@ -1,53 +0,0 @@
-import { DexParams } from './types';
-import { DexConfigMap, AdapterMappings } from '../../types';
-import { Network, SwapSide } from '../../constants';
-import { Address } from '../../types';
-// import RamsesV2StateMulticallABI from '../../abi/RamsesV2StateMulticall.abi.json';
-// import { AbiItem } from 'web3-utils';
-// import { decodeStateMultiCallResultWithRelativeBitmaps } from './forks/ramses-v2/utils';
-// import { RamsesV2EventPool } from './forks/ramses-v2/ramses-v2-pool';
-
-const SUPPORTED_FEES = [10000n, 2500n, 450n, 80n];
-
-// Pools that will be initialized on app startup
-// They are added for testing
-export const PoolsToPreload: DexConfigMap<
-  { token0: Address; token1: Address }[]
-> = {
-  BaseswapV3: {
-    [Network.BASE]: [
-      {
-        token0: '0x4200000000000000000000000000000000000006'.toLowerCase(),
-        token1: '0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA'.toLowerCase(), // USDbC
-      },
-      {
-        token0: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'.toLowerCase(), // USDC
-        token1: '0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA'.toLowerCase(), // USDbC
-      },
-    ],
-  },
-};
-
-export const BaseswapV3Config: DexConfigMap<DexParams> = {
-  BaseswapV3: {
-    [Network.BASE]: {
-      factory: '0x38015D05f4fEC8AFe15D7cc0386a126574e8077B',
-      quoter: '0x4fDBD73aD4B1DDde594BF05497C15f76308eFfb9',
-      router: '0x1B8eea9315bE495187D873DA7773a874545D9D48',
-      supportedFees: SUPPORTED_FEES,
-      stateMulticall: '0x7160f736c52e1e78e92FD4eE4D73e21A7Cf4F950',
-      uniswapMulticall: '0x091e99cb1C49331a94dD62755D168E941AbD0693',
-      chunksCount: 10,
-      initRetryFrequency: 10,
-      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
-      subgraphURL: 'https://api.thegraph.com/subgraphs/name/baseswapfi/v3-base',
-    },
-  },
-};
-
-export const Adapters: Record<number, AdapterMappings> = {
-  [Network.BASE]: {
-    [SwapSide.SELL]: [{ name: 'BaseAdapter01', index: 1 }],
-    [SwapSide.BUY]: [{ name: 'BaseBuyAdapter', index: 1 }],
-  },
-};

package/src/dex/baseswap-v3/constants.ts

@@ -1,41 +0,0 @@
-export const UNISWAPV3_TICK_GAS_COST = 24_000; // Ceiled
-export const UNISWAPV3_TICK_BASE_OVERHEAD = 75_000;
-export const UNISWAPV3_POOL_SEARCH_OVERHEAD = 10_000;
-
-// This is used for price calculation. If out of scope, return 0n
-export const TICK_BITMAP_TO_USE = 4n;
-
-// This is used to check if the state is still valid.
-export const TICK_BITMAP_BUFFER = 8n;
-
-export const MAX_PRICING_COMPUTATION_STEPS_ALLOWED = 128;
-
-export const UNISWAPV3_SUBGRAPH_URL =
-  'https://api.thegraph.com/subgraphs/name/baseswapfi/v3-base';
-
-export const UNISWAPV3_EFFICIENCY_FACTOR = 3;
-
-export const ZERO_TICK_INFO = {
-  liquidityGross: 0n,
-  liquidityNet: 0n,
-  tickCumulativeOutside: 0n,
-  secondsPerLiquidityOutsideX128: 0n,
-  secondsOutside: 0n,
-  initialized: false,
-};
-
-export const ZERO_ORACLE_OBSERVATION = {
-  blockTimestamp: 0n,
-  tickCumulative: 0n,
-  secondsPerLiquidityCumulativeX128: 0n,
-  initialized: false,
-};
-
-export const OUT_OF_RANGE_ERROR_POSTFIX = `INVALID_TICK_BIT_MAP_RANGES`;
-
-export const DEFAULT_POOL_INIT_CODE_HASH = `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`;
-
-export enum DirectMethods {
-  directSell = 'directUniV3Swap',
-  directBuy = 'directUniV3Buy',
-}

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

@@ -1,90 +0,0 @@
-import {
-  BI_MAX_UINT128,
-  BI_MAX_UINT16,
-  BI_MAX_UINT32,
-  BI_MAX_UINT64,
-  BI_MAX_UINT8,
-} from '../../../bigint-constants';
-import { _require } from '../../../utils';
-
-export class BitMath {
-  static mostSignificantBit(x: bigint): bigint {
-    _require(x > 0, '', { x }, 'x > 0');
-    let r = 0n;
-
-    if (x >= 0x100000000000000000000000000000000n) {
-      x >>= 128n;
-      r += 128n;
-    }
-    if (x >= 0x10000000000000000n) {
-      x >>= 64n;
-      r += 64n;
-    }
-    if (x >= 0x100000000n) {
-      x >>= 32n;
-      r += 32n;
-    }
-    if (x >= 0x10000n) {
-      x >>= 16n;
-      r += 16n;
-    }
-    if (x >= 0x100n) {
-      x >>= 8n;
-      r += 8n;
-    }
-    if (x >= 0x10n) {
-      x >>= 4n;
-      r += 4n;
-    }
-    if (x >= 0x4n) {
-      x >>= 2n;
-      r += 2n;
-    }
-    if (x >= 0x2n) r += 1n;
-
-    return r;
-  }
-
-  static leastSignificantBit(x: bigint): bigint {
-    _require(x > 0, '', { x }, 'x > 0');
-
-    let r = 255n;
-    if ((x & BI_MAX_UINT128) > 0n) {
-      r -= 128n;
-    } else {
-      x >>= 128n;
-    }
-    if ((x & BI_MAX_UINT64) > 0n) {
-      r -= 64n;
-    } else {
-      x >>= 64n;
-    }
-    if ((x & BI_MAX_UINT32) > 0n) {
-      r -= 32n;
-    } else {
-      x >>= 32n;
-    }
-    if ((x & BI_MAX_UINT16) > 0n) {
-      r -= 16n;
-    } else {
-      x >>= 16n;
-    }
-    if ((x & BI_MAX_UINT8) > 0n) {
-      r -= 8n;
-    } else {
-      x >>= 8n;
-    }
-    if ((x & 0xfn) > 0n) {
-      r -= 4n;
-    } else {
-      x >>= 4n;
-    }
-    if ((x & 0x3n) > 0n) {
-      r -= 2n;
-    } else {
-      x >>= 2n;
-    }
-    if ((x & 0x1n) > 0n) r -= 1n;
-    return r;
-  }
-}

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

@@ -1,3 +0,0 @@
-export class FixedPoint128 {
-  static readonly Q128 = 0x100000000000000000000000000000000n;
-}

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

@@ -1,4 +0,0 @@
-export class FixedPoint96 {
-  static readonly RESOLUTION = 96n;
-  static readonly Q96 = 0x1000000000000000000000000n;
-}

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

@@ -1,30 +0,0 @@
-import { BI_MAX_UINT256 } from '../../../bigint-constants';
-import { _require } from '../../../utils';
-
-export class FullMath {
-  static mulDiv(a: bigint, b: bigint, denominator: bigint) {
-    const result = (a * b) / denominator;
-
-    _require(
-      result <= BI_MAX_UINT256,
-      '',
-      { result, BI_MAX_UINT: BI_MAX_UINT256 },
-      'result <= BI_MAX_UINT',
-    );
-
-    return result;
-  }
-
-  static mulDivRoundingUp(a: bigint, b: bigint, denominator: bigint) {
-    const result = (a * b + denominator - 1n) / denominator;
-
-    _require(
-      result <= BI_MAX_UINT256,
-      '',
-      { result, BI_MAX_UINT: BI_MAX_UINT256 },
-      'result <= BI_MAX_UINT',
-    );
-
-    return result;
-  }
-}

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

@@ -1,17 +0,0 @@
-import { _require } from '../../../utils';
-
-export class LiquidityMath {
-  static addDelta(x: bigint, y: bigint): bigint {
-    let z;
-    if (y < 0) {
-      const _y = BigInt.asUintN(128, -y);
-      z = x - _y;
-      _require(z < x, 'LS', { z, x, y, _y }, 'z < x');
-    } else {
-      const _y = BigInt.asUintN(128, y);
-      z = x + _y;
-      _require(z >= x, 'LA', { z, x, y, _y }, 'z >= x');
-    }
-    return z;
-  }
-}

package/src/dex/baseswap-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/baseswap-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,
-          ),
-        );
-  }
-}