@paraswap/dex-lib 2.36.0 → 2.36.2-cache-invalidation

package/src/dex/algebra/algebra.ts

@@ -38,14 +38,15 @@ import {
 import { AlgebraMath } from './lib/AlgebraMath';
 import { AlgebraEventPoolV1_1 } from './algebra-pool-v1_1';
 import { AlgebraEventPoolV1_9 } from './algebra-pool-v1_9';
+import { AlgebraFactory, OnPoolCreatedCallback } from './algebra-factory';
 
 type PoolPairsInfo = {
   token0: Address;
   token1: Address;
 };
 
-const ALGEBRA_CLEAN_NOT_EXISTING_POOL_TTL_MS = 3 * 60 * 60 * 1000; // 3 hours
-const ALGEBRA_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS = 30 * 60 * 1000; // Once in 30 minutes
+const ALGEBRA_CLEAN_NOT_EXISTING_POOL_TTL_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
+const ALGEBRA_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS = 24 * 60 * 60 * 1000; // Once in a day
 const ALGEBRA_EFFICIENCY_FACTOR = 3;
 const ALGEBRA_TICK_GAS_COST = 24_000; // Ceiled
 const ALGEBRA_TICK_BASE_OVERHEAD = 75_000;
@@ -59,6 +60,7 @@ const MAX_STALE_STATE_BLOCK_AGE = {
 type IAlgebraEventPool = AlgebraEventPoolV1_1 | AlgebraEventPoolV1_9;
 
 export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
+  private readonly factory: AlgebraFactory;
   readonly isFeeOnTransferSupported: boolean = false;
   protected eventPools: Record<string, IAlgebraEventPool | null> = {};
 
@@ -114,6 +116,14 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
 
     this.AlgebraPoolImplem =
       config.version === 'v1.1' ? AlgebraEventPoolV1_1 : AlgebraEventPoolV1_9;
+
+    this.factory = new AlgebraFactory(
+      dexHelper,
+      dexKey,
+      this.config.factory,
+      this.logger,
+      this.onPoolCreatedDeleteFromNonExistingSet.bind(this),
+    );
   }
 
   getAdapters(side: SwapSide): { name: string; index: number }[] | null {
@@ -126,13 +136,13 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
   }
 
   async initializePricing(blockNumber: number) {
-    const cleanNonExistingPoolTTLMs =
-      this.config.cleanExistingPoolTTLMs ||
-      ALGEBRA_CLEAN_NOT_EXISTING_POOL_TTL_MS;
+    // Init listening to new pools creation
+    await this.factory.initialize(blockNumber);
 
     if (!this.dexHelper.config.isSlave) {
       const cleanExpiredNotExistingPoolsKeys = async () => {
-        const maxTimestamp = Date.now() - cleanNonExistingPoolTTLMs;
+        const maxTimestamp =
+          Date.now() - ALGEBRA_CLEAN_NOT_EXISTING_POOL_TTL_MS;
         await this.dexHelper.cache.zremrangebyscore(
           this.notExistingPoolSetKey,
           0,
@@ -147,6 +157,37 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
     }
   }
 
+  /*
+   * When a non existing pool is queried, it's blacklisted for an arbitrary long period in order to prevent issuing too many rpc calls
+   * Once the pool is created, it gets immediately flagged
+   */
+  onPoolCreatedDeleteFromNonExistingSet: OnPoolCreatedCallback = async ({
+    token0,
+    token1,
+  }) => {
+    const logPrefix = '[Algebra.onPoolCreatedDeleteFromNonExistingSet]';
+    const [_token0, _token1] = this._sortTokens(token0, token1);
+    const poolKey = `${token0}_${token1}`.toLowerCase();
+
+    // consider doing it only from master pool for less calls to distant cache
+
+    // delete entry locally to let local instance discover the pool
+    delete this.eventPools[this.getPoolIdentifier(_token0, _token1)];
+
+    try {
+      this.logger.info(
+        `${logPrefix} delete pool from not existing set: ${poolKey}`,
+      );
+      // delete pool record from set
+      await this.dexHelper.cache.zrem(this.notExistingPoolSetKey, [poolKey]);
+    } catch (error) {
+      this.logger.error(
+        `${logPrefix} failed to delete pool from set: ${poolKey}`,
+        error,
+      );
+    }
+  };
+
   async getPool(
     srcAddress: Address,
     destAddress: Address,

package/src/dex/algebra/config.ts

@@ -83,7 +83,6 @@ export const AlgebraConfig: DexConfigMap<DexParams> = {
       uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
       deployer: '0x6dd3fb9653b10e806650f107c3b5a0a6ff974f65',
       version: 'v1.9',
-      cleanExistingPoolTTLMs: 20 * 60 * 1000,
     },
   },
 };

package/src/dex/algebra/types.ts

@@ -51,6 +51,8 @@ export type PoolState_v1_9 = {
   areTicksCompressed: boolean;
 };
 
+export type FactoryState = Record<string, never>;
+
 export type AlgebraData = {
   path: {
     tokenIn: Address;
@@ -73,7 +75,6 @@ export type DexParams = {
   version: 'v1.1' | 'v1.9';
   forceRPC?: boolean;
   forceManualStateGenerate?: boolean;
-  cleanExistingPoolTTLMs?: number;
 };
 
 export type IAlgebraPoolState = PoolStateV1_1 | PoolState_v1_9;

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

@@ -2,7 +2,11 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 import { testE2E } from '../../../tests/utils-e2e';
-import { Holders, NativeTokenSymbols, Tokens } from '../../../tests/constants-e2e';
+import {
+  Holders,
+  NativeTokenSymbols,
+  Tokens,
+} from '../../../tests/constants-e2e';
 import { ContractMethod, Network, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 
@@ -37,13 +41,7 @@ function testForNetwork(
         ContractMethod.megaSwap,
       ],
     ],
-    [
-      SwapSide.BUY,
-      [
-        ContractMethod.simpleBuy,
-        ContractMethod.buy,
-      ],
-    ],
+    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
   ]);
 
   describe(`${network}`, () => {

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

@@ -80,5 +80,5 @@ export const Adapters: Record<number, AdapterMappings> = {
   [Network.BASE]: {
     [SwapSide.SELL]: [{ name: 'BaseAdapter01', index: 4 }],
     [SwapSide.BUY]: [{ name: 'BaseBuyAdapter', index: 3 }],
-  }
+  },
 };

package/src/dex/curve-v1/config.ts

@@ -939,44 +939,46 @@ export const CurveV1Config: DexConfigMap<DexParams> = {
           isMetapool: false,
           baseToken: '0x321162Cd933E2Be498Cd2267a90534A804051b11',
         },
-        main_gDAI_gUSDC_gUSDT: {
-          underlying: [
-            '0x8D11eC38a3EB5E956B052f67Da8Bdc9bef8Abf3E', // DAI
-            '0x04068DA6C83AFCFA0e13ba15A6696662335D5B75', // USDC
-            '0x049d68029688eAbF473097a2fC38ef61633A3C7A', // fUSDT
-          ],
-          coins: [
-            '0x07E6332dD090D287d3489245038daF987955DCFB', // gDAI
-            '0xe578C856933D8e1082740bf7661e379Aa2A30b26', // gUSDC
-            '0x940F41F0ec9ba1A34CF001cc03347ac092F5F6B5', // gUSDT
-          ],
-          address: '0x0fa949783947Bf6c1b171DB13AEACBB488845B3f',
-          name: 'main_gDAI_gUSDC_gUSDT',
-          type: 2,
-          version: 3,
-          isLending: true,
-          isMetapool: false,
-          baseToken: '0x8D11eC38a3EB5E956B052f67Da8Bdc9bef8Abf3E',
-        },
-        main_iDAI_iUSDC_iFUSDT: {
-          underlying: [
-            '0x8D11eC38a3EB5E956B052f67Da8Bdc9bef8Abf3E', // DAI
-            '0x04068DA6C83AFCFA0e13ba15A6696662335D5B75', // USDC
-            '0x049d68029688eAbF473097a2fC38ef61633A3C7A', // fUSDT
-          ],
-          coins: [
-            '0x04c762a5dF2Fa02FE868F25359E0C259fB811CfE', // iDAI
-            '0x328A7b4d538A2b3942653a9983fdA3C12c571141', // iUSDC
-            '0x70faC71debfD67394D1278D98A29dea79DC6E57A', // iFUSDT
-          ],
-          address: '0x4FC8D635c3cB1d0aa123859e2B2587d0FF2707b1',
-          name: 'main_iDAI_iUSDC_iFUSDT',
-          type: 2,
-          version: 3,
-          isLending: true,
-          isMetapool: false,
-          baseToken: '0x8D11eC38a3EB5E956B052f67Da8Bdc9bef8Abf3E',
-        },
+        // Disabled pool
+        // main_gDAI_gUSDC_gUSDT: {
+        //   underlying: [
+        //     '0x8D11eC38a3EB5E956B052f67Da8Bdc9bef8Abf3E', // DAI
+        //     '0x04068DA6C83AFCFA0e13ba15A6696662335D5B75', // USDC
+        //     '0x049d68029688eAbF473097a2fC38ef61633A3C7A', // fUSDT
+        //   ],
+        //   coins: [
+        //     '0x07E6332dD090D287d3489245038daF987955DCFB', // gDAI
+        //     '0xe578C856933D8e1082740bf7661e379Aa2A30b26', // gUSDC
+        //     '0x940F41F0ec9ba1A34CF001cc03347ac092F5F6B5', // gUSDT
+        //   ],
+        //   address: '0x0fa949783947Bf6c1b171DB13AEACBB488845B3f',
+        //   name: 'main_gDAI_gUSDC_gUSDT',
+        //   type: 2,
+        //   version: 3,
+        //   isLending: true,
+        //   isMetapool: false,
+        //   baseToken: '0x8D11eC38a3EB5E956B052f67Da8Bdc9bef8Abf3E',
+        // },
+        // Disabled pool
+        // main_iDAI_iUSDC_iFUSDT: {
+        //   underlying: [
+        //     '0x8D11eC38a3EB5E956B052f67Da8Bdc9bef8Abf3E', // DAI
+        //     '0x04068DA6C83AFCFA0e13ba15A6696662335D5B75', // USDC
+        //     '0x049d68029688eAbF473097a2fC38ef61633A3C7A', // fUSDT
+        //   ],
+        //   coins: [
+        //     '0x04c762a5dF2Fa02FE868F25359E0C259fB811CfE', // iDAI
+        //     '0x328A7b4d538A2b3942653a9983fdA3C12c571141', // iUSDC
+        //     '0x70faC71debfD67394D1278D98A29dea79DC6E57A', // iFUSDT
+        //   ],
+        //   address: '0x4FC8D635c3cB1d0aa123859e2B2587d0FF2707b1',
+        //   name: 'main_iDAI_iUSDC_iFUSDT',
+        //   type: 2,
+        //   version: 3,
+        //   isLending: true,
+        //   isMetapool: false,
+        //   baseToken: '0x8D11eC38a3EB5E956B052f67Da8Bdc9bef8Abf3E',
+        // },
       },
     },
     [Network.AVALANCHE]: {

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

@@ -38,13 +38,7 @@ function testForNetwork(
         ContractMethod.megaSwap,
       ],
     ],
-    [
-      SwapSide.BUY,
-      [
-        ContractMethod.simpleBuy,
-        ContractMethod.buy,
-      ],
-    ],
+    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
   ]);
 
   describe(`${network}`, () => {

package/src/dex/pancakeswap-v3/pancakeswap-v3-e2e.test.ts

@@ -38,13 +38,7 @@ function testForNetwork(
         ContractMethod.megaSwap,
       ],
     ],
-    [
-      SwapSide.BUY,
-      [
-        ContractMethod.simpleBuy,
-        ContractMethod.buy,
-      ],
-    ],
+    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
   ]);
 
   describe(`${network}`, () => {

package/src/dex/pancakeswap-v3/pancakeswap-v3-factory.ts

@@ -0,0 +1,73 @@
+import { Interface } from '@ethersproject/abi';
+import { DeepReadonly } from 'ts-essentials';
+import FactoryABI from '../../abi/pancakeswap-v3/PancakeswapV3Factory.abi.json';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { Address, Log, Logger } from '../../types';
+import { LogDescription } from 'ethers/lib/utils';
+import { FactoryState } from '../uniswap-v3/types';
+
+export type OnPoolCreatedCallback = ({
+  token0,
+  token1,
+  fee,
+}: {
+  token0: string;
+  token1: string;
+  fee: bigint;
+}) => Promise<void>;
+
+/*
+ * "Stateless" event subscriber in order to capture "PoolCreated" event on new pools created.
+ * State is present, but it's a placeholder to actually make the events reach handlers (if there's no previous state - `processBlockLogs` is not called)
+ */
+export class PancakeswapV3Factory extends StatefulEventSubscriber<FactoryState> {
+  handlers: {
+    [event: string]: (event: any) => Promise<void>;
+  } = {};
+
+  logDecoder: (log: Log) => any;
+
+  public readonly factoryIface = new Interface(FactoryABI);
+
+  constructor(
+    readonly dexHelper: IDexHelper,
+    parentName: string,
+    protected readonly factoryAddress: Address,
+    logger: Logger,
+    protected readonly onPoolCreated: OnPoolCreatedCallback,
+    mapKey: string = '',
+  ) {
+    super(parentName, `${parentName} Factory`, dexHelper, logger, true, mapKey);
+
+    this.addressesSubscribed = [factoryAddress];
+
+    this.logDecoder = (log: Log) => this.factoryIface.parseLog(log);
+
+    this.handlers['PoolCreated'] = this.handleNewPool.bind(this);
+  }
+
+  generateState(): FactoryState {
+    return {};
+  }
+
+  protected async processLog(
+    _: DeepReadonly<FactoryState>,
+    log: Readonly<Log>,
+  ): Promise<FactoryState> {
+    const event = this.logDecoder(log);
+    if (event.name in this.handlers) {
+      await this.handlers[event.name](event);
+    }
+
+    return {};
+  }
+
+  async handleNewPool(event: LogDescription) {
+    const token0 = event.args.token0;
+    const token1 = event.args.token1;
+    const fee = event.args.fee;
+
+    await this.onPoolCreated({ token0, token1, fee });
+  }
+}

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

@@ -56,6 +56,10 @@ import {
   DEFAULT_ID_ERC20,
   DEFAULT_ID_ERC20_AS_STRING,
 } from '../../lib/tokens/types';
+import {
+  OnPoolCreatedCallback,
+  PancakeswapV3Factory,
+} from './pancakeswap-v3-factory';
 
 type PoolPairsInfo = {
   token0: Address;
@@ -63,14 +67,15 @@ type PoolPairsInfo = {
   fee: string;
 };
 
-const PANCAKESWAPV3_CLEAN_NOT_EXISTING_POOL_TTL_MS = 60 * 60 * 24 * 1000; // 24 hours
-const PANCAKESWAPV3_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS = 30 * 60 * 1000; // Once in 30 minutes
+const PANCAKESWAPV3_CLEAN_NOT_EXISTING_POOL_TTL_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
+const PANCAKESWAPV3_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS = 24 * 60 * 60 * 1000; // Once in a day
 const PANCAKESWAPV3_QUOTE_GASLIMIT = 200_000;
 
 export class PancakeswapV3
   extends SimpleExchange
   implements IDex<UniswapV3Data>
 {
+  private readonly factory: PancakeswapV3Factory;
   readonly isFeeOnTransferSupported: boolean = false;
   readonly eventPools: Record<string, PancakeSwapV3EventPool | null> = {};
 
@@ -117,6 +122,14 @@ export class PancakeswapV3
 
     this.notExistingPoolSetKey =
       `${CACHE_PREFIX}_${network}_${dexKey}_not_existings_pool_set`.toLowerCase();
+
+    this.factory = new PancakeswapV3Factory(
+      dexHelper,
+      dexKey,
+      this.config.factory,
+      this.logger,
+      this.onPoolCreatedDeleteFromNonExistingSet.bind(this),
+    );
   }
 
   get supportedFees() {
@@ -133,6 +146,9 @@ export class PancakeswapV3
   }
 
   async initializePricing(blockNumber: number) {
+    // Init listening to new pools creation
+    await this.factory.initialize(blockNumber);
+
     if (!this.dexHelper.config.isSlave) {
       const cleanExpiredNotExistingPoolsKeys = async () => {
         const maxTimestamp =
@@ -151,6 +167,38 @@ export class PancakeswapV3
     }
   }
 
+  /*
+   * When a non existing pool is queried, it's blacklisted for an arbitrary long period in order to prevent issuing too many rpc calls
+   * Once the pool is created, it gets immediately flagged
+   */
+  onPoolCreatedDeleteFromNonExistingSet: OnPoolCreatedCallback = async ({
+    token0,
+    token1,
+    fee,
+  }) => {
+    const logPrefix = '[PancakeV3.onPoolCreatedDeleteFromNonExistingSet]';
+    const [_token0, _token1] = this._sortTokens(token0, token1);
+    const poolKey = `${token0}_${token1}_${fee}`.toLowerCase();
+
+    // consider doing it only from master pool for less calls to distant cache
+
+    // delete entry locally to let local instance discover the pool
+    delete this.eventPools[this.getPoolIdentifier(_token0, _token1, fee)];
+
+    try {
+      this.logger.info(
+        `${logPrefix} delete pool from not existing set: ${poolKey}`,
+      );
+      // delete pool record from set
+      await this.dexHelper.cache.zrem(this.notExistingPoolSetKey, [poolKey]);
+    } catch (error) {
+      this.logger.error(
+        `${logPrefix} failed to delete pool from set :${poolKey}`,
+        error,
+      );
+    }
+  };
+
   async getPool(
     srcAddress: Address,
     destAddress: Address,

package/src/dex/quick-perps/pool.ts

@@ -104,6 +104,7 @@ export class QuickPerpsEventPool extends ComposedEventSubscriber<PoolState> {
     const evenState = this.getState(blockNumber);
     if (evenState) return evenState;
     const onChainState = await this.generateState(blockNumber);
+    this.logger.warn(`State is generated in RPC fallback call`);
     this.setState(onChainState, blockNumber);
     return onChainState;
   }
@@ -283,7 +284,8 @@ export class QuickPerpsEventPool extends ComposedEventSubscriber<PoolState> {
     for (let priceFeed of priceFeeds) {
       const api3ServerAddressCallData =
         Api3FeedSubscriber.getApi3ServerV1MultiCallInput(priceFeed);
-      const dataFeedIdCallData = Api3FeedSubscriber.getDataFeedId(priceFeed);
+      const dataFeedIdCallData =
+        Api3FeedSubscriber.getDapiNameHashMultiCallInput(priceFeed);
       multiCallData.push(...[api3ServerAddressCallData, dataFeedIdCallData]);
       multicallSlices.push([i, i + 2]);
       i += 2;
@@ -315,24 +317,31 @@ export class QuickPerpsEventPool extends ComposedEventSubscriber<PoolState> {
       await multiContract.methods.aggregate(multiCallData).call({}, blockNumber)
     ).returnData;
 
-    const api3ServerV1: {
+    const api3ServerV1Prep: {
       [address: string]: {
         proxy: Address;
         api3ServerV1: Address;
-        dataFeedId: string;
       };
     } = {};
+    const getFeedIdRequests: MultiCallInput[] = [];
+
     for (let token of tokens) {
-      const [api3ServerAddressRes, dataFeedIdRes] = configResults.slice(
+      const [api3ServerAddressRes, dapiNameHashRes] = configResults.slice(
         ...multicallSlices.shift()!,
       );
       const serverV1Address =
         Api3FeedSubscriber.decodeApi3ServerV1Result(api3ServerAddressRes);
-      const dataFeedId = Api3FeedSubscriber.decodeDataFeedId(dataFeedIdRes);
-      api3ServerV1[token] = {
+      const dapiNameHash =
+        Api3FeedSubscriber.decodeDapiNameHash(dapiNameHashRes);
+      getFeedIdRequests.push(
+        Api3FeedSubscriber.getFeedIdFromDapiNameHash(
+          serverV1Address,
+          dapiNameHash,
+        ),
+      );
+      api3ServerV1Prep[token] = {
         proxy: priceFeeds.shift(),
         api3ServerV1: serverV1Address,
-        dataFeedId,
       };
     }
 
@@ -355,6 +364,32 @@ export class QuickPerpsEventPool extends ComposedEventSubscriber<PoolState> {
     const vaultConfigResults = configResults.slice(...multicallSlices.shift()!);
     const vaultConfig = Vault.getConfig(vaultConfigResults, tokens);
 
+    const feedIdResults = (
+      await multiContract.methods
+        .aggregate(getFeedIdRequests)
+        .call({}, blockNumber)
+    ).returnData;
+
+    const api3ServerV1: {
+      [address: string]: {
+        proxy: Address;
+        api3ServerV1: Address;
+        dataFeedId: string;
+      };
+    } = {};
+    for (let [i, token] of tokens.entries()) {
+      const { proxy, api3ServerV1: api3ServerAddress } =
+        api3ServerV1Prep[token];
+      const dataFeedId = Api3FeedSubscriber.decodeFeedIdFromDapiNameHash(
+        feedIdResults[i],
+      );
+      api3ServerV1[token] = {
+        proxy,
+        api3ServerV1: api3ServerAddress,
+        dataFeedId,
+      };
+    }
+
     return {
       vaultAddress: dexParams.vault,
       readerAddress: dexParams.reader,

package/src/dex/quick-perps/quick-perps-events.test.ts

@@ -81,7 +81,6 @@ describe('QuickPerps Event', function () {
             dexKey,
             network,
             dexHelper,
-            logger,
             config,
           );
           await testEventSubscriber(

package/src/dex/quick-perps/quick-perps.ts

@@ -117,45 +117,55 @@ export class QuickPerps extends SimpleExchange implements IDex<QuickPerpsData> {
     limitPools?: string[],
   ): Promise<null | ExchangePrices<QuickPerpsData>> {
     if (side === SwapSide.BUY || !this.pool) return null;
-    const srcAddress = this.dexHelper.config
-      .wrapETH(srcToken)
-      .address.toLowerCase();
-    const destAddress = this.dexHelper.config
-      .wrapETH(destToken)
-      .address.toLowerCase();
-    if (
-      srcAddress === destAddress ||
-      !(
-        this.supportedTokensMap[srcAddress] &&
-        this.supportedTokensMap[destAddress]
+    try {
+      const srcAddress = this.dexHelper.config
+        .wrapETH(srcToken)
+        .address.toLowerCase();
+      const destAddress = this.dexHelper.config
+        .wrapETH(destToken)
+        .address.toLowerCase();
+      if (
+        srcAddress === destAddress ||
+        !(
+          this.supportedTokensMap[srcAddress] &&
+          this.supportedTokensMap[destAddress]
+        )
       )
-    )
-      return null;
-    const srcPoolIdentifier = `${this.dexKey}_${srcAddress}`;
-    const destPoolIdentifier = `${this.dexKey}_${destAddress}`;
-    const pools = [srcPoolIdentifier, destPoolIdentifier];
-    if (limitPools && pools.some(p => !limitPools.includes(p))) return null;
+        return null;
+      const srcPoolIdentifier = `${this.dexKey}_${srcAddress}`;
+      const destPoolIdentifier = `${this.dexKey}_${destAddress}`;
+      const pools = [srcPoolIdentifier, destPoolIdentifier];
+      if (limitPools && pools.some(p => !limitPools.includes(p))) return null;
 
-    const unitVolume = getBigIntPow(srcToken.decimals);
-    const prices = await this.pool.getAmountOut(
-      srcAddress,
-      destAddress,
-      [unitVolume, ...amounts],
-      blockNumber,
-    );
+      const unitVolume = getBigIntPow(srcToken.decimals);
+      const prices = await this.pool.getAmountOut(
+        srcAddress,
+        destAddress,
+        [unitVolume, ...amounts],
+        blockNumber,
+      );
 
-    if (!prices) return null;
+      if (!prices) return null;
 
-    return [
-      {
-        prices: prices.slice(1),
-        unit: prices[0],
-        gasCost: QuickPerpsGasCost,
-        exchange: this.dexKey,
-        data: {},
-        poolAddresses: [this.params.vault],
-      },
-    ];
+      return [
+        {
+          prices: prices.slice(1),
+          unit: prices[0],
+          gasCost: QuickPerpsGasCost,
+          exchange: this.dexKey,
+          data: {},
+          poolAddresses: [this.params.vault],
+        },
+      ];
+    } catch (e) {
+      this.logger.error(
+        `Error_getPrices ${srcToken.symbol || srcToken.address}, ${
+          destToken.symbol || destToken.address
+        }, ${side}: `,
+        e,
+      );
+      return null;
+    }
   }
 
   // Returns estimated gas cost of calldata for this DEX in multiSwap

package/src/dex/solidly/config.ts

@@ -204,5 +204,5 @@ export const Adapters: Record<number, AdapterMappings> = {
   },
   [Network.BASE]: {
     [SwapSide.SELL]: [{ name: 'BaseAdapter01', index: 3 }], // aerodrome, equalizer
-  }
+  },
 };

package/src/dex/solidly/forks-override/aerodrome.ts

@@ -16,11 +16,7 @@ export class Aerodrome extends VelodromeV2 {
     dexKey: string,
     protected dexHelper: IDexHelper,
   ) {
-    super(
-      network,
-      dexKey,
-      dexHelper,
-    );
+    super(network, dexKey, dexHelper);
 
     this.factory = new dexHelper.web3Provider.eth.Contract(
       AerodromeFactoryABI as any,

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

@@ -220,8 +220,7 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       chunksCount: 10,
       initRetryFrequency: 10,
       initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
-      subgraphURL:
-        'https://api.studio.thegraph.com/query/32073/v3-base/v0.0.1',
+      subgraphURL: 'https://api.studio.thegraph.com/query/32073/v3-base/v0.0.1',
     },
   },
   ChronosV3: {