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

package/src/dex/solidly/solidly.ts

@@ -66,12 +66,16 @@ export class Solidly extends UniswapV2 {
     getDexKeysWithNetwork(
       _.omit(SolidlyConfig, [
         'Velodrome',
+        'VelodromeV2',
         'SpiritSwapV2',
         'Cone',
         'SolidlyV2',
         'Thena',
         'SoliSnek',
         'Chronos',
+        'Ramses',
+        'Equalizer',
+        'Aerodrome',
       ]),
     );
 
@@ -520,6 +524,7 @@ export class Solidly extends UniswapV2 {
     const pair = await this.findSolidlyPair(from, to, stable);
     if (!(pair && pair.pool && pair.exchange)) return null;
     const pairState = pair.pool.getState(blockNumber);
+
     if (!pairState) {
       this.logger.error(
         `Error_orderPairParams expected reserves, got none (maybe the pool doesn't exist) ${

package/src/dex/uniswap-v2/nomiswap-v2.ts

@@ -0,0 +1,63 @@
+import { Network } from '../../constants';
+import { getDexKeysWithNetwork } from '../../utils';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { UniswapV2, UniswapV2Pair } from '../uniswap-v2/uniswap-v2';
+import { Interface } from '@ethersproject/abi';
+import NomiswapPoolABI from '../../abi/nomiswap-v2/nomiswap-v2-pool.json';
+import { DexParams } from './types';
+import { DexConfigMap } from '../../types';
+
+export const NomiswapV2Config: DexConfigMap<DexParams> = {
+  NomiswapV2: {
+    [Network.BSC]: {
+      factoryAddress: '0xd6715A8be3944ec72738F0BFDC739d48C3c29349',
+      initCode:
+        '0x83eb759f5ea0525124f03d4ac741bb4af0bb1c703d5f694bd42a8bd72e495a01',
+      poolGasCost: 120 * 1000,
+      feeCode: 0, // this is ignored as Nomiswap uses dynamic fees,
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/nominex/nomiswap-exchange-subgraph',
+    },
+  },
+};
+
+export class NomiswapV2 extends UniswapV2 {
+  nomiswapPool: Interface;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(NomiswapV2Config);
+
+  constructor(
+    protected network: Network,
+    dexKey: string,
+    protected dexHelper: IDexHelper,
+  ) {
+    super(
+      network,
+      dexKey,
+      dexHelper,
+      true,
+      NomiswapV2Config[dexKey][network].factoryAddress,
+      NomiswapV2Config[dexKey][network].subgraphURL,
+      NomiswapV2Config[dexKey][network].initCode,
+      NomiswapV2Config[dexKey][network].feeCode,
+      NomiswapV2Config[dexKey][network].poolGasCost,
+    );
+    this.nomiswapPool = new Interface(NomiswapPoolABI);
+  }
+
+  protected getFeesMultiCallData(pair: UniswapV2Pair) {
+    const callEntry = {
+      target: pair.exchange!,
+      callData: this.nomiswapPool.encodeFunctionData('swapFee', []),
+    };
+    const callDecoder = (values: any[]) =>
+      parseInt(
+        this.nomiswapPool.decodeFunctionResult('swapFee', values)[0].toString(),
+      ) * 10;
+    return {
+      callEntry,
+      callDecoder,
+    };
+  }
+}

package/src/dex/uniswap-v2/uniswap-v2-e2e-bsc.test.ts

@@ -2,11 +2,108 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 import { testE2E } from '../../../tests/utils-e2e';
-import { Tokens, Holders } from '../../../tests/constants-e2e';
+import {
+  Tokens,
+  Holders,
+  NativeTokenSymbols,
+} from '../../../tests/constants-e2e';
 import { Network, ContractMethod, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { generateConfig } from '../../config';
 
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+  nativeTokenAmount: string,
+  slippage?: number | undefined,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+  const nativeTokenSymbol = NativeTokenSymbols[network];
+
+  const sideToContractMethods = new Map([
+    [
+      SwapSide.SELL,
+      [
+        ContractMethod.simpleSwap,
+        ContractMethod.multiSwap,
+        ContractMethod.megaSwap,
+      ],
+    ],
+    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+  ]);
+
+  describe(`${network}`, () => {
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            it(`${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[nativeTokenSymbol],
+                tokens[tokenASymbol],
+                holders[nativeTokenSymbol],
+                side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+            it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[nativeTokenSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
 describe('UniswapV2 E2E BSC', () => {
   const network = Network.BSC;
   const tokens = Tokens[network];
@@ -1407,6 +1504,28 @@ describe('UniswapV2 E2E BSC', () => {
     });
   });
 
+  describe('NomiswapV2', () => {
+    const dexKey = 'NomiswapV2';
+    const network = Network.BSC;
+
+    const tokenASymbol: string = 'USDC';
+    const tokenBSymbol: string = 'USDT';
+
+    const tokenAAmount: string = '1111100000';
+    const tokenBAmount: string = '1000000000';
+    const nativeTokenAmount = '11000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+      nativeTokenAmount,
+    );
+  });
+
   describe(`Swapsicle`, () => {
     const dexKey = 'Swapsicle';
 

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

@@ -2,6 +2,10 @@ import { DexParams } from './types';
 import { DexConfigMap, AdapterMappings } from '../../types';
 import { Network, SwapSide } from '../../constants';
 import { Address } from '../../types';
+import RamsesV2StateMulticallABI from '../../abi/RamsesV2StateMulticall.abi.json';
+import { AbiItem } from 'web3-utils';
+import { decodeStateMultiCallResultWithRelativeBitmaps } from './forks/ramses-v2/utils';
+import { RamsesV2EventPool } from './forks/ramses-v2/ramses-v2-pool';
 
 const SUPPORTED_FEES = [10000n, 3000n, 500n, 100n];
 
@@ -103,6 +107,158 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       subgraphURL:
         'https://api.thegraph.com/subgraphs/name/lynnshaoyu/uniswap-v3-avax',
     },
+    [Network.BASE]: {
+      factory: '0x33128a8fC17869897dcE68Ed026d694621f6FDfD',
+      quoter: '0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a',
+      router: '0xaeE2b8d4A154e36f479dAeCe3FB3e6c3c03d396E',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0x7160f736c52e1e78e92FD4eE4D73e21A7Cf4F950',
+      uniswapMulticall: '0x091e99cb1C49331a94dD62755D168E941AbD0693',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
+      subgraphURL:
+        'https://api.studio.thegraph.com/query/48211/uniswap-v3-base/version/latest',
+    },
+  },
+  SushiSwapV3: {
+    [Network.MAINNET]: {
+      factory: '0xbACEB8eC6b9355Dfc0269C18bac9d6E2Bdc29C4F',
+      quoter: '0x64e8802FE490fa7cc61d3463958199161Bb608A7',
+      router: '0x00F23572b16c5e9e58e7b965DEF51Ff8Ff546E34',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0x9c764D2e92dA68E4CDfD784B902283A095ff8b63',
+      uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/sushi-v3/v3-ethereum',
+    },
+    [Network.POLYGON]: {
+      factory: '0x917933899c6a5f8e37f31e19f92cdbff7e8ff0e2',
+      quoter: '0xb1E835Dc2785b52265711e17fCCb0fd018226a6e',
+      router: '0x34D41cE301257a4615D4F5AD260FA91D03925243',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0x6Dc993Fe1e945A640576B4Dca81281d8e998DF71',
+      uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/sushi-v3/v3-polygon',
+    },
+    [Network.BSC]: {
+      factory: '0x126555dd55a39328F69400d6aE4F782Bd4C34ABb',
+      quoter: '0xb1E835Dc2785b52265711e17fCCb0fd018226a6e',
+      router: '0xDCf4EE5B700e2a5Fec458e06B763A4a3E3004494',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0x593F39A4Ba26A9c8ed2128ac95D109E8e403C485',
+      uniswapMulticall: '0x963Df249eD09c358A4819E39d9Cd5736c3087184',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
+      subgraphURL: 'https://api.thegraph.com/subgraphs/name/sushi-v3/v3-bsc',
+    },
+    [Network.AVALANCHE]: {
+      factory: '0x3e603C14aF37EBdaD31709C4f848Fc6aD5BEc715',
+      quoter: '0xb1E835Dc2785b52265711e17fCCb0fd018226a6e',
+      router: '0x24c90C7d8fb463722e304A71255341610Fa7589b',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0x30F6B9b6485ff0B67E881f5ac80D3F1c70A4B23d',
+      uniswapMulticall: '0x8C0F842791F03C095b6c633759224FcC9ACe68ea',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/sushi-v3/v3-avalanche',
+    },
+    [Network.FANTOM]: {
+      factory: '0x7770978eED668a3ba661d51a773d3a992Fc9DDCB',
+      quoter: '0xb1E835Dc2785b52265711e17fCCb0fd018226a6e',
+      router: '0xDCf4EE5B700e2a5Fec458e06B763A4a3E3004494',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0x30F6B9b6485ff0B67E881f5ac80D3F1c70A4B23d',
+      uniswapMulticall: '0xB1395e098c0a847CC719Bcf1Fc8114421a9F8232',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
+      subgraphURL: 'https://api.thegraph.com/subgraphs/name/sushi-v3/v3-fantom',
+    },
+    [Network.ARBITRUM]: {
+      factory: '0x1af415a1eba07a4986a52b6f2e7de7003d82231e',
+      quoter: '0x0524E833cCD057e4d7A296e3aaAb9f7675964Ce1',
+      router: '0xbDa4176fD98b47018aF673805d069b9dbd49373D',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0xaBB58098A7B5172A9b0B38a1925A522dbf0b4FC3',
+      uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/sushi-v3/v3-arbitrum',
+    },
+    [Network.OPTIMISM]: {
+      factory: '0x9c6522117e2ed1fE5bdb72bb0eD5E3f2bdE7DBe0',
+      quoter: '0xb1E835Dc2785b52265711e17fCCb0fd018226a6e',
+      router: '0xa05d8C3F278fC7b20b39Ea7A3035E3aD8D808c78',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0x4FF0dEC5f9a763Aa1E5C2a962aa6f4eDFeE4f9eA',
+      uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/sushi-v3/v3-optimism',
+    },
+    [Network.BASE]: {
+      factory: '0xc35DADB65012eC5796536bD9864eD8773aBc74C4',
+      quoter: '0xb1E835Dc2785b52265711e17fCCb0fd018226a6e',
+      router: '0xCc0e85901f33D375FcdD9a888B05Df9616F68277',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0x7160f736c52e1e78e92FD4eE4D73e21A7Cf4F950',
+      uniswapMulticall: '0x091e99cb1C49331a94dD62755D168E941AbD0693',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
+      subgraphURL: 'https://api.studio.thegraph.com/query/32073/v3-base/v0.0.1',
+    },
+  },
+  ChronosV3: {
+    [Network.ARBITRUM]: {
+      factory: '0x4Db9D624F67E00dbF8ef7AE0e0e8eE54aF1dee49',
+      quoter: '0x6E7f0Ca45171a4440c0CDdF3A46A8dC5D4c2d4A0',
+      router: '0xE0aBdFD837D451640CF43cB1Ec4eE87976eFbb41',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0x46b44eb4Cc3bEbB9f04C419f691aB85Ff885A4D6',
+      uniswapMulticall: '0xaBB58098A7B5172A9b0B38a1925A522dbf0b4FC3',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash:
+        '0x09c178be473df44d1de6970978a4fdedce1ce52a23b2b979754547f6b43a19a5',
+      subgraphURL:
+        'https://subgraph.chronos.exchange/subgraphs/name/chronos-v3',
+    },
+  },
+  RamsesV2: {
+    [Network.ARBITRUM]: {
+      factory: '0xAA2cd7477c451E703f3B9Ba5663334914763edF8',
+      deployer: '0xb3e423ab9cE6C03D98326A3A2a0D7D96b0829f22',
+      quoter: '0xAA20EFF7ad2F523590dE6c04918DaAE0904E3b20',
+      router: '0xAA23611badAFB62D37E7295A682D21960ac85A90',
+      supportedFees: [...SUPPORTED_FEES, 50n],
+      stateMulticall: '0x50EE4112Cab9c79812F23bE079aB3911395ACc8e',
+      stateMultiCallAbi: RamsesV2StateMulticallABI as AbiItem[],
+      uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      eventPoolImplementation: RamsesV2EventPool,
+      decodeStateMultiCallResultWithRelativeBitmaps,
+      initHash:
+        '0x1565b129f2d1790f12d45301b9b084335626f0c92410bc43130763b69971135d',
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/ramsesexchange/concentrated-liquidity-graph',
+    },
   },
   'QuickSwapV3.1': {
     [Network.ZKEVM]: {
@@ -119,6 +275,20 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
         'https://api.studio.thegraph.com/query/44554/uniswap-v3/version/latest',
     },
   },
+  Retro: {
+    [Network.POLYGON]: {
+      factory: '0x91e1B99072f238352f59e58de875691e20Dc19c1',
+      quoter: '0xfe08be075758935cb6cb9318d1fbb60920416d4e',
+      router: '0x1891783cb3497Fdad1F25C933225243c2c7c4102',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0x6Dc993Fe1e945A640576B4Dca81281d8e998DF71',
+      uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: `0x817e07951f93017a93327ac8cc31e946540203a19e1ecc37bc1761965c2d1090`,
+      subgraphURL: 'https://api.thegraph.com/subgraphs/name/ruvlol/univ3-test',
+    },
+  },
 };
 
 export const Adapters: Record<number, AdapterMappings> = {
@@ -154,4 +324,8 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'AvalancheAdapter02', index: 5 }],
     [SwapSide.BUY]: [{ name: 'AvalancheBuyAdapter', index: 6 }],
   },
+  [Network.BASE]: {
+    [SwapSide.SELL]: [{ name: 'BaseAdapter01', index: 1 }],
+    [SwapSide.BUY]: [{ name: 'BaseBuyAdapter', index: 1 }],
+  },
 };

package/src/dex/uniswap-v3/forks/ramses-v2/ramses-v2-pool.ts

@@ -0,0 +1,156 @@
+import { UniswapV3EventPool } from '../../uniswap-v3-pool';
+import {
+  DecodedStateMultiCallResultWithRelativeBitmaps,
+  DecodeStateMultiCallFunc,
+  PoolState,
+} 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 { uint24ToBigInt } from '../../../../lib/decoders';
+import { Interface } from 'ethers/lib/utils';
+import RamsesV2PoolABI from '../../../../abi/ramses-v2/RamsesV2Pool.abi.json';
+import { IDexHelper } from '../../../../dex-helper';
+import { Contract } from 'web3-eth-contract';
+import { Address, Logger } from '../../../../types';
+
+export class RamsesV2EventPool extends UniswapV3EventPool {
+  public readonly poolIface = new Interface(RamsesV2PoolABI);
+
+  constructor(
+    readonly dexHelper: IDexHelper,
+    parentName: string,
+    readonly stateMultiContract: Contract,
+    readonly decodeStateMultiCallResultWithRelativeBitmaps:
+      | DecodeStateMultiCallFunc
+      | undefined,
+    readonly erc20Interface: Interface,
+    protected readonly factoryAddress: Address,
+    public feeCode: bigint,
+    token0: Address,
+    token1: Address,
+    logger: Logger,
+    mapKey: string = '',
+    readonly poolInitCodeHash: string,
+  ) {
+    super(
+      dexHelper,
+      parentName,
+      stateMultiContract,
+      decodeStateMultiCallResultWithRelativeBitmaps,
+      erc20Interface,
+      factoryAddress,
+      feeCode,
+      token0,
+      token1,
+      logger,
+      mapKey,
+      poolInitCodeHash,
+    );
+
+    this.handlers['FeeAdjustment'] = this.handleFeeAdjustmentEvent.bind(this);
+  }
+
+  handleFeeAdjustmentEvent(event: any, pool: PoolState): PoolState {
+    const newFee = bigIntify(event.args.newFee);
+
+    pool.fee = newFee;
+
+    return pool;
+  }
+
+  async generateState(blockNumber: number): Promise<Readonly<PoolState>> {
+    const callData = this._getStateRequestCallData();
+
+    const calldataWithFee = [
+      ...callData,
+      {
+        target: this.poolAddress,
+        callData: this.poolIface.encodeFunctionData('currentFee'),
+        decodeFunction: uint24ToBigInt,
+      },
+    ];
+
+    this._stateRequestCallData = calldataWithFee;
+
+    const [resBalance0, resBalance1, resState, resCurrentFee] =
+      await this.dexHelper.multiWrapper.tryAggregate<
+        bigint | DecodedStateMultiCallResultWithRelativeBitmaps
+      >(
+        false,
+        calldataWithFee,
+        blockNumber,
+        this.dexHelper.multiWrapper.defaultBatchSize,
+        false,
+      );
+
+    assert(resState.success, 'Pool does not exist');
+
+    const [balance0, balance1, _state, fee] = [
+      resBalance0.returnData,
+      resBalance1.returnData,
+      resState.returnData,
+      resCurrentFee.returnData,
+    ] as [
+      bigint,
+      bigint,
+      DecodedStateMultiCallResultWithRelativeBitmaps,
+      bigint,
+    ];
+
+    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,
+      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: bigIntify(_state.slot0.feeProtocol),
+      },
+      liquidity: bigIntify(_state.liquidity),
+      fee,
+      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,
+    };
+  }
+}

package/src/dex/uniswap-v3/forks/ramses-v2/utils.ts

@@ -0,0 +1,72 @@
+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,
+          uint8 feeProtocol,
+          bool unlocked,
+        ) slot0,
+        uint128 liquidity,
+        int24 tickSpacing,
+        uint128 maxLiquidityPerTick,
+        tuple(
+          uint32 blockTimestamp,
+          int56 tickCumulative,
+          uint160 secondsPerLiquidityCumulativeX128,
+          bool initialized,
+          uint160 secondsPerBoostedLiquidityPeriodX128,
+          uint32 boostedInRange,
+        ) observation,
+        tuple(
+          int16 index,
+          uint256 value
+        )[] tickBitmap,
+        tuple(
+          int24 index,
+          tuple(
+            uint128 liquidityGross,
+            int128 liquidityNet,
+            uint128 cleanUnusedSlot,
+            uint128 cleanUnusedSlot2,
+            uint256 feeGrowthOutside0X128,
+            uint256 feeGrowthOutside1X128,
+            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/types.ts

@@ -1,6 +1,9 @@
-import { BigNumber } from 'ethers';
+import { BigNumber, BytesLike } from 'ethers';
 import { NumberAsString } from '../../types';
 import { Address } from '../../types';
+import { AbiItem } from 'web3-utils';
+import { MultiResult } from '../../lib/multi-wrapper';
+import { UniswapV3EventPool } from './uniswap-v3-pool';
 
 export type OracleObservation = {
   blockTimestamp: bigint;
@@ -51,15 +54,22 @@ export type PoolState = {
   balance1: bigint;
 };
 
+export type FactoryState = Record<string, never>;
+
 export type UniswapV3Data = {
   path: {
     tokenIn: Address;
     tokenOut: Address;
     fee: NumberAsString;
+    currentFee?: NumberAsString;
   }[];
   isApproved?: boolean;
 };
 
+export type DecodeStateMultiCallFunc = (
+  result: MultiResult<BytesLike> | BytesLike,
+) => DecodedStateMultiCallResultWithRelativeBitmaps;
+
 export type DexParams = {
   router: Address;
   quoter: Address;
@@ -72,6 +82,9 @@ export type DexParams = {
   deployer?: Address;
   subgraphURL: string;
   initHash: string;
+  stateMultiCallAbi?: AbiItem[];
+  eventPoolImplementation?: typeof UniswapV3EventPool;
+  decodeStateMultiCallResultWithRelativeBitmaps?: DecodeStateMultiCallFunc;
 };
 
 export type UniswapV3SimpleSwapSellParam = {