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

package/src/composed-event-subscriber.ts

@@ -110,17 +110,22 @@ export abstract class ComposedEventSubscriber<
           .call({}, blockNumber)
       ).returnData;
     }
-    const stateParts = await Promise.all(
-      this.parts.map((p, i) =>
-        p.generateState(
-          returnData.slice(...this.multiCallSlices[i]),
-          blockNumber,
+    try {
+      const stateParts = await Promise.all(
+        this.parts.map((p, i) =>
+          p.generateState(
+            returnData.slice(...this.multiCallSlices[i]),
+            blockNumber,
+          ),
         ),
-      ),
-    );
-    return this.parts.reduce(
-      (acc, p, i) => p.lens.set(stateParts[i])(acc),
-      this.blankState,
-    );
+      );
+      return this.parts.reduce(
+        (acc, p, i) => p.lens.set(stateParts[i])(acc),
+        this.blankState,
+      );
+    } catch (e) {
+      this.logger.error(`Error generating state: ${e}`);
+      throw e;
+    }
   }
 }

package/src/config.ts

@@ -30,6 +30,7 @@ type BaseConfig = {
   hashFlowAuthToken?: string;
   hashFlowDisabledMMs: string[];
   swaapV2AuthToken?: string;
+  forceRpcFallbackDexs: string[];
 };
 
 const baseConfigs: { [network: number]: BaseConfig } = {
@@ -49,9 +50,9 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     adapterAddresses: {
       Adapter01: '0x9bE264469eF954c139Da4A45Cf76CbCC5e3A6A73',
       Adapter02: '0xFC2Ba6E830a04C25e207B8214b26d8C713F6881F',
-      Adapter03: '0x7c7f62e5ba00783f57b39df0530e32c195696a57',
+      Adapter03: '0xfb2a3de6c7B8c77b520E3da16021f3D8A4E93168',
       Adapter04: '0x30F6B9b6485ff0B67E881f5ac80D3F1c70A4B23d',
-      BuyAdapter: '0xDCf4EE5B700e2a5Fec458e06B763A4a3E3004494',
+      BuyAdapter: '0x613876f3dE2Ec633f8054fE7a561324c1a01d9cB',
     },
     uniswapV2ExchangeRouterAddress:
       '0xF9234CB08edb93c0d4a4d4c70cC3FfD070e78e07',
@@ -115,6 +116,7 @@ const baseConfigs: { [network: number]: BaseConfig } = {
         },
       },
     },
+    forceRpcFallbackDexs: [],
   },
   [Network.ROPSTEN]: {
     network: Network.ROPSTEN,
@@ -142,6 +144,7 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     rfqConfigs: {},
     rpcPollingMaxAllowedStateDelayInBlocks: 5,
     rpcPollingBlocksBackToTriggerUpdate: 3,
+    forceRpcFallbackDexs: [],
   },
   [Network.BSC]: {
     network: Network.BSC,
@@ -160,14 +163,15 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_56`]?.split(',') || [],
     adapterAddresses: {
       BscAdapter01: '0xA31d9C571DF00e0F428B0bD24c34D103E8112222',
-      BscAdapter02: '0x1d2Fd92a1942A92a51198168eFCd626ed441CEC0',
-      BscBuyAdapter: '0x64C856fafE4C83a818514cBDfD661a3563a71B98',
+      BscAdapter02: '0x02f2c31ebDE63E871AD0E74c01E21c819292a59D',
+      BscBuyAdapter: '0x301c2813e3ceb43A448a12f21551EDBcdC37F157',
     },
     rpcPollingMaxAllowedStateDelayInBlocks: 1,
     rpcPollingBlocksBackToTriggerUpdate: 1,
     uniswapV2ExchangeRouterAddress:
       '0x53e693c6C7FFC4446c53B205Cf513105Bf140D7b',
     rfqConfigs: {},
+    forceRpcFallbackDexs: [],
   },
   [Network.POLYGON]: {
     network: Network.POLYGON,
@@ -187,8 +191,8 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_137`]?.split(',') || [],
     adapterAddresses: {
       PolygonAdapter01: '0xE44769f42E1e9592f86B82f206407a8f7C84b4ed',
-      PolygonAdapter02: '0xa05d8C3F278fC7b20b39Ea7A3035E3aD8D808c78',
-      PolygonBuyAdapter: '0xB11bCA7B01b425afD0743A4D77B4f593883f94C0',
+      PolygonAdapter02: '0x654cD2Cf97D23059B3db4FaA38BB2b1F8351211d',
+      PolygonBuyAdapter: '0x4426a1F87Ee7e366542c58e29c02AFa2b5878b37',
     },
     uniswapV2ExchangeRouterAddress:
       '0xf3938337F7294fEf84e9B2c6D548A93F956Cc281',
@@ -197,6 +201,7 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     rpcPollingMaxAllowedStateDelayInBlocks: 2,
     rpcPollingBlocksBackToTriggerUpdate: 1,
     swaapV2AuthToken: process.env.API_KEY_SWAAP_V2_AUTH_TOKEN || '',
+    forceRpcFallbackDexs: [],
   },
   [Network.AVALANCHE]: {
     network: Network.AVALANCHE,
@@ -216,14 +221,15 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_43114`]?.split(',') || [],
     adapterAddresses: {
       AvalancheAdapter01: '0x745Ec73855CeC7249E5fF4c9DD81cc65b4D297a9',
-      AvalancheAdapter02: '0xDCf4EE5B700e2a5Fec458e06B763A4a3E3004494',
-      AvalancheBuyAdapter: '0x7ebbDBB57d2ab59079423cf8337cf8805e225bB1',
+      AvalancheAdapter02: '0xFb8773AA4Fd02e54bbd352061D8Be1911FAa210a',
+      AvalancheBuyAdapter: '0x434C1Cca4842629230067674Dd54E21a14D9FD5D',
     },
     uniswapV2ExchangeRouterAddress:
       '0x53e693c6C7FFC4446c53B205Cf513105Bf140D7b',
     rfqConfigs: {},
     rpcPollingMaxAllowedStateDelayInBlocks: 2,
     rpcPollingBlocksBackToTriggerUpdate: 1,
+    forceRpcFallbackDexs: [],
   },
   [Network.FANTOM]: {
     network: Network.FANTOM,
@@ -251,6 +257,7 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     rfqConfigs: {},
     rpcPollingMaxAllowedStateDelayInBlocks: 2,
     rpcPollingBlocksBackToTriggerUpdate: 1,
+    forceRpcFallbackDexs: [],
   },
   [Network.ARBITRUM]: {
     network: Network.ARBITRUM,
@@ -269,9 +276,9 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     hashFlowDisabledMMs:
       process.env[`HASHFLOW_DISABLED_MMS_42161`]?.split(',') || [],
     adapterAddresses: {
-      ArbitrumAdapter01: '0x745Ec73855CeC7249E5fF4c9DD81cc65b4D297a9',
-      ArbitrumAdapter02: '0x3ad7f275E27AC579cA88e0b4765828242A9E8C49',
-      ArbitrumBuyAdapter: '0x6c33C7f6CBB4a428fe9ee31ca500a787c9f1525b',
+      ArbitrumAdapter01: '0xD8134ACfc9c71Ab51452b5bA23A31354F4739032',
+      ArbitrumAdapter02: '0xD1F70c98a78d48A93F0B4dDa49057469dc5aC126',
+      ArbitrumBuyAdapter: '0x434C1Cca4842629230067674Dd54E21a14D9FD5D',
     },
     uniswapV2ExchangeRouterAddress:
       '0xB41dD984730dAf82f5C41489E21ac79D5e3B61bC',
@@ -279,6 +286,7 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     rfqConfigs: {},
     rpcPollingMaxAllowedStateDelayInBlocks: 4,
     rpcPollingBlocksBackToTriggerUpdate: 3,
+    forceRpcFallbackDexs: [],
   },
   [Network.OPTIMISM]: {
     network: Network.OPTIMISM,
@@ -298,8 +306,8 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_10`]?.split(',') || [],
 
     adapterAddresses: {
-      OptimismAdapter01: '0x4669D27A649f5451e0D44C20a2b246431F1B0572',
-      OptimismBuyAdapter: '0xb2634B3CBc1E401AB3C2743DB44d459C5c9aA662',
+      OptimismAdapter01: '0x3ad7f275E27AC579cA88e0b4765828242A9E8C49',
+      OptimismBuyAdapter: '0xfdDD975FE4c1af20c24A3Ad2b33e8609a62DDC73',
     },
     uniswapV2ExchangeRouterAddress:
       '0xB41dD984730dAf82f5C41489E21ac79D5e3B61bC',
@@ -307,6 +315,63 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     rfqConfigs: {},
     rpcPollingMaxAllowedStateDelayInBlocks: 5,
     rpcPollingBlocksBackToTriggerUpdate: 3,
+    forceRpcFallbackDexs: [],
+  },
+  [Network.ZKEVM]: {
+    network: Network.ZKEVM,
+    networkName: 'Polygon zkEVM',
+    isTestnet: false,
+    nativeTokenName: 'Ether',
+    nativeTokenSymbol: 'ETH',
+    wrappedNativeTokenAddress: '0x4F9A0e7FD2Bf6067db6994CF12E4495Df938E6e9',
+    hasEIP1559: true,
+    augustusAddress: '0xB83B554730d29cE4Cb55BB42206c3E2c03E4A40A',
+    augustusRFQAddress: '0x7Ee1F7fa4C0b2eDB0Fdd5944c14A07167700486E',
+    tokenTransferProxyAddress: '0xc8a21fcd5a100c3ecc037c97e2f9c53a8d3a02a1',
+    multicallV2Address: '0x6cA478C852DfA8941FC819fDf248606eA04780B6',
+    privateHttpProvider: process.env.HTTP_PROVIDER_1101,
+    adapterAddresses: {
+      PolygonZkEvmAdapter01: '0xd63B7691dD98fa89A2ea5e1604700489c585aa7B',
+      PolygonZkEvmBuyAdapter: '0xe2137168CdA486a2555E16c597905854C84F9127',
+    },
+
+    rpcPollingMaxAllowedStateDelayInBlocks: 0,
+    rpcPollingBlocksBackToTriggerUpdate: 0,
+    hashFlowAuthToken: process.env.API_KEY_HASHFLOW_AUTH_TOKEN || '',
+    hashFlowDisabledMMs:
+      process.env[`HASHFLOW_DISABLED_MMS_10`]?.split(',') || [],
+    uniswapV3EventLoggingSampleRate: 0,
+    rfqConfigs: {},
+    forceRpcFallbackDexs: [],
+    // FIXME: Not set properly
+    uniswapV2ExchangeRouterAddress: '',
+  },
+  [Network.BASE]: {
+    network: Network.BASE,
+    networkName: 'Base',
+    isTestnet: false,
+    nativeTokenName: 'Ether',
+    nativeTokenSymbol: 'ETH',
+    wrappedNativeTokenAddress: '0x4200000000000000000000000000000000000006',
+    hasEIP1559: false,
+    augustusAddress: '0x59C7C832e96D2568bea6db468C1aAdcbbDa08A52',
+    augustusRFQAddress: '0xa003dFBA51C9e1e56C67ae445b852bdEd7aC5EEd',
+    tokenTransferProxyAddress: '0x93aAAe79a53759cD164340E4C8766E4Db5331cD7',
+    multicallV2Address: '0xeDF6D2a16e8081F777eB623EeB4411466556aF3d',
+    privateHttpProvider: process.env.HTTP_PROVIDER_8453,
+    hashFlowAuthToken: process.env.API_KEY_HASHFLOW_AUTH_TOKEN || '',
+    hashFlowDisabledMMs: [],
+    adapterAddresses: {
+      BaseAdapter01: '0x30F6B9b6485ff0B67E881f5ac80D3F1c70A4B23d',
+      BaseBuyAdapter: '0xB11bCA7B01b425afD0743A4D77B4f593883f94C0',
+    },
+    uniswapV2ExchangeRouterAddress:
+      '0x75d199EfB540e47D27D52c62Da3E7daC2B9e834F',
+    uniswapV3EventLoggingSampleRate: 0,
+    rfqConfigs: {},
+    rpcPollingMaxAllowedStateDelayInBlocks: 5,
+    rpcPollingBlocksBackToTriggerUpdate: 3,
+    forceRpcFallbackDexs: [],
   },
 };
 
@@ -350,6 +415,7 @@ export function generateConfig(network: number): Config {
     hashFlowAuthToken: baseConfig.hashFlowAuthToken,
     swaapV2AuthToken: baseConfig.swaapV2AuthToken,
     hashFlowDisabledMMs: baseConfig.hashFlowDisabledMMs,
+    forceRpcFallbackDexs: baseConfig.forceRpcFallbackDexs,
   };
 }
 
@@ -359,7 +425,7 @@ export class ConfigHelper {
   constructor(
     public isSlave: boolean,
     public data: Config,
-    private masterCachePrefix: string,
+    masterCachePrefix: string,
   ) {
     this.masterBlockNumberCacheKey =
       `${masterCachePrefix}_${data.network}_bn`.toLowerCase();

package/src/constants.ts

@@ -38,6 +38,7 @@ export enum Network {
   FANTOM = 250,
   ARBITRUM = 42161,
   OPTIMISM = 10,
+  BASE = 8453,
 }
 export const SUBGRAPH_TIMEOUT = 20 * 1000;
 

package/src/dex/algebra/algebra-factory.ts

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

package/src/dex/algebra/algebra-integration.test.ts

@@ -14,21 +14,8 @@ import {
 } from '../../../tests/utils';
 import { Tokens } from '../../../tests/constants-e2e';
 import { Address } from '@paraswap/core';
-
-/*
-  README
-  ======
-
-  This test script adds tests for Algebra general integration
-  with the DEX interface. The test cases below are example tests.
-  It is recommended to add tests which cover Algebra specific
-  logic.
-
-  You can run this individual test script by running:
-  `npx jest src/dex/<dex-name>/<dex-name>-integration.test.ts`
-
-  (This comment should be removed from the final implementation)
-*/
+import { AlgebraEventPoolV1_1 } from './algebra-pool-v1_1';
+import { DecodedStateMultiCallResultWithRelativeBitmapsV1_1 } from './types';
 
 function getReaderCalldata(
   exchangeAddress: string,
@@ -70,7 +57,7 @@ async function checkOnChainPricing(
   tokenOut: Address,
   amounts: bigint[],
 ) {
-  const exchangeAddress = '0xa15f0d7377b2a0c0c10db057f641bed21028fc89'; // Quoter address
+  const exchangeAddress = algebra.config.quoter;
 
   const readerIface = algebra.quoterIface;
 
@@ -155,6 +142,199 @@ async function testPricingOnNetwork(
   );
 }
 
+describe('CamelotV3', function () {
+  const dexKey = 'CamelotV3';
+  let blockNumber: number;
+  let algebra: Algebra;
+
+  describe('Arbitrum', () => {
+    const network = Network.ARBITRUM;
+    const dexHelper = new DummyDexHelper(network);
+
+    const tokens = Tokens[network];
+
+    describe('GRAIL => USDCe', () => {
+      const srcTokenSymbol = 'GRAIL';
+      const destTokenSymbol = 'USDCe';
+
+      const amountsForSell = [
+        0n,
+        10n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        20n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        30n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        40n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        50n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        60n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        70n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        80n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        90n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        100n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      ];
+
+      const amountsForBuy = [
+        0n,
+        1n * BI_POWS[tokens[destTokenSymbol].decimals],
+        2n * BI_POWS[tokens[destTokenSymbol].decimals],
+        3n * BI_POWS[tokens[destTokenSymbol].decimals],
+        4n * BI_POWS[tokens[destTokenSymbol].decimals],
+        5n * BI_POWS[tokens[destTokenSymbol].decimals],
+        6n * BI_POWS[tokens[destTokenSymbol].decimals],
+        7n * BI_POWS[tokens[destTokenSymbol].decimals],
+        8n * BI_POWS[tokens[destTokenSymbol].decimals],
+        9n * BI_POWS[tokens[destTokenSymbol].decimals],
+        10n * BI_POWS[tokens[destTokenSymbol].decimals],
+      ];
+
+      beforeAll(async () => {
+        blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        algebra = new Algebra(network, dexKey, dexHelper);
+        if (algebra.initializePricing) {
+          await algebra.initializePricing(blockNumber);
+        }
+      });
+
+      it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+        await testPricingOnNetwork(
+          algebra,
+          network,
+          dexKey,
+          dexHelper,
+          blockNumber,
+          srcTokenSymbol,
+          destTokenSymbol,
+          SwapSide.SELL,
+          amountsForSell,
+          'quoteExactInputSingle',
+        );
+      });
+
+      it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+        await testPricingOnNetwork(
+          algebra,
+          network,
+          dexKey,
+          dexHelper,
+          blockNumber,
+          srcTokenSymbol,
+          destTokenSymbol,
+          SwapSide.BUY,
+          amountsForBuy,
+          'quoteExactOutputSingle',
+        );
+      });
+
+      it('getTopPoolsForToken', async function () {
+        // We have to check without calling initializePricing, because
+        // pool-tracker is not calling that function
+        const newAlgebra = new Algebra(network, dexKey, dexHelper);
+        const poolLiquidity = await newAlgebra.getTopPoolsForToken(
+          tokens[srcTokenSymbol].address,
+          10,
+        );
+        console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
+
+        if (!newAlgebra.hasConstantPriceLargeAmounts) {
+          checkPoolsLiquidity(
+            poolLiquidity,
+            Tokens[network][srcTokenSymbol].address,
+            dexKey,
+          );
+        }
+      });
+    });
+
+    describe('USDCe => GRAIL', () => {
+      const srcTokenSymbol = 'USDCe';
+      const destTokenSymbol = 'GRAIL';
+
+      const amountsForSell = [
+        0n,
+        10n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        20n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        30n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        40n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        50n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        60n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        70n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        80n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        90n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        100n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      ];
+
+      const amountsForBuy = [
+        0n,
+        1n * BI_POWS[tokens[destTokenSymbol].decimals],
+        2n * BI_POWS[tokens[destTokenSymbol].decimals],
+        3n * BI_POWS[tokens[destTokenSymbol].decimals],
+        4n * BI_POWS[tokens[destTokenSymbol].decimals],
+        5n * BI_POWS[tokens[destTokenSymbol].decimals],
+        6n * BI_POWS[tokens[destTokenSymbol].decimals],
+        7n * BI_POWS[tokens[destTokenSymbol].decimals],
+        8n * BI_POWS[tokens[destTokenSymbol].decimals],
+        9n * BI_POWS[tokens[destTokenSymbol].decimals],
+        10n * BI_POWS[tokens[destTokenSymbol].decimals],
+      ];
+
+      beforeAll(async () => {
+        blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        algebra = new Algebra(network, dexKey, dexHelper);
+        if (algebra.initializePricing) {
+          await algebra.initializePricing(blockNumber);
+        }
+      });
+
+      it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+        await testPricingOnNetwork(
+          algebra,
+          network,
+          dexKey,
+          dexHelper,
+          blockNumber,
+          srcTokenSymbol,
+          destTokenSymbol,
+          SwapSide.SELL,
+          amountsForSell,
+          'quoteExactInputSingle',
+        );
+      });
+
+      it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+        await testPricingOnNetwork(
+          algebra,
+          network,
+          dexKey,
+          dexHelper,
+          blockNumber,
+          srcTokenSymbol,
+          destTokenSymbol,
+          SwapSide.BUY,
+          amountsForBuy,
+          'quoteExactOutputSingle',
+        );
+      });
+
+      it('getTopPoolsForToken', async function () {
+        // We have to check without calling initializePricing, because
+        // pool-tracker is not calling that function
+        const newAlgebra = new Algebra(network, dexKey, dexHelper);
+        const poolLiquidity = await newAlgebra.getTopPoolsForToken(
+          tokens[srcTokenSymbol].address,
+          10,
+        );
+        console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
+
+        if (!newAlgebra.hasConstantPriceLargeAmounts) {
+          checkPoolsLiquidity(
+            poolLiquidity,
+            Tokens[network][srcTokenSymbol].address,
+            dexKey,
+          );
+        }
+      });
+    });
+  });
+});
+
 describe('Algebra', function () {
   const dexKey = 'QuickSwapV3';
   let blockNumber: number;
@@ -254,5 +434,125 @@ describe('Algebra', function () {
         );
       }
     });
+
+    it('both generate state result match', async function () {
+      const pool = (await algebra.getPool(
+        tokens[srcTokenSymbol].address,
+        tokens[destTokenSymbol].address,
+        blockNumber,
+      )) as AlgebraEventPoolV1_1;
+
+      const [balance0, balance1, stateMulticallFull] =
+        await pool.fetchPoolStateSingleStep(blockNumber);
+
+      const stateMulticall = {
+        pool: stateMulticallFull.pool.toLowerCase(),
+        globalState: {
+          price: stateMulticallFull.globalState.price,
+          tick: stateMulticallFull.globalState.tick,
+          fee: stateMulticallFull.globalState.fee,
+          communityFeeToken0: stateMulticallFull.globalState.communityFeeToken0,
+          communityFeeToken1: stateMulticallFull.globalState.communityFeeToken1,
+        },
+        liquidity: stateMulticallFull.liquidity,
+        tickSpacing: stateMulticallFull.tickSpacing,
+        maxLiquidityPerTick: stateMulticallFull.maxLiquidityPerTick,
+        tickBitmap: stateMulticallFull.tickBitmap.map(t => ({
+          index: t.index,
+          value: t.value,
+        })),
+        ticks: stateMulticallFull.ticks.map(t => ({
+          index: t.index,
+          value: {
+            liquidityNet: t.value.liquidityNet,
+            liquidityGross: t.value.liquidityGross,
+            secondsOutside: t.value.secondsOutside,
+            secondsPerLiquidityOutsideX128:
+              t.value.secondsPerLiquidityOutsideX128,
+            tickCumulativeOutside: t.value.tickCumulativeOutside,
+            initialized: t.value.initialized,
+          },
+        })),
+      };
+
+      const stateMulticallWithBalance = [balance0, balance1, stateMulticall];
+      const stateManually = await pool.fetchStateManually(blockNumber);
+      // @ts-ignore
+      delete stateManually[2]['blockTimestamp'];
+      stateManually[2].pool = stateManually[2].pool.toLowerCase();
+
+      expect(stateMulticallWithBalance).toStrictEqual(stateManually);
+    });
+  });
+
+  describe('ZKEVM', () => {
+    const network = Network.ZKEVM;
+    const dexHelper = new DummyDexHelper(network);
+
+    beforeAll(async () => {
+      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      algebra = new Algebra(network, dexKey, dexHelper);
+      if (algebra.initializePricing) {
+        await algebra.initializePricing(blockNumber);
+      }
+    });
+
+    it('WETH/DAI generate state is working for problematic pool', async function () {
+      const pool = (await algebra.getPool(
+        '0x4F9A0e7FD2Bf6067db6994CF12E4495Df938E6e9',
+        '0xc5015b9d9161dca7e18e32f6f25c4ad850731fd4',
+        blockNumber,
+      )) as AlgebraEventPoolV1_1;
+
+      const stateManually = await pool.fetchStateManually(blockNumber);
+      // We can not compare with usual way, because this pool can not be requested normally
+      expect(Array.isArray(stateManually)).toBeTruthy();
+    });
+
+    it('WETH/MATIC generate state is working for problematic pool', async function () {
+      const pool = (await algebra.getPool(
+        '0x4f9a0e7fd2bf6067db6994cf12e4495df938e6e9',
+        '0xa2036f0538221a77a3937f1379699f44945018d0',
+        blockNumber,
+      )) as AlgebraEventPoolV1_1;
+
+      const stateManually = await pool.fetchStateManually(blockNumber);
+      // We can not compare with usual way, because this pool can not be requested normally
+      expect(Array.isArray(stateManually)).toBeTruthy();
+    });
+
+    it('stMATIC/WETH generate state is working for problematic pool', async function () {
+      const pool = (await algebra.getPool(
+        '0x83b874c1e09d316059d929da402dcb1a98e92082',
+        '0x4f9a0e7fd2bf6067db6994cf12e4495df938e6e9',
+        blockNumber,
+      )) as AlgebraEventPoolV1_1;
+
+      const stateManually = await pool.fetchStateManually(blockNumber);
+      // We can not compare with usual way, because this pool can not be requested normally
+      expect(Array.isArray(stateManually)).toBeTruthy();
+    });
+
+    it('WETH/USDC generate state is working for problematic pool', async function () {
+      const pool = (await algebra.getPool(
+        '0x4f9a0e7fd2bf6067db6994cf12e4495df938e6e9',
+        '0xa8ce8aee21bc2a48a5ef670afcc9274c7bbbc035',
+        blockNumber,
+      )) as AlgebraEventPoolV1_1;
+
+      const stateManually = await pool.fetchStateManually(blockNumber);
+      // We can not compare with usual way, because this pool can not be requested normally
+      expect(Array.isArray(stateManually)).toBeTruthy();
+    });
+
+    it('recognize pool does not exist error', async function () {
+      const pool = (await algebra.getPool(
+        '0x8aaebb46e1742f4623e6e1621f909f01846ca5e2',
+        '0xf9ed88937b2d82707d0eabd8c3d9aa4870b714d3',
+        blockNumber,
+      )) as AlgebraEventPoolV1_1;
+
+      expect(pool).toBeNull();
+    });
   });
 });