@paraswap/dex-lib 2.28.9-take-surplus.0 → 2.28.9-take-surplus.1

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

@@ -12,6 +12,7 @@ import { IDexHelper } from '../../dex-helper/idex-helper';
 import {
   PoolState,
   DecodedStateMultiCallResultWithRelativeBitmaps,
+  DecodeStateMultiCallFunc,
 } from './types';
 import UniswapV3PoolABI from '../../abi/uniswap-v3/UniswapV3Pool.abi.json';
 import { bigIntify, catchParseLogError, isSampled } from '../../utils';
@@ -45,7 +46,7 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
 
   private _poolAddress?: Address;
 
-  private _stateRequestCallData?: MultiCallParams<
+  protected _stateRequestCallData?: MultiCallParams<
     bigint | DecodedStateMultiCallResultWithRelativeBitmaps
   >[];
 
@@ -54,15 +55,18 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
   public initFailed = false;
   public initRetryAttemptCount = 0;
 
-  public readonly feeCodeAsString;
+  public feeCodeAsString;
 
   constructor(
     readonly dexHelper: IDexHelper,
     parentName: string,
     readonly stateMultiContract: Contract,
+    readonly decodeStateMultiCallResultWithRelativeBitmaps:
+      | DecodeStateMultiCallFunc
+      | undefined,
     readonly erc20Interface: Interface,
     protected readonly factoryAddress: Address,
-    public readonly feeCode: bigint,
+    public feeCode: bigint,
     token0: Address,
     token1: Address,
     logger: Logger,
@@ -195,7 +199,7 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
     return null; // ignore unrecognized event
   }
 
-  private _getStateRequestCallData() {
+  protected _getStateRequestCallData() {
     if (!this._stateRequestCallData) {
       const callData: MultiCallParams<
         bigint | DecodedStateMultiCallResultWithRelativeBitmaps
@@ -226,9 +230,13 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
               this.getBitmapRangeToRequest(),
             )
             .encodeABI(),
-          decodeFunction: decodeStateMultiCallResultWithRelativeBitmaps,
+          decodeFunction:
+            this.decodeStateMultiCallResultWithRelativeBitmaps !== undefined
+              ? this.decodeStateMultiCallResultWithRelativeBitmaps
+              : decodeStateMultiCallResultWithRelativeBitmaps,
         },
       ];
+
       this._stateRequestCallData = callData;
     }
     return this._stateRequestCallData;

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

@@ -2,20 +2,20 @@ import { defaultAbiCoder, Interface } from '@ethersproject/abi';
 import _ from 'lodash';
 import { pack } from '@ethersproject/solidity';
 import {
-  Token,
+  AdapterExchangeParam,
   Address,
   ExchangePrices,
-  AdapterExchangeParam,
-  SimpleExchangeParam,
-  PoolLiquidity,
+  ExchangeTxInfo,
   Logger,
   NumberAsString,
+  PoolLiquidity,
   PoolPrices,
-  TxInfo,
   PreprocessTransactionOptions,
-  ExchangeTxInfo,
+  SimpleExchangeParam,
+  Token,
+  TxInfo,
 } from '../../types';
-import { SwapSide, Network, CACHE_PREFIX } from '../../constants';
+import { CACHE_PREFIX, Network, SwapSide } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
 import {
   getBigIntPow,
@@ -39,10 +39,10 @@ import {
   getLocalDeadlineAsFriendlyPlaceholder,
   SimpleExchange,
 } from '../simple-exchange';
-import { UniswapV3Config, Adapters, PoolsToPreload } from './config';
+import { Adapters, PoolsToPreload, UniswapV3Config } from './config';
 import { UniswapV3EventPool } from './uniswap-v3-pool';
 import UniswapV3RouterABI from '../../abi/uniswap-v3/UniswapV3Router.abi.json';
-import UniswapV3QuoterABI from '../../abi/uniswap-v3/UniswapV3Quoter.abi.json';
+import UniswapV3QuoterV2ABI from '../../abi/uniswap-v3/UniswapV3QuoterV2.abi.json';
 import UniswapV3MultiABI from '../../abi/uniswap-v3/UniswapMulti.abi.json';
 import DirectSwapABI from '../../abi/DirectSwap.json';
 import UniswapV3StateMulticallABI from '../../abi/uniswap-v3/UniswapV3StateMulticall.abi.json';
@@ -64,6 +64,7 @@ import {
   DEFAULT_ID_ERC20_AS_STRING,
 } from '../../lib/tokens/types';
 import { OptimalSwapExchange } from '@paraswap/core';
+import { OnPoolCreatedCallback, UniswapV3Factory } from './uniswap-v3-factory';
 
 type PoolPairsInfo = {
   token0: Address;
@@ -71,14 +72,15 @@ type PoolPairsInfo = {
   fee: string;
 };
 
-const UNISWAPV3_CLEAN_NOT_EXISTING_POOL_TTL_MS = 60 * 60 * 24 * 1000; // 24 hours
-const UNISWAPV3_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS = 30 * 60 * 1000; // Once in 30 minutes
+const UNISWAPV3_CLEAN_NOT_EXISTING_POOL_TTL_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
+const UNISWAPV3_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS = 24 * 60 * 60 * 1000; // Once in a day
 const UNISWAPV3_QUOTE_GASLIMIT = 200_000;
 
 export class UniswapV3
   extends SimpleExchange
   implements IDex<UniswapV3Data, UniswapV3Param>
 {
+  private readonly factory: UniswapV3Factory;
   readonly isFeeOnTransferSupported: boolean = false;
   readonly eventPools: Record<string, UniswapV3EventPool | null> = {};
 
@@ -91,7 +93,14 @@ export class UniswapV3
 
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
     getDexKeysWithNetwork(
-      _.pick(UniswapV3Config, ['UniswapV3', 'QuickSwapV3.1']),
+      _.pick(UniswapV3Config, [
+        'UniswapV3',
+        'SushiSwapV3',
+        'QuickSwapV3.1',
+        'RamsesV2',
+        'ChronosV3',
+        'Retro',
+      ]),
     );
 
   logger: Logger;
@@ -107,7 +116,7 @@ export class UniswapV3
     protected dexHelper: IDexHelper,
     protected adapters = Adapters[network] || {},
     readonly routerIface = new Interface(UniswapV3RouterABI),
-    readonly quoterIface = new Interface(UniswapV3QuoterABI),
+    readonly quoterIface = new Interface(UniswapV3QuoterV2ABI),
     protected config = UniswapV3Config[dexKey][network],
     protected poolsToPreload = PoolsToPreload[dexKey]?.[network] || [],
   ) {
@@ -118,7 +127,9 @@ export class UniswapV3
       this.config.uniswapMulticall,
     );
     this.stateMultiContract = new this.dexHelper.web3Provider.eth.Contract(
-      UniswapV3StateMulticallABI as AbiItem[],
+      this.config.stateMultiCallAbi !== undefined
+        ? this.config.stateMultiCallAbi
+        : (UniswapV3StateMulticallABI as AbiItem[]),
       this.config.stateMulticall,
     );
 
@@ -130,6 +141,14 @@ export class UniswapV3
 
     this.notExistingPoolSetKey =
       `${CACHE_PREFIX}_${network}_${dexKey}_not_existings_pool_set`.toLowerCase();
+
+    this.factory = new UniswapV3Factory(
+      dexHelper,
+      dexKey,
+      this.config.factory,
+      this.logger,
+      this.onPoolCreatedDeleteFromNonExistingSet,
+    );
   }
 
   get supportedFees() {
@@ -146,6 +165,9 @@ export class UniswapV3
   }
 
   async initializePricing(blockNumber: number) {
+    // Init listening to new pools creation
+    await this.factory.initialize(blockNumber);
+
     // This is only for testing, because cold pool fetching is goes out of
     // FETCH_POOL_INDENTIFIER_TIMEOUT range
     await Promise.all(
@@ -176,6 +198,38 @@ export class UniswapV3
     }
   }
 
+  /*
+   * 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 = '[UniswapV3.onPoolCreatedDeleteFromNonExistingSet]';
+    const [_token0, _token1] = this._sortTokens(token0, token1);
+    const poolKey = `${_token0}_${_token1}_${fee}`;
+
+    // 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,
@@ -233,12 +287,17 @@ export class UniswapV3
     }
 
     this.logger.trace(`starting to listen to new pool: ${key}`);
+    const poolImplementation =
+      this.config.eventPoolImplementation !== undefined
+        ? this.config.eventPoolImplementation
+        : UniswapV3EventPool;
     pool =
       pool ||
-      new UniswapV3EventPool(
+      new poolImplementation(
         this.dexHelper,
         this.dexKey,
         this.stateMultiContract,
+        this.config.decodeStateMultiCallResultWithRelativeBitmaps,
         this.erc20Interface,
         this.config.factory,
         fee,
@@ -365,6 +424,7 @@ export class UniswapV3
     amounts: bigint[],
     side: SwapSide,
     pools: UniswapV3EventPool[],
+    states: PoolState[],
   ): Promise<ExchangePrices<UniswapV3Data> | null> {
     if (pools.length === 0) {
       return null;
@@ -462,7 +522,7 @@ export class UniswapV3
     };
 
     let i = 0;
-    const result = pools.map(pool => {
+    const result = pools.map((pool, index) => {
       const _rates = _amounts.map(() => decode(i++));
       const unit: bigint = _rates[0];
 
@@ -482,6 +542,7 @@ export class UniswapV3
               tokenIn: from.address,
               tokenOut: to.address,
               fee: pool.feeCodeAsString,
+              currentFee: states[index].fee.toString(),
             },
           ],
           exchange: pool.poolAddress,
@@ -593,16 +654,17 @@ export class UniswapV3
         },
       );
 
+      const states = poolsToUse.poolWithState.map(
+        p => p.getState(blockNumber)!,
+      );
+
       const rpcResultsPromise = this.getPricingFromRpc(
         _srcToken,
         _destToken,
         amounts,
         side,
         this.network === Network.ZKEVM ? [] : poolsToUse.poolWithoutState,
-      );
-
-      const states = poolsToUse.poolWithState.map(
-        p => p.getState(blockNumber)!,
+        this.network === Network.ZKEVM ? [] : states,
       );
 
       const unitAmount = getBigIntPow(
@@ -676,6 +738,7 @@ export class UniswapV3
                   tokenIn: _srcAddress,
                   tokenOut: _destAddress,
                   fee: pool.feeCode.toString(),
+                  currentFee: state.fee.toString(),
                 },
               ],
             },
@@ -1055,6 +1118,10 @@ export class UniswapV3
       deployer: this.config.deployer?.toLowerCase(),
       initHash: this.config.initHash,
       subgraphURL: this.config.subgraphURL,
+      stateMultiCallAbi: this.config.stateMultiCallAbi,
+      eventPoolImplementation: this.config.eventPoolImplementation,
+      decodeStateMultiCallResultWithRelativeBitmaps:
+        this.config.decodeStateMultiCallResultWithRelativeBitmaps,
     };
     return newConfig;
   }

package/src/dex/weth/config.ts

@@ -25,6 +25,9 @@ export const WethConfig: DexConfigMap<DexParams> = {
     [Network.ZKEVM]: {
       poolGasCost: WethGasCost,
     },
+    [Network.BASE]: {
+      poolGasCost: WethGasCost,
+    },
   },
   Wbnb: {
     [Network.BSC]: {

package/src/dex/woo-fi-v2/config.ts

@@ -64,6 +64,16 @@ export const WooFiV2Config: DexConfigMap<DexParams> = {
         decimals: 6,
       },
     },
+    [Network.BASE]: {
+      wooPPV2Address: '0xb130a49065178465931d4f887056328CeA5D723f',
+      wooOracleV2Address: '0x2Fe5E5D341cFFa606a5d9DA1B6B646a381B0f7ec',
+      integrationHelperAddress: '0xC4E9B633685461E7B7A807D12a246C81f96F31B8',
+      // USDbC
+      quoteToken: {
+        address: '0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA',
+        decimals: 6,
+      },
+    },
   },
 };
 
@@ -84,4 +94,7 @@ export const Adapters: Record<number, AdapterMappings> = {
   [Network.AVALANCHE]: {
     [SwapSide.SELL]: [{ name: 'AvalancheAdapter01', index: 12 }],
   },
+  [Network.BASE]: {
+    [SwapSide.SELL]: [{ name: 'BaseAdapter01', index: 5 }],
+  },
 };

package/src/dex/woo-fi-v2/woo-fi-v2-e2e.test.ts

@@ -213,4 +213,68 @@ describe('WooFiV2 E2E', () => {
       tokenQuoteAmount,
     );
   });
+
+  describe('Base', () => {
+    const network = Network.BASE;
+
+    const baseATokenSymbol = 'USDbC';
+    const baseBTokenSymbol = 'ETH';
+
+    const tokenBaseAAmount = '100000000';
+    const tokenBaseBAmount = '1000000000000000000';
+
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+
+    const sideToContractMethods = new Map([
+      [
+        SwapSide.SELL,
+        [
+          ContractMethod.simpleSwap,
+          ContractMethod.multiSwap,
+          ContractMethod.megaSwap,
+        ],
+      ],
+    ]);
+
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            it(`${baseATokenSymbol} -> ${baseBTokenSymbol}`, async () => {
+              await testE2E(
+                tokens[baseATokenSymbol],
+                tokens[baseBTokenSymbol],
+                holders[baseATokenSymbol],
+                tokenBaseAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${baseBTokenSymbol} -> ${baseATokenSymbol}`, async () => {
+              await testE2E(
+                tokens[baseBTokenSymbol],
+                tokens[baseATokenSymbol],
+                holders[baseBTokenSymbol],
+                tokenBaseBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
 });

package/src/dex-helper/dummy-dex-helper.ts

@@ -41,6 +41,7 @@ class DummyCache implements ICache {
   }
 
   async rawget(key: string): Promise<string | null> {
+    return this.storage[key] ? this.storage[key] : null;
     return null;
   }
 
@@ -49,10 +50,12 @@ class DummyCache implements ICache {
     value: string,
     ttl: number,
   ): Promise<string | null> {
-    return null;
+    this.storage[key] = value;
+    return 'OK';
   }
 
   async rawdel(key: string): Promise<void> {
+    delete this.storage[key];
     return;
   }
 
@@ -112,6 +115,10 @@ class DummyCache implements ICache {
     return 0;
   }
 
+  async zrem(key: string, membersKeys: string[]): Promise<number> {
+    return 0;
+  }
+
   async zadd(key: string, bulkItemsToAdd: (number | string)[], option?: 'NX') {
     return 0;
   }

package/src/dex-helper/icache.ts

@@ -46,6 +46,8 @@ export interface ICache {
 
   zremrangebyscore(key: string, min: number, max: number): Promise<number>;
 
+  zrem(key: string, membersKeys: string[]): Promise<number>;
+
   zscore(setKey: string, key: string): Promise<string | null>;
 
   sismember(setKey: string, key: string): Promise<boolean>;

package/src/lib/api3-feed.ts

@@ -0,0 +1,175 @@
+import { DeepReadonly } from 'ts-essentials';
+import { PartialEventSubscriber } from '../composed-event-subscriber';
+import {
+  Address,
+  BlockHeader,
+  Log,
+  Logger,
+  MultiCallInput,
+  MultiCallOutput,
+} from '../types';
+import { Lens } from '../lens';
+import { Interface } from '@ethersproject/abi';
+import ProxyABI from '../abi/api3-proxy.json';
+import Api3ServerV1ABI from '../abi/api3-server-v1.json';
+
+export type Api3FeedSubscriberState = {
+  value: bigint;
+  timestamp: bigint;
+};
+
+export class Api3FeedSubscriber<State> extends PartialEventSubscriber<
+  State,
+  Api3FeedSubscriberState
+> {
+  static readonly proxyInterface = new Interface(ProxyABI);
+  static readonly api3ServerV1Iface = new Interface(Api3ServerV1ABI);
+  static readonly ANSWER_UPDATED_SIGNED_DATA =
+    Api3FeedSubscriber.api3ServerV1Iface.getEventTopic(
+      'UpdatedBeaconWithSignedData',
+    );
+  static readonly ANSWER_UPDATED_BEACON_SET_DATA =
+    Api3FeedSubscriber.api3ServerV1Iface.getEventTopic(
+      'UpdatedBeaconSetWithBeacons',
+    );
+
+  constructor(
+    private proxy: Address,
+    api3Server: Address,
+    private dataFeedId: string,
+    lens: Lens<DeepReadonly<State>, DeepReadonly<Api3FeedSubscriberState>>,
+    logger: Logger,
+  ) {
+    super([api3Server], lens, logger);
+  }
+
+  static getApi3ServerV1MultiCallInput(proxy: Address): MultiCallInput {
+    return {
+      target: proxy,
+      callData:
+        Api3FeedSubscriber.proxyInterface.encodeFunctionData('api3ServerV1'),
+    };
+  }
+
+  static getDapiNameHashMultiCallInput(proxy: Address): MultiCallInput {
+    return {
+      target: proxy,
+      callData:
+        Api3FeedSubscriber.proxyInterface.encodeFunctionData('dapiNameHash'),
+    };
+  }
+
+  static getDataFeedId(proxy: Address): MultiCallInput {
+    return {
+      target: proxy,
+      callData:
+        Api3FeedSubscriber.proxyInterface.encodeFunctionData('dataFeedId'),
+    };
+  }
+
+  static getFeedIdFromDapiNameHash(
+    api3Server: Address,
+    dapiNameHash: string,
+  ): MultiCallInput {
+    return {
+      target: api3Server,
+      callData: Api3FeedSubscriber.api3ServerV1Iface.encodeFunctionData(
+        'dapiNameHashToDataFeedId',
+        [dapiNameHash],
+      ),
+    };
+  }
+
+  static decodeFeedIdFromDapiNameHash(multicallOutput: MultiCallOutput) {
+    return Api3FeedSubscriber.api3ServerV1Iface.decodeFunctionResult(
+      'dapiNameHashToDataFeedId',
+      multicallOutput,
+    )[0];
+  }
+
+  static decodeDapiNameHash(multicallOutput: MultiCallOutput) {
+    return Api3FeedSubscriber.proxyInterface.decodeFunctionResult(
+      'dapiNameHash',
+      multicallOutput,
+    )[0];
+  }
+
+  static decodeDataFeedId(multicallOutput: MultiCallOutput) {
+    return Api3FeedSubscriber.proxyInterface.decodeFunctionResult(
+      'dataFeedId',
+      multicallOutput,
+    )[0];
+  }
+
+  static decodeApi3ServerV1Result(multicallOutput: MultiCallOutput): Address {
+    return Api3FeedSubscriber.proxyInterface.decodeFunctionResult(
+      'api3ServerV1',
+      multicallOutput,
+    )[0];
+  }
+
+  public processLog(
+    state: DeepReadonly<Api3FeedSubscriberState>,
+    log: Readonly<Log>,
+    blockHeader: Readonly<BlockHeader>,
+  ): DeepReadonly<Api3FeedSubscriberState> | null {
+    if (log.topics[0] === Api3FeedSubscriber.ANSWER_UPDATED_SIGNED_DATA) {
+      const decoded = Api3FeedSubscriber.api3ServerV1Iface.decodeEventLog(
+        'UpdatedBeaconWithSignedData',
+        log.data,
+        log.topics,
+      );
+
+      if (decoded.beaconId !== this.dataFeedId) return null;
+
+      return {
+        value: BigInt(decoded.value.toString()),
+        timestamp: BigInt(decoded.timestamp.toString()),
+      };
+    } else if (
+      log.topics[0] === Api3FeedSubscriber.ANSWER_UPDATED_BEACON_SET_DATA
+    ) {
+      const decoded = Api3FeedSubscriber.api3ServerV1Iface.decodeEventLog(
+        'UpdatedBeaconSetWithBeacons',
+        log.data,
+        log.topics,
+      );
+
+      if (decoded.beaconSetId !== this.dataFeedId) return null;
+
+      return {
+        value: BigInt(decoded.value.toString()),
+        timestamp: BigInt(decoded.timestamp.toString()),
+      };
+    } else {
+      return null;
+    }
+  }
+
+  public getGenerateStateMultiCallInputs(): MultiCallInput[] {
+    return [
+      {
+        target: this.proxy,
+        callData: Api3FeedSubscriber.proxyInterface.encodeFunctionData('read'),
+      },
+    ];
+  }
+
+  public generateState(
+    multicallOutputs: MultiCallOutput[],
+    blockNumber?: number | 'latest',
+  ): DeepReadonly<Api3FeedSubscriberState> {
+    const decoded = Api3FeedSubscriber.proxyInterface.decodeFunctionResult(
+      'read',
+      multicallOutputs[0],
+    );
+    return {
+      value: BigInt(decoded.value.toString()),
+      timestamp: BigInt(decoded.timestamp.toString()),
+    };
+  }
+
+  public getLatestData(state: DeepReadonly<State>): bigint {
+    return this.lens.get()(state).value;
+  }
+}

package/src/lib/decoders.ts

@@ -1,5 +1,6 @@
 import { Result } from '@ethersproject/abi';
 import BigNumber from 'bignumber.js';
+import { BigNumber as EthersBigNumber } from 'ethers';
 import { BytesLike, defaultAbiCoder } from 'ethers/lib/utils';
 import _, { parseInt } from 'lodash';
 import { BN_0 } from '../bignumber-constants';
@@ -50,6 +51,18 @@ export const uint256ToBigInt = (
   return generalDecoder(result, ['uint256'], 0n, value => value[0].toBigInt());
 };
 
+export const uint128ToBigNumber = (
+  result: MultiResult<BytesLike> | BytesLike,
+): EthersBigNumber => {
+  return generalDecoder(result, ['uint128'], 0n, value => value[0]);
+};
+
+export const int24ToNumber = (
+  result: MultiResult<BytesLike> | BytesLike,
+): number => {
+  return generalDecoder(result, ['int24'], 0n, value => value[0]);
+};
+
 export const uint256ArrayDecode = (
   result: MultiResult<BytesLike> | BytesLike,
 ): bigint => {

package/src/stateful-event-subscriber.ts

@@ -18,6 +18,7 @@ type StateCache<State> = {
 export type InitializeStateOptions<State> = {
   state?: DeepReadonly<State>;
   initCallback?: (state: DeepReadonly<State>) => void;
+  forceRegenerate?: boolean;
 };
 
 export abstract class StatefulEventSubscriber<State>
@@ -89,6 +90,13 @@ export abstract class StatefulEventSubscriber<State>
     let masterBn: undefined | number = undefined;
     if (options && options.state) {
       this.setState(options.state, blockNumber);
+    } else if (options && options.forceRegenerate) {
+      // ZkEVM forces to always regenerate state when it is old
+      this.logger.debug(
+        `${this.parentName}: ${this.name}: forced to regenerate state`,
+      );
+      const state = await this.generateState(blockNumber);
+      this.setState(state, blockNumber);
     } else {
       if (this.dexHelper.config.isSlave && this.masterPoolNeeded) {
         let stateAsString = await this.dexHelper.cache.hget(

package/src/types.ts

@@ -276,6 +276,7 @@ export type Config = {
   hashFlowDisabledMMs: string[];
   uniswapV3EventLoggingSampleRate?: number;
   swaapV2AuthToken?: string;
+  forceRpcFallbackDexs: string[];
 };
 
 export type BigIntAsString = string;
@@ -290,6 +291,7 @@ export type PreprocessTransactionOptions = {
   hmac?: string;
   mockRfqAndLO?: boolean;
   isDirectMethod?: boolean;
+  partner?: string;
 };
 
 export type TransferFeeParams = {