@paraswap/dex-lib 4.1.6 → 4.1.7-mwrappedm.0

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

@@ -97,9 +97,6 @@ async function checkOnChainPricing(
     fee,
   );
 
-  console.log('blockNumber: ', blockNumber);
-  console.log('readerCallData: ', readerCallData);
-
   let readerResult;
   try {
     readerResult = (
@@ -125,16 +122,10 @@ async function checkOnChainPricing(
   // we skipped first, so add +1 on result
   firstZeroIndex = firstZeroIndex === -1 ? prices.length : firstZeroIndex;
 
-  console.log('prices: ', prices);
-  console.log('expectedPrices: ', expectedPrices);
-
   // Compare only the ones for which we were able to calculate prices
   expect(prices.slice(0, firstZeroIndex)).toEqual(
     expectedPrices.slice(0, firstZeroIndex),
   );
-
-  expect(prices).toStrictEqual(expectedPrices);
-
   return true;
 }
 
@@ -146,680 +137,344 @@ describe('UniswapV3', () => {
   let uniswapV3: UniswapV3;
   let uniswapV3Mainnet: UniswapV3;
 
-  describe('Mainnet', () => {
-    const network = Network.MAINNET;
-    const dexHelper = new DummyDexHelper(network);
+  beforeEach(async () => {
+    blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    uniswapV3 = new UniswapV3(network, dexKey, dexHelper);
+    uniswapV3Mainnet = new UniswapV3(
+      Network.ARBITRUM,
+      dexKey,
+      new DummyDexHelper(Network.ARBITRUM),
+    );
+  });
 
-    describe('DAI -> USDC', () => {
-      const TokenASymbol = 'DAI';
-      const TokenA = Tokens[network][TokenASymbol];
+  it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+    const pools = await uniswapV3.getPoolIdentifiers(
+      TokenA,
+      TokenB,
+      SwapSide.SELL,
+      blockNumber,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `, pools);
 
-      const TokenBSymbol = 'USDC';
-      const TokenB = Tokens[network][TokenBSymbol];
+    expect(pools.length).toBeGreaterThan(0);
 
-      beforeEach(async () => {
-        // blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
-        blockNumber = 21766507;
-        uniswapV3 = new UniswapV3(network, dexKey, dexHelper);
+    const poolPrices = await uniswapV3.getPricesVolume(
+      TokenA,
+      TokenB,
+      amounts,
+      SwapSide.SELL,
+      blockNumber,
+      pools,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `, poolPrices);
 
-        console.log('blocknumber: ', blockNumber);
-      });
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
 
-      it('DAI -> USDC getPoolIdentifiers and getPricesVolume SELL', async () => {
-        const amounts = [
-          0n,
-          2n * BI_POWS[18],
-          3n * BI_POWS[18],
-          4n * BI_POWS[18],
-          5n * BI_POWS[18],
-          6n * BI_POWS[18],
-          7n * BI_POWS[18],
-          8n * BI_POWS[18],
-          9n * BI_POWS[18],
-          10n * BI_POWS[18],
-        ];
-
-        const pools = await uniswapV3.getPoolIdentifiers(
-          TokenA,
-          TokenB,
-          SwapSide.SELL,
+    let falseChecksCounter = 0;
+    await Promise.all(
+      poolPrices!.map(async price => {
+        const fee = uniswapV3.eventPools[price.poolIdentifier!]!.feeCode;
+        const res = await checkOnChainPricing(
+          dexHelper,
+          uniswapV3,
+          'quoteExactInputSingle',
           blockNumber,
+          '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
+          price.prices,
+          TokenA.address,
+          TokenB.address,
+          fee,
+          amounts,
         );
-        console.log(
-          `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
-          pools,
-        );
+        if (res === false) falseChecksCounter++;
+      }),
+    );
 
-        expect(pools.length).toBeGreaterThan(0);
+    expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+  });
 
-        const prices = await uniswapV3.getPricesVolume(
-          TokenA,
-          TokenB,
-          amounts,
-          SwapSide.SELL,
-          blockNumber,
-          pools,
-        );
+  it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+    const pools = await uniswapV3.getPoolIdentifiers(
+      TokenA,
+      TokenB,
+      SwapSide.BUY,
+      blockNumber,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `, pools);
 
-        const poolPrices = prices?.filter(
-          price =>
-            price.poolIdentifier &&
-            price.poolIdentifier.toLowerCase() ===
-              'UniswapV3_0x6b175474e89094c44da98b954eedeac495271d0f_0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48_10000'.toLowerCase(),
-        );
+    expect(pools.length).toBeGreaterThan(0);
 
-        console.log(
-          `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
-          poolPrices,
-        );
+    const poolPrices = await uniswapV3.getPricesVolume(
+      TokenA,
+      TokenB,
+      amountsBuy,
+      SwapSide.BUY,
+      blockNumber,
+      pools,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `, poolPrices);
 
-        expect(poolPrices).not.toBeNull();
-        // checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, amountsBuy, SwapSide.BUY, dexKey);
 
-        let falseChecksCounter = 0;
-        await Promise.all(
-          poolPrices!.map(async price => {
-            const fee = uniswapV3.eventPools[price.poolIdentifier!]!.feeCode;
-            const res = await checkOnChainPricing(
-              dexHelper,
-              uniswapV3,
-              'quoteExactInputSingle',
-              blockNumber,
-              '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
-              price.prices,
-              TokenA.address,
-              TokenB.address,
-              fee,
-              amounts,
-            );
-            if (res === false) falseChecksCounter++;
-          }),
+    // Check if onchain pricing equals to calculated ones
+    let falseChecksCounter = 0;
+    await Promise.all(
+      poolPrices!.map(async price => {
+        const fee = uniswapV3.eventPools[price.poolIdentifier!]!.feeCode;
+        const res = await checkOnChainPricing(
+          dexHelper,
+          uniswapV3,
+          'quoteExactOutputSingle',
+          blockNumber,
+          '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
+          price.prices,
+          TokenA.address,
+          TokenB.address,
+          fee,
+          amountsBuy,
         );
+        if (res === false) falseChecksCounter++;
+      }),
+    );
+    expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+  });
 
-        expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
-      });
+  it('getPoolIdentifiers and getPricesVolume SELL stable pairs', async function () {
+    const TokenASymbol = 'USDT';
+    const TokenA = Tokens[network][TokenASymbol];
 
-      it('DAI -> USDC getPoolIdentifiers and getPricesVolume BUY', async () => {
-        const amounts = [
-          0n,
-          2n * BI_POWS[18],
-          3n * BI_POWS[18],
-          4n * BI_POWS[18],
-          5n * BI_POWS[18],
-        ];
+    const TokenBSymbol = 'USDC';
+    const TokenB = Tokens[network][TokenBSymbol];
 
-        const pools = await uniswapV3.getPoolIdentifiers(
-          TokenA,
-          TokenB,
-          SwapSide.BUY,
-          blockNumber,
-        );
-        console.log(
-          `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
-          pools,
-        );
+    const amounts = [
+      0n,
+      6000000n,
+      12000000n,
+      18000000n,
+      24000000n,
+      30000000n,
+      36000000n,
+      42000000n,
+      48000000n,
+      54000000n,
+      60000000n,
+      66000000n,
+      72000000n,
+      78000000n,
+      84000000n,
+      90000000n,
+      96000000n,
+      102000000n,
+      108000000n,
+      114000000n,
+      120000000n,
+      126000000n,
+      132000000n,
+      138000000n,
+      144000000n,
+      150000000n,
+      156000000n,
+      162000000n,
+      168000000n,
+      174000000n,
+      180000000n,
+      186000000n,
+      192000000n,
+      198000000n,
+      204000000n,
+      210000000n,
+      216000000n,
+      222000000n,
+      228000000n,
+      234000000n,
+      240000000n,
+      246000000n,
+      252000000n,
+      258000000n,
+      264000000n,
+      270000000n,
+      276000000n,
+      282000000n,
+      288000000n,
+      294000000n,
+      300000000n,
+    ];
 
-        expect(pools.length).toBeGreaterThan(0);
+    const pools = await uniswapV3.getPoolIdentifiers(
+      TokenA,
+      TokenB,
+      SwapSide.SELL,
+      blockNumber,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `, pools);
 
-        const prices = await uniswapV3.getPricesVolume(
-          TokenA,
-          TokenB,
-          amounts,
-          SwapSide.BUY,
-          blockNumber,
-          pools,
-        );
+    expect(pools.length).toBeGreaterThan(0);
 
-        console.log('poolPrices: ');
+    const poolPrices = await uniswapV3.getPricesVolume(
+      TokenA,
+      TokenB,
+      amounts,
+      SwapSide.SELL,
+      blockNumber,
+      pools,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `, poolPrices);
 
-        const poolPrices = prices?.filter(
-          price =>
-            price.poolIdentifier &&
-            price.poolIdentifier.toLowerCase() ===
-              'UniswapV3_0x6b175474e89094c44da98b954eedeac495271d0f_0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48_10000'.toLowerCase(),
-        );
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(
+      poolPrices!.filter(pp => pp.unit !== 0n),
+      amounts,
+      SwapSide.SELL,
+      dexKey,
+    );
 
-        console.log(
-          `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
-          poolPrices,
+    // Check if onchain pricing equals to calculated ones
+    let falseChecksCounter = 0;
+    await Promise.all(
+      poolPrices!.map(async price => {
+        const fee = uniswapV3.eventPools[price.poolIdentifier!]!.feeCode;
+        const res = await checkOnChainPricing(
+          dexHelper,
+          uniswapV3,
+          'quoteExactInputSingle',
+          blockNumber,
+          '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
+          price.prices,
+          TokenA.address,
+          TokenB.address,
+          fee,
+          amounts,
         );
+        if (res === false) falseChecksCounter++;
+      }),
+    );
+    expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+  });
 
-        expect(poolPrices).not.toBeNull();
-        // checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+  it('getPoolIdentifiers and getPricesVolume BUY stable pairs', async function () {
+    const TokenASymbol = 'DAI';
+    const TokenA = Tokens[network][TokenASymbol];
 
-        let falseChecksCounter = 0;
-        await Promise.all(
-          poolPrices!.map(async price => {
-            const fee = uniswapV3.eventPools[price.poolIdentifier!]!.feeCode;
-            const res = await checkOnChainPricing(
-              dexHelper,
-              uniswapV3,
-              'quoteExactOutputSingle',
-              blockNumber,
-              '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
-              price.prices,
-              TokenA.address,
-              TokenB.address,
-              fee,
-              amounts,
-            );
-            if (res === false) falseChecksCounter++;
-          }),
-        );
-
-        expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
-      });
-
-      it('USDC -> DAI getPoolIdentifiers and getPricesVolume SELL', async () => {
-        const amounts = [
-          0n,
-          2n * BI_POWS[6],
-          3n * BI_POWS[6],
-          4n * BI_POWS[6],
-          5n * BI_POWS[6],
-        ];
-
-        const pools = await uniswapV3.getPoolIdentifiers(
-          TokenB,
-          TokenA,
-          SwapSide.SELL,
-          blockNumber,
-        );
-        console.log(
-          `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
-          pools,
-        );
-
-        expect(pools.length).toBeGreaterThan(0);
-
-        const prices = await uniswapV3.getPricesVolume(
-          TokenB,
-          TokenA,
-          amounts,
-          SwapSide.SELL,
-          blockNumber,
-          pools,
-        );
-
-        const poolPrices = prices?.filter(
-          price =>
-            price.poolIdentifier &&
-            price.poolIdentifier.toLowerCase() ===
-              'UniswapV3_0x6b175474e89094c44da98b954eedeac495271d0f_0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48_10000'.toLowerCase(),
-        );
-
-        console.log(
-          `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
-          poolPrices,
-        );
+    const TokenBSymbol = 'USDC';
+    const TokenB = Tokens[network][TokenBSymbol];
 
-        expect(poolPrices).not.toBeNull();
-        // checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+    const amountsBuy = [
+      0n,
+      6000000n,
+      12000000n,
+      18000000n,
+      24000000n,
+      30000000n,
+      36000000n,
+      42000000n,
+      48000000n,
+      54000000n,
+      60000000n,
+      66000000n,
+      72000000n,
+      78000000n,
+      84000000n,
+      90000000n,
+      96000000n,
+      102000000n,
+      108000000n,
+      114000000n,
+      120000000n,
+      126000000n,
+      132000000n,
+      138000000n,
+      144000000n,
+      150000000n,
+      156000000n,
+      162000000n,
+      168000000n,
+      174000000n,
+      180000000n,
+      186000000n,
+      192000000n,
+      198000000n,
+      204000000n,
+      210000000n,
+      216000000n,
+      222000000n,
+      228000000n,
+      234000000n,
+      240000000n,
+      246000000n,
+      252000000n,
+      258000000n,
+      264000000n,
+      270000000n,
+      276000000n,
+      282000000n,
+      288000000n,
+      294000000n,
+      300000000n,
+    ];
 
-        let falseChecksCounter = 0;
-        await Promise.all(
-          poolPrices!.map(async price => {
-            const fee = uniswapV3.eventPools[price.poolIdentifier!]!.feeCode;
-            const res = await checkOnChainPricing(
-              dexHelper,
-              uniswapV3,
-              'quoteExactInputSingle',
-              blockNumber,
-              '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
-              price.prices,
-              TokenB.address,
-              TokenA.address,
-              fee,
-              amounts,
-            );
-            if (res === false) falseChecksCounter++;
-          }),
-        );
+    const pools = await uniswapV3.getPoolIdentifiers(
+      TokenA,
+      TokenB,
+      SwapSide.BUY,
+      blockNumber,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `, pools);
 
-        expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
-      });
+    expect(pools.length).toBeGreaterThan(0);
 
-      it('USDC -> DAI getPoolIdentifiers and getPricesVolume BUY', async () => {
-        const amounts = [
-          0n,
-          1n * BI_POWS[17],
-          5n * BI_POWS[17],
-          5n * BI_POWS[17],
-          6n * BI_POWS[17],
-          7n * BI_POWS[17],
-          8n * BI_POWS[17],
-          9n * BI_POWS[17],
-          1n * BI_POWS[18],
-          2n * BI_POWS[18],
-          3n * BI_POWS[18],
-        ];
-
-        const pools = await uniswapV3.getPoolIdentifiers(
-          TokenB,
-          TokenA,
-          SwapSide.BUY,
-          blockNumber,
-        );
-        console.log(
-          `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
-          pools,
-        );
+    const poolPrices = await uniswapV3.getPricesVolume(
+      TokenA,
+      TokenB,
+      amountsBuy,
+      SwapSide.BUY,
+      blockNumber,
+      pools,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `, poolPrices);
 
-        expect(pools.length).toBeGreaterThan(0);
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(
+      poolPrices!.filter(pp => pp.unit !== 0n),
+      amountsBuy,
+      SwapSide.BUY,
+      dexKey,
+    );
 
-        const prices = await uniswapV3.getPricesVolume(
-          TokenB,
-          TokenA,
-          amounts,
-          SwapSide.BUY,
+    // Check if onchain pricing equals to calculated ones
+    let falseChecksCounter = 0;
+    await Promise.all(
+      poolPrices!.map(async price => {
+        const fee = uniswapV3.eventPools[price.poolIdentifier!]!.feeCode;
+        const res = await checkOnChainPricing(
+          dexHelper,
+          uniswapV3,
+          'quoteExactOutputSingle',
           blockNumber,
-          pools,
-        );
-
-        const poolPrices = prices?.filter(
-          price =>
-            price.poolIdentifier &&
-            price.poolIdentifier.toLowerCase() ===
-              'UniswapV3_0x6b175474e89094c44da98b954eedeac495271d0f_0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48_10000'.toLowerCase(),
-        );
-
-        console.log(
-          `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
-          poolPrices,
-        );
-
-        expect(poolPrices).not.toBeNull();
-        // checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
-
-        let falseChecksCounter = 0;
-        await Promise.all(
-          poolPrices!.map(async price => {
-            const fee = uniswapV3.eventPools[price.poolIdentifier!]!.feeCode;
-            const res = await checkOnChainPricing(
-              dexHelper,
-              uniswapV3,
-              'quoteExactOutputSingle',
-              blockNumber,
-              '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
-              price.prices,
-              TokenB.address,
-              TokenA.address,
-              fee,
-              amounts,
-            );
-            if (res === false) falseChecksCounter++;
-          }),
+          '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
+          price.prices,
+          TokenA.address,
+          TokenB.address,
+          fee,
+          amountsBuy,
         );
-
-        expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
-      });
-    });
+        if (res === false) falseChecksCounter++;
+      }),
+    );
+    expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
   });
 
-  describe('Arbitrum', () => {
-    beforeEach(async () => {
-      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
-      uniswapV3 = new UniswapV3(network, dexKey, dexHelper);
-      uniswapV3Mainnet = new UniswapV3(
-        Network.ARBITRUM,
-        dexKey,
-        new DummyDexHelper(Network.ARBITRUM),
-      );
-    });
-
-    it('getPoolIdentifiers and getPricesVolume SELL', async function () {
-      const pools = await uniswapV3.getPoolIdentifiers(
-        TokenA,
-        TokenB,
-        SwapSide.SELL,
-        blockNumber,
-      );
-      console.log(
-        `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
-        pools,
-      );
-
-      expect(pools.length).toBeGreaterThan(0);
-
-      const poolPrices = await uniswapV3.getPricesVolume(
-        TokenA,
-        TokenB,
-        amounts,
-        SwapSide.SELL,
-        blockNumber,
-        pools,
-      );
-      console.log(
-        `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
-        poolPrices,
-      );
-
-      expect(poolPrices).not.toBeNull();
-      checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
-
-      let falseChecksCounter = 0;
-      await Promise.all(
-        poolPrices!.map(async price => {
-          const fee = uniswapV3.eventPools[price.poolIdentifier!]!.feeCode;
-          const res = await checkOnChainPricing(
-            dexHelper,
-            uniswapV3,
-            'quoteExactInputSingle',
-            blockNumber,
-            '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
-            price.prices,
-            TokenA.address,
-            TokenB.address,
-            fee,
-            amounts,
-          );
-          if (res === false) falseChecksCounter++;
-        }),
-      );
-
-      expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
-    });
-
-    it('getPoolIdentifiers and getPricesVolume BUY', async function () {
-      const pools = await uniswapV3.getPoolIdentifiers(
-        TokenA,
-        TokenB,
-        SwapSide.BUY,
-        blockNumber,
-      );
-      console.log(
-        `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
-        pools,
-      );
-
-      expect(pools.length).toBeGreaterThan(0);
-
-      const poolPrices = await uniswapV3.getPricesVolume(
-        TokenA,
-        TokenB,
-        amountsBuy,
-        SwapSide.BUY,
-        blockNumber,
-        pools,
-      );
-      console.log(
-        `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
-        poolPrices,
-      );
-
-      expect(poolPrices).not.toBeNull();
-      checkPoolPrices(poolPrices!, amountsBuy, SwapSide.BUY, dexKey);
-
-      // Check if onchain pricing equals to calculated ones
-      let falseChecksCounter = 0;
-      await Promise.all(
-        poolPrices!.map(async price => {
-          const fee = uniswapV3.eventPools[price.poolIdentifier!]!.feeCode;
-          const res = await checkOnChainPricing(
-            dexHelper,
-            uniswapV3,
-            'quoteExactOutputSingle',
-            blockNumber,
-            '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
-            price.prices,
-            TokenA.address,
-            TokenB.address,
-            fee,
-            amountsBuy,
-          );
-          if (res === false) falseChecksCounter++;
-        }),
-      );
-      expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
-    });
-
-    it('getPoolIdentifiers and getPricesVolume SELL stable pairs', async function () {
-      const TokenASymbol = 'USDT';
-      const TokenA = Tokens[network][TokenASymbol];
-
-      const TokenBSymbol = 'USDC';
-      const TokenB = Tokens[network][TokenBSymbol];
-
-      const amounts = [
-        0n,
-        6000000n,
-        12000000n,
-        18000000n,
-        24000000n,
-        30000000n,
-        36000000n,
-        42000000n,
-        48000000n,
-        54000000n,
-        60000000n,
-        66000000n,
-        72000000n,
-        78000000n,
-        84000000n,
-        90000000n,
-        96000000n,
-        102000000n,
-        108000000n,
-        114000000n,
-        120000000n,
-        126000000n,
-        132000000n,
-        138000000n,
-        144000000n,
-        150000000n,
-        156000000n,
-        162000000n,
-        168000000n,
-        174000000n,
-        180000000n,
-        186000000n,
-        192000000n,
-        198000000n,
-        204000000n,
-        210000000n,
-        216000000n,
-        222000000n,
-        228000000n,
-        234000000n,
-        240000000n,
-        246000000n,
-        252000000n,
-        258000000n,
-        264000000n,
-        270000000n,
-        276000000n,
-        282000000n,
-        288000000n,
-        294000000n,
-        300000000n,
-      ];
-
-      const pools = await uniswapV3.getPoolIdentifiers(
-        TokenA,
-        TokenB,
-        SwapSide.SELL,
-        blockNumber,
-      );
-      console.log(
-        `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
-        pools,
-      );
-
-      expect(pools.length).toBeGreaterThan(0);
-
-      const poolPrices = await uniswapV3.getPricesVolume(
-        TokenA,
-        TokenB,
-        amounts,
-        SwapSide.SELL,
-        blockNumber,
-        pools,
-      );
-      console.log(
-        `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
-        poolPrices,
-      );
-
-      expect(poolPrices).not.toBeNull();
-      checkPoolPrices(
-        poolPrices!.filter(pp => pp.unit !== 0n),
-        amounts,
-        SwapSide.SELL,
-        dexKey,
-      );
-
-      // Check if onchain pricing equals to calculated ones
-      let falseChecksCounter = 0;
-      await Promise.all(
-        poolPrices!.map(async price => {
-          const fee = uniswapV3.eventPools[price.poolIdentifier!]!.feeCode;
-          const res = await checkOnChainPricing(
-            dexHelper,
-            uniswapV3,
-            'quoteExactInputSingle',
-            blockNumber,
-            '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
-            price.prices,
-            TokenA.address,
-            TokenB.address,
-            fee,
-            amounts,
-          );
-          if (res === false) falseChecksCounter++;
-        }),
-      );
-      expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
-    });
-
-    it('getPoolIdentifiers and getPricesVolume BUY stable pairs', async function () {
-      const TokenASymbol = 'DAI';
-      const TokenA = Tokens[network][TokenASymbol];
-
-      const TokenBSymbol = 'USDC';
-      const TokenB = Tokens[network][TokenBSymbol];
-
-      const amountsBuy = [
-        0n,
-        6000000n,
-        12000000n,
-        18000000n,
-        24000000n,
-        30000000n,
-        36000000n,
-        42000000n,
-        48000000n,
-        54000000n,
-        60000000n,
-        66000000n,
-        72000000n,
-        78000000n,
-        84000000n,
-        90000000n,
-        96000000n,
-        102000000n,
-        108000000n,
-        114000000n,
-        120000000n,
-        126000000n,
-        132000000n,
-        138000000n,
-        144000000n,
-        150000000n,
-        156000000n,
-        162000000n,
-        168000000n,
-        174000000n,
-        180000000n,
-        186000000n,
-        192000000n,
-        198000000n,
-        204000000n,
-        210000000n,
-        216000000n,
-        222000000n,
-        228000000n,
-        234000000n,
-        240000000n,
-        246000000n,
-        252000000n,
-        258000000n,
-        264000000n,
-        270000000n,
-        276000000n,
-        282000000n,
-        288000000n,
-        294000000n,
-        300000000n,
-      ];
-
-      const pools = await uniswapV3.getPoolIdentifiers(
-        TokenA,
-        TokenB,
-        SwapSide.BUY,
-        blockNumber,
-      );
-      console.log(
-        `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
-        pools,
-      );
-
-      expect(pools.length).toBeGreaterThan(0);
-
-      const poolPrices = await uniswapV3.getPricesVolume(
-        TokenA,
-        TokenB,
-        amountsBuy,
-        SwapSide.BUY,
-        blockNumber,
-        pools,
-      );
-      console.log(
-        `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
-        poolPrices,
-      );
-
-      expect(poolPrices).not.toBeNull();
-      checkPoolPrices(
-        poolPrices!.filter(pp => pp.unit !== 0n),
-        amountsBuy,
-        SwapSide.BUY,
-        dexKey,
-      );
-
-      // Check if onchain pricing equals to calculated ones
-      let falseChecksCounter = 0;
-      await Promise.all(
-        poolPrices!.map(async price => {
-          const fee = uniswapV3.eventPools[price.poolIdentifier!]!.feeCode;
-          const res = await checkOnChainPricing(
-            dexHelper,
-            uniswapV3,
-            'quoteExactOutputSingle',
-            blockNumber,
-            '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
-            price.prices,
-            TokenA.address,
-            TokenB.address,
-            fee,
-            amountsBuy,
-          );
-          if (res === false) falseChecksCounter++;
-        }),
-      );
-      expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
-    });
-
-    it('getTopPoolsForToken', async function () {
-      const poolLiquidity = await uniswapV3Mainnet.getTopPoolsForToken(
-        Tokens[Network.MAINNET]['USDC'].address,
-        10,
-      );
-      console.log(`${TokenASymbol} Top Pools:`, poolLiquidity);
+  it('getTopPoolsForToken', async function () {
+    const poolLiquidity = await uniswapV3Mainnet.getTopPoolsForToken(
+      Tokens[Network.MAINNET]['USDC'].address,
+      10,
+    );
+    console.log(`${TokenASymbol} Top Pools:`, poolLiquidity);
 
-      if (!uniswapV3.hasConstantPriceLargeAmounts) {
-        checkPoolsLiquidity(poolLiquidity, TokenA.address, dexKey);
-      }
-    });
+    if (!uniswapV3.hasConstantPriceLargeAmounts) {
+      checkPoolsLiquidity(poolLiquidity, TokenA.address, dexKey);
+    }
   });
 });