@paraswap/dex-lib 3.0.6 → 3.2.5-return-amount-pos.4

package/src/dex/hashflow/hashflow.ts

@@ -35,11 +35,14 @@ import {
   SimpleExchangeParam,
   Token,
 } from '../../types';
-import { getDexKeysWithNetwork } from '../../utils';
+import { getDexKeysWithNetwork, Utils } from '../../utils';
 import { TooStrictSlippageCheckError } from '../generic-rfq/types';
 import { SimpleExchange } from '../simple-exchange';
 import { Adapters, HashflowConfig } from './config';
 import {
+  CONSECUTIVE_ERROR_THRESHOLD,
+  CONSECUTIVE_ERROR_TIMESPAN_MS,
+  ERROR_CODE_TO_RESTRICT_TTL,
   HASHFLOW_API_CLIENT_NAME,
   HASHFLOW_API_MARKET_MAKERS_POLLING_INTERVAL_MS,
   HASHFLOW_API_PRICES_POLLING_INTERVAL_MS,
@@ -50,9 +53,12 @@ import {
   HASHFLOW_MIN_SLIPPAGE_FACTOR_THRESHOLD_FOR_RESTRICTION,
   HASHFLOW_MM_RESTRICT_TTL_S,
   HASHFLOW_PRICES_CACHES_TTL_S,
+  UNKNOWN_ERROR_CODE,
 } from './constants';
 import { RateFetcher } from './rate-fetcher';
 import {
+  CacheErrorCodesData,
+  ErrorCode,
   HashflowData,
   PriceLevel,
   RfqError,
@@ -71,6 +77,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
   private hashFlowAuthToken: string;
   private disabledMMs: Set<string>;
   private runtimeMMsRestrictHashMapKey: string;
+  private runtimeMMsRestrictHashMapErrorCodesKey: string;
 
   private pricesCacheKey: string;
   private marketMakersCacheKey: string;
@@ -110,6 +117,8 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     this.disabledMMs = new Set(dexHelper.config.data.hashFlowDisabledMMs);
     this.runtimeMMsRestrictHashMapKey =
       `${CACHE_PREFIX}_${this.dexKey}_${this.network}_restricted_mms`.toLowerCase();
+    this.runtimeMMsRestrictHashMapErrorCodesKey =
+      `${CACHE_PREFIX}_${this.dexKey}_${this.network}_restricted_mms_error_codes`.toLowerCase();
 
     this.rateFetcher = new RateFetcher(
       this.dexHelper,
@@ -599,7 +608,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
           normalizedDestToken.address,
         )}: ${JSON.stringify(rfq)}`;
         this.logger.warn(message);
-        throw new RfqError(message);
+        throw new RfqError(message, `${rfq?.error?.code}` as ErrorCode);
       } else if (!rfq.quotes[0].quoteData) {
         const message = `${this.dexKey}-${
           this.network
@@ -608,7 +617,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
           normalizedDestToken.address,
         )}. Missing quote data`;
         this.logger.warn(message);
-        throw new RfqError(message);
+        throw new RfqError(message, 'MISSING_QUOTE_DATA');
       } else if (!rfq.quotes[0].signature) {
         const message = `${this.dexKey}-${
           this.network
@@ -617,7 +626,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
           normalizedDestToken.address,
         )}. Missing signature`;
         this.logger.warn(message);
-        throw new RfqError(message);
+        throw new RfqError(message, 'MISSING_SIGNATURE_DATA');
       }
 
       assert(
@@ -718,7 +727,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     } catch (e) {
       if (
         e instanceof Error &&
-        e.message.endsWith('User is restricted from using Hashflow')
+        e.message?.toLowerCase().includes('user is restricted')
       ) {
         this.logger.warn(
           `${this.dexKey}-${this.network}: Encountered restricted user=${options.txOrigin}. Adding to local blacklist cache`,
@@ -730,7 +739,16 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
             `${this.dexKey}-${this.network}: Market Maker ${mm} failed to build transaction on side ${side} with too strict slippage. Skipping restriction`,
           );
         } else {
-          await this.restrictMM(mm);
+          this.logger.warn(
+            `${this.dexKey}-${this.network} MM unknown preprocess transaction error: ${e}`,
+          );
+          const code =
+            e instanceof RfqError || e instanceof SlippageCheckError
+              ? e?.code || UNKNOWN_ERROR_CODE
+              : UNKNOWN_ERROR_CODE;
+          await this.restrictMM(mm, code).catch(err =>
+            this.logger.warn(`Failed to restrict MM ${mm}: ${err}`),
+          );
         }
       }
 
@@ -738,24 +756,111 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     }
   }
 
-  async restrictMM(mm: string): Promise<void> {
-    this.logger.warn(
-      `${this.dexKey}-${this.network}: ${mm} was restricted for ${HASHFLOW_MM_RESTRICT_TTL_S} sec. due to fails`,
-    );
-
-    // We use timestamp for creation date to later discern if it already expired or not
-    await this.dexHelper.cache.hset(
-      this.runtimeMMsRestrictHashMapKey,
+  async restrictMM(mm: string, errorCode: ErrorCode): Promise<void> {
+    const errorCodesRaw = await this.dexHelper.cache.hget(
+      this.runtimeMMsRestrictHashMapErrorCodesKey,
       mm,
-      Date.now().toString(),
     );
 
-    // Expiry cache because it has levels for blacklisted MM
-    this.dexHelper.cache.del(this.dexKey, this.network, 'levels').catch(e => {
-      this.logger.error(
-        `${this.dexKey}-${this.network}: Failed to delete levels cache: ${e.message}`,
+    const errorCodes: CacheErrorCodesData = Utils.Parse(errorCodesRaw) || {};
+
+    const error = errorCodes?.[errorCode];
+
+    if (
+      !error ||
+      error.addedDatetimeMS + CONSECUTIVE_ERROR_TIMESPAN_MS < Date.now()
+    ) {
+      this.logger.warn(
+        `${this.dexKey}-${this.network}: First encounter of error code=${errorCode} for ${mm} OR error ocurred outside of threshold, setting up counter`,
       );
-    });
+      const data: CacheErrorCodesData = {
+        ...errorCodes,
+        [errorCode]: {
+          count: 1,
+          addedDatetimeMS: Date.now(),
+        },
+      };
+      await this.dexHelper.cache.hset(
+        this.runtimeMMsRestrictHashMapErrorCodesKey,
+        mm,
+        Utils.Serialize(data),
+      );
+      return;
+    } else {
+      const restrictTTLMs =
+        ERROR_CODE_TO_RESTRICT_TTL[errorCode] ||
+        ERROR_CODE_TO_RESTRICT_TTL[UNKNOWN_ERROR_CODE];
+
+      if (error.count + 1 > CONSECUTIVE_ERROR_THRESHOLD) {
+        this.logger.warn(
+          `${this.dexKey}-${this.network}: ${mm} was restricted for ${
+            restrictTTLMs / 1000
+          } sec. due to ${errorCode} happening ${
+            error.count + 1
+          } times within last ${Math.floor(
+            CONSECUTIVE_ERROR_TIMESPAN_MS / 1000 / 60,
+          )} minutes`,
+        );
+
+        // date added is checked against HASHFLOW_MM_RESTRICT_TTL_S, as a hack we set a date so that it's checked against specific ttls based on error type to not change parsing logic for mms
+        //
+        // Example1: ttl for a particular error is 20 minutes (< default 60 minutes)
+        // Meaning we need to set `addedDatetimeMS` for restrict hash as Date.now() - 40 minutes (diff between default restrict ttl=1h and particular error restrict ttl = 20 minutes). So the `addedDatetimeMS` is in the past, and after 20 minutes mm will not be considered as restricted
+        //
+        // Example 2: ttl for a particular error is 80 minutes (> default 60 minutes)
+        // Meaning we need to set `addedDatetimeMS` for restrict hash as Date.now() + 20 minutes (in the future), then after an hour (default) it'll still be 20 minutes left for restriction to be cleared
+
+        const defaultRestrictTTLMS = Math.floor(
+          HASHFLOW_MM_RESTRICT_TTL_S * 1000,
+        );
+        const dateModifierMS =
+          defaultRestrictTTLMS > restrictTTLMs
+            ? -(defaultRestrictTTLMS - restrictTTLMs)
+            : restrictTTLMs - defaultRestrictTTLMS;
+
+        const date = (Date.now() + dateModifierMS).toString();
+
+        // We use timestamp for creation date to later discern if it already expired or not
+        await this.dexHelper.cache.hset(
+          this.runtimeMMsRestrictHashMapKey,
+          mm,
+          date,
+        );
+
+        // resetting error count
+        const data: CacheErrorCodesData = {
+          ...errorCodes,
+          [errorCode]: {
+            count: 1,
+            addedDatetimeMS: Date.now(),
+          },
+        };
+        await this.dexHelper.cache.hset(
+          this.runtimeMMsRestrictHashMapErrorCodesKey,
+          mm,
+          Utils.Serialize(data),
+        );
+
+        return;
+      } else {
+        const newCount = +error.count + 1;
+        this.logger.warn(
+          `${this.dexKey}-${this.network}: ${mm} Error with code: ${errorCode} happened ${newCount} times (below or equal to the limit: ${CONSECUTIVE_ERROR_THRESHOLD}), updating counter`,
+        );
+        const data: CacheErrorCodesData = {
+          ...errorCodes,
+          [errorCode]: {
+            count: newCount,
+            addedDatetimeMS: error.addedDatetimeMS, // initial date stays
+          },
+        };
+        await this.dexHelper.cache.hset(
+          this.runtimeMMsRestrictHashMapErrorCodesKey,
+          mm,
+          Utils.Serialize(data),
+        );
+      }
+    }
   }
 
   getCalldataGasCost(poolPrices: PoolPrices<HashflowData>): number | number[] {
@@ -934,6 +1039,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
       dexFuncHasRecipient: true,
       exchangeData,
       targetExchange: this.routerAddress,
+      returnAmountPos: undefined,
     };
   }
 

package/src/dex/hashflow/types.ts

@@ -1,5 +1,6 @@
 import { Chain, QuoteData } from '@hashflow/taker-js/dist/types/common';
 import { RequestHeaders } from '../../dex-helper';
+import { ERROR_CODE_TO_RESTRICT_TTL, UNKNOWN_ERROR_CODE } from './constants';
 
 export type HashflowData = {
   mm: string;
@@ -16,14 +17,22 @@ export interface PriceLevel {
   p: string;
 }
 
-export class RfqError extends Error {}
+export class RfqError extends Error {
+  code: ErrorCode;
+  constructor(message: string, code: ErrorCode = UNKNOWN_ERROR_CODE) {
+    super(message);
+    this.code = code;
+  }
+}
 
 export enum RFQType {
   RFQT = 0,
   RFQM = 1,
 }
 
-export class SlippageCheckError extends Error {}
+export class SlippageCheckError extends Error {
+  code: ErrorCode = 'SLIPPAGE';
+}
 
 export type HashflowRatesLevel = {
   pair: Record<string, string>;
@@ -63,3 +72,12 @@ export type HashflowRateFetcherConfig = {
     marketMakersCacheTTLSecs: number;
   };
 };
+
+export type ErrorCode = keyof typeof ERROR_CODE_TO_RESTRICT_TTL;
+
+export type CacheErrorCodesData = {
+  [code in ErrorCode]: {
+    addedDatetimeMS: number;
+    count: number;
+  } | null;
+};

package/src/dex/idex.ts

@@ -83,6 +83,7 @@ export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
     data: ExchangeData,
     side: SwapSide,
     context: Context,
+    executorAddress: Address,
   ): AsyncOrSync<DexExchangeParam>;
 
   // Returns params required by direct swap method.
@@ -228,7 +229,7 @@ export interface IDex<
     IDexPooltracker {}
 
 // Defines the static objects of the IDex class
-export interface DexContructor<
+export interface DexConstructor<
   ExchangeData,
   DirectParam = null,
   OptimizedExchangeData = ExchangeData,

package/src/dex/index.ts

@@ -1,7 +1,7 @@
 import _ from 'lodash';
 import { UnoptimizedRate } from '../types';
 import { CurveV2 } from './curve-v2/curve-v2';
-import { IDexTxBuilder, DexContructor, IDex, IRouteOptimizer } from './idex';
+import { IDexTxBuilder, DexConstructor, IDex, IRouteOptimizer } from './idex';
 import { Jarvis } from './jarvis';
 import { JarvisV6 } from './jarvis-v6/jarvis-v6';
 import { StablePool } from './stable-pool/stable-pool';
@@ -79,12 +79,17 @@ import { SpiritSwapV3 } from './quickswap/spiritswap-v3';
 import { TraderJoeV21 } from './trader-joe-v2.1/trader-joe-v2.1';
 import { PancakeswapV3 } from './pancakeswap-v3/pancakeswap-v3';
 import { Algebra } from './algebra/algebra';
+import { AngleStakedStable } from './angle-staked-stable/angle-staked-stable';
 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';
 import { Swell } from './swell/swell';
+import { PharaohV1 } from './solidly/forks-override/pharaohV1';
+import { EtherFi } from './etherfi';
+import { Spark } from './spark/spark';
+import { VelodromeSlipstream } from './uniswap-v3/forks/velodrome-slipstream/velodrome-slipstream';
 
 const LegacyDexes = [
   CurveV2,
@@ -108,6 +113,7 @@ const LegacyDexes = [
   Jarvis,
   Lido,
   AugustusRFQOrder,
+  EtherFi,
 ];
 
 const Dexes = [
@@ -121,6 +127,7 @@ const Dexes = [
   UniswapV3,
   Algebra,
   PancakeswapV3,
+  VelodromeSlipstream,
   BiSwap,
   MDEX,
   Dfyn,
@@ -160,12 +167,15 @@ const Dexes = [
   MaverickV1,
   Camelot,
   SwaapV2,
+  AngleStakedStable,
   QuickPerps,
   NomiswapV2,
   SolidlyV3,
   Smardex,
   Wombat,
   Swell,
+  PharaohV1,
+  Spark,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<
@@ -180,7 +190,7 @@ interface IGetDirectFunctionName {
 
 export class DexAdapterService {
   dexToKeyMap: {
-    [key: string]: LegacyDexConstructor | DexContructor<any, any, any>;
+    [key: string]: LegacyDexConstructor | DexConstructor<any, any, any>;
   } = {};
   directFunctionsNames: string[];
   directFunctionsNamesV6: string[];

package/src/dex/jarvis-v6/jarvis-v6.ts

@@ -483,6 +483,7 @@ export class JarvisV6
       dexFuncHasRecipient: true,
       exchangeData,
       targetExchange: data.poolAddress.toLowerCase(),
+      returnAmountPos: undefined,
     };
   }
 

package/src/dex/jarvis.ts

@@ -12,6 +12,7 @@ import { SimpleExchange } from './simple-exchange';
 import JarvisABI from '../abi/Jarvis.json';
 import Web3 from 'web3';
 import { IDexHelper } from '../dex-helper';
+import { extractReturnAmountPosition } from '../executor/utils';
 
 const THIRTY_MINUTES = 60 * 30;
 
@@ -197,6 +198,8 @@ export class Jarvis
     const swapFunction = data.method;
     const timestamp = (Date.now() / 1000 + THIRTY_MINUTES).toFixed(0);
     let swapFunctionParams: JarvisParam;
+    let outputName: string;
+
     switch (swapFunction) {
       case JarvisFunctions.mint:
         swapFunctionParams = [
@@ -207,6 +210,7 @@ export class Jarvis
           timestamp,
           recipient,
         ];
+        outputName = 'syntheticTokensMinted';
         break;
       case JarvisFunctions.redeem:
         swapFunctionParams = [
@@ -217,6 +221,7 @@ export class Jarvis
           timestamp,
           recipient,
         ];
+        outputName = 'collateralRedeemed';
         break;
       case JarvisFunctions.exchange:
         swapFunctionParams = [
@@ -229,6 +234,7 @@ export class Jarvis
           timestamp,
           recipient,
         ];
+        outputName = 'destNumTokensMinted';
         break;
       default:
         throw new Error(`Unknown function ${swapFunction}`);
@@ -243,6 +249,14 @@ export class Jarvis
       dexFuncHasRecipient: true,
       exchangeData: swapData,
       targetExchange: data.pools[0],
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.poolInterface,
+              swapFunction,
+              outputName,
+            )
+          : undefined,
     };
   }
 }

package/src/dex/kyberdmm/kyberdmm.ts

@@ -38,6 +38,7 @@ import kyberDmmFactoryABI from '../../abi/kyberdmm/kyber-dmm-factory.abi.json';
 import kyberDmmPoolABI from '../../abi/kyberdmm/kyber-dmm-pool.abi.json';
 import KyberDmmExchangeRouterABI from '../../abi/kyberdmm/kyber-dmm-exchange-router.abi.json';
 import { getBigIntPow, getDexKeysWithNetwork } from '../../utils';
+import { extractReturnAmountPosition } from '../../executor/utils';
 
 const MAX_TRACKED_PAIR_POOLS = 3;
 
@@ -262,6 +263,14 @@ export class KyberDmm
       dexFuncHasRecipient: true,
       exchangeData,
       targetExchange: data.router,
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.exchangeRouterInterface,
+              KyberDMMFunctions.swapExactTokensForTokens,
+              'amounts',
+            )
+          : undefined,
     };
   }
 

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

@@ -33,6 +33,16 @@ const testForNetwork = (
         amount: '100000000000000000000',
       },
     ],
+    [
+      {
+        symbol: 'WETH',
+        amount: '100000000000000000000',
+      },
+      {
+        symbol: 'STETH',
+        amount: '100000000000000000000',
+      },
+    ],
   ];
 
   swapMap.forEach((contractMethods, side) =>

package/src/dex/lido/lido.ts

@@ -12,19 +12,26 @@ import { NULL_ADDRESS } from '../../constants';
 import { IDexHelper } from '../../dex-helper';
 import { LidoData, stETHFunctions } from './types';
 import { stETH } from './config';
+import { WethFunctions } from '../weth/types';
+import ERC20ABI from '../../abi/erc20.json';
+import { extractReturnAmountPosition } from '../../executor/utils';
 
 export class Lido implements IDexTxBuilder<LidoData, any> {
   static dexKeys = ['lido'];
   stETHInterface: Interface;
+  erc20Interface: Interface;
 
   needWrapNative = false;
 
   private network: number;
+  private wethAddress: Address =
+    '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'.toLowerCase();
 
   constructor(dexHelper: IDexHelper) {
     this.network = dexHelper.config.data.network;
 
     this.stETHInterface = new Interface(stETHAbi as JsonFragment[]);
+    this.erc20Interface = new Interface(ERC20ABI);
   }
 
   getAdapterParam(
@@ -63,10 +70,14 @@ export class Lido implements IDexTxBuilder<LidoData, any> {
     };
   }
 
+  protected isWETH(tokenAddress: string) {
+    return tokenAddress.toLowerCase() === this.wethAddress;
+  }
+
   getDexParam(
-    _srcToken: Address,
+    srcToken: Address,
     _destToken: Address,
-    _srcAmount: NumberAsString,
+    srcAmount: NumberAsString,
     _destAmount: NumberAsString,
     _recipient: Address,
     _data: LidoData,
@@ -82,6 +93,18 @@ export class Lido implements IDexTxBuilder<LidoData, any> {
       dexFuncHasRecipient: false,
       exchangeData: swapData,
       targetExchange: stETH[this.network],
+      preSwapUnwrapCalldata: this.isWETH(srcToken)
+        ? this.erc20Interface.encodeFunctionData(WethFunctions.withdraw, [
+            srcAmount,
+          ])
+        : undefined,
+      returnAmountPos:
+        _side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.stETHInterface,
+              stETHFunctions.submit,
+            )
+          : undefined,
     };
   }
 }

package/src/dex/maker-psm/maker-psm.ts

@@ -541,6 +541,7 @@ export class MakerPsm extends SimpleExchange implements IDex<MakerPsmData> {
       targetExchange: data.psmAddress,
       specialDexFlag,
       spender: isGemSell ? data.gemJoinAddress : data.psmAddress,
+      returnAmountPos: undefined,
     };
   }
   // Returns list of top pools based on liquidity. Max

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

@@ -41,6 +41,7 @@ import {
 import { SUBGRAPH_TIMEOUT } from '../../constants';
 import RouterABI from '../../abi/maverick-v1/router.json';
 import { NumberAsString } from '@paraswap/core';
+import { extractReturnAmountPosition } from '../../executor/utils';
 
 const MAX_POOL_CNT = 1000;
 
@@ -402,6 +403,14 @@ export class MaverickV1
       dexFuncHasRecipient: true,
       exchangeData,
       targetExchange: this.config.routerAddress,
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.routerIface,
+              MaverickV1Functions.exactInputSingle,
+              'amountOut',
+            )
+          : undefined,
     };
   }
 

package/src/dex/nerve/nerve.ts

@@ -33,6 +33,7 @@ import { NerveConfig, Adapters, NERVE_GAS_COST } from './config';
 import { NerveEventPool } from './nerve-pool';
 import _ from 'lodash';
 import { bigIntify } from './utils';
+import { extractReturnAmountPosition } from '../../executor/utils';
 
 export class Nerve
   extends SimpleExchange
@@ -382,6 +383,13 @@ export class Nerve
       dexFuncHasRecipient: false,
       exchangeData: swapData,
       targetExchange: exchange,
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.nervePoolIface,
+              NervePoolFunctions.swap,
+            )
+          : undefined,
     };
   }
 

package/src/dex/onebit/onebit.ts

@@ -13,6 +13,7 @@ import { SimpleExchange } from '../simple-exchange';
 import OnebitABI from '../../abi/Onebit.json';
 import { IDexHelper } from '../../dex-helper';
 import { OnebitData, OnebitFunctions, OnebitParam } from './types';
+import { extractReturnAmountPosition } from '../../executor/utils';
 
 export class Onebit
   extends SimpleExchange
@@ -100,6 +101,13 @@ export class Onebit
       dexFuncHasRecipient: true,
       exchangeData: swapData,
       targetExchange: data.router,
+      returnAmountPos:
+        _side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.exchangeRouterInterface,
+              swapFunction,
+            )
+          : undefined,
     };
   }
 }

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

@@ -69,6 +69,38 @@ export const PancakeswapV3Config: DexConfigMap<DexParams> = {
         'https://api.studio.thegraph.com/query/45376/exchange-v3-base/version/latest',
     },
   },
+  DackieSwapV3: {
+    [Network.BASE]: {
+      factory: '0x3D237AC6D2f425D2E890Cc99198818cc1FA48870',
+      quoter: '0x4fDBD73aD4B1DDde594BF05497C15f76308eFfb9',
+      deployer: '0x4f205D69834f9B101b9289F7AFFAc9B77B3fF9b7',
+      router: '0x4030ebafeb76e5fc848891076dfe315993800ba5',
+      supportedFees: [10000n, 2500n, 500n, 100n],
+      stateMulticall: '0xeBF40A40CA3D4310Bf53048F48e860656e1D7C81',
+      uniswapMulticall: '0x091e99cb1C49331a94dD62755D168E941AbD0693',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: `0x6ce8eb472fa82df5469c6ab6d485f17c3ad13c8cd7af59b3d4a8026c5ce0f7e2`,
+      subgraphURL:
+        'https://api.studio.thegraph.com/query/50473/exchange-clmm/version/latest',
+    },
+  },
+  SwapBasedV3: {
+    [Network.BASE]: {
+      factory: '0xb5620f90e803c7f957a9ef351b8db3c746021bea',
+      quoter: '0x4fDBD73aD4B1DDde594BF05497C15f76308eFfb9',
+      deployer: '0x905a650133147012390c42624eeba4d3313bec6c',
+      router: '0x756c6bbdd915202adac7bebb1c6c89ac0886503f',
+      supportedFees: [10000n, 2500n, 500n, 100n, 35n],
+      stateMulticall: '0xeBF40A40CA3D4310Bf53048F48e860656e1D7C81',
+      uniswapMulticall: '0x091e99cb1C49331a94dD62755D168E941AbD0693',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: `0x6ce8eb472fa82df5469c6ab6d485f17c3ad13c8cd7af59b3d4a8026c5ce0f7e2`,
+      subgraphURL:
+        'https://api.studio.thegraph.com/query/67101/swapbased-pcsv3-core/version/latest',
+    },
+  },
 };
 
 export const Adapters: Record<number, AdapterMappings> = {

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

@@ -435,4 +435,25 @@ describe('PancakeswapV3 E2E', () => {
       nativeTokenAmount,
     );
   });
+
+  describe('SwapBasedV3 Base', () => {
+    const network = Network.BASE;
+
+    const tokenASymbol: string = 'USDbC';
+    const tokenBSymbol: string = 'USDC';
+
+    const tokenAAmount: string = '11111000000';
+    const tokenBAmount: string = '11111000000';
+    const nativeTokenAmount = '110000000000000000000';
+
+    testForNetwork(
+      network,
+      'SwapBasedV3',
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+      nativeTokenAmount,
+    );
+  });
 });

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

@@ -38,7 +38,14 @@ export class PancakeswapV3Factory extends StatefulEventSubscriber<FactoryState>
     protected readonly onPoolCreated: OnPoolCreatedCallback,
     mapKey: string = '',
   ) {
-    super(parentName, `${parentName} Factory`, dexHelper, logger, true, mapKey);
+    super(
+      parentName,
+      `${parentName} Factory`,
+      dexHelper,
+      logger,
+      false,
+      mapKey,
+    );
 
     this.addressesSubscribed = [factoryAddress];