@paraswap/dex-lib 2.28.5 → 2.28.7-balancer-v2-multihop.0

package/src/dex/algebra/lib/AlgebraMath.ts

@@ -3,7 +3,6 @@ import { PoolStateV1_1, PoolState_v1_9 } from '../types';
 import { NumberAsString, SwapSide } from '@paraswap/core';
 import { OutputResult, TickInfo } from '../../uniswap-v3/types';
 import { Tick } from '../../uniswap-v3/contract-math/Tick';
-import { TickBitMap } from '../../uniswap-v3/contract-math/TickBitMap';
 import { SqrtPriceMath } from '../../uniswap-v3/contract-math/SqrtPriceMath';
 import { TickMath } from '../../uniswap-v3/contract-math/TickMath';
 import { LiquidityMath } from '../../uniswap-v3/contract-math/LiquidityMath';
@@ -21,6 +20,8 @@ import {
   MAX_PRICING_COMPUTATION_STEPS_ALLOWED,
   OUT_OF_RANGE_ERROR_POSTFIX,
 } from '../../uniswap-v3/constants';
+import { TickManager } from './TickManager';
+import { TickTable } from './TickTable';
 
 type UpdatePositionCache = {
   price: bigint;
@@ -112,12 +113,12 @@ function _priceComputationCycles(
 
     try {
       [step.tickNext, step.initialized] =
-        TickBitMap.nextInitializedTickWithinOneWord(
+        TickTable.nextInitializedTickWithinOneWord(
           poolState,
           state.tick,
-          poolState.tickSpacing,
           zeroForOne,
           true,
+          poolState.areTicksCompressed ? poolState.tickSpacing : undefined,
         );
     } catch (e) {
       if (
@@ -378,9 +379,9 @@ class AlgebraMathClass {
     currentTick: bigint,
     currentPrice: bigint,
   ) {
-    let amount0;
-    let amount1;
-    let globalLiquidityDelta;
+    let amount0 = 0n;
+    let amount1 = 0n;
+    let globalLiquidityDelta = 0n;
     // If current tick is less than the provided bottom one then only the token0 has to be provided
     if (currentTick < bottomTick) {
       amount0 = SqrtPriceMath._getAmount0DeltaO(
@@ -434,7 +435,7 @@ class AlgebraMathClass {
       const time = this._blockTimestamp(state);
 
       if (
-        Tick.update(
+        TickManager.update(
           state,
           bottomTick,
           cache.tick,
@@ -447,10 +448,14 @@ class AlgebraMathClass {
         )
       ) {
         toggledBottom = true;
-        TickBitMap.flipTick(state, bottomTick, state.tickSpacing);
+        TickTable.toggleTick(
+          state,
+          bottomTick,
+          state.areTicksCompressed ? state.tickSpacing : undefined,
+        );
       }
       if (
-        Tick.update(
+        TickManager.update(
           state,
           topTick,
           cache.tick,
@@ -463,13 +468,17 @@ class AlgebraMathClass {
         )
       ) {
         toggledTop = true;
-        TickBitMap.flipTick(state, topTick, state.tickSpacing);
+        TickTable.toggleTick(
+          state,
+          topTick,
+          state.areTicksCompressed ? state.tickSpacing : undefined,
+        );
       }
     }
 
     // skip fee && position related stuffs
 
-    // same as UniwapV3Pool.sol line 327 ->   if (params.liquidityDelta != 0) {
+    // same as UniswapV3Pool.sol line 327 ->   if (params.liquidityDelta != 0) {
     if (liquidityDelta !== 0n) {
       // if liquidityDelta is negative and the tick was toggled, it means that it should not be initialized anymore, so we delete it
       if (liquidityDelta < 0) {
@@ -510,7 +519,7 @@ class AlgebraMathClass {
 
     let cache: SwapCalculationCache = {
       amountCalculated: 0n,
-      amountRequiredInitial: BI_MAX_INT, // similarly to waht we did for uniswap
+      amountRequiredInitial: BI_MAX_INT, // similarly to what we did for uniswap
       communityFee: 0n,
       exactInput: false,
       fee: 0n,
@@ -563,19 +572,18 @@ class AlgebraMathClass {
       stepSqrtPrice: 0n,
       tickCount: 0,
     };
-    let i = 0;
     // swap until there is remaining input or output tokens or we reach the price limit
     while (true) {
       step.stepSqrtPrice = currentPrice;
 
       //equivalent of tickTable.nextTickInTheSameRow(currentTick, zeroToOne);
       [step.nextTick, step.initialized] =
-        TickBitMap.nextInitializedTickWithinOneWord(
+        TickTable.nextInitializedTickWithinOneWord(
           poolState,
           currentTick,
-          poolState.tickSpacing,
           zeroToOne,
           false,
+          poolState.areTicksCompressed ? poolState.tickSpacing : undefined,
         );
 
       step.nextTickPrice = TickMath.getSqrtRatioAtTick(step.nextTick);

package/src/dex/algebra/lib/TickManager.ts

@@ -0,0 +1,91 @@
+import { IAlgebraPoolState } from '../types';
+import { LiquidityMath } from '../../uniswap-v3/contract-math/LiquidityMath';
+import { _require } from '../../../utils';
+import { NumberAsString } from '@paraswap/core';
+import { ZERO_TICK_INFO } from '../../uniswap-v3/constants';
+import { TickInfo } from '../../uniswap-v3/types';
+
+export class TickManager {
+  static update(
+    state: Pick<IAlgebraPoolState, '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;
+    }
+
+    // uint128 liquidityTotalBefore = data.liquidityTotal;
+    // uint128 liquidityTotalAfter = LiquidityMath.addDelta(liquidityTotalBefore, liquidityDelta);
+    // require(liquidityTotalAfter < Constants.MAX_LIQUIDITY_PER_TICK + 1, 'LO');
+    const liquidityGrossBefore = info.liquidityGross;
+    const liquidityGrossAfter = LiquidityMath.addDelta(
+      liquidityGrossBefore,
+      liquidityDelta,
+    );
+    _require(
+      liquidityGrossAfter <= maxLiquidity,
+      'LO',
+      { liquidityGrossAfter, maxLiquidity },
+      'liquidityGrossAfter <= maxLiquidity',
+    );
+
+    // int128 liquidityDeltaBefore = data.liquidityDelta;
+    const liquidityNetBefore = info.liquidityNet;
+
+    // // when the lower (upper) tick is crossed left to right (right to left), liquidity must be added (removed)
+    // data.liquidityDelta = upper
+    //   ? int256(liquidityDeltaBefore).sub(liquidityDelta).toInt128()
+    //   : int256(liquidityDeltaBefore).add(liquidityDelta).toInt128();
+    //
+    // data.liquidityTotal = liquidityTotalAfter;
+    info.liquidityNet = upper
+      ? BigInt.asIntN(
+          128,
+          BigInt.asIntN(256, liquidityNetBefore) - liquidityDelta,
+        )
+      : BigInt.asIntN(
+          128,
+          BigInt.asIntN(256, liquidityNetBefore) + liquidityDelta,
+        );
+
+    // flipped = (liquidityTotalAfter == 0);
+    // if (liquidityTotalBefore == 0) {
+    //   flipped = !flipped;
+    //   // by convention, we assume that all growth before a tick was initialized happened _below_ the tick
+    //   if (tick <= currentTick) {
+    //     data.outerFeeGrowth0Token = totalFeeGrowth0Token;
+    //     data.outerFeeGrowth1Token = totalFeeGrowth1Token;
+    //     data.outerSecondsPerLiquidity = secondsPerLiquidityCumulative;
+    //     data.outerTickCumulative = tickCumulative;
+    //     data.outerSecondsSpent = time;
+    //   }
+    //   data.initialized = true;
+    // }
+
+    let flipped = liquidityGrossAfter === 0n;
+    if (liquidityGrossBefore === 0n) {
+      flipped = !flipped;
+      if (tick <= tickCurrent) {
+        info.secondsPerLiquidityOutsideX128 = secondsPerLiquidityCumulativeX128;
+        info.tickCumulativeOutside = tickCumulative;
+        info.secondsOutside = time;
+      }
+      info.initialized = true;
+    }
+
+    // data.liquidityTotal = liquidityTotalAfter;
+    info.liquidityGross = liquidityGrossAfter;
+
+    return flipped;
+  }
+}

package/src/dex/algebra/lib/TickTable.ts

@@ -0,0 +1,216 @@
+import { IAlgebraPoolState } from '../types';
+import { _require } from '../../../utils';
+import { DeepReadonly } from 'ts-essentials';
+import {
+  OUT_OF_RANGE_ERROR_POSTFIX,
+  TICK_BITMAP_BUFFER,
+  TICK_BITMAP_TO_USE,
+} from '../../uniswap-v3/constants';
+import { TickMath } from '../../uniswap-v3/contract-math/TickMath';
+import { Yul } from './yul-helper';
+
+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 TickTable {
+  static position(tick: bigint) {
+    return [
+      // wordPos
+      BigInt.asIntN(16, tick >> 8n),
+      // bitPos
+      BigInt.asUintN(8, tick & BigInt(0xff)),
+    ];
+  }
+
+  static toggleTick(
+    state: Pick<IAlgebraPoolState, 'startTickBitmap' | 'tickBitmap'>,
+    tick: bigint,
+    tickSpacing?: bigint,
+  ) {
+    if (tickSpacing !== undefined) {
+      tick /= tickSpacing;
+    }
+    const [rowNumber, bitNumber] = TickTable.position(tick);
+    const mask = 1n << bitNumber;
+
+    // toggleTick is used only in _updatePosition which is always state changing event
+    // Therefore it is never used in price query
+    isWordPosOut(rowNumber, state.startTickBitmap, false);
+
+    const stringWordPos = rowNumber.toString();
+    if (state.tickBitmap[stringWordPos] === undefined) {
+      state.tickBitmap[stringWordPos] = 0n;
+    }
+
+    state.tickBitmap[stringWordPos] ^= mask;
+    if (state.tickBitmap[stringWordPos] === 0n) {
+      delete state.tickBitmap[stringWordPos];
+    }
+  }
+
+  static nextInitializedTickWithinOneWord(
+    state: DeepReadonly<
+      Pick<IAlgebraPoolState, 'startTickBitmap' | 'tickBitmap'>
+    >,
+    tick: bigint,
+    lte: boolean,
+    isPriceQuery: boolean,
+    tickSpacing?: bigint,
+  ): [bigint, boolean] {
+    if (tickSpacing !== undefined) {
+      tick = Yul.sub(
+        Yul.sdiv(tick, tickSpacing),
+        Yul.and(
+          Yul.slt(tick, 0n),
+          Yul.not(Yul.iszero(Yul.smod(tick, tickSpacing))),
+        ),
+      );
+    }
+    const [rowNumber, bitNumber] = TickTable.position(tick);
+    isWordPosOut(rowNumber, state.startTickBitmap, isPriceQuery);
+    let tickBitmapValue = state.tickBitmap[rowNumber.toString()];
+    tickBitmapValue = tickBitmapValue === undefined ? 0n : tickBitmapValue;
+    if (lte) {
+      const _row = tickBitmapValue << (255n - bitNumber);
+      if (_row != 0n) {
+        tick -= BigInt.asIntN(24, 255n - TickTable.getMostSignificantBit(_row));
+        return [TickTable.boundTick(tick, tickSpacing), true];
+      } else {
+        tick -= BigInt.asIntN(24, bitNumber);
+        return [TickTable.boundTick(tick, tickSpacing), false];
+      }
+    } else {
+      tick += 1n;
+      const _row = tickBitmapValue >> bitNumber;
+      if (_row !== 0n) {
+        tick += BigInt.asIntN(
+          24,
+          TickTable.getSingleSignificantBit(-_row & _row),
+        );
+        return [TickTable.boundTick(tick, tickSpacing), true];
+      } else {
+        tick += BigInt.asIntN(24, 255n - bitNumber);
+        return [TickTable.boundTick(tick, tickSpacing), false];
+      }
+    }
+  }
+
+  static getSingleSignificantBit(word: bigint): bigint {
+    let singleBitPos = 0n;
+    singleBitPos = Yul.iszero(
+      word &&
+        BigInt(
+          '0x5555555555555555555555555555555555555555555555555555555555555555',
+        ),
+    );
+    singleBitPos =
+      singleBitPos ||
+      Yul.iszero(
+        word &&
+          BigInt(
+            '0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff',
+          ),
+      ) << 7n;
+    singleBitPos =
+      singleBitPos ||
+      Yul.iszero(
+        word &&
+          BigInt(
+            '0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff',
+          ),
+      ) << 6n;
+    singleBitPos =
+      singleBitPos ||
+      Yul.iszero(
+        word &&
+          BigInt(
+            '0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff',
+          ),
+      ) << 5n;
+    singleBitPos =
+      singleBitPos ||
+      Yul.iszero(
+        word &&
+          BigInt(
+            '0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff',
+          ),
+      ) << 4n;
+    singleBitPos =
+      singleBitPos ||
+      Yul.iszero(
+        word &&
+          BigInt(
+            '0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff',
+          ),
+      ) << 3n;
+    singleBitPos =
+      singleBitPos ||
+      Yul.iszero(
+        word &&
+          BigInt(
+            '0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f',
+          ),
+      ) << 2n;
+    singleBitPos =
+      singleBitPos ||
+      Yul.iszero(
+        word &&
+          BigInt(
+            '0x3333333333333333333333333333333333333333333333333333333333333333',
+          ),
+      ) << 1n;
+
+    return BigInt.asUintN(8, singleBitPos);
+  }
+
+  static getMostSignificantBit(word: bigint): bigint {
+    word = word || word >> 1n;
+    word = word || word >> 2n;
+    word = word || word >> 4n;
+    word = word || word >> 8n;
+    word = word || word >> 16n;
+    word = word || word >> 32n;
+    word = word || word >> 64n;
+    word = word || word >> 128n;
+    word = word - (word >> 1n);
+    return TickTable.getSingleSignificantBit(BigInt.asUintN(256, word));
+  }
+
+  static boundTick(tick: bigint, tickSpacing?: bigint): bigint {
+    if (tickSpacing !== undefined) {
+      tick *= tickSpacing;
+    }
+    let boundedTick = tick;
+    if (boundedTick < TickMath.MIN_TICK) {
+      boundedTick = TickMath.MIN_TICK;
+    } else if (boundedTick > TickMath.MAX_TICK) {
+      boundedTick = TickMath.MAX_TICK;
+    }
+    return boundedTick;
+  }
+}

package/src/dex/algebra/lib/yul-helper.ts

@@ -0,0 +1,29 @@
+export class Yul {
+  static sub(x: bigint, y: bigint): bigint {
+    return x - y;
+  }
+
+  static sdiv(x: bigint, y: bigint): bigint {
+    return y === 0n ? 0n : x / y;
+  }
+
+  static and(x: bigint, y: bigint): bigint {
+    return x & y;
+  }
+
+  static slt(x: bigint, y: bigint): bigint {
+    return x < y ? 1n : 0n;
+  }
+
+  static not(x: bigint): bigint {
+    return ~x;
+  }
+
+  static iszero(x: bigint): bigint {
+    return x === 0n ? 1n : 0n;
+  }
+
+  static smod(x: bigint, y: bigint): bigint {
+    return y === 0n ? 0n : x % y;
+  }
+}

package/src/dex/algebra/types.ts

@@ -23,6 +23,7 @@ export type PoolStateV1_1 = {
   startTickBitmap: bigint;
   balance0: bigint;
   balance1: bigint;
+  areTicksCompressed: boolean;
 };
 
 type GlobalState_v1_9 = {
@@ -47,6 +48,7 @@ export type PoolState_v1_9 = {
   startTickBitmap: bigint;
   balance0: bigint;
   balance1: bigint;
+  areTicksCompressed: boolean;
 };
 
 export type AlgebraData = {
@@ -71,6 +73,8 @@ export type DexParams = {
   version: 'v1.1' | 'v1.9';
 };
 
+export type IAlgebraPoolState = PoolStateV1_1 | PoolState_v1_9;
+
 export type TickBitMapMappingsWithBigNumber = {
   index: number;
   value: BigNumber;

package/src/dex/balancer-v2/optimizer.ts

@@ -3,68 +3,66 @@ import { BalancerSwapV2 } from './types';
 import { SwapSide } from '../../constants';
 import { BalancerConfig } from './config';
 
-const MAX_UINT256 =
-  '115792089237316195423570985008687907853269984665640564039457584007913129639935';
-
-const AllBalancerV2Forks = Object.keys(BalancerConfig);
-
 export function balancerV2Merge(or: UnoptimizedRate): UnoptimizedRate {
   const fixSwap = (
     rawSwap: OptimalSwapExchange<any>[],
+    exchange: string,
     side: SwapSide,
   ): OptimalSwapExchange<any>[] => {
-    const newBalancers: { [key: string]: OptimalSwapExchange<any> } = {};
+    const exchangeLower = exchange.toLowerCase();
+    const newBalancer: OptimalSwapExchange<any> = {
+      exchange,
+      srcAmount: '0',
+      destAmount: '0',
+      percent: 0,
+      poolAddresses: [],
+      data: {
+        swaps: new Array<BalancerSwapV2>(),
+        gasUSD: '0',
+      },
+    };
     let optimizedSwap = new Array<OptimalSwapExchange<any>>();
-    rawSwap.forEach((s: OptimalSwapExchange<any>) => {
-      const exchangeKey = s.exchange.toLowerCase();
-      if (AllBalancerV2Forks.some(d => d.toLowerCase() === exchangeKey)) {
-        if (!(exchangeKey in newBalancers)) {
-          newBalancers[exchangeKey] = {
-            exchange: s.exchange,
-            srcAmount: '0',
-            destAmount: '0',
-            percent: 0,
-            poolAddresses: [],
-            data: {
-              swaps: new Array<BalancerSwapV2>(),
-              gasUSD: '0',
-            },
-          };
-        }
-        newBalancers[exchangeKey].srcAmount = (
-          BigInt(newBalancers[exchangeKey].srcAmount) + BigInt(s.srcAmount)
+    rawSwap.forEach((_s: OptimalSwapExchange<any>) => {
+      if (_s.exchange.toLowerCase() === exchangeLower) {
+        const s = _s;
+        newBalancer.srcAmount = (
+          BigInt(newBalancer.srcAmount) + BigInt(s.srcAmount)
         ).toString();
 
-        newBalancers[exchangeKey].destAmount = (
-          BigInt(newBalancers[exchangeKey].destAmount) + BigInt(s.destAmount)
+        newBalancer.destAmount = (
+          BigInt(newBalancer.destAmount) + BigInt(s.destAmount)
         ).toString();
 
-        newBalancers[exchangeKey].percent += s.percent;
-        newBalancers[exchangeKey].data.exchangeProxy = s.data.exchangeProxy;
-        newBalancers[exchangeKey].data.gasUSD = (
-          parseFloat(newBalancers[exchangeKey].data.gasUSD) +
-          parseFloat(s.data.gasUSD)
+        newBalancer.percent += s.percent;
+        newBalancer.data.exchangeProxy = s.data.exchangeProxy;
+        newBalancer.data.gasUSD = (
+          parseFloat(newBalancer.data.gasUSD) + parseFloat(s.data.gasUSD)
         ).toFixed(6);
 
-        newBalancers[exchangeKey].data.swaps.push({
+        newBalancer.data.swaps.push({
           poolId: s.data.poolId,
           amount: side === SwapSide.SELL ? s.srcAmount : s.destAmount,
         });
-        newBalancers[exchangeKey].poolAddresses!.push(s.poolAddresses![0]);
+        newBalancer.poolAddresses!.push(s.poolAddresses![0]);
       } else {
-        optimizedSwap.push(s);
+        optimizedSwap.push(_s);
       }
     });
-    optimizedSwap = optimizedSwap.concat(Object.values(newBalancers));
+    if (newBalancer.data!.swaps.length) optimizedSwap.push(newBalancer);
     return optimizedSwap;
   };
 
   or.bestRoute = or.bestRoute.map(r => ({
     ...r,
-    swaps: r.swaps.map(s => ({
-      ...s,
-      swapExchanges: fixSwap(s.swapExchanges, or.side),
-    })),
+    swaps: r.swaps.map(s => {
+      return {
+        ...s,
+        swapExchanges: Object.keys(BalancerConfig).reduce(
+          (acc, exchange) => fixSwap(acc, exchange, or.side),
+          s.swapExchanges,
+        ),
+      };
+    }),
   }));
   return or;
 }

package/src/dex/uniswap-v2/uniswap-v2-e2e-arbitrum.test.ts

@@ -381,8 +381,16 @@ describe('UniswapV2 E2E Arbitrum', () => {
         { name: 'USDC', sellAmount: '940617', buyAmount: '505000000000000' },
       ],
       [
-        { name: 'ETH', sellAmount: '631955000000000', buyAmount: '1000000000000000000' },
-        { name: 'ARB', sellAmount: '1000000000000000000', buyAmount: '631955000000000' },
+        {
+          name: 'ETH',
+          sellAmount: '631955000000000',
+          buyAmount: '1000000000000000000',
+        },
+        {
+          name: 'ARB',
+          sellAmount: '1000000000000000000',
+          buyAmount: '631955000000000',
+        },
       ],
     ];
 

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

@@ -120,13 +120,4 @@ export class TickBitMap {
 
     return [next, initialized];
   }
-
-  static _putZeroIfUndefined(
-    state: PoolState,
-    tickBitmapValue: bigint | undefined,
-    wordPos: bigint,
-    isPriceQuery: boolean = false,
-  ): bigint {
-    return tickBitmapValue === undefined ? 0n : tickBitmapValue;
-  }
 }

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

@@ -38,16 +38,18 @@ export function _reduceTicks(
 ) {
   return ticksToReduce.reduce<Record<string, TickInfo>>((acc, curr) => {
     const { index, value } = curr;
-    acc[index] = {
-      liquidityGross: bigIntify(value.liquidityGross),
-      liquidityNet: bigIntify(value.liquidityNet),
-      tickCumulativeOutside: bigIntify(value.tickCumulativeOutside),
-      secondsPerLiquidityOutsideX128: bigIntify(
-        value.secondsPerLiquidityOutsideX128,
-      ),
-      secondsOutside: bigIntify(value.secondsOutside),
-      initialized: value.initialized,
-    };
+    if (value.initialized) {
+      acc[index] = {
+        liquidityGross: bigIntify(value.liquidityGross),
+        liquidityNet: bigIntify(value.liquidityNet),
+        tickCumulativeOutside: bigIntify(value.tickCumulativeOutside),
+        secondsPerLiquidityOutsideX128: bigIntify(
+          value.secondsPerLiquidityOutsideX128,
+        ),
+        secondsOutside: bigIntify(value.secondsOutside),
+        initialized: value.initialized,
+      };
+    }
     return acc;
   }, ticks);
 }

package/src/dex/uniswap-v3/uniswap-v3.ts

@@ -276,7 +276,7 @@ export class UniswapV3
           e,
         );
       } else {
-        // on unkown error mark as failed and increase retryCount for retry init strategy
+        // on unknown error mark as failed and increase retryCount for retry init strategy
         // note: state would be null by default which allows to fallback
         this.logger.warn(
           `${this.dexKey}: Can not generate pool state for srcAddress=${srcAddress}, destAddress=${destAddress}, fee=${fee} pool fallback to rpc and retry every ${this.config.initRetryFrequency} times, initRetryAttemptCount=${pool.initRetryAttemptCount}`,

package/tests/constants-e2e.ts

@@ -705,7 +705,7 @@ export const Tokens: {
     HATCHY: {
       address: '0x502580fc390606b47fc3b741d6d49909383c28a9',
       decimals: 18,
-    }
+    },
   },
   [Network.ARBITRUM]: {
     DAI: {
@@ -785,6 +785,14 @@ export const Tokens: {
       address: '0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f',
       decimals: 8,
     },
+    USDCe: {
+      address: '0xff970a61a04b1ca14834a43f5de4533ebddb5cc8',
+      decimals: 6,
+    },
+    LEX: {
+      address: '0x6bB7A17AcC227fd1F6781D1EEDEAE01B42047eE0',
+      decimals: 18,
+    },
   },
   [Network.OPTIMISM]: {
     DAI: {