@paraswap/dex-lib 2.42.30-smardex → 2.42.31

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/smardex/config.ts

@@ -13,14 +13,6 @@ export const SmardexConfig: DexConfigMap<DexParams> = {
     [Network.MAINNET]: {
       factoryAddress: '0xB878DC600550367e14220d4916Ff678fB284214F',
       router: '0xC33984ABcAe20f47a754eF78f6526FeF266c0C6F',
-      legacyInitCode:
-        '0xb477a06204165d50e6d795c7c216306290eff5d6015f8b65bb46002a8775b548',
-      legacyPairs: [
-        '0xd2bf378cea07fe117ffdfd3f5b7e53c2b0b78c05',
-        '0xf3a4b8efe3e3049f6bc71b47ccb7ce6665420179',
-        '0xe547ff1c20a6fb24f4afc20a3a02c6d7b0210799',
-        '0xd2df60073c0a9c0b607ca6ac809acecc0d9250bd',
-      ],
       initCode: MAINNET_INIT_HASH,
       subgraphURL: `${GATEWAY_SUBGRAPH}/ethereum`,
     },

package/src/dex/smardex/constants.ts

@@ -29,7 +29,7 @@ export const SUBGRAPH_TIMEOUT = 20 * 1000;
 
 export const DefaultSmardexPoolGasCost = 130 * 1000;
 
-export const FEES_LEGACY_LAYER_ONE: SmardexFees = {
+export const FEES_LAYER_ONE: SmardexFees = {
   feesLP: 500n,
   feesPool: 200n,
 };

package/src/dex/smardex/sdk/utils.ts

@@ -1,5 +1,7 @@
 import { parseUnits } from 'ethers/lib/utils';
 
+import { CurrencyAmount, Trade } from './types';
+
 // Constants to compute approximate equality
 const APPROX_EQ_PRECISION = 1n;
 const APPROX_EQ_BASE_PRECISION = 1000000n;

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

@@ -79,39 +79,27 @@ describe('SmarDex E2E', () => {
       [
         {
           name: 'USDT',
-          sellAmount: '1200000000', // USDT to sell
-          buyAmount: '1200000000000000000000000', // SDEX to buy
+          sellAmount: '1200000000',
+          buyAmount: '120000',
         },
         {
           name: 'SDEX',
-          sellAmount: '300000000000000000000000', // SDEX to sell
-          buyAmount: '30000000000', // USDT to buy
+          sellAmount: '300000000000000000000000',
+          buyAmount: '30000000000',
         },
       ],
       [
         {
           name: 'SDEX',
           sellAmount: '300000000000000000000000',
-          buyAmount: '3000000000',
+          buyAmount: '30000000000',
         },
         {
           name: 'ETH',
           sellAmount: '11000000000000000',
-          buyAmount: '1100000000000000000000000',
+          buyAmount: '1100000000',
         },
       ],
-      [
-        {
-          name: 'WASSIE',
-          sellAmount: '567000789000000000000000000',
-          buyAmount: '1200000000000000000',
-        },
-        {
-          name: 'WETH',
-          sellAmount: '1200000000000000000',
-          buyAmount: '567000789000000000000000000',
-        },
-      ]
     ];
 
     testForNetwork(network, dexKey, pairs);
@@ -125,7 +113,7 @@ describe('SmarDex E2E', () => {
         {
           name: 'USDC',
           sellAmount: '1200000000',
-          buyAmount: '1200000000000000000000000',
+          buyAmount: '120000',
         },
         {
           name: 'SDEX',
@@ -137,12 +125,12 @@ describe('SmarDex E2E', () => {
         {
           name: 'SDEX',
           sellAmount: '300000000000000000000000',
-          buyAmount: '800000000000000000',
+          buyAmount: '11000000000000000',
         },
         {
           name: 'ETH',
           sellAmount: '11000000000000000',
-          buyAmount: '1100000000000000000000000',
+          buyAmount: '11000000',
         },
       ],
     ];
@@ -235,6 +223,18 @@ describe('SmarDex E2E', () => {
           buyAmount: '2500000000',
         },
       ],
+      [
+        {
+          name: 'SDEX',
+          sellAmount: '190000000000000000000000',
+          buyAmount: '8000000',
+        },
+        {
+          name: 'WBTC',
+          sellAmount: '8000000',
+          buyAmount: '190000000000000000000000',
+        },
+      ],
     ];
 
     testForNetwork(network, dexKey, pairs);
@@ -245,7 +245,6 @@ describe('SmarDex E2E', () => {
 
     const pairs = [
       [
-        // Success when holder has enough balance. eg: USDbC: '0x13a13869b814be8f13b86e9875ab51bda882e391'
         {
           name: 'WETH',
           sellAmount: '1500000000000000000',

package/src/dex/smardex/smardex-event-pool.ts

@@ -4,7 +4,7 @@ import { AbiCoder, Interface } from '@ethersproject/abi';
 import { IDexHelper } from '../../dex-helper';
 import { Address, Log, Logger, Token } from '../../types';
 import { DeepReadonly } from 'ts-essentials';
-import { FEES_LEGACY_LAYER_ONE, TOPICS } from './constants';
+import { FEES_LAYER_ONE, TOPICS } from './constants';
 
 const coder = new AbiCoder();
 
@@ -21,7 +21,7 @@ export class SmardexEventPool extends StatefulEventSubscriber<SmardexPoolState>
       callData: string;
     },
     protected smardexFeesMulticallDecoder?: (values: any[]) => SmardexFees,
-    private legacyPairs?: string[],
+    private isLayerOne = true,
   ) {
     super('Smardex', `${token0.address}_${token1.address}`, dexHelper, logger);
   }
@@ -37,8 +37,7 @@ export class SmardexEventPool extends StatefulEventSubscriber<SmardexPoolState>
         callData: this.poolInterface.encodeFunctionData('getPriceAverage', []),
       },
     ];
-    const isLegacyPool = this.legacyPairs?.includes(this.poolAddress.toLowerCase());
-    if (!isLegacyPool) {
+    if (!this.isLayerOne) {
       calldata.push(this.smardexFeesMultiCallEntry!);
     }
 
@@ -52,8 +51,8 @@ export class SmardexEventPool extends StatefulEventSubscriber<SmardexPoolState>
       data.returnData[0],
     )[2];
 
-    const fees = isLegacyPool
-      ? FEES_LEGACY_LAYER_ONE
+    const fees = this.isLayerOne
+      ? FEES_LAYER_ONE
       : this.smardexFeesMulticallDecoder!(data.returnData[1]);
     return {
       feesLP: fees.feesLP,
@@ -87,7 +86,7 @@ export class SmardexEventPool extends StatefulEventSubscriber<SmardexPoolState>
           feesLP: fetchedSync.feesLP,
           feesPool: fetchedSync.feesPool,
         };
-      case 'FeesChanged':
+      case 'FeesChanged': // only triggerd on L2
         return {
           reserves0: state.reserves0,
           reserves1: state.reserves1,
@@ -124,8 +123,7 @@ export class SmardexEventPool extends StatefulEventSubscriber<SmardexPoolState>
         callData: this.poolInterface.encodeFunctionData('getPriceAverage', []),
       },
     ];
-    const isLegacyPool = this.legacyPairs?.includes(this.poolAddress.toLowerCase());
-    if (!isLegacyPool) {
+    if (!this.isLayerOne) {
       calldata.push(this.smardexFeesMultiCallEntry!);
     }
 
@@ -147,8 +145,8 @@ export class SmardexEventPool extends StatefulEventSubscriber<SmardexPoolState>
     const [priceAverage0, priceAverage1, priceAverageLastTimestamp] =
       coder.decode(['uint256', 'uint256', 'uint256'], data.returnData[2]);
 
-    const fees = isLegacyPool
-      ? FEES_LEGACY_LAYER_ONE
+    const fees = this.isLayerOne
+      ? FEES_LAYER_ONE
       : this.smardexFeesMulticallDecoder!(data.returnData[3]);
 
     return {

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

@@ -4,7 +4,8 @@ import { Interface } from '@ethersproject/abi';
 import { Tokens } from '../../../tests/constants-e2e';
 dotenv.config();
 
-import SmardexPoolABI from '../../abi/smardex/smardex-pool.json';
+import SmardexPoolLayerOneABI from '../../abi/smardex/layer-1/smardex-pool.json';
+import SmardexPoolLayerTwoABI from '../../abi/smardex/layer-2/smardex-pool.json';
 import { Smardex } from './smardex';
 import { SmardexEventPool } from './smardex-event-pool';
 import { Network } from '../../constants';
@@ -49,7 +50,7 @@ const NETWORK_CONFIGS: NetworkConfig[] = [
           ],
           ['Burn']: [17231921, 17762042, 17762668],
           ['Mint']: [17739609, 17973926, 18062443],
-          // ['FeesChanged']: [], // none on Legacy pair
+          // ['FeesChanged']: [], // none on L1
           ['Sync']: [
             18064045,
             18064060,
@@ -60,6 +61,7 @@ const NETWORK_CONFIGS: NetworkConfig[] = [
           ['Transfer']: [18064025, 18064045, 18065266],
         },
       },
+
       {
         address: '0xf3a4B8eFe3e3049F6BC71B47ccB7Ce6665420179',
         symbol0: 'SDEX',
@@ -74,7 +76,7 @@ const NETWORK_CONFIGS: NetworkConfig[] = [
           ],
           ['Burn']: [18114357, 18089610, 18026115],
           ['Mint']: [18115825, 18109975, 18093408],
-          // ['FeesChanged']: [], // none on Legacy pair
+          // ['FeesChanged']: [], // none on L1
           ['Sync']: [
             18120396,
             18120367, // multiple Sync events
@@ -85,24 +87,6 @@ const NETWORK_CONFIGS: NetworkConfig[] = [
           ['Transfer']: [18108643, 18105778, 18105793],
         },
       },
-      {
-        // New pool created after the Factory migration (it has configurable fees enabled)
-        address: '0xf178ADc7D707Cea43FBB3206b3364CB416F044A2',
-        symbol0: 'WASSIE',
-        symbol1: 'WETH',
-        events: {
-          ['Swap']: [18588928, 18572677, 18571765],
-          ['Burn']: [18572334, 18569122],
-          ['Mint']: [18571808, 18688592],
-          ['FeesChanged']: [18562522],
-          ['Sync']: [
-            18588928, 18572677, 18572334, 18571808, 18571765, 18569122,
-          ],
-          ['Transfer']: [
-            18588928, 18572677, 18572334, 18571808, 18571765, 18569122,
-          ],
-        },
-      },
     ],
   },
   {
@@ -131,7 +115,7 @@ const NETWORK_CONFIGS: NetworkConfig[] = [
           ['Swap']: [47448993, 47449888, 47449861, 47448993, 47449214],
           ['Burn']: [47434291, 47433030, 47426957],
           ['Mint']: [47354112, 47268128, 47252146],
-          ['FeesChanged']: [50575166],
+          ['FeesChanged']: [], // Fees didn't change on this pool
           ['Sync']: [47448993, 47449888, 47449861, 47448993, 47449214],
           ['Transfer']: [47338250, 47338178, 47333469],
         },
@@ -151,7 +135,7 @@ const NETWORK_CONFIGS: NetworkConfig[] = [
           ['Swap']: [130424308, 130422563, 130418994, 130415253, 130382808],
           ['Burn']: [129969327, 129138853, 126200497],
           ['Mint']: [130028302, 129940404, 129728771],
-          ['FeesChanged']: [117755384],
+          ['FeesChanged']: [], // Fees didn't change on this pool
           ['Sync']: [130424308, 130422563, 130418994, 130415253, 130382808],
           ['Transfer']: [130028373, 129918802, 129668897],
         },
@@ -164,7 +148,7 @@ const NETWORK_CONFIGS: NetworkConfig[] = [
           ['Swap']: [130429535, 130419879, 130417306, 130414469, 130416990],
           ['Burn']: [130200966, 127933595, 125698828],
           ['Mint']: [130263032, 130331095, 128594710],
-          ['FeesChanged']: [155564828],
+          ['FeesChanged']: [], // Fees didn't change on this pool
           ['Sync']: [130429535, 130419879, 130417306, 130414469, 130416990],
           ['Transfer']: [130423567, 130423514, 130331095],
         },
@@ -197,7 +181,7 @@ const NETWORK_CONFIGS: NetworkConfig[] = [
           ['Swap']: [31678534, 31675409, 31678534, 31675014, 31674391],
           ['Burn']: [31666734, 31586726, 31462652],
           ['Mint']: [31662048, 31554796, 31524123],
-          ['FeesChanged']: [33946671],
+          ['FeesChanged']: [], // Fees didn't change on this pool
           ['Sync']: [31678534, 31675409, 31678534, 31675014, 31674391],
           ['Transfer']: [31666734, 31632200, 31586970],
         },
@@ -271,7 +255,11 @@ NETWORK_CONFIGS.forEach(({ name, network, pools, tokens }) => {
               const smardex = new Smardex(network, dexKey, dexHelper);
               const multicall = smardex.getFeesMultiCallData(poolAddress);
               const SmardexPool = new SmardexEventPool(
-                new Interface(SmardexPoolABI),
+                new Interface(
+                  smardex.isLayer1()
+                    ? SmardexPoolLayerOneABI
+                    : SmardexPoolLayerTwoABI,
+                ),
                 dexHelper,
                 poolAddress,
                 token0,
@@ -279,7 +267,7 @@ NETWORK_CONFIGS.forEach(({ name, network, pools, tokens }) => {
                 logger,
                 multicall?.callEntry,
                 multicall?.callDecoder,
-                smardex.legacyPairs,
+                smardex.isLayer1(),
               );
 
               // It is done in generateState. But here have to make it manually

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

@@ -70,7 +70,7 @@ const networkConfigs: Array<NetworkConfig> = [
         src: 'SDEX',
         dest: 'WBTC',
         sell: [0, 100_000, 200_000, 300_000],
-        buy: [0, 1, 2],
+        buy: [0, 1, 2, 3],
       },
       {
         src: 'ARB',
@@ -237,18 +237,12 @@ networkConfigs.forEach(({ name, network, tokens, tokenPairs }) => {
 
     it('getTopPoolsForToken', async () => {
       const smardex = new Smardex(network, dexKey, dexHelper);
-      // Initialize all smardex pairs
-      for (const pair of tokenPairs) {
-        await smardex.findPair(tokens[pair.src], tokens[pair.dest]);
-      }
       // Get all distinct tokens of the pairs
       const distinctTokens = tokenPairs
         .reduce((acc, pair) => [...acc, pair.src, pair.dest], [] as string[])
         .filter((value, index, self) => self.indexOf(value) === index)
         // Native token doesn't have a pool, avoid it
         .filter(token => tokens[token].address !== ETHER_ADDRESS);
-      // First getTopPoolsForToken for reserves caching (at least 1 token initializes the whole cache)
-      await smardex.getTopPoolsForToken(tokens['USDC'].address, 10);
       // Get top pools for each token and check liquidity
       await Promise.all(
         distinctTokens.map(async token =>

package/src/dex/smardex/smardex.ts

@@ -20,25 +20,28 @@ import {
   SimpleExchangeParam,
   Token,
   TransferFeeParams,
+  TxInfo,
 } from '../../types';
 import { IDexHelper } from '../../dex-helper/index';
 import {
   SmardexFees,
   SmardexPair,
+  SmardexPool,
   SmardexPoolOrderedParams,
   SmardexPoolState,
 } from './types';
 import { getBigIntPow, getDexKeysWithNetwork, isETHAddress } from '../../utils';
-import SmardexFactoryABI from '../../abi/smardex/smardex-factory.json';
-import SmardexPoolABI from '../../abi/smardex/smardex-pool.json';
-import SmardexRouterABI from '../../abi/smardex/smardex-router.json';
+import SmardexFactoryLayerOneABI from '../../abi/smardex/layer-1/smardex-factory.json';
+import SmardexFactoryLayerTwoABI from '../../abi/smardex/layer-2/smardex-factory.json';
 
+import SmardexRouterABI from '../../abi/smardex/all/smardex-router.json';
 import { SimpleExchange } from '../simple-exchange';
 import {
   SmardexRouterFunctions,
   directSmardexFunctionName,
   DefaultSmardexPoolGasCost,
-  FEES_LEGACY_LAYER_ONE,
+  SUBGRAPH_TIMEOUT,
+  FEES_LAYER_ONE,
 } from '../smardex/constants';
 import { SmardexData, SmardexParam } from '../smardex/types';
 import { IDex } from '../..';
@@ -48,12 +51,24 @@ import ParaSwapABI from '../../abi/IParaswap.json';
 import { applyTransferFee } from '../../lib/token-transfer-fee';
 import { computeAmountIn, computeAmountOut } from './sdk/core';
 import { SmardexEventPool } from './smardex-event-pool';
-import { USDReservesService } from './usd-reserves';
+import SmardexPoolLayerOneABI from '../../abi/smardex/layer-1/smardex-pool.json';
+import SmardexPoolLayerTwoABI from '../../abi/smardex/layer-2/smardex-pool.json';
 
-const smardexPool = new Interface(SmardexPoolABI);
+const smardexPoolL1 = new Interface(SmardexPoolLayerOneABI);
+const smardexPoolL2 = new Interface(SmardexPoolLayerTwoABI);
 
 const coder = new AbiCoder();
 
+function encodePools(pools: SmardexPool[]): NumberAsString[] {
+  return pools.map(({ fee, direction, address }) => {
+    return (
+      (BigInt(fee) << 161n) +
+      ((direction ? 0n : 1n) << 160n) +
+      BigInt(address)
+    ).toString();
+  });
+}
+
 export class Smardex
   extends SimpleExchange
   implements IDex<SmardexData, SmardexParam>
@@ -70,22 +85,13 @@ export class Smardex
 
   protected subgraphURL: string | undefined;
   protected initCode: string;
-  protected legacyInitCode: string;
-
-  public legacyPairs: string[];
 
   logger: Logger;
   readonly hasConstantPriceLargeAmounts = false;
-  readonly isFeeOnTransferSupported: boolean = false;
+  readonly isFeeOnTransferSupported: boolean = true;
   readonly SRC_TOKEN_DEX_TRANSFERS = 1;
   readonly DEST_TOKEN_DEX_TRANSFERS = 1;
 
-  // Constants for top pools caching
-  readonly CACHED_RESERVES_USD_TTL = 3000;
-  readonly CACHED_RESERVES_USD_KEY = 'cachedReservesUSD';
-
-  readonly usdReserves: USDReservesService;
-
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
     getDexKeysWithNetwork(SmardexConfig);
 
@@ -102,21 +108,15 @@ export class Smardex
     this.factoryAddress = config[network].factoryAddress;
     this.subgraphURL = config[network].subgraphURL;
     this.initCode = config[network].initCode;
-    this.legacyInitCode = config[network].legacyInitCode || '';
-    this.legacyPairs = config[network].legacyPairs || [];
-    const factoryAbi = SmardexFactoryABI;
+    const factoryAbi = this.isLayer1()
+      ? SmardexFactoryLayerOneABI
+      : SmardexFactoryLayerTwoABI;
     this.factory = new dexHelper.web3Provider.eth.Contract(
       factoryAbi as any,
       this.factoryAddress,
     );
     this.routerInterface = new Interface(ParaSwapABI);
     this.exchangeRouterInterface = new Interface(SmardexRouterABI);
-    this.usdReserves = new USDReservesService(
-      this.dexKey,
-      this.network,
-      this.dexHelper,
-      this.subgraphURL!,
-    );
   }
 
   getAdapters(side: SwapSide): { name: string; index: number }[] | null {
@@ -237,9 +237,7 @@ export class Smardex
             router: this.routerAddress,
             path: [from.address.toLowerCase(), to.address.toLowerCase()],
             factory: this.factoryAddress,
-            initCode: this.legacyPairs.includes(pairParam.exchange)
-              ? this.legacyInitCode
-              : this.initCode,
+            initCode: this.initCode,
             pools: [
               {
                 address: pairParam.exchange,
@@ -420,15 +418,18 @@ export class Smardex
 
   // On Smardex the fees are upgradable on layer 2.
   public getFeesMultiCallData(pairAddress: string) {
-    if (this.legacyPairs.includes(pairAddress.toLowerCase())) {
+    if (this.isLayer1()) {
       return null;
     }
     const callEntry = {
       target: pairAddress,
-      callData: smardexPool.encodeFunctionData('getPairFees'),
+      callData: smardexPoolL2.encodeFunctionData('getPairFees'),
     };
     const callDecoder = (values: any[]): SmardexFees => {
-      const feesData = smardexPool.decodeFunctionResult('getPairFees', values);
+      const feesData = smardexPoolL2.decodeFunctionResult(
+        'getPairFees',
+        values,
+      );
       return {
         feesLP: feesData.feesLP_.toBigInt(),
         feesPool: feesData.feesPool_.toBigInt(),
@@ -455,15 +456,16 @@ export class Smardex
   ) {
     const multiCallFeeData = this.getFeesMultiCallData(pair.exchange!);
     pair.pool = new SmardexEventPool(
-      smardexPool,
+      this.isLayer1() ? smardexPoolL1 : smardexPoolL2,
       this.dexHelper,
       pair.exchange!,
       pair.token0,
       pair.token1,
       this.logger,
+      // For layer 2 we need to fetch the fees
       multiCallFeeData?.callEntry,
       multiCallFeeData?.callDecoder,
-      this.legacyPairs,
+      this.isLayer1(),
     );
     pair.pool.addressesSubscribed.push(pair.exchange!);
 
@@ -495,20 +497,19 @@ export class Smardex
           let calldata = [
             {
               target: pair.exchange!,
-              callData: smardexPool.encodeFunctionData('getReserves'),
+              callData: smardexPoolL1.encodeFunctionData('getReserves'),
             },
             {
               target: pair.exchange!,
-              callData: smardexPool.encodeFunctionData('getFictiveReserves'),
+              callData: smardexPoolL1.encodeFunctionData('getFictiveReserves'),
             },
             {
               target: pair.exchange!,
-              callData: smardexPool.encodeFunctionData('getPriceAverage'),
+              callData: smardexPoolL1.encodeFunctionData('getPriceAverage'),
             },
           ];
-          // Exclude legacy pairs from fees call
-          !this.legacyPairs.includes(pair.exchange!.toLowerCase()) &&
-            calldata.push(multiCallFeeData[i]!.callEntry);
+          // Fetch fees only on layer 2
+          !this.isLayer1() && calldata.push(multiCallFeeData[i]!.callEntry);
           return calldata;
         })
         .flat();
@@ -541,11 +542,11 @@ export class Smardex
         priceAverageLastTimestamp: coder
           .decode(['uint256', 'uint256', 'uint256'], returnData[i][2])[2]
           .toString(),
-        feesLP: this.legacyPairs.includes(_pair.exchange!.toLowerCase())
-          ? FEES_LEGACY_LAYER_ONE.feesLP
+        feesLP: this.isLayer1()
+          ? FEES_LAYER_ONE.feesLP
           : multiCallFeeData[i]!.callDecoder(returnData[i][3]).feesLP,
-        feesPool: this.legacyPairs.includes(_pair.exchange!.toLowerCase())
-          ? FEES_LEGACY_LAYER_ONE.feesPool
+        feesPool: this.isLayer1()
+          ? FEES_LAYER_ONE.feesPool
           : multiCallFeeData[i]!.callDecoder(returnData[i][3]).feesPool,
       }));
     } catch (e) {
@@ -687,36 +688,83 @@ export class Smardex
     );
   }
 
+  isLayer1(): boolean {
+    return this.network === Network.MAINNET;
+  }
+
   async getTopPoolsForToken(
     tokenAddress: Address,
     limit: number,
   ): Promise<PoolLiquidity[]> {
-    tokenAddress = tokenAddress.toLowerCase();
-    const liquidityPromises = Object.values(this.pairs)
-      .filter(
-        pair =>
-          pair.token0.address.toLowerCase() === tokenAddress ||
-          pair.token1.address.toLowerCase() === tokenAddress,
-      )
-      .filter(pair => pair.exchange)
-      .map(async pair => {
-        const usdReserve = await this.usdReserves.getUSDReserveForPair(
-          pair.exchange!,
-        );
-        return {
-          exchange: this.dexKey,
-          address: pair.exchange!,
-          liquidityUSD: usdReserve,
-          connectorTokens: [
-            tokenAddress === pair.token0.address.toLowerCase()
-              ? pair.token1
-              : pair.token0,
-          ],
-        };
-      });
-    const resolvedLiquidity = await Promise.all(liquidityPromises);
-    return resolvedLiquidity
-      .sort((a, b) => b.liquidityUSD - a.liquidityUSD)
-      .slice(0, limit);
+    if (!this.subgraphURL) return [];
+    const query = `
+      query ($token: Bytes!, $limit: Int) {
+        pools0: pairs(first: $limit, orderBy: reserveUSD, orderDirection: desc, where: {token0: $token, reserve0_gt: 1, reserve1_gt: 1}) {
+        id
+        token0 {
+          id
+          decimals
+        }
+        token1 {
+          id
+          decimals
+        }
+        reserveUSD
+      }
+      pools1: pairs(first: $limit, orderBy: reserveUSD, orderDirection: desc, where: {token1: $token, reserve0_gt: 1, reserve1_gt: 1}) {
+        id
+        token0 {
+          id
+          decimals
+        }
+        token1 {
+          id
+          decimals
+        }
+        reserveUSD
+      }
+    }`;
+
+    const { data } = await this.dexHelper.httpRequest.post(
+      this.subgraphURL,
+      {
+        query,
+        variables: { token: tokenAddress.toLowerCase(), limit },
+      },
+      SUBGRAPH_TIMEOUT,
+      { 'x-api-key': this.dexHelper.config.data.smardexSubgraphAuthToken! },
+    );
+
+    if (!(data && data.pools0 && data.pools1))
+      throw new Error("Couldn't fetch the pools from the subgraph");
+    const pools0 = _.map(data.pools0, pool => ({
+      exchange: this.dexKey,
+      address: pool.id.toLowerCase(),
+      connectorTokens: [
+        {
+          address: pool.token1.id.toLowerCase(),
+          decimals: parseInt(pool.token1.decimals),
+        },
+      ],
+      liquidityUSD: parseFloat(pool.reserveUSD),
+    }));
+
+    const pools1 = _.map(data.pools1, pool => ({
+      exchange: this.dexKey,
+      address: pool.id.toLowerCase(),
+      connectorTokens: [
+        {
+          address: pool.token0.id.toLowerCase(),
+          decimals: parseInt(pool.token0.decimals),
+        },
+      ],
+      liquidityUSD: parseFloat(pool.reserveUSD),
+    }));
+
+    return _.slice(
+      _.sortBy(_.concat(pools0, pools1), [pool => -1 * pool.liquidityUSD]),
+      0,
+      limit,
+    );
   }
 }