@paraswap/dex-lib 2.42.30 → 2.42.32

package/src/dex/camelot/camelot-pool-discovery.test.ts

@@ -0,0 +1,149 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { Network, SwapSide } from '../../constants';
+import { DummyDexHelper } from '../../dex-helper';
+import { BlockHeader } from 'web3-eth';
+import { Camelot } from './camelot';
+import { CamelotConfig } from './config';
+import { Log } from 'web3-core';
+
+const network = Network.ARBITRUM;
+const dexKey = 'Camelot';
+
+interface Pool {
+  startBlockNumber: number;
+  endBlockNumber: number;
+  address: string;
+  srcToken: { address: string; decimals: number };
+  destToken: { address: string; decimals: number };
+}
+
+const factoryAddress = CamelotConfig[dexKey][network].factoryAddress;
+const blockHeaders: Record<number, BlockHeader> = {};
+
+const pools: Pool[] = [
+  {
+    address: '0x19d51dc52e52407656b40b197b1bbe14294b955b',
+    startBlockNumber: 162099096,
+    endBlockNumber: 162099098,
+    srcToken: {
+      address: `0x82aF49447D8a07e3bd95BD0d56f35241523fBab1`,
+      decimals: 18,
+    },
+    destToken: {
+      address: '0x939727d85D99d0aC339bF1B76DfE30Ca27C19067',
+      decimals: 18,
+    },
+  },
+  {
+    address: '0x8b5c25d5f9be67dc6243e2fafcb36ec10ba54aa2',
+    startBlockNumber: 163124111,
+    endBlockNumber: 163124113,
+    srcToken: {
+      address: `0x82aF49447D8a07e3bd95BD0d56f35241523fBab1`,
+      decimals: 18,
+    },
+    destToken: {
+      address: '0x38CC4c71425e9aB6B0A6Ec4240121598efE08398',
+      decimals: 18,
+    },
+  },
+];
+
+function groupAndSortLogsByBlockNumber(logsToDispatch: any[]): {
+  logsByBlockNumber: Record<number, any[]>;
+  sortedBlocks: number[];
+} {
+  const logsByBlockNumber: Record<number, any[]> = {};
+  for (let log of logsToDispatch) {
+    if (!logsByBlockNumber[log.blockNumber]) {
+      logsByBlockNumber[log.blockNumber] = [];
+    }
+    logsByBlockNumber[log.blockNumber].push(log);
+  }
+
+  const sortedBlocks = Object.keys(logsByBlockNumber)
+    .map(Number)
+    .sort((a, b) => Number(a) - Number(b));
+
+  return { logsByBlockNumber, sortedBlocks };
+}
+
+async function testPoolDiscovery(pool: Pool) {
+  const { startBlockNumber, endBlockNumber, srcToken, destToken, address } =
+    pool;
+  describe(`${address}: from ${startBlockNumber} to ${endBlockNumber}`, () => {
+    const dexHelper = new DummyDexHelper(network);
+    const camelot = new Camelot(network, dexKey, dexHelper);
+
+    let logsByBlockNumber: Record<number, Log[]> = {};
+    let sortedBlocks: number[] = [];
+
+    it('should have pair created event', async () => {
+      const logsToDispatch = await dexHelper.provider.getLogs({
+        fromBlock: startBlockNumber,
+        toBlock: endBlockNumber,
+        address: factoryAddress,
+      });
+
+      expect(logsToDispatch.length).toBe(1);
+
+      const groupedLogs = groupAndSortLogsByBlockNumber(logsToDispatch);
+      logsByBlockNumber = groupedLogs.logsByBlockNumber;
+      sortedBlocks = groupedLogs.sortedBlocks;
+    });
+
+    it('prices before pool discovery should be empty', async () => {
+      // override default block to force camelot.factory.call() use block before pool was created
+      camelot.factory.defaultBlock = startBlockNumber;
+      const pricesBeforePoolDiscovery = await camelot.getPricesVolume(
+        srcToken,
+        destToken,
+        [10000000000000000000n, 10000000000000000000n],
+        SwapSide.SELL,
+        startBlockNumber,
+      );
+
+      // prices before pool created should not be available
+      expect(pricesBeforePoolDiscovery).toBe(null);
+    });
+
+    it('prices after pool discovery should not be empty', async () => {
+      // @ts-ignore
+      // initialize factory state
+      await camelot.factoryInst?.initialize(startBlockNumber);
+
+      for (let blockNumber of sortedBlocks) {
+        if (!blockHeaders[blockNumber]) {
+          blockHeaders[blockNumber] = await dexHelper.web3Provider.eth.getBlock(
+            blockNumber,
+          );
+        }
+
+        // override default block to force camelot.factory.call() use specific block
+        camelot.factory.defaultBlock = blockNumber;
+
+        // @ts-ignore
+        // emit PairCreated event for factory
+        await camelot.factoryInst?.update(logsByBlockNumber[blockNumber], {
+          [blockNumber]: blockHeaders[blockNumber],
+        });
+      }
+
+      const pricesAfterPoolDiscovery = await camelot.getPricesVolume(
+        srcToken,
+        destToken,
+        [10000000000000000000n, 10000000000000000000n],
+        SwapSide.SELL,
+        endBlockNumber,
+      );
+
+      expect(pricesAfterPoolDiscovery).not.toBe(null);
+    });
+  });
+}
+
+describe(`Test ${dexKey} pool discovery`, () => {
+  pools.forEach(pool => testPoolDiscovery(pool));
+});

package/src/dex/index.ts

@@ -38,7 +38,6 @@ import { Excalibur } from './uniswap-v2/excalibur';
 import { MakerPsm } from './maker-psm/maker-psm';
 import { KyberDmm } from './kyberdmm/kyberdmm';
 import { Platypus } from './platypus/platypus';
-//import { Wombat } from './wombat/wombat';
 import { GMX } from './gmx/gmx';
 import { WooFiV2 } from './woo-fi-v2/woo-fi-v2';
 import { ParaSwapLimitOrders } from './paraswap-limit-orders/paraswap-limit-orders';
@@ -83,6 +82,7 @@ import { QuickPerps } from './quick-perps/quick-perps';
 import { NomiswapV2 } from './uniswap-v2/nomiswap-v2';
 import { Dexalot } from './dexalot/dexalot';
 import { Smardex } from './smardex/smardex';
+import { Wombat } from './wombat/wombat';
 
 const LegacyDexes = [
   CurveV2,
@@ -162,7 +162,7 @@ const Dexes = [
   NomiswapV2,
   SolidlyV3,
   Smardex,
-  //Wombat,
+  Wombat,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

package/src/dex/wombat/utils.ts

@@ -60,3 +60,23 @@ export const uint120ToBigInt = (
 ): bigint => {
   return generalDecoder(result, ['uint120'], 0n, value => value[0].toBigInt());
 };
+
+export function convertUint256ToInt256(uint256Value: bigint): bigint {
+  const isNegative =
+    (uint256Value &
+      BigInt(
+        '0x8000000000000000000000000000000000000000000000000000000000000000',
+      )) !==
+    BigInt(0);
+
+  if (isNegative) {
+    return (
+      uint256Value -
+      BigInt(
+        '0x10000000000000000000000000000000000000000000000000000000000000000',
+      )
+    );
+  } else {
+    return uint256Value;
+  }
+}

package/src/dex/wombat/wombat-bmw.ts

@@ -10,7 +10,7 @@ import { IDexHelper } from '../../dex-helper';
 import { BmwState } from './types';
 import BmwABI from '../../abi/wombat/bmw.json';
 import AssetABI from '../../abi/wombat/asset.json';
-import PoolABI from '../../abi/wombat/pool.json';
+import PoolABI from '../../abi/wombat/pool-v2.json';
 
 export class WombatBmw extends StatefulEventSubscriber<BmwState> {
   static readonly bmwInterface = new Interface(BmwABI);
@@ -36,13 +36,12 @@ export class WombatBmw extends StatefulEventSubscriber<BmwState> {
     protected bmwAddress: Address,
     protected onAssetAdded: (
       pool: Address,
-      asset2TokenMap: Map<Address, Address>,
       blockNumber: number,
     ) => Promise<void>,
   ) {
     super(
-      `${dexKey} ${name}`,
-      `${dexKey}-${network} ${name}`,
+      `${dexKey}-${name}`,
+      `${dexKey}-${network}-${name}`,
       dexHelper,
       logger,
     );
@@ -118,11 +117,6 @@ export class WombatBmw extends StatefulEventSubscriber<BmwState> {
 
     inputs = [];
     for (const lpToken of lpTokens) {
-      inputs.push({
-        target: lpToken,
-        callData:
-          WombatBmw.assetInterface.encodeFunctionData('underlyingToken'),
-      });
       inputs.push({
         target: lpToken,
         callData: WombatBmw.assetInterface.encodeFunctionData('pool'),
@@ -135,26 +129,20 @@ export class WombatBmw extends StatefulEventSubscriber<BmwState> {
         .call({}, blockNumber)
     ).returnData;
 
-    const pool2AssetInfo = new Map<Address, Map<Address, Address>>();
+    const poolAddressSet = new Set<Address>();
     let i = 0;
     for (const lpToken of lpTokens) {
-      const underlyingToken = WombatBmw.assetInterface
-        .decodeFunctionResult('underlyingToken', returnData[i++])[0]
-        .toLowerCase();
       const pool = WombatBmw.assetInterface
         .decodeFunctionResult('pool', returnData[i++])[0]
         .toLowerCase();
 
-      if (!pool2AssetInfo.has(pool)) {
-        pool2AssetInfo.set(pool, new Map<Address, Address>());
-      }
-      pool2AssetInfo.get(pool)!.set(lpToken, underlyingToken);
+      poolAddressSet.add(pool);
     }
 
     const promises: Promise<void>[] = [];
-    pool2AssetInfo.forEach((asset2TokenMap, pool) => {
+    poolAddressSet.forEach(pool => {
       bmwState.pools.push(pool);
-      promises.push(this.onAssetAdded(pool, asset2TokenMap, blockNumber));
+      promises.push(this.onAssetAdded(pool, blockNumber));
     });
     await Promise.all(promises);
 
@@ -173,10 +161,6 @@ export class WombatBmw extends StatefulEventSubscriber<BmwState> {
       target: lpToken,
       callData: WombatBmw.assetInterface.encodeFunctionData('pool'),
     });
-    multiCallInputs.push({
-      target: lpToken,
-      callData: WombatBmw.assetInterface.encodeFunctionData('underlyingToken'),
-    });
 
     const returnData = (
       await this.dexHelper.multiContract.methods
@@ -187,15 +171,8 @@ export class WombatBmw extends StatefulEventSubscriber<BmwState> {
     const pool = WombatBmw.assetInterface
       .decodeFunctionResult('pool', returnData[0])[0]
       .toLowerCase();
-    const underlyingToken = WombatBmw.assetInterface
-      .decodeFunctionResult('underlyingToken', returnData[1])[0]
-      .toLowerCase();
 
-    await this.onAssetAdded(
-      pool,
-      new Map<Address, Address>().set(lpToken, underlyingToken),
-      log.blockNumber,
-    );
+    await this.onAssetAdded(pool, log.blockNumber);
     if (!state.pools.includes(pool)) {
       return {
         pools: [...state.pools, pool],

package/src/dex/wombat/wombat-e2e.test.ts

@@ -172,7 +172,7 @@ describe('Wombat E2E', () => {
           buyAmount: '1000000000000000000',
         },
         {
-          name: 'wstETH',
+          name: 'frxETH',
           sellAmount: '1000000000000000000',
           buyAmount: '1000000000000000000',
         },
@@ -252,6 +252,18 @@ describe('Wombat E2E', () => {
           buyAmount: '100000000',
         },
       ],
+      [
+        {
+          name: 'ETH',
+          sellAmount: '100000000000000000',
+          buyAmount: '100000000000000000',
+        },
+        {
+          name: 'frxETH',
+          sellAmount: '100000000000000000',
+          buyAmount: '100000000000000000',
+        },
+      ],
     ];
 
     testForNetwork(network, dexKey, pairs);

package/src/dex/wombat/wombat-events.test.ts

@@ -0,0 +1,147 @@
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+import { DeepReadonly } from 'ts-essentials';
+import { WombatPool } from './wombat-pool';
+import { Network } from '../../constants';
+import { Address } from '../../types';
+import { DummyDexHelper } from '../../dex-helper';
+import { BmwState, PoolState } from './types';
+import { WombatConfig } from './config';
+import { Wombat } from './wombat';
+import { WombatBmw } from './wombat-bmw';
+import { testEventSubscriber } from '../../../tests/utils-events';
+
+jest.setTimeout(100 * 1000);
+
+async function fetchPoolState(
+  wombatPool: WombatPool,
+  blockNumber: number,
+): Promise<DeepReadonly<PoolState>> {
+  return await wombatPool.generateState(blockNumber);
+}
+
+async function fetchBmwState(
+  wombatBmw: WombatBmw,
+  blockNumber: number,
+): Promise<DeepReadonly<BmwState>> {
+  return await wombatBmw.generateState(blockNumber);
+}
+
+// eventName -> blockNumbers
+type EventMappings = Record<string, number[]>;
+
+describe('Wombat EventPool BSC', function () {
+  const dexKey = 'Wombat';
+  const network = Network.BSC;
+  const dexHelper = new DummyDexHelper(network);
+  const logger = dexHelper.getLogger(dexKey);
+  const v2Pool = '0x9498563e47D7CFdFa22B818bb8112781036c201C'; // stable guild pool
+  const v3Pool = '0x1ee15673e07105Bcf360139fa8CafeBDd7754BeF'; // cross chain pool
+  const eventsToTest: Record<Address, EventMappings> = {
+    [v2Pool]: {
+      // topic0: 0xf5dd9317b9e63ac316ce44acc85f670b54b339cfa3e9076e1dd55065b922314b
+      ['Deposit']: [34556359, 34556365, 34558365],
+      // topic0: 0xfb80d861da582b723be2d19507ce3e03851820c464abea89156ec77e089b1ad9
+      ['Withdraw']: [34208250, 34262795, 34549292],
+      // topic0: 0x54787c404bb33c88e86f4baf88183a3b0141d0a848e6a9f7a13b66ae3a9b73d1
+      ['Swap']: [34588909, 34590323, 34593343, 34600568, 34602207],
+      ['SetAmpFactor']: [],
+      ['SetHaircutRate']: [],
+      // topic0: 0x0bb5715f0f217c2fe9a0c877ea87d474380c641102f3440ee2a4c8b9d9790918
+      ['AssetAdded']: [28050075],
+      // topic0: 0x0fa1e4606af435f32f05b3804033d2933e691fab32ee74d2db6fa82d2741f1ea
+      ['AssetRemoved']: [34463362],
+      // topic0: 0x4941e18a2bcbb0f9fa0081238f26793a8ad8c202b913ae8bf5f7e523f68ff137
+      ['FillPool']: [],
+      ['Paused']: [34342956],
+      // topic0: 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa
+      ['Unpaused']: [34463362],
+      // topic0: 0xdcb65c0553aaa433aadd180404ff195259c48f78aa50f877ebcb4bb215129a4e
+      ['PausedAsset']: [34463362],
+      ['UnpausedAsset']: [],
+    },
+    [v3Pool]: {
+      // topic0: 0xf5dd9317b9e63ac316ce44acc85f670b54b339cfa3e9076e1dd55065b922314b
+      ['Deposit']: [34558302, 34564573, 34597601],
+      // // topic0: 0xfb80d861da582b723be2d19507ce3e03851820c464abea89156ec77e089b1ad9
+      ['Withdraw']: [34567962, 34569797, 34596990],
+      // // topic0: 0x7fa01e8d24e5a6ec56e00b4ff8ee7ed97e7650a7846ec494bbaa5d65f1be9ea4
+      ['SwapV2']: [34609776, 34610336, 34610364, 34611146, 34611872],
+      // topic0: 0x0fa1e4606af435f32f05b3804033d2933e691fab32ee74d2db6fa82d2741f1ea
+      ['AssetRemoved']: [34463362],
+    },
+  };
+
+  for (const [poolAddress, events] of Object.entries(eventsToTest)) {
+    describe(`Events for ${poolAddress}`, () => {
+      for (const [eventName, blockNumbers] of Object.entries(events)) {
+        describe(`${eventName}`, () => {
+          for (const blockNumber of blockNumbers) {
+            it(`State after ${blockNumber}`, async function () {
+              const wombatPool = new WombatPool(
+                dexKey,
+                poolAddress,
+                network,
+                dexHelper,
+                logger,
+                poolAddress.toLowerCase(),
+              );
+              await wombatPool.initialize(blockNumber - 1);
+
+              await testEventSubscriber(
+                wombatPool,
+                wombatPool.addressesSubscribed,
+                (_blockNumber: number) =>
+                  fetchPoolState(wombatPool, _blockNumber),
+                blockNumber,
+                `${dexKey}_${poolAddress}`,
+                dexHelper.provider,
+              );
+            });
+          }
+        });
+      }
+    });
+  }
+});
+describe('Wombat BMW ARB', function () {
+  const dexKey = 'Wombat';
+  const network = Network.ARBITRUM;
+  const dexHelper = new DummyDexHelper(network);
+  const bmwAddress = WombatConfig.Wombat[network].bmwAddress;
+  const eventsToTest: Record<Address, EventMappings> = {
+    [bmwAddress]: {
+      // topic0: 0xec85b1d1f037ff3a8722aaf5d4d8e7d93c7ff10c056430c18d76a9ec23aa397e
+      ['Add']: [158157042, 162173973],
+    },
+  };
+
+  const wombat = new Wombat(network, dexKey, dexHelper);
+
+  for (const [poolAddress, events] of Object.entries(eventsToTest)) {
+    describe(`Events for ${poolAddress}`, () => {
+      for (const [eventName, blockNumbers] of Object.entries(events)) {
+        describe(`${eventName}`, () => {
+          for (const blockNumber of blockNumbers) {
+            it(`State after ${blockNumber}`, async function () {
+              if (wombat.initializePricing) {
+                await wombat.initializePricing(blockNumber);
+              }
+              await testEventSubscriber(
+                wombat.bmw,
+                wombat.bmw.addressesSubscribed,
+                (_blockNumber: number) =>
+                  fetchBmwState(wombat.bmw, _blockNumber),
+                blockNumber,
+                `${dexKey}_${bmwAddress}`,
+                dexHelper.provider,
+              );
+            });
+          }
+        });
+      }
+    });
+  }
+});

package/src/dex/wombat/wombat-integration.test.ts

@@ -3,15 +3,11 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 import { Interface, Result } from '@ethersproject/abi';
-import { DummyDexHelper } from '../../dex-helper/index';
+import { DummyDexHelper } from '../../dex-helper';
 import { Network, SwapSide } from '../../constants';
 import { BI_POWS } from '../../bigint-constants';
 import { Wombat } from './wombat';
-import {
-  checkPoolPrices,
-  checkPoolsLiquidity,
-  checkConstantPoolPrices,
-} from '../../../tests/utils';
+import { checkPoolPrices, checkConstantPoolPrices } from '../../../tests/utils';
 import { Tokens } from '../../../tests/constants-e2e';
 import { Token } from '../../types';
 import { Address } from '@paraswap/core';
@@ -150,109 +146,72 @@ describe('Wombat', function () {
   let blockNumber: number;
   let wombat: Wombat;
 
-  //   Object.keys(WombatConfig[dexKey]).forEach(key => {
-  //     describe(`network ${key}`, () => {
-  //       const network = Number(key) as Network;
-  //       const dexHelper = new DummyDexHelper(network);
-
-  //       const tokens = Tokens[network];
-
-  //       const srcTokenSymbol = 'USDC';
-  //       const destTokenSymbol = network == Network.BASE ? 'USDbC' : 'USDT';
-
-  //       let amountsForSell = [
-  //         0n,
-  //         1n * BI_POWS[tokens[srcTokenSymbol].decimals],
-  //         2n * BI_POWS[tokens[srcTokenSymbol].decimals],
-  //         3n * BI_POWS[tokens[srcTokenSymbol].decimals],
-  //         4n * BI_POWS[tokens[srcTokenSymbol].decimals],
-  //         5n * BI_POWS[tokens[srcTokenSymbol].decimals],
-  //         6n * BI_POWS[tokens[srcTokenSymbol].decimals],
-  //         7n * BI_POWS[tokens[srcTokenSymbol].decimals],
-  //         8n * BI_POWS[tokens[srcTokenSymbol].decimals],
-  //         9n * BI_POWS[tokens[srcTokenSymbol].decimals],
-  //         10n * BI_POWS[tokens[srcTokenSymbol].decimals],
-  //       ];
-
-  //       let amountsForBuy = [
-  //         0n,
-  //         1n * BI_POWS[tokens[destTokenSymbol].decimals],
-  //         2n * BI_POWS[tokens[destTokenSymbol].decimals],
-  //         3n * BI_POWS[tokens[destTokenSymbol].decimals],
-  //         4n * BI_POWS[tokens[destTokenSymbol].decimals],
-  //         5n * BI_POWS[tokens[destTokenSymbol].decimals],
-  //         6n * BI_POWS[tokens[destTokenSymbol].decimals],
-  //         7n * BI_POWS[tokens[destTokenSymbol].decimals],
-  //         8n * BI_POWS[tokens[destTokenSymbol].decimals],
-  //         9n * BI_POWS[tokens[destTokenSymbol].decimals],
-  //         10n * BI_POWS[tokens[destTokenSymbol].decimals],
-  //       ];
-
-  //       // OPTIMISM has very low liquidity currently, so we have to use very small amounts
-  //       // if (network === Network.OPTIMISM) {
-  //       //   amountsForSell = amountsForSell.map(a => a / 100n);
-  //       //   amountsForBuy = amountsForBuy.map(a => a / 100n);
-  //       // }
-
-  //       beforeAll(async () => {
-  //         blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
-  //         wombat = new Wombat(network, dexKey, dexHelper);
-  //       });
-
-  //       it('getTopPoolsForToken', async function () {
-  //         // We have to check without calling initializePricing, because
-  //         // pool-tracker is not calling that function
-  //         if (wombat.updatePoolState) {
-  //           await wombat.updatePoolState();
-  //         }
-  //         const poolLiquidity = await wombat.getTopPoolsForToken(
-  //           tokens[srcTokenSymbol].address,
-  //           10,
-  //         );
-  //         console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
-
-  //         if (!wombat.hasConstantPriceLargeAmounts) {
-  //           checkPoolsLiquidity(
-  //             poolLiquidity,
-  //             Tokens[network][srcTokenSymbol].address,
-  //             dexKey,
-  //           );
-  //         }
-  //       });
-
-  //       it('getPoolIdentifiers and getPricesVolume SELL', async function () {
-  //         if (wombat.initializePricing) {
-  //           await wombat.initializePricing(blockNumber);
-  //         }
-  //         await testPricingOnNetwork(
-  //           wombat,
-  //           network,
-  //           dexKey,
-  //           blockNumber,
-  //           srcTokenSymbol,
-  //           destTokenSymbol,
-  //           SwapSide.SELL,
-  //           amountsForSell,
-  //           'quotePotentialSwap',
-  //         );
-  //       });
-
-  //       it('getPoolIdentifiers and getPricesVolume BUY', async function () {
-  //         if (wombat.initializePricing) {
-  //           await wombat.initializePricing(blockNumber);
-  //         }
-  //         await testPricingOnNetwork(
-  //           wombat,
-  //           network,
-  //           dexKey,
-  //           blockNumber,
-  //           srcTokenSymbol,
-  //           destTokenSymbol,
-  //           SwapSide.BUY,
-  //           amountsForBuy,
-  //           'quotePotentialSwap',
-  //         );
-  //       });
-  //     });
-  //   });
+  Object.keys(WombatConfig[dexKey]).forEach(key => {
+    describe(`network ${key}`, () => {
+      const network = Number(key) as Network;
+      const dexHelper = new DummyDexHelper(network);
+
+      const tokens = Tokens[network];
+
+      const srcTokenSymbol = 'USDC';
+      const destTokenSymbol = network == Network.BASE ? 'USDbC' : 'USDT';
+
+      let amountsForSell = [
+        0n,
+        1n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        2n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        3n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        4n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        5n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        6n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        7n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        8n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        9n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        10n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      ];
+
+      beforeAll(async () => {
+        blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        wombat = new Wombat(network, dexKey, dexHelper);
+      });
+
+      // it('getTopPoolsForToken', async function () {
+      //   // We have to check without calling initializePricing, because
+      //   // pool-tracker is not calling that function
+      //   if (wombat.updatePoolState) {
+      //     await wombat.updatePoolState();
+      //   }
+      //   const poolLiquidity = await wombat.getTopPoolsForToken(
+      //     tokens[srcTokenSymbol].address,
+      //     10,
+      //   );
+      //   console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
+      //
+      //   if (!wombat.hasConstantPriceLargeAmounts) {
+      //     checkPoolsLiquidity(
+      //       poolLiquidity,
+      //       Tokens[network][srcTokenSymbol].address,
+      //       dexKey,
+      //     );
+      //   }
+      // });
+
+      it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+        if (wombat.initializePricing) {
+          await wombat.initializePricing(blockNumber);
+        }
+        await testPricingOnNetwork(
+          wombat,
+          network,
+          dexKey,
+          blockNumber,
+          srcTokenSymbol,
+          destTokenSymbol,
+          SwapSide.SELL,
+          amountsForSell,
+          'quotePotentialSwap',
+        );
+      });
+    });
+  });
 });