@paraswap/dex-lib 2.33.4-balancer-v2-multihop.2 → 2.35.0

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

@@ -317,6 +317,36 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     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: '',
+  },
 };
 
 // Should not be used, except by internal test code

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

@@ -14,6 +14,8 @@ import {
 } from '../../../tests/utils';
 import { Tokens } from '../../../tests/constants-e2e';
 import { Address } from '@paraswap/core';
+import { AlgebraEventPoolV1_1 } from './algebra-pool-v1_1';
+import { DecodedStateMultiCallResultWithRelativeBitmapsV1_1 } from './types';
 
 function getReaderCalldata(
   exchangeAddress: string,
@@ -432,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();
+    });
   });
 });

package/src/dex/algebra/algebra-pool-v1_1.ts

@@ -9,31 +9,47 @@ import {
 } from '../../stateful-event-subscriber';
 import { IDexHelper } from '../../dex-helper/idex-helper';
 import {
+  DecodedGlobalStateV1_1,
   PoolStateV1_1,
   TickBitMapMappingsWithBigNumber,
   TickInfoMappingsWithBigNumber,
+  TickInfoWithBigNumber,
 } from './types';
-import { ethers } from 'ethers';
+import { BigNumber, ethers } from 'ethers';
 import { Contract } from 'web3-eth-contract';
 import AlgebraABI from '../../abi/algebra/AlgebraPool-v1_1.abi.json';
+import FactoryABI from '../../abi/algebra/AlgebraFactory-v1_1.abi.json';
 import { DecodedStateMultiCallResultWithRelativeBitmapsV1_1 } from './types';
 import {
   OUT_OF_RANGE_ERROR_POSTFIX,
   TICK_BITMAP_BUFFER,
   TICK_BITMAP_TO_USE,
 } from '../uniswap-v3/constants';
-import { uint256ToBigInt } from '../../lib/decoders';
+import {
+  addressDecode,
+  uint256ToBigInt,
+  uint128ToBigNumber,
+  int24ToNumber,
+} from '../../lib/decoders';
 import { MultiCallParams } from '../../lib/multi-wrapper';
-import { decodeStateMultiCallResultWithRelativeBitmapsV1_1 } from './utils';
+import {
+  decodeGlobalStateV1_1,
+  decodeStateMultiCallResultWithRelativeBitmapsV1_1,
+  decodeTicksV1_1,
+} from './utils';
 import { AlgebraMath } from './lib/AlgebraMath';
 import {
   _reduceTickBitmap,
   _reduceTicks,
 } from '../uniswap-v3/contract-math/utils';
 import { Constants } from './lib/Constants';
-import { Network } from '../../constants';
+import { Network, NULL_ADDRESS } from '../../constants';
 import { TickTable } from './lib/TickTable';
 
+const BN_ZERO = BigNumber.from(0);
+const MAX_BATCH_SIZE = 100;
+const MAX_NUMBER_OF_BATCH_REQUEST_HALVING = 3;
+
 export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1> {
   handlers: {
     [event: string]: (
@@ -53,6 +69,13 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
   readonly token1: Address;
 
   public readonly poolIface = new Interface(AlgebraABI);
+  public readonly factoryIface = new Interface(FactoryABI);
+
+  private readonly cachedStateMultiCalls: MultiCallParams<
+    string | bigint | BigNumber | number | DecodedGlobalStateV1_1
+  >[];
+
+  private optimalTickRequestBatchSize?: number;
 
   public initFailed = false;
   public initRetryAttemptCount = 0;
@@ -69,6 +92,7 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
     mapKey: string = '',
     readonly poolInitCodeHash: string,
     readonly poolDeployer: string,
+    private readonly forceManualStateGeneration: boolean = false,
   ) {
     super(parentName, `${token0}_${token1}`, dexHelper, logger, true, mapKey);
     this.token0 = token0.toLowerCase();
@@ -84,6 +108,8 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
     this.handlers['Flash'] = this.handleFlashEvent.bind(this);
     this.handlers['Collect'] = this.handleCollectEvent.bind(this);
     this.handlers['CommunityFee'] = this.handleCommunityFee.bind(this);
+
+    this.cachedStateMultiCalls = this._getStateMulticall();
   }
 
   get poolAddress() {
@@ -174,7 +200,7 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
     return TICK_BITMAP_TO_USE + TICK_BITMAP_BUFFER;
   }
 
-  private async _fetchPoolStateSingleStep(
+  async fetchPoolStateSingleStep(
     blockNumber: number,
   ): Promise<
     [bigint, bigint, DecodedStateMultiCallResultWithRelativeBitmapsV1_1]
@@ -336,7 +362,7 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
     [bigint, bigint, DecodedStateMultiCallResultWithRelativeBitmapsV1_1]
   > {
     try {
-      return await this._fetchPoolStateSingleStep(blockNumber);
+      return await this.fetchPoolStateSingleStep(blockNumber);
     } catch (e) {
       if (e instanceof Error && e.message.includes('Pool does not exist'))
         throw e;
@@ -347,9 +373,234 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
     }
   }
 
+  private _getStateMulticall(): MultiCallParams<
+    string | bigint | BigNumber | number | DecodedGlobalStateV1_1
+  >[] {
+    return [
+      {
+        target: this.factoryAddress,
+        callData: this.factoryIface.encodeFunctionData('poolByPair', [
+          this.token0,
+          this.token1,
+        ]),
+        decodeFunction: addressDecode,
+      },
+      {
+        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.poolAddress,
+        callData: this.poolIface.encodeFunctionData('liquidity', []),
+        decodeFunction: uint128ToBigNumber,
+      },
+      {
+        target: this.poolAddress,
+        callData: this.poolIface.encodeFunctionData('tickSpacing', []),
+        decodeFunction: int24ToNumber,
+      },
+      {
+        target: this.poolAddress,
+        callData: this.poolIface.encodeFunctionData('maxLiquidityPerTick', []),
+        decodeFunction: uint128ToBigNumber,
+      },
+      {
+        target: this.poolAddress,
+        callData: this.poolIface.encodeFunctionData('globalState', []),
+        decodeFunction: decodeGlobalStateV1_1,
+      },
+    ];
+  }
+
+  async fetchStateManually(
+    blockNumber: number,
+  ): Promise<
+    [bigint, bigint, DecodedStateMultiCallResultWithRelativeBitmapsV1_1]
+  > {
+    // Unfortunately I can not unite this call with the next one. For some reason even if pool does not exist
+    // call succeeds and makes decoding function to throw. Otherwise, I should rewrite decoders in different which
+    // require some time
+    const [poolAddress] = (await this.dexHelper.multiWrapper.aggregate<
+      string | bigint | BigNumber | number | DecodedGlobalStateV1_1
+    >(this.cachedStateMultiCalls.slice(0, 1), blockNumber, MAX_BATCH_SIZE)) as [
+      string,
+    ];
+
+    if (poolAddress === NULL_ADDRESS) {
+      throw new Error('Pool does not exist');
+    }
+
+    const [
+      balance0,
+      balance1,
+      liquidity,
+      tickSpacing,
+      maxLiquidityPerTick,
+      globalState,
+    ] = (await this.dexHelper.multiWrapper.aggregate<
+      string | bigint | BigNumber | number | DecodedGlobalStateV1_1
+    >(this.cachedStateMultiCalls.slice(1), blockNumber, MAX_BATCH_SIZE)) as [
+      bigint,
+      bigint,
+      BigNumber,
+      number,
+      BigNumber,
+      DecodedGlobalStateV1_1,
+    ];
+
+    assert(
+      poolAddress.toLowerCase() === this.poolAddress.toLowerCase(),
+      `Pool address mismatch: ${poolAddress.toLowerCase()} != ${this.poolAddress.toLowerCase()}`,
+    );
+
+    const currentBitMapIndex = TickTable.position(
+      BigInt(BigInt(globalState.tick) / BigInt(tickSpacing)),
+    )[0];
+
+    const leftBitMapIndex = currentBitMapIndex - this.getBitmapRangeToRequest();
+    const rightBitMapIndex =
+      currentBitMapIndex + this.getBitmapRangeToRequest();
+
+    const allTickBitMaps = await this.dexHelper.multiWrapper.aggregate(
+      _.range(Number(leftBitMapIndex), Number(rightBitMapIndex + 1n)).map(
+        index => {
+          return {
+            target: poolAddress,
+            callData: this.poolIface.encodeFunctionData('tickTable', [
+              int16(BigInt(index)),
+            ]),
+            decodeFunction: uint256ToBigInt,
+          };
+        },
+      ),
+      blockNumber,
+      MAX_BATCH_SIZE,
+    );
+
+    const tickBitmap: TickBitMapMappingsWithBigNumber[] = [];
+
+    let globalIndex = 0;
+    for (let i = leftBitMapIndex; i <= rightBitMapIndex; i++) {
+      const index = Number(int16(i));
+      const bitmap = allTickBitMaps[globalIndex];
+      globalIndex++;
+      if (bitmap == 0n) continue;
+      tickBitmap.push({ index: Number(index), value: BigNumber.from(bitmap) });
+    }
+
+    const tickIndexes: bigint[] = [];
+
+    const tickRequests = tickBitmap
+      .map(tb => {
+        const allBits: MultiCallParams<TickInfoWithBigNumber>[] = [];
+        if (tb.value === BN_ZERO) return allBits;
+
+        _.range(0, 256).forEach(j => {
+          if ((tb.value.toBigInt() & (1n << BigInt(j))) > 0n) {
+            const populatedTick =
+              (BigInt.asIntN(16, BigInt(tb.index) << 8n) + BigInt(j)) *
+              BigInt(tickSpacing);
+
+            tickIndexes.push(populatedTick);
+            allBits.push({
+              target: poolAddress,
+              callData: this.poolIface.encodeFunctionData('ticks', [
+                populatedTick,
+              ]),
+              decodeFunction: decodeTicksV1_1,
+            });
+          }
+        });
+        return allBits;
+      })
+      .flat();
+
+    let ticksValues: TickInfoWithBigNumber[] = [];
+    if (this.optimalTickRequestBatchSize) {
+      ticksValues = await this.dexHelper.multiWrapper.aggregate(
+        tickRequests,
+        blockNumber,
+        this.optimalTickRequestBatchSize,
+      );
+      // If we don't know what is optimal number of requests for this pool, we want to try it experimentally and save it
+      // Maybe later to consider distant caching
+    } else {
+      for (const i of _.range(0, MAX_NUMBER_OF_BATCH_REQUEST_HALVING)) {
+        const currentBatchSize = MAX_BATCH_SIZE / (+i + 1);
+        try {
+          // Some of the pools fails with 100 batch size, for them we want to try additionally with reduced batch size
+          ticksValues = await this.dexHelper.multiWrapper.aggregate(
+            tickRequests,
+            blockNumber,
+            currentBatchSize,
+          );
+          this.optimalTickRequestBatchSize = currentBatchSize;
+          break;
+        } catch (e) {
+          if (+i + 1 === MAX_NUMBER_OF_BATCH_REQUEST_HALVING) {
+            this.logger.warn(
+              `Failed to fetch ticks for pool ${poolAddress} (${this.token0}_${this.token1}) with batch size ${currentBatchSize}`,
+              e,
+            );
+            throw e;
+          }
+        }
+      }
+    }
+
+    assert(
+      tickIndexes.length === ticksValues.length,
+      `Tick indexes mismatch: ${tickIndexes.length} != ${ticksValues.length}`,
+    );
+
+    const ticks: TickInfoMappingsWithBigNumber[] = new Array(
+      tickIndexes.length,
+    );
+
+    tickIndexes.forEach((tickIndex, index) => {
+      ticks[index] = {
+        index: Number(tickIndex),
+        value: ticksValues[index],
+      };
+    });
+
+    return [
+      balance0,
+      balance1,
+      {
+        pool: poolAddress,
+        blockTimestamp: BigNumber.from(Date.now()),
+        globalState,
+        liquidity,
+        tickSpacing,
+        maxLiquidityPerTick,
+        tickBitmap,
+        ticks,
+      },
+    ];
+  }
+
   async generateState(blockNumber: number): Promise<Readonly<PoolStateV1_1>> {
-    const [balance0, balance1, _state] =
-      await this._fetchInitStateMultiStrategies(blockNumber);
+    let balance0 = 0n;
+    let balance1 = 0n;
+    let _state: DecodedStateMultiCallResultWithRelativeBitmapsV1_1;
+    if (this.forceManualStateGeneration) {
+      [balance0, balance1, _state] = await this.fetchStateManually(blockNumber);
+    } else {
+      [balance0, balance1, _state] = await this._fetchInitStateMultiStrategies(
+        blockNumber,
+      );
+    }
 
     const tickBitmap = {};
     const ticks = {};

package/src/dex/algebra/algebra.ts

@@ -160,14 +160,15 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
         if (this.network !== Network.ZKEVM) return pool;
 
         if (
-          pool.getState(blockNumber) === null &&
-          blockNumber - pool.getStateBlockNumber() >
-            MAX_STALE_STATE_BLOCK_AGE[this.network]
+          pool.getStaleState() === null ||
+          (pool.getState(blockNumber) === null &&
+            blockNumber - pool.getStateBlockNumber() >
+              MAX_STALE_STATE_BLOCK_AGE[this.network])
         ) {
           /* reload state, on zkEVM this would most likely timeout during request life
            * but would allow to rely on staleState for couple of min for next requests
            */
-          await pool.initialize(blockNumber);
+          await pool.initialize(blockNumber, { forceRegenerate: true });
         }
 
         return pool;
@@ -226,6 +227,7 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
         this.cacheStateKey,
         this.config.initHash,
         this.config.deployer,
+        this.config.forceManualStateGenerate,
       );
 
     try {
@@ -255,10 +257,10 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
           e,
         );
       } else {
-        // on unkown error mark as failed and increase retryCount for retry init strategy
+        // on unknown error mark as failed and increase retryCount for retry init strategy
         // note: state would be null by default which allows to fallback
         this.logger.warn(
-          `${this.dexKey}: Can not generate pool state for srcAddress=${srcAddress}, destAddress=${destAddress}pool fallback to rpc and retry every ${this.config.initRetryFrequency} times, initRetryAttemptCount=${pool.initRetryAttemptCount}`,
+          `${this.dexKey}: Can not generate pool state for srcAddress=${srcAddress}, destAddress=${destAddress} pool fallback to rpc and retry every ${this.config.initRetryFrequency} times, initRetryAttemptCount=${pool.initRetryAttemptCount}`,
           e,
         );
         pool.initFailed = true;
@@ -790,6 +792,7 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
       subgraphURL: this.config.subgraphURL,
       version: this.config.version,
       forceRPC: this.config.forceRPC,
+      forceManualStateGenerate: this.config.forceManualStateGenerate,
     };
     return newConfig;
   }

package/src/dex/algebra/config.ts

@@ -33,6 +33,7 @@ export const AlgebraConfig: DexConfigMap<DexParams> = {
       uniswapMulticall: '0x61530d6E1c7A47BBB3e48e8b8EdF7569DcFeE121',
       deployer: '0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270',
       version: 'v1.1',
+      forceManualStateGenerate: true,
     },
   },
   ZyberSwapV3: {

package/src/dex/algebra/types.ts

@@ -2,7 +2,7 @@ import { BigNumber } from 'ethers';
 import { Address, NumberAsString } from '../../types';
 import { TickInfo } from '../uniswap-v3/types';
 
-type GlobalStateV1_1 = {
+export type GlobalStateV1_1 = {
   price: bigint; // The square root of the current price in Q64.96 format
   tick: bigint; // The current tick
   fee: bigint; // The current fee in hundredths of a bip, i.e. 1e-6
@@ -72,6 +72,7 @@ export type DexParams = {
   initHash: string;
   version: 'v1.1' | 'v1.9';
   forceRPC?: boolean;
+  forceManualStateGenerate?: boolean;
 };
 
 export type IAlgebraPoolState = PoolStateV1_1 | PoolState_v1_9;
@@ -95,7 +96,7 @@ export type TickInfoMappingsWithBigNumber = {
   value: TickInfoWithBigNumber;
 };
 
-type DecodedGlobalStateV1_1 = {
+export type DecodedGlobalStateV1_1 = {
   price: BigNumber;
   tick: number;
   fee: number;