@paraswap/dex-lib 2.16.7 → 2.16.8-pancakeswapv3.0

package/src/dex/index.ts

@@ -64,8 +64,8 @@ import { QuickSwapV3 } from './quickswap/quickswap-v3';
 import { ZyberSwapV3 } from './quickswap/zyberswap-v3';
 import { TraderJoeV2 } from './trader-joe-v2';
 import { SpiritSwapV3 } from './quickswap/spiritswap-v3';
-import { PancakeswapV3 } from './uniswap-v3/forks/pancakeswap-v3/pancakeswap-v3';
 import { TraderJoeV21 } from './trader-joe-v2.1';
+import { PancakeswapV3 } from './pancakeswap-v3/pancakeswap-v3';
 
 const LegacyDexes = [
   CurveV2,

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

@@ -0,0 +1,68 @@
+import { DexParams } from '../uniswap-v3/types';
+import { DexConfigMap, AdapterMappings } from '../../types';
+import { Network, SwapSide } from '../../constants';
+import { Address } from '../../types';
+
+const PANCAKE_SUPPORTED_FEES = [10000n, 2500n, 500n, 100n];
+
+// Pools that will be initialized on app startup
+// They are added for testing
+export const PancakeswapV3Config: DexConfigMap<DexParams> = {
+  PancakeswapV3: {
+    [Network.MAINNET]: {
+      factory: '0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865',
+      deployer: '0x41ff9AA7e16B8B1a8a8dc4f0eFacd93D02d071c9',
+      quoter: '0xB048Bbc1Ee6b733FFfCFb9e9CeF7375518e25997',
+      router: '0x1b81D678ffb9C0263b24A97847620C99d213eB14',
+      supportedFees: PANCAKE_SUPPORTED_FEES,
+      stateMulticall: '0x80898f80cFA3Fa3AbF410d90e69aDc432AE5D4c2',
+      uniswapMulticall: '0xac1cE734566f390A94b00eb9bf561c2625BF44ea',
+      chunksCount: 10,
+      initHash:
+        '0x6ce8eb472fa82df5469c6ab6d485f17c3ad13c8cd7af59b3d4a8026c5ce0f7e2',
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/pancakeswap/exchange-v3-eth',
+    },
+    [Network.BSC]: {
+      factory: '0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865',
+      deployer: '0x41ff9AA7e16B8B1a8a8dc4f0eFacd93D02d071c9',
+      quoter: '0xB048Bbc1Ee6b733FFfCFb9e9CeF7375518e25997',
+      router: '0x1b81D678ffb9C0263b24A97847620C99d213eB14',
+      supportedFees: PANCAKE_SUPPORTED_FEES,
+      stateMulticall: '0x9DAd2ED7ADc6eaacf81589Cd043579c9684E5C81',
+      uniswapMulticall: '0xac1cE734566f390A94b00eb9bf561c2625BF44ea',
+      chunksCount: 10,
+      initHash:
+        '0x6ce8eb472fa82df5469c6ab6d485f17c3ad13c8cd7af59b3d4a8026c5ce0f7e2',
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/pancakeswap/exchange-v3-bsc',
+    },
+  },
+};
+
+export const Adapters: Record<number, AdapterMappings> = {
+  [Network.MAINNET]: {
+    [SwapSide.SELL]: [{ name: 'Adapter01', index: 6 }],
+    [SwapSide.BUY]: [{ name: 'BuyAdapter', index: 2 }],
+  },
+  [Network.BSC]: {
+    [SwapSide.SELL]: [{ name: 'BscAdapter02', index: 4 }],
+    [SwapSide.BUY]: [{ name: 'BscBuyAdapter', index: 5 }],
+  },
+  [Network.POLYGON]: {
+    [SwapSide.SELL]: [{ name: 'PolygonAdapter01', index: 13 }],
+    [SwapSide.BUY]: [{ name: 'PolygonBuyAdapter', index: 2 }],
+  },
+  [Network.ARBITRUM]: {
+    [SwapSide.SELL]: [{ name: 'ArbitrumAdapter01', index: 3 }],
+    [SwapSide.BUY]: [{ name: 'ArbitrumBuyAdapter', index: 2 }],
+  },
+  [Network.OPTIMISM]: {
+    [SwapSide.SELL]: [{ name: 'OptimismAdapter01', index: 3 }],
+    [SwapSide.BUY]: [{ name: 'OptimismBuyAdapter', index: 2 }],
+  },
+  [Network.FANTOM]: {
+    [SwapSide.SELL]: [{ name: 'FantomAdapter01', index: 11 }],
+    [SwapSide.BUY]: [{ name: 'FantomBuyAdapter', index: 3 }],
+  },
+};

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

@@ -0,0 +1,35 @@
+export const PANCAKESWAP3_FUNCTION_CALL_GAS_COST = 21_000; // Ceiled
+export const PANCAKESWAPV3_TICK_GAS_COST = 24_000; // Ceiled
+
+// 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 PANCAKESWAPV3_SUBGRAPH_URL =
+  'https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v3';
+
+export const PANCAKESWAPV3_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`;

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

@@ -0,0 +1,90 @@
+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/pancakeswap-v3/contract-math/FixedPoint128.ts

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

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

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

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

@@ -0,0 +1,30 @@
+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/pancakeswap-v3/contract-math/LiquidityMath.ts

@@ -0,0 +1,17 @@
+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/pancakeswap-v3/contract-math/Oracle.ts

@@ -0,0 +1,226 @@
+import {
+  OracleObservation,
+  OracleObservationCandidates,
+  PoolState,
+} from '../../uniswap-v3/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,
+          ),
+      ];
+    }
+  }
+}