@paraswap/dex-lib 4.1.19-pools.0 → 4.1.19-pools.1

package/src/dex/maverick-v2/maverick-math/maverick-swap-math.ts

@@ -1,199 +0,0 @@
-import { BI_POWS } from '../../../bigint-constants';
-import { _require } from '../../../utils';
-import { TickData } from '../types';
-import { Delta } from './maverick-delta-math';
-import { MaverickBasicMath } from './maverick-basic-math';
-
-export class MaverickSwapMath {
-  static amountToBinNetOfProtocolFee(
-    deltaInErc: bigint,
-    feeBasis: bigint,
-    protocolFeeD3: bigint,
-  ): bigint {
-    return protocolFeeD3 != 0n
-      ? MaverickBasicMath.clip(
-          deltaInErc,
-          MaverickBasicMath.mulDivUp(feeBasis, protocolFeeD3, BI_POWS[3]),
-        )
-      : deltaInErc;
-  }
-
-  static remainingBinInputSpaceGivenOutput(
-    binLiquidity: bigint,
-    output: bigint,
-    sqrtPrice: bigint,
-    tokenAIn: boolean,
-  ): bigint {
-    let outOverL =
-      binLiquidity === 0n ? 0n : MaverickBasicMath.divUp(output, binLiquidity);
-
-    if (tokenAIn) {
-      return MaverickBasicMath.mulDivUp(
-        output,
-        sqrtPrice,
-        MaverickBasicMath.invFloor(sqrtPrice) - outOverL,
-      );
-    } else {
-      return MaverickBasicMath.divUp(
-        output,
-        MaverickBasicMath.mulDown(sqrtPrice, sqrtPrice - outOverL),
-      );
-    }
-  }
-
-  static computeSwapExactIn(
-    sqrtPrice: bigint,
-    tickData: TickData,
-    amountIn: bigint,
-    tokenAIn: boolean,
-    fee: bigint,
-    protocolFeeD3: bigint,
-  ): Delta {
-    let delta: Delta = {
-      deltaInBinInternal: 0n,
-      deltaInErc: 0n,
-      deltaOutErc: 0n,
-      excess: 0n,
-      tokenAIn: tokenAIn,
-      exactOutput: false,
-      swappedToMaxPrice: false,
-      skipCombine: false,
-      tickLimit: 0n,
-      sqrtLowerTickPrice: 0n,
-      sqrtUpperTickPrice: 0n,
-      sqrtPrice: 0n,
-      fractionalPart: 0n,
-    };
-
-    delta.deltaOutErc = tokenAIn
-      ? tickData.currentReserveB
-      : tickData.currentReserveA;
-
-    let binAmountIn = this.remainingBinInputSpaceGivenOutput(
-      tickData.currentLiquidity,
-      delta.deltaOutErc,
-      sqrtPrice,
-      tokenAIn,
-    );
-
-    let feeBasis;
-    let userBinAmountIn = MaverickBasicMath.mulDown(
-      amountIn,
-      BI_POWS[18] - fee,
-    );
-
-    if (userBinAmountIn < binAmountIn) {
-      binAmountIn = userBinAmountIn;
-      delta.deltaInErc = amountIn;
-      feeBasis = delta.deltaInErc - userBinAmountIn;
-    } else {
-      feeBasis = MaverickBasicMath.mulDivUp(
-        binAmountIn,
-        fee,
-        BI_POWS[18] - fee,
-      );
-      delta.deltaInErc = binAmountIn + feeBasis;
-      delta.excess = MaverickBasicMath.clip(amountIn, delta.deltaInErc);
-    }
-
-    delta.deltaInBinInternal = this.amountToBinNetOfProtocolFee(
-      delta.deltaInErc,
-      feeBasis,
-      protocolFeeD3,
-    );
-
-    if (delta.excess != 0n) return delta;
-
-    let inOverL = MaverickBasicMath.divUp(
-      binAmountIn,
-      tickData.currentLiquidity + 1n,
-    );
-
-    delta.deltaOutErc = MaverickBasicMath.min(
-      delta.deltaOutErc,
-      MaverickBasicMath.mulDivDown(
-        binAmountIn,
-        tokenAIn ? MaverickBasicMath.invFloor(sqrtPrice) : sqrtPrice,
-        inOverL + (tokenAIn ? sqrtPrice : MaverickBasicMath.invCeil(sqrtPrice)),
-      ),
-    );
-
-    return delta;
-  }
-
-  static computeSwapExactOut(
-    sqrtPrice: bigint,
-    tickData: TickData,
-    amountOut: bigint,
-    tokenAIn: boolean,
-    fee: bigint,
-    protocolFeeD3: bigint,
-  ): Delta {
-    let delta: Delta = {
-      deltaInBinInternal: 0n,
-      deltaInErc: 0n,
-      deltaOutErc: 0n,
-      excess: 0n,
-      tokenAIn: false,
-      exactOutput: false,
-      swappedToMaxPrice: false,
-      skipCombine: false,
-      tickLimit: 0n,
-      sqrtLowerTickPrice: 0n,
-      sqrtUpperTickPrice: 0n,
-      sqrtPrice: 0n,
-      fractionalPart: 0n,
-    };
-
-    let amountOutAvailable = tokenAIn
-      ? tickData.currentReserveB
-      : tickData.currentReserveA;
-    let swapped = amountOutAvailable <= amountOut;
-    delta.deltaOutErc = swapped ? amountOutAvailable : amountOut;
-    let binAmountIn = this.remainingBinInputSpaceGivenOutput(
-      tickData.currentLiquidity,
-      delta.deltaOutErc,
-      sqrtPrice,
-      tokenAIn,
-    );
-
-    let feeBasis = MaverickBasicMath.mulDivUp(
-      binAmountIn,
-      fee,
-      BI_POWS[18] - fee,
-    );
-    delta.deltaInErc = binAmountIn + feeBasis;
-    delta.deltaInBinInternal = this.amountToBinNetOfProtocolFee(
-      delta.deltaInErc,
-      feeBasis,
-      protocolFeeD3,
-    );
-    delta.excess = swapped
-      ? MaverickBasicMath.clip(amountOut, delta.deltaOutErc)
-      : 0n;
-
-    return delta;
-  }
-
-  static computeEndPrice(delta: Delta, newDelta: Delta, tickData: TickData) {
-    let endSqrtPrice =
-      MaverickBasicMath.divDown(
-        newDelta.deltaInBinInternal,
-        tickData.currentLiquidity,
-      ) +
-      (delta.tokenAIn
-        ? delta.sqrtPrice
-        : MaverickBasicMath.invFloor(delta.sqrtPrice));
-    if (!delta.tokenAIn) {
-      endSqrtPrice = MaverickBasicMath.invFloor(endSqrtPrice);
-    }
-
-    newDelta.fractionalPart = MaverickBasicMath.min(
-      BI_POWS[8],
-      MaverickBasicMath.divDown(
-        MaverickBasicMath.clip(endSqrtPrice, delta.sqrtLowerTickPrice),
-        BI_POWS[10] * (delta.sqrtUpperTickPrice - delta.sqrtLowerTickPrice),
-      ),
-    );
-  }
-}

package/src/dex/maverick-v2/maverick-math/maverick-tick-math.ts

@@ -1,171 +0,0 @@
-import { BI_MAX_UINT256, BI_POWS } from '../../../bigint-constants';
-import { _require } from '../../../utils';
-import { MaverickBasicMath } from './maverick-basic-math';
-
-const MAX_TICK = 460540;
-
-export class MaverickTickMath {
-  static getTickSqrtPriceAndL(
-    reserveA: bigint,
-    reserveB: bigint,
-    sqrtLowerTickPrice: bigint,
-    sqrtUpperTickPrice: bigint,
-  ): [bigint, bigint] {
-    let liquidity = this.getTickL(
-      reserveA,
-      reserveB,
-      sqrtLowerTickPrice,
-      sqrtUpperTickPrice,
-    );
-
-    let sqrtPrice = this.getSqrtPrice(
-      reserveA,
-      reserveB,
-      sqrtLowerTickPrice,
-      sqrtUpperTickPrice,
-      liquidity,
-    );
-
-    return [sqrtPrice, liquidity];
-  }
-
-  static getSqrtPrice(
-    reserveA: bigint,
-    reserveB: bigint,
-    sqrtLowerTickPrice: bigint,
-    sqrtUpperTickPrice: bigint,
-    liquidity: bigint,
-  ): bigint {
-    if (reserveA === 0n) {
-      return sqrtLowerTickPrice;
-    }
-    if (reserveB === 0n) {
-      return sqrtUpperTickPrice;
-    }
-
-    let sqrtPrice = MaverickBasicMath.sqrt(
-      BI_POWS[18] *
-        MaverickBasicMath.divDown(
-          reserveA + MaverickBasicMath.mulDown(liquidity, sqrtLowerTickPrice),
-          reserveB + MaverickBasicMath.divDown(liquidity, sqrtUpperTickPrice),
-        ),
-    );
-
-    return MaverickBasicMath.min(
-      MaverickBasicMath.max(sqrtPrice, sqrtLowerTickPrice),
-      sqrtUpperTickPrice,
-    );
-  }
-
-  static getTickL(
-    reserveA: bigint,
-    reserveB: bigint,
-    sqrtLowerTickPrice: bigint,
-    sqrtUpperTickPrice: bigint,
-  ): bigint {
-    let precisionBump = 0n;
-
-    if (reserveA >> 78n === 0n && reserveB >> 78n === 0n) {
-      precisionBump = 57n;
-      reserveA <<= precisionBump;
-      reserveB <<= precisionBump;
-    }
-
-    let diff;
-    let b =
-      MaverickBasicMath.divDown(reserveA, sqrtUpperTickPrice) +
-      MaverickBasicMath.mulDown(reserveB, sqrtLowerTickPrice);
-    diff = sqrtUpperTickPrice - sqrtLowerTickPrice;
-
-    if (reserveA === 0n || reserveB === 0n)
-      return (
-        MaverickBasicMath.mulDivDown(b, sqrtUpperTickPrice, diff) >>
-        precisionBump
-      );
-
-    b >>= 1n;
-
-    return (
-      MaverickBasicMath.mulDiv(
-        b +
-          MaverickBasicMath.sqrt(
-            MaverickBasicMath.mulDiv(b, b, BI_POWS[18]) +
-              MaverickBasicMath.mulDiv(
-                MaverickBasicMath.mulFloor(reserveB, reserveA),
-                diff,
-                sqrtUpperTickPrice,
-              ),
-          ) *
-            BI_POWS[9],
-        sqrtUpperTickPrice,
-        diff,
-      ) >> precisionBump
-    );
-  }
-
-  static tickSqrtPrices(tickSpacing: bigint, tick: bigint): [bigint, bigint] {
-    return [
-      this.tickSqrtPrice(tickSpacing, tick),
-      this.tickSqrtPrice(tickSpacing, tick + 1n),
-    ];
-  }
-
-  static subTickIndex(tickSpacing: bigint, tick: bigint): bigint {
-    let subTick = MaverickBasicMath.abs(tick);
-    subTick *= tickSpacing;
-    if (subTick > MAX_TICK) {
-      throw new Error('OB');
-    }
-    return subTick;
-  }
-
-  static tickSqrtPrice(tickSpacing: bigint, _tick: bigint): bigint {
-    let tick = this.subTickIndex(tickSpacing, _tick);
-
-    let ratio: bigint =
-      (tick & 0x1n) != 0n
-        ? 0xfffcb933bd6fad9d3af5f0b9f25db4d6n
-        : 0x100000000000000000000000000000000n;
-    if ((tick & 0x2n) != 0n)
-      ratio = (ratio * 0xfff97272373d41fd789c8cb37ffcaa1cn) >> 128n;
-    if ((tick & 0x4n) != 0n)
-      ratio = (ratio * 0xfff2e50f5f656ac9229c67059486f389n) >> 128n;
-    if ((tick & 0x8n) != 0n)
-      ratio = (ratio * 0xffe5caca7e10e81259b3cddc7a064941n) >> 128n;
-    if ((tick & 0x10n) != 0n)
-      ratio = (ratio * 0xffcb9843d60f67b19e8887e0bd251eb7n) >> 128n;
-    if ((tick & 0x20n) != 0n)
-      ratio = (ratio * 0xff973b41fa98cd2e57b660be99eb2c4an) >> 128n;
-    if ((tick & 0x40n) != 0n)
-      ratio = (ratio * 0xff2ea16466c9838804e327cb417cafcbn) >> 128n;
-    if ((tick & 0x80n) != 0n)
-      ratio = (ratio * 0xfe5dee046a99d51e2cc356c2f617dbe0n) >> 128n;
-    if ((tick & 0x100n) != 0n)
-      ratio = (ratio * 0xfcbe86c7900aecf64236ab31f1f9dcb5n) >> 128n;
-    if ((tick & 0x200n) != 0n)
-      ratio = (ratio * 0xf987a7253ac4d9194200696907cf2e37n) >> 128n;
-    if ((tick & 0x400n) != 0n)
-      ratio = (ratio * 0xf3392b0822b88206f8abe8a3b44dd9ben) >> 128n;
-    if ((tick & 0x800n) != 0n)
-      ratio = (ratio * 0xe7159475a2c578ef4f1d17b2b235d480n) >> 128n;
-    if ((tick & 0x1000n) != 0n)
-      ratio = (ratio * 0xd097f3bdfd254ee83bdd3f248e7e785en) >> 128n;
-    if ((tick & 0x2000n) != 0n)
-      ratio = (ratio * 0xa9f746462d8f7dd10e744d913d033333n) >> 128n;
-    if ((tick & 0x4000n) != 0n)
-      ratio = (ratio * 0x70d869a156ddd32a39e257bc3f50aa9bn) >> 128n;
-    if ((tick & 0x8000n) != 0n)
-      ratio = (ratio * 0x31be135f97da6e09a19dc367e3b6da40n) >> 128n;
-    if ((tick & 0x10000n) != 0n)
-      ratio = (ratio * 0x9aa508b5b7e5a9780b0cc4e25d61a56n) >> 128n;
-    if ((tick & 0x20000n) != 0n)
-      ratio = (ratio * 0x5d6af8dedbcb3a6ccb7ce618d14225n) >> 128n;
-    if ((tick & 0x40000n) != 0n)
-      ratio = (ratio * 0x2216e584f630389b2052b8db590en) >> 128n;
-    if ((tick & 0x80000n) != 0n)
-      ratio = (ratio * 0x48a1703920644d4030024fen) >> 128n;
-    if ((tick & 0x100000n) != 0n) ratio = (ratio * 0x149b34ee7b4532n) >> 128n;
-    if (_tick > 0) ratio = BI_MAX_UINT256 / ratio;
-    return (ratio * BI_POWS[18]) >> 128n;
-  }
-}

package/src/dex/maverick-v2/maverick-math/maverick-twa-math.ts

@@ -1,54 +0,0 @@
-import { BI_POWS } from '../../../bigint-constants';
-import { _require } from '../../../utils';
-import { PoolState } from '../types';
-import { MaverickBasicMath } from './maverick-basic-math';
-
-export class TwaMath {
-  static updateValue(
-    self: PoolState,
-    value: bigint,
-    lookback: bigint,
-    timestamp: bigint,
-  ) {
-    if (timestamp === self.lastTimestamp) return;
-    self.lastTwaD8 = this.getTwa(self, lookback, timestamp);
-    self.lastTimestamp = timestamp;
-    self.lastLogPriceD8 = value;
-  }
-
-  static floor(self: PoolState) {
-    return MaverickBasicMath.floorD8Unchecked(self.lastTwaD8);
-  }
-
-  static getTwa(self: PoolState, lookback: bigint, timestamp: bigint): bigint {
-    let timeDiff = timestamp - self.lastTimestamp;
-    timeDiff = MaverickBasicMath.min(lookback, timeDiff);
-    if (timeDiff === 0n) return self.lastTwaD8;
-
-    let absValueDeviation = MaverickBasicMath.min(
-      BI_POWS[8],
-      MaverickBasicMath.abs(self.lastLogPriceD8 - self.lastTwaD8),
-    );
-
-    if (absValueDeviation === 0n) return self.lastTwaD8;
-    let twaDeviation = MaverickBasicMath.mulDivDown(
-      absValueDeviation,
-      timeDiff,
-      lookback,
-    );
-
-    return self.lastTwaD8 > self.lastLogPriceD8
-      ? -twaDeviation + self.lastTwaD8
-      : twaDeviation + self.lastTwaD8;
-  }
-
-  static getTwaFloor(
-    self: PoolState,
-    lookback: bigint,
-    timestamp: bigint,
-  ): bigint {
-    return MaverickBasicMath.floorD8Unchecked(
-      this.getTwa(self, lookback, timestamp),
-    );
-  }
-}

package/src/dex/maverick-v2/maverick-v2-e2e.test.ts

@@ -1,171 +0,0 @@
-/* eslint-disable no-console */
-import dotenv from 'dotenv';
-dotenv.config();
-
-import { testE2E } from '../../../tests/utils-e2e';
-import {
-  Tokens,
-  Holders,
-  NativeTokenSymbols,
-} from '../../../tests/constants-e2e';
-import { Network, ContractMethod, SwapSide } from '../../constants';
-import { StaticJsonRpcProvider } from '@ethersproject/providers';
-import { generateConfig } from '../../config';
-import { ContractMethodV6 } from '@paraswap/sdk';
-
-/*
-  README
-  ======
-
-  This test script should add e2e tests for MaverickV2. The tests
-  should cover as many cases as possible. Most of the DEXes follow
-  the following test structure:
-    - DexName
-      - ForkName + Network
-        - ContractMethod
-          - ETH -> Token swap
-          - Token -> ETH swap
-          - Token -> Token swap
-
-  The template already enumerates the basic structure which involves
-  testing simpleSwap, multiSwap, megaSwap contract methods for
-  ETH <> TOKEN and TOKEN <> TOKEN swaps. You should replace tokenA and
-  tokenB with any two highly liquid tokens on MaverickV2 for the tests
-  to work. If the tokens that you would like to use are not defined in
-  Tokens or Holders map, you can update the './tests/constants-e2e'
-
-  Other than the standard cases that are already added by the template
-  it is highly recommended to add test cases which could be specific
-  to testing MaverickV2 (Eg. Tests based on poolType, special tokens,
-  etc).
-
-  You can run this individual test script by running:
-  `npx jest src/dex/<dex-name>/<dex-name>-e2e.test.ts`
-
-  e2e tests use the Tenderly fork api. Please add the following to your
-  .env file:
-  TENDERLY_TOKEN=Find this under Account>Settings>Authorization.
-  TENDERLY_ACCOUNT_ID=Your Tenderly account name.
-  TENDERLY_PROJECT=Name of a Tenderly project you have created in your
-  dashboard.
-
-  (This comment should be removed from the final implementation)
-*/
-
-function testForNetwork(
-  network: Network,
-  dexKey: string,
-  tokenASymbol: string,
-  tokenBSymbol: string,
-  tokenAAmount: string,
-  tokenBAmount: string,
-  nativeTokenAmount: string,
-) {
-  const provider = new StaticJsonRpcProvider(
-    generateConfig(network).privateHttpProvider,
-    network,
-  );
-  const tokens = Tokens[network];
-  const holders = Holders[network];
-  const nativeTokenSymbol = NativeTokenSymbols[network];
-
-  const sideToContractMethods = new Map([
-    [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
-    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
-  ]);
-
-  describe(`${network}`, () => {
-    sideToContractMethods.forEach((contractMethods, side) =>
-      describe(`${side}`, () => {
-        contractMethods.forEach((contractMethod: ContractMethod) => {
-          describe(`${contractMethod}`, () => {
-            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
-              await testE2E(
-                tokens[tokenASymbol],
-                tokens[tokenBSymbol],
-                holders[tokenASymbol],
-                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
-                side,
-                dexKey,
-                contractMethod,
-                network,
-                provider,
-              );
-            });
-            it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
-              await testE2E(
-                tokens[tokenBSymbol],
-                tokens[tokenASymbol],
-                holders[tokenBSymbol],
-                side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
-                side,
-                dexKey,
-                contractMethod,
-                network,
-                provider,
-              );
-            });
-          });
-        });
-      }),
-    );
-  });
-}
-
-describe('MaverickV2 E2E', () => {
-  const dexKey = 'MaverickV2';
-
-  const testCases = [
-    {
-      network: Network.BASE,
-      tokenASymbol: 'USDC',
-      tokenBSymbol: 'ETH',
-      tokenAAmount: '1000000000',
-      tokenBAmount: '1000000000000000000',
-    },
-    {
-      network: Network.ARBITRUM,
-      tokenASymbol: 'USDC',
-      tokenBSymbol: 'ETH',
-      tokenAAmount: '1000000',
-      tokenBAmount: '1000000000000000000',
-    },
-    {
-      network: Network.BSC,
-      tokenASymbol: 'USDC',
-      tokenBSymbol: 'USDT',
-      tokenAAmount: '100000000',
-      tokenBAmount: '100000000',
-    },
-    {
-      network: Network.MAINNET,
-      tokenASymbol: 'GHO',
-      tokenBSymbol: 'USDC',
-      tokenAAmount: '1000000000000000000000',
-      tokenBAmount: '100000000000',
-    },
-    {
-      network: Network.MAINNET,
-      tokenASymbol: 'ETH',
-      tokenBSymbol: 'USDC',
-      tokenAAmount: '1000000000000000000',
-      tokenBAmount: '1000000',
-    },
-  ];
-
-  testCases.forEach(
-    ({ network, tokenAAmount, tokenBAmount, tokenASymbol, tokenBSymbol }) => {
-      const nativeTokenAmount = '1000000000000000000';
-
-      testForNetwork(
-        network,
-        dexKey,
-        tokenASymbol,
-        tokenBSymbol,
-        tokenAAmount,
-        tokenBAmount,
-        nativeTokenAmount,
-      );
-    },
-  );
-});

package/src/dex/maverick-v2/maverick-v2-events.test.ts

@@ -1,112 +0,0 @@
-/* eslint-disable no-console */
-import dotenv from 'dotenv';
-dotenv.config();
-
-import { MaverickV2EventPool } from './maverick-v2-pool';
-import { Network } from '../../constants';
-import { Address } from '../../types';
-import { DummyDexHelper } from '../../dex-helper/index';
-import { testEventSubscriber } from '../../../tests/utils-events';
-import { PoolState } from './types';
-import { Tokens } from '../../../tests/constants-e2e';
-
-jest.setTimeout(50 * 1000);
-
-async function fetchPoolState(
-  maverickV2Pool: MaverickV2EventPool,
-  blockNumber: number,
-  poolAddress: string,
-): Promise<PoolState> {
-  return maverickV2Pool.generateState(blockNumber);
-}
-
-// eventName -> blockNumbers
-type EventMappings = Record<string, number[]>;
-
-describe('MaverickV2 EventPool Mainnet', function () {
-  const dexKey = 'MaverickV2';
-  const network = Network.BASE;
-  const tokens = Tokens[network];
-  const dexHelper = new DummyDexHelper(network);
-  const logger = dexHelper.getLogger(dexKey);
-  let maverickV2Pool: MaverickV2EventPool;
-
-  // poolAddress -> EventMappings
-  const eventsToTest: Record<Address, EventMappings> = {
-    '0xe789204A908Fc586743f7b8acbEE9194E5e2Ea73': {
-      Swap: [
-        14716574, 14845131, 14845133, 14845136, 14845138, 14845141, 14845144,
-        14845146, 14845149, 14845151, 14845154, 14845206, 14845209, 14845212,
-        14845215, 14845217, 14845220, 14845223, 14845225, 14845228, 14845231,
-        14845274, 14845277, 14845279, 14845282, 14845285, 14845287, 14845290,
-        14845293, 14845295, 14845298, 14845301, 14845362, 14845364, 14845367,
-        14845370, 14845373, 14845375, 14845378, 14845381, 14845383, 14845386,
-        14845389, 14845413, 14845416, 14845419, 14845421, 14845424, 14845427,
-        14845429, 14845432, 14845435, 14845437, 14845440,
-      ],
-      AddLiquidity: [
-        14762449, 14845350, 14845402, 14845120, 14845195, 14718361, 14845262,
-        14716574,
-      ],
-      RemoveLiquidity: [14845359, 14845203, 14845128, 14845410, 14845271],
-    },
-  };
-
-  const pools: any = {
-    '0xe789204A908Fc586743f7b8acbEE9194E5e2Ea73': {
-      tokenA: tokens.DAI,
-      tokenB: tokens.USDC,
-      feeA: 1000000000000,
-      feeB: 1000000000000,
-      tickSpacing: 8,
-      protocolFee: 0,
-      lookback: 360000,
-      activeTick: 0,
-    },
-  };
-
-  Object.entries(eventsToTest).forEach(
-    ([poolAddress, events]: [string, EventMappings]) => {
-      describe(`Events for ${poolAddress}`, () => {
-        beforeEach(() => {
-          let pool = pools[poolAddress];
-          maverickV2Pool = new MaverickV2EventPool(
-            dexKey,
-            network,
-            dexHelper,
-            logger,
-            pool.tokenA,
-            pool.tokenB,
-            pool.feeA,
-            pool.feeB,
-            pool.tickSpacing,
-            pool.protocolFee,
-            pool.lookback,
-            pool.activeTick,
-            poolAddress,
-            '0x8cf8d1159d8381433556974238c34EB7599321c4',
-          );
-        });
-        Object.entries(events).forEach(
-          ([eventName, blockNumbers]: [string, number[]]) => {
-            describe(`${eventName}`, () => {
-              blockNumbers.forEach((blockNumber: number) => {
-                it(`State after ${blockNumber}`, async function () {
-                  await testEventSubscriber(
-                    maverickV2Pool,
-                    maverickV2Pool.addressesSubscribed,
-                    (_blockNumber: number) =>
-                      fetchPoolState(maverickV2Pool, _blockNumber, poolAddress),
-                    blockNumber,
-                    `${dexKey}_${poolAddress}`,
-                    dexHelper.provider,
-                  );
-                });
-              });
-            });
-          },
-        );
-      });
-    },
-  );
-});