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

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

@@ -3,11 +3,16 @@ import { DexConfigMap, AdapterMappings } from '../../types';
 import { Network, SwapSide } from '../../constants';
 import { Address } from '../../types';
 import RamsesV2StateMulticallABI from '../../abi/RamsesV2StateMulticall.abi.json';
+import VelodromeSlipstreamMulticallABi from '../../abi/velodrome-slipstream/VelodromeSlipstreamStateMulticall.abi.json';
 import { AbiItem } from 'web3-utils';
-import { decodeStateMultiCallResultWithRelativeBitmaps } from './forks/ramses-v2/utils';
+import { decodeStateMultiCallResultWithRelativeBitmaps as decodeStateMultiCallResultWithRelativeBitmapsForRamses } from './forks/ramses-v2/utils';
+import { decodeStateMultiCallResultWithRelativeBitmaps as decodeStateMultiCallResultWithRelativeBitmapsForVelodromeSlipstream } from './forks/velodrome-slipstream/utils';
 import { RamsesV2EventPool } from './forks/ramses-v2/ramses-v2-pool';
+import { VelodromeSlipstreamEventPool } from './forks/velodrome-slipstream/velodrome-slipstream-pool';
+import { VelodromeSlipstreamFactory } from './forks/velodrome-slipstream/velodrome-slipstream-factory';
 
 const SUPPORTED_FEES = [10000n, 3000n, 500n, 100n];
+const RAMSES_FORKS_FEES = [...SUPPORTED_FEES, 50n, 250n];
 
 // Pools that will be initialized on app startup
 // They are added for testing
@@ -246,20 +251,42 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       deployer: '0xb3e423ab9cE6C03D98326A3A2a0D7D96b0829f22',
       quoter: '0xAA20EFF7ad2F523590dE6c04918DaAE0904E3b20',
       router: '0xAA23611badAFB62D37E7295A682D21960ac85A90',
-      supportedFees: [...SUPPORTED_FEES, 50n],
+      supportedFees: RAMSES_FORKS_FEES,
       stateMulticall: '0x50EE4112Cab9c79812F23bE079aB3911395ACc8e',
       stateMultiCallAbi: RamsesV2StateMulticallABI as AbiItem[],
       uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
       chunksCount: 10,
       initRetryFrequency: 10,
       eventPoolImplementation: RamsesV2EventPool,
-      decodeStateMultiCallResultWithRelativeBitmaps,
+      decodeStateMultiCallResultWithRelativeBitmaps:
+        decodeStateMultiCallResultWithRelativeBitmapsForRamses,
       initHash:
         '0x1565b129f2d1790f12d45301b9b084335626f0c92410bc43130763b69971135d',
       subgraphURL:
         'https://api.thegraph.com/subgraphs/name/ramsesexchange/concentrated-liquidity-graph',
     },
   },
+  PharaohV2: {
+    [Network.AVALANCHE]: {
+      factory: '0xAAA32926fcE6bE95ea2c51cB4Fcb60836D320C42',
+      deployer: '0x95120704f4E2D545Aea8b6B3c16d9Da1fa32E30F',
+      quoter: '0xAAAEA10b0e6FBe566FE27c3A023DC5D8cA6Bca3d',
+      router: '0xAAAE99091Fbb28D400029052821653C1C752483B',
+      supportedFees: RAMSES_FORKS_FEES,
+      stateMulticall: '0xd32C191e0febaa6Cc93A29Cb676474c72486E00b',
+      stateMultiCallAbi: RamsesV2StateMulticallABI as AbiItem[],
+      uniswapMulticall: '0x0139141Cd4Ee88dF3Cdb65881D411bAE271Ef0C2',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      eventPoolImplementation: RamsesV2EventPool,
+      decodeStateMultiCallResultWithRelativeBitmaps:
+        decodeStateMultiCallResultWithRelativeBitmapsForRamses,
+      initHash:
+        '0x1565b129f2d1790f12d45301b9b084335626f0c92410bc43130763b69971135d',
+      subgraphURL:
+        'https://api.studio.thegraph.com/query/66247/pharaoh-cl/version/latest',
+    },
+  },
   'QuickSwapV3.1': {
     [Network.ZKEVM]: {
       factory: '0xD9a2AD9E927Bd7014116CC5c7328f028D4318178',
@@ -275,6 +302,22 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
         'https://api.studio.thegraph.com/query/44554/uniswap-v3/version/latest',
     },
   },
+  SpookySwapV3: {
+    [Network.FANTOM]: {
+      factory: '0x7928a2c48754501f3a8064765ECaE541daE5c3E6',
+      quoter: '0xB9507f2ED171D52c5c2EFaeAbdE440d264504A92',
+      router: '0x765132A0630Cd4401b971706Bb21c0FB5Ab547ad',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0x2cc482a66dd677ad33900018f774052717c533fb',
+      uniswapMulticall: '0x96a7F0E4905F39508b17Faef5aC456C72a4E1319',
+      chunksCount: 5,
+      initRetryFrequency: 30,
+      initHash:
+        '0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54',
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/0xalucard/ftm-spooky-v3',
+    },
+  },
   Retro: {
     [Network.POLYGON]: {
       factory: '0x91e1B99072f238352f59e58de875691e20Dc19c1',
@@ -303,6 +346,72 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       subgraphURL: 'https://api.thegraph.com/subgraphs/name/baseswapfi/v3-base',
     },
   },
+  AlienBaseV3: {
+    [Network.BASE]: {
+      factory: '0x0Fd83557b2be93617c9C1C1B6fd549401C74558C',
+      quoter: '0x4fDBD73aD4B1DDde594BF05497C15f76308eFfb9',
+      router: '0x79edabc464dcdce8cbf1b60c003aceef7e0282d9',
+      supportedFees: [10000n, 3000n, 750n, 200n],
+      stateMulticall: '0x7160f736c52e1e78e92FD4eE4D73e21A7Cf4F950',
+      uniswapMulticall: '0x091e99cb1C49331a94dD62755D168E941AbD0693',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
+      subgraphURL: 'https://api.studio.thegraph.com/query/59130/v3alb/0.3',
+    },
+  },
+  VelodromeSlipstream: {
+    [Network.OPTIMISM]: {
+      factory: '0x548118C7E0B865C2CfA94D15EC86B666468ac758',
+      quoter: '0xA2DEcF05c16537C702779083Fe067e308463CE45',
+      router: '0x93A3b44C38A8557E935B3e2549B2809a582c28EE',
+      supportedFees: SUPPORTED_FEES,
+      tickSpacings: [1n, 50n, 100n, 200n, 2000n],
+      tickSpacingsToFees: {
+        '1': 100n,
+        '50': 500n,
+        '100': 500n,
+        '200': 3000n,
+        '2000': 10000n,
+      },
+      stateMulticall: '0xc055b23319b3a140D4De2d0001bd0A885B3d7DbB',
+      stateMultiCallAbi: VelodromeSlipstreamMulticallABi as AbiItem[],
+      eventPoolImplementation: VelodromeSlipstreamEventPool,
+      factoryImplementation: VelodromeSlipstreamFactory,
+      decodeStateMultiCallResultWithRelativeBitmaps:
+        decodeStateMultiCallResultWithRelativeBitmapsForVelodromeSlipstream,
+      uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: '0xE0A596c403E854FFb9C828aB4f07eEae04A05D37', // pool implementation address from factory contract is used instead of initHash here
+    },
+  },
+  AerodromeSlipstream: {
+    [Network.BASE]: {
+      factory: '0x5e7BB104d84c7CB9B682AaC2F3d509f5F406809A',
+      quoter: '0x254cF9E1E6e233aa1AC962CB9B05b2cfeAaE15b0',
+      router: '0x1b2b6cE813b99b840Fe632c63bcA5394938Ef01e',
+      supportedFees: SUPPORTED_FEES,
+      tickSpacings: [1n, 50n, 100n, 200n, 2000n],
+      tickSpacingsToFees: {
+        '1': 100n,
+        '50': 500n,
+        '100': 500n,
+        '200': 3000n,
+        '2000': 10000n,
+      },
+      stateMulticall: '0x736518161516c1cfBD5bf5e7049FCBDC9b933987',
+      stateMultiCallAbi: VelodromeSlipstreamMulticallABi as AbiItem[],
+      eventPoolImplementation: VelodromeSlipstreamEventPool,
+      factoryImplementation: VelodromeSlipstreamFactory,
+      decodeStateMultiCallResultWithRelativeBitmaps:
+        decodeStateMultiCallResultWithRelativeBitmapsForVelodromeSlipstream,
+      uniswapMulticall: '0x091e99cb1C49331a94dD62755D168E941AbD0693',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: '0xeC8E5342B19977B4eF8892e02D8DAEcfa1315831', // pool implementation address from factory contract is used instead of initHash here
+    },
+  },
 };
 
 export const Adapters: Record<number, AdapterMappings> = {

package/src/dex/uniswap-v3/forks/velodrome-slipstream/utils.ts

@@ -0,0 +1,65 @@
+import { MultiResult } from '../../../../lib/multi-wrapper';
+import { BytesLike, ethers } from 'ethers';
+import { DecodedStateMultiCallResultWithRelativeBitmaps } from '../../types';
+import { extractSuccessAndValue } from '../../../../lib/decoders';
+import { assert } from 'ts-essentials';
+
+export function decodeStateMultiCallResultWithRelativeBitmaps(
+  result: MultiResult<BytesLike> | BytesLike,
+): DecodedStateMultiCallResultWithRelativeBitmaps {
+  const [isSuccess, toDecode] = extractSuccessAndValue(result);
+
+  assert(
+    isSuccess && toDecode !== '0x',
+    `decodeStateMultiCallResultWithRelativeBitmaps failed to get decodable result: ${result}`,
+  );
+
+  const decoded = ethers.utils.defaultAbiCoder.decode(
+    [
+      // I don't want to pass here any interface, so I just use it in ethers format
+      `
+      tuple(
+        address pool,
+        uint256 blockTimestamp,
+        tuple(
+          uint160 sqrtPriceX96,
+          int24 tick,
+          uint16 observationIndex,
+          uint16 observationCardinality,
+          uint16 observationCardinalityNext,
+          bool unlocked,
+        ) slot0,
+        uint128 liquidity,
+        int24 tickSpacing,
+        uint128 maxLiquidityPerTick,
+        tuple(
+          uint32 blockTimestamp,
+          int56 tickCumulative,
+          uint160 secondsPerLiquidityCumulativeX128,
+          bool initialized,
+        ) observation,
+        tuple(
+          int16 index,
+          uint256 value
+        )[] tickBitmap,
+        tuple(
+          int24 index,
+          tuple(
+            uint128 liquidityGross,
+            int128 liquidityNet,
+            int56 tickCumulativeOutside,
+            uint160 secondsPerLiquidityOutsideX128,
+            uint32 secondsOutside,
+            bool initialized,
+          ) value,
+        )[] ticks
+      )
+    `,
+    ],
+    toDecode,
+  )[0];
+
+  // This conversion is not precise, because when we decode, we have more values
+  // But I typed only the ones that are used later
+  return decoded as DecodedStateMultiCallResultWithRelativeBitmaps;
+}

package/src/dex/uniswap-v3/forks/velodrome-slipstream/velodrome-slipstream-factory.ts

@@ -0,0 +1,16 @@
+import { UniswapV3Factory } from '../../uniswap-v3-factory';
+import { LogDescription } from 'ethers/lib/utils';
+import { Interface } from '@ethersproject/abi';
+import FactoryABI from '../../../../abi/velodrome-slipstream/VelodromeSlipstreamFactory.abi.json';
+
+export class VelodromeSlipstreamFactory extends UniswapV3Factory {
+  public readonly factoryIface = new Interface(FactoryABI);
+
+  async handleNewPool(event: LogDescription) {
+    const token0 = event.args.token0.toLowerCase();
+    const token1 = event.args.token1.toLowerCase();
+    const tickSpacing = event.args.tickSpacing;
+
+    await this.onPoolCreated({ token0, token1, fee: tickSpacing });
+  }
+}

package/src/dex/uniswap-v3/forks/velodrome-slipstream/velodrome-slipstream-pool.ts

@@ -0,0 +1,197 @@
+import { UniswapV3EventPool } from '../../uniswap-v3-pool';
+import { Interface } from 'ethers/lib/utils';
+import VelodromeSlipstreamPoolABI from '../../../../abi/velodrome-slipstream/VelodromeSlipstreamPool.abi.json';
+import VelodromeSlipstreamFactoryABI from '../../../../abi/velodrome-slipstream/VelodromeSlipstreamFactory.abi.json';
+import { MultiCallParams } from '../../../../lib/multi-wrapper';
+import {
+  DecodedStateMultiCallResultWithRelativeBitmaps,
+  PoolState,
+} from '../../types';
+import { uint24ToBigInt, uint256ToBigInt } from '../../../../lib/decoders';
+import { decodeStateMultiCallResultWithRelativeBitmaps } from './utils';
+import { Address, Logger } from '../../../../types';
+import { assert } from 'ts-essentials';
+import { _reduceTickBitmap, _reduceTicks } from '../../contract-math/utils';
+import { bigIntify } from '../../../../utils';
+import { TickBitMap } from '../../contract-math/TickBitMap';
+import { ethers } from 'ethers';
+
+export class VelodromeSlipstreamEventPool extends UniswapV3EventPool {
+  public readonly poolIface = new Interface(VelodromeSlipstreamPoolABI);
+  public readonly factoryIface = new Interface(VelodromeSlipstreamFactoryABI);
+
+  protected _getStateRequestCallData() {
+    if (!this._stateRequestCallData) {
+      const callData: MultiCallParams<
+        bigint | DecodedStateMultiCallResultWithRelativeBitmaps
+      >[] = [
+        {
+          target: this.token0,
+          callData: this.erc20Interface.encodeFunctionData('balanceOf', [
+            this.poolAddress,
+          ]),
+          decodeFunction: uint256ToBigInt,
+        },
+        {
+          target: this.token1,
+          callData: this.erc20Interface.encodeFunctionData('balanceOf', [
+            this.poolAddress,
+          ]),
+          decodeFunction: uint256ToBigInt,
+        },
+        {
+          target: this.factoryAddress,
+          callData: this.factoryIface.encodeFunctionData('getSwapFee', [
+            this.poolAddress,
+          ]),
+          decodeFunction: uint24ToBigInt,
+        },
+        {
+          target: this.stateMultiContract.options.address,
+          callData: this.stateMultiContract.methods
+            .getFullStateWithRelativeBitmaps(
+              this.factoryAddress,
+              this.token0,
+              this.token1,
+              this.tickSpacing,
+              this.getBitmapRangeToRequest(),
+              this.getBitmapRangeToRequest(),
+            )
+            .encodeABI(),
+          decodeFunction:
+            this.decodeStateMultiCallResultWithRelativeBitmaps !== undefined
+              ? this.decodeStateMultiCallResultWithRelativeBitmaps
+              : decodeStateMultiCallResultWithRelativeBitmaps,
+        },
+      ];
+
+      this._stateRequestCallData = callData;
+    }
+    return this._stateRequestCallData;
+  }
+
+  async generateState(blockNumber: number): Promise<Readonly<PoolState>> {
+    const callData = this._getStateRequestCallData();
+
+    const [resBalance0, resBalance1, resSwapFee, resState] =
+      await this.dexHelper.multiWrapper.tryAggregate<
+        bigint | DecodedStateMultiCallResultWithRelativeBitmaps
+      >(
+        false,
+        callData,
+        blockNumber,
+        this.dexHelper.multiWrapper.defaultBatchSize,
+        false,
+      );
+
+    // Quite ugly solution, but this is the one that fits to current flow.
+    // I think UniswapV3 callbacks subscriptions are complexified for no reason.
+    // Need to be revisited later
+    assert(resState.success, 'Pool does not exist');
+
+    const [balance0, balance1, fee, _state] = [
+      resBalance0.returnData,
+      resBalance1.returnData,
+      resSwapFee.returnData,
+      resState.returnData,
+    ] as [
+      bigint,
+      bigint,
+      bigint,
+      DecodedStateMultiCallResultWithRelativeBitmaps,
+    ];
+
+    const tickBitmap = {};
+    const ticks = {};
+
+    _reduceTickBitmap(tickBitmap, _state.tickBitmap);
+    _reduceTicks(ticks, _state.ticks);
+
+    const observations = {
+      [_state.slot0.observationIndex]: {
+        blockTimestamp: bigIntify(_state.observation.blockTimestamp),
+        tickCumulative: bigIntify(_state.observation.tickCumulative),
+        secondsPerLiquidityCumulativeX128: bigIntify(
+          _state.observation.secondsPerLiquidityCumulativeX128,
+        ),
+        initialized: _state.observation.initialized,
+      },
+    };
+
+    const currentTick = bigIntify(_state.slot0.tick);
+    const tickSpacing = bigIntify(_state.tickSpacing);
+
+    const startTickBitmap = TickBitMap.position(currentTick / tickSpacing)[0];
+    const requestedRange = this.getBitmapRangeToRequest();
+
+    return {
+      pool: _state.pool,
+      fee,
+      blockTimestamp: bigIntify(_state.blockTimestamp),
+      slot0: {
+        sqrtPriceX96: bigIntify(_state.slot0.sqrtPriceX96),
+        tick: currentTick,
+        observationIndex: +_state.slot0.observationIndex,
+        observationCardinality: +_state.slot0.observationCardinality,
+        observationCardinalityNext: +_state.slot0.observationCardinalityNext,
+        feeProtocol: this.feeCode,
+      },
+      liquidity: bigIntify(_state.liquidity),
+      tickSpacing,
+      maxLiquidityPerTick: bigIntify(_state.maxLiquidityPerTick),
+      tickBitmap,
+      ticks,
+      observations,
+      isValid: true,
+      startTickBitmap,
+      lowestKnownTick:
+        (BigInt.asIntN(24, startTickBitmap - requestedRange) << 8n) *
+        tickSpacing,
+      highestKnownTick:
+        ((BigInt.asIntN(24, startTickBitmap + requestedRange) << 8n) +
+          BigInt.asIntN(24, 255n)) *
+        tickSpacing,
+      balance0,
+      balance1,
+    };
+  }
+
+  private predictDeterministicAddress(
+    factory: string,
+    implementation: string,
+    salt: string,
+  ) {
+    const creationCode = [
+      '0x3d602d80600a3d3981f3363d3d373d3d3d363d73', // https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/proxy/Clones.sol#L110
+      implementation.replace(/0x/, '').toLowerCase(),
+      '5af43d82803e903d91602b57fd5bf3', // https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/proxy/Clones.sol#L108
+    ].join('');
+
+    return ethers.utils.getCreate2Address(
+      factory,
+      salt,
+      ethers.utils.keccak256(creationCode),
+    ) as Address;
+  }
+
+  protected _computePoolAddress(
+    token0: Address,
+    token1: Address,
+    fee: bigint,
+  ): Address {
+    if (token0 > token1) [token0, token1] = [token1, token0];
+
+    const encodedKey = ethers.utils.keccak256(
+      ethers.utils.defaultAbiCoder.encode(
+        ['address', 'address', 'int24'],
+        [token0, token1, BigInt.asUintN(24, this.tickSpacing!)],
+      ),
+    );
+
+    return this.predictDeterministicAddress(
+      this.factoryAddress,
+      this.poolInitCodeHash, // actually this is pool implementation address
+      encodedKey,
+    );
+  }
+}

package/src/dex/uniswap-v3/forks/velodrome-slipstream/velodrome-slipstream.ts

@@ -0,0 +1,237 @@
+import {
+  UniswapV3,
+  UNISWAPV3_CLEAN_NOT_EXISTING_POOL_TTL_MS,
+  UNISWAPV3_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS,
+} from '../../uniswap-v3';
+import { Network, SwapSide } from '../../../../constants';
+import { IDexHelper } from '../../../../dex-helper';
+import { Adapters, UniswapV3Config } from '../../config';
+import { Interface } from '@ethersproject/abi';
+import UniswapV3RouterABI from '../../../../abi/uniswap-v3/UniswapV3Router.abi.json';
+import UniswapV3QuoterV2ABI from '../../../../abi/uniswap-v3/UniswapV3QuoterV2.abi.json';
+import { getDexKeysWithNetwork } from '../../../../utils';
+import _ from 'lodash';
+import { Address, NumberAsString, Token } from '../../../../types';
+import { pack } from '@ethersproject/solidity';
+import { PoolState } from '../../types';
+import { VelodromeSlipstreamEventPool } from './velodrome-slipstream-pool';
+import { UniswapV3EventPool } from '../../uniswap-v3-pool';
+import {
+  OnPoolCreatedCallback,
+  UniswapV3Factory,
+} from '../../uniswap-v3-factory';
+
+type VelodromeSlipstreamData = {
+  path: {
+    tokenIn: Address;
+    tokenOut: Address;
+    fee: NumberAsString;
+    currentFee?: NumberAsString;
+    tickSpacing?: NumberAsString;
+  }[];
+  isApproved?: boolean;
+};
+
+export class VelodromeSlipstream extends UniswapV3 {
+  readonly eventPools: Record<string, VelodromeSlipstreamEventPool | null> = {};
+
+  constructor(
+    protected network: Network,
+    dexKey: string,
+    protected dexHelper: IDexHelper,
+    protected adapters = Adapters[network] || {},
+    readonly routerIface = new Interface(UniswapV3RouterABI),
+    readonly quoterIface = new Interface(UniswapV3QuoterV2ABI),
+    protected config = UniswapV3Config[dexKey][network],
+    protected poolsToPreload = [],
+  ) {
+    super(
+      network,
+      dexKey,
+      dexHelper,
+      adapters,
+      routerIface,
+      quoterIface,
+      config,
+      poolsToPreload,
+    );
+  }
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(
+      _.pick(UniswapV3Config, ['VelodromeSlipstream', 'AerodromeSlipstream']),
+    );
+
+  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 =
+          Date.now() - UNISWAPV3_CLEAN_NOT_EXISTING_POOL_TTL_MS;
+        await this.dexHelper.cache.zremrangebyscore(
+          this.notExistingPoolSetKey,
+          0,
+          maxTimestamp,
+        );
+      };
+
+      this.intervalTask = setInterval(
+        cleanExpiredNotExistingPoolsKeys.bind(this),
+        UNISWAPV3_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS,
+      );
+    }
+  }
+
+  async getPoolsForIdentifiers(
+    srcAddress: string,
+    destAddress: string,
+    blockNumber: number,
+  ): Promise<(UniswapV3EventPool | null)[]> {
+    return Promise.all(
+      this.config.tickSpacings!.map(async tickSpacing =>
+        this.getPool(
+          srcAddress,
+          destAddress,
+          this.config.tickSpacingsToFees![tickSpacing.toString()],
+          blockNumber,
+          tickSpacing,
+        ),
+      ),
+    );
+  }
+
+  protected async getSelectedPools(
+    srcAddress: string,
+    destAddress: string,
+    blockNumber: number,
+  ): Promise<(UniswapV3EventPool | null)[]> {
+    return Promise.all(
+      this.config.tickSpacings!.map(async tickSpacing => {
+        const fee = this.config.tickSpacingsToFees![tickSpacing.toString()];
+        const locallyFoundPool =
+          this.eventPools[
+            this.getPoolIdentifier(srcAddress, destAddress, fee, tickSpacing)
+          ];
+
+        if (locallyFoundPool) return locallyFoundPool;
+
+        const newlyFetchedPool = await this.getPool(
+          srcAddress,
+          destAddress,
+          fee,
+          blockNumber,
+          tickSpacing,
+        );
+        return newlyFetchedPool;
+      }),
+    );
+  }
+
+  protected _encodePath(
+    path: {
+      tokenIn: Address;
+      tokenOut: Address;
+      tickSpacing: NumberAsString;
+      fee: NumberAsString;
+    }[],
+    side: SwapSide,
+  ): string {
+    if (path.length === 0) {
+      this.logger.error(
+        `${this.dexKey}: Received invalid path=${path} for side=${side} to encode`,
+      );
+      return '0x';
+    }
+
+    const { _path, types } = path.reduce(
+      (
+        { _path, types }: { _path: string[]; types: string[] },
+        curr,
+        index,
+      ): { _path: string[]; types: string[] } => {
+        if (index === 0) {
+          return {
+            types: ['address', 'uint24', 'address'],
+            _path: [curr.tokenIn, curr.tickSpacing, curr.tokenOut],
+          };
+        } else {
+          return {
+            types: [...types, 'uint24', 'address'],
+            _path: [..._path, curr.tickSpacing, curr.tokenOut],
+          };
+        }
+      },
+      { _path: [], types: [] },
+    );
+
+    return side === SwapSide.BUY
+      ? pack(types.reverse(), _path.reverse())
+      : pack(types, _path);
+  }
+
+  protected prepareData(
+    srcAddress: string,
+    destAddress: string,
+    pool: UniswapV3EventPool,
+    state: PoolState,
+  ): VelodromeSlipstreamData {
+    return {
+      path: [
+        {
+          tokenIn: srcAddress,
+          tokenOut: destAddress,
+          fee: pool.feeCode.toString(),
+          currentFee: state.fee.toString(),
+          tickSpacing: state.tickSpacing!.toString(),
+        },
+      ],
+    };
+  }
+
+  /*
+   * 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
+   */
+  protected onPoolCreatedDeleteFromNonExistingSet(): OnPoolCreatedCallback {
+    return async ({
+      token0,
+      token1,
+      fee, // actually this is a tickSpacing in this case
+    }) => {
+      const tickSpacing = fee;
+      const actualFee = this.config.tickSpacingsToFees![tickSpacing.toString()];
+
+      const logPrefix = '[onPoolCreatedDeleteFromNonExistingSet]';
+      const [_token0, _token1] = this._sortTokens(token0, token1);
+      const poolKey = `${_token0}_${_token1}_${actualFee}_${tickSpacing}`;
+
+      // 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, actualFee, tickSpacing)
+      ];
+
+      try {
+        this.logger.info(
+          `${logPrefix} delete pool from not existing set=${this.notExistingPoolSetKey}; key=${poolKey}`,
+        );
+        // delete pool record from set
+        const result = await this.dexHelper.cache.zrem(
+          this.notExistingPoolSetKey,
+          [poolKey],
+        );
+        this.logger.info(
+          `${logPrefix} delete pool from not existing set=${this.notExistingPoolSetKey}; key=${poolKey}; result: ${result}`,
+        );
+      } catch (error) {
+        this.logger.error(
+          `${logPrefix} ERROR: failed to delete pool from set: set=${this.notExistingPoolSetKey}; key=${poolKey}`,
+          error,
+        );
+      }
+    };
+  }
+}