@paraswap/dex-lib 2.31.3 → 2.31.4-zkevm-revive.1

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,77 @@ 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('both generate state result match', async function () {
+      const pool = (await algebra.getPool(
+        '0x4F9A0e7FD2Bf6067db6994CF12E4495Df938E6e9',
+        '0xc5015b9d9161dca7e18e32f6f25c4ad850731fd4',
+        blockNumber,
+      )) as AlgebraEventPoolV1_1;
+
+      const stateManually = await pool.fetchStateManually(blockNumber);
+    });
   });
 });

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

@@ -2,29 +2,41 @@ import _ from 'lodash';
 import { Interface } from '@ethersproject/abi';
 import { DeepReadonly, assert } from 'ts-essentials';
 import { Address, BlockHeader, Log, Logger } from '../../types';
-import { bigIntify, catchParseLogError, int16 } from '../../utils';
+import { bigIntify, catchParseLogError, int16, uint128 } from '../../utils';
 import {
   InitializeStateOptions,
   StatefulEventSubscriber,
 } 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,
+  uint128ToBigInt,
+  int24ToBigInt,
+} 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,
@@ -53,6 +65,7 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
   readonly token1: Address;
 
   public readonly poolIface = new Interface(AlgebraABI);
+  public readonly factoryIface = new Interface(FactoryABI);
 
   public initFailed = false;
   public initRetryAttemptCount = 0;
@@ -69,6 +82,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();
@@ -174,7 +188,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]
@@ -330,13 +344,14 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
     return [balance0, balance1, _state];
   }
 
+  // FIXME: Here happens double conversion in types, but for prototyping and to check if this approach helps, it is nor very important
   async _fetchInitStateMultiStrategies(
     blockNumber: number,
   ): Promise<
     [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 +362,178 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
     }
   }
 
+  async fetchStateManually(
+    blockNumber: number,
+  ): Promise<
+    [bigint, bigint, DecodedStateMultiCallResultWithRelativeBitmapsV1_1]
+  > {
+    // FIXME: If this approach works, need to add caching of multicalls
+    const [poolAddress] = await this.dexHelper.multiWrapper.aggregate([
+      {
+        target: this.factoryAddress,
+        callData: this.factoryIface.encodeFunctionData('poolByPair', [
+          this.token0,
+          this.token1,
+        ]),
+        decodeFunction: addressDecode,
+      },
+    ]);
+    assert(
+      poolAddress === this.poolAddress,
+      `Pool address mismatch: ${poolAddress} != ${this.poolAddress}`,
+    );
+
+    const [
+      balance0,
+      balance1,
+      liquidity,
+      tickSpacing,
+      maxLiquidityPerTick,
+      globalState,
+    ] = (await this.dexHelper.multiWrapper.aggregate<
+      bigint | number | DecodedGlobalStateV1_1
+    >([
+      {
+        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: poolAddress,
+        callData: this.poolIface.encodeFunctionData('liquidity', []),
+        decodeFunction: uint128ToBigInt,
+      },
+      {
+        target: poolAddress,
+        callData: this.poolIface.encodeFunctionData('tickSpacing', []),
+        decodeFunction: int24ToBigInt,
+      },
+      {
+        target: poolAddress,
+        callData: this.poolIface.encodeFunctionData('maxLiquidityPerTick', []),
+        decodeFunction: uint128ToBigInt,
+      },
+      {
+        target: poolAddress,
+        callData: this.poolIface.encodeFunctionData('globalState', []),
+        decodeFunction: decodeGlobalStateV1_1,
+      },
+    ])) as [bigint, bigint, bigint, bigint, bigint, DecodedGlobalStateV1_1];
+
+    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,
+          };
+        },
+      ),
+    );
+
+    const tickBitmap: TickBitMapMappingsWithBigNumber[] = [];
+
+    let globalIndex = 0;
+
+    for (let i = leftBitMapIndex; i <= rightBitMapIndex; i++) {
+      const index = int16(i);
+      const bitmap = allTickBitMaps[globalIndex];
+      globalIndex++;
+      if (bitmap == 0n) continue;
+      tickBitmap.push({ index: Number(index), value: BigNumber.from(bitmap) });
+    }
+
+    const tickIndexes: bigint[] = [];
+    const ticksValues = await this.dexHelper.multiWrapper.aggregate(
+      tickBitmap
+        .map(tb => {
+          const allBits: MultiCallParams<TickInfoWithBigNumber>[] = [];
+          if (tb.value === BigNumber.from(0)) 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)) *
+                tickSpacing;
+
+              tickIndexes.push(populatedTick);
+              allBits.push({
+                target: poolAddress,
+                callData: this.poolIface.encodeFunctionData('ticks', [
+                  populatedTick,
+                ]),
+                decodeFunction: decodeTicksV1_1,
+              });
+            }
+          });
+          return allBits;
+        })
+        .flat(),
+    );
+    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,
+      // FIXME: If we validate that this is working, remove redundant conversions
+      {
+        pool: poolAddress,
+        blockTimestamp: BigNumber.from(Date.now()),
+        globalState,
+        liquidity: BigNumber.from(liquidity),
+        tickSpacing: Number(tickSpacing),
+        maxLiquidityPerTick: BigNumber.from(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

@@ -167,7 +167,7 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
           /* 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 +226,7 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
         this.cacheStateKey,
         this.config.initHash,
         this.config.deployer,
+        this.config.forceManualStateGenerate,
       );
 
     try {
@@ -258,7 +259,7 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
         // on unkown 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;

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;

package/src/dex/algebra/utils.ts

@@ -1,11 +1,12 @@
-import { BytesLike, ethers } from 'ethers';
+import { BigNumber, BytesLike, ethers } from 'ethers';
 import { assert } from 'ts-essentials';
 import { extractSuccessAndValue } from '../../lib/decoders';
 import { MultiResult } from '../../lib/multi-wrapper';
 import {
-  DecodedGlobalStateV1_9,
+  DecodedGlobalStateV1_1,
   DecodedStateMultiCallResultWithRelativeBitmapsV1_1,
   DecodedStateMultiCallResultWithRelativeBitmapsV1_9,
+  TickInfoWithBigNumber,
 } from './types';
 
 export function decodeStateMultiCallResultWithRelativeBitmapsV1_1(
@@ -134,3 +135,83 @@ export function decodeStateMultiCallResultWithRelativeBitmapsV1_9(
   // But I typed only the ones that are used later
   return decoded as DecodedStateMultiCallResultWithRelativeBitmapsV1_9;
 }
+
+export function decodeGlobalStateV1_1(
+  result: MultiResult<BytesLike> | BytesLike,
+): DecodedGlobalStateV1_1 {
+  const [isSuccess, toDecode] = extractSuccessAndValue(result);
+
+  assert(
+    isSuccess && toDecode !== '0x',
+    `decodeGlobalStateV1_1 failed to get decodable result: ${result}`,
+  );
+
+  const results: DecodedGlobalStateV1_1 = {
+    price: BigNumber.from(0),
+    tick: 0,
+    fee: 0,
+    communityFeeToken0: 0,
+    communityFeeToken1: 0,
+  };
+
+  [
+    results.price,
+    results.tick,
+    results.fee,
+    ,
+    results.communityFeeToken0,
+    results.communityFeeToken1,
+  ] = ethers.utils.defaultAbiCoder.decode(
+    [`uint160`, `int24`, `uint16`, `uint16`, `uint8`, `uint8`, `bool`],
+    toDecode,
+  );
+  // This conversion is not precise, because when we decode, we have more values
+  // But used later
+  return results;
+}
+
+export function decodeTicksV1_1(
+  result: MultiResult<BytesLike> | BytesLike,
+): TickInfoWithBigNumber {
+  const [isSuccess, toDecode] = extractSuccessAndValue(result);
+
+  assert(
+    isSuccess && toDecode !== '0x',
+    `decodeGlobalStateV1_1 failed to get decodable result: ${result}`,
+  );
+
+  const results: TickInfoWithBigNumber = {
+    liquidityNet: BigNumber.from(0),
+    liquidityGross: BigNumber.from(0),
+    secondsOutside: 0,
+    secondsPerLiquidityOutsideX128: BigNumber.from(0),
+    tickCumulativeOutside: BigNumber.from(0),
+    initialized: false,
+  };
+
+  [
+    results.liquidityGross,
+    results.liquidityNet,
+    ,
+    ,
+    results.tickCumulativeOutside,
+    results.secondsPerLiquidityOutsideX128,
+    results.secondsOutside,
+    results.initialized,
+  ] = ethers.utils.defaultAbiCoder.decode(
+    [
+      `uint128`,
+      `int128`,
+      `uint256`,
+      `uint256`,
+      `int256`,
+      `uint160`,
+      `uint32`,
+      `bool`,
+    ],
+    toDecode,
+  );
+  // This conversion is not precise, because when we decode, we have more values
+  // But used later
+  return results;
+}

package/src/dex/balancer-v2/balancer-v2.ts

@@ -74,16 +74,16 @@ import { NumberAsString, OptimalSwapExchange } from '@paraswap/core';
 
 // If you disable some pool, don't forget to clear the cache, otherwise changes won't be applied immediately
 const enabledPoolTypes = [
-  // BalancerPoolTypes.MetaStable,
-  // BalancerPoolTypes.Stable,
+  // BalancerPoolTypes.MetaStable, // BOOSTED POOLS Disabled since vulnerability https://github.com/BalancerMaxis/multisig-ops/blob/main/BIPs/00notGov/2023-08-mitigation.md
+  BalancerPoolTypes.Stable,
   BalancerPoolTypes.Weighted,
-  // BalancerPoolTypes.LiquidityBootstrapping,
-  // BalancerPoolTypes.Investment,
-  // BalancerPoolTypes.StablePhantom,
+  BalancerPoolTypes.LiquidityBootstrapping,
+  BalancerPoolTypes.Investment,
+  BalancerPoolTypes.StablePhantom,
   BalancerPoolTypes.AaveLinear,
   BalancerPoolTypes.ERC4626Linear,
   BalancerPoolTypes.Linear,
-  // BalancerPoolTypes.ComposableStable,
+  BalancerPoolTypes.ComposableStable,
   BalancerPoolTypes.BeefyLinear,
   BalancerPoolTypes.GearboxLinear,
   BalancerPoolTypes.MidasLinear,
@@ -93,6 +93,70 @@ const enabledPoolTypes = [
   BalancerPoolTypes.YearnLinear,
 ];
 
+const disabledPoolIds = [
+  // broken ?
+  '0xbd482ffb3e6e50dc1c437557c3bea2b68f3683ee0000000000000000000003c6',
+
+  /* DISABLED POOLS SINCE VULNERABILITY https://github.com/BalancerMaxis/multisig-ops/blob/main/BIPs/00notGov/2023-08-mitigation.md*/
+  /* START:2023-08-mitigation */
+  //mainnet
+  '0xbf2ef8bdc2fc0f3203b3a01778e3ec5009aeef3300000000000000000000058d',
+  '0x99c88ad7dc566616548adde8ed3effa730eb6c3400000000000000000000049a',
+  '0x60683b05e9a39e3509d8fdb9c959f23170f8a0fa000000000000000000000489',
+  '0xa13a9247ea42d743238089903570127dda72fe4400000000000000000000035d',
+  '0x7b50775383d3d6f0215a8f290f2c9e2eebbeceb20000000000000000000000fe',
+  '0x25accb7943fd73dda5e23ba6329085a3c24bfb6a000200000000000000000387',
+  '0x50cf90b954958480b8df7958a9e965752f62712400000000000000000000046f',
+  '0x133d241f225750d2c92948e464a5a80111920331000000000000000000000476',
+  '0x8a6b25e33b12d1bb6929a8793961076bd1f9d3eb0002000000000000000003e8',
+  '0x959216bb492b2efa72b15b7aacea5b5c984c3cca000200000000000000000472',
+  '0x9b692f571b256140a39a34676bffa30634c586e100000000000000000000059d',
+
+  // polygon
+  '0xb3d658d5b95bf04e2932370dd1ff976fe18dd66a000000000000000000000ace',
+  '0x48e6b98ef6329f8f0a30ebb8c7c960330d64808500000000000000000000075b',
+  '0xb54b2125b711cd183edd3dd09433439d5396165200000000000000000000075e',
+
+  // arbitrum
+  '0xa8af146d79ac0bb981e4e0d8b788ec5711b1d5d000000000000000000000047b',
+  '0x077794c30afeccdf5ad2abc0588e8cee7197b71a000000000000000000000352',
+  '0x519cce718fcd11ac09194cff4517f12d263be067000000000000000000000382',
+
+  // optimism
+  '0x23ca0306b21ea71552b148cf3c4db4fc85ae19290000000000000000000000ac',
+  '0x62cf35db540152e94936de63efc90d880d4e241b0000000000000000000000ef',
+  '0x098f32d98d0d64dba199fc1923d3bf4192e787190001000000000000000000d2',
+  '0x43da214fab3315aa6c02e0b8f2bfb7ef2e3c60a50000000000000000000000ae',
+  '0xb1c9ac57594e9b1ec0f3787d9f6744ef4cb0a02400000000000000000000006e',
+  '0xde45f101250f2ca1c0f8adfc172576d10c12072d00000000000000000000003f',
+  '0x05e7732bf9ae5592e6aa05afe8cd80f7ab0a7bea00020000000000000000005a',
+  '0x981fb05b738e981ac532a99e77170ecb4bc27aef00010000000000000000004b',
+  '0x6222ae1d2a9f6894da50aa25cb7b303497f9bebd000000000000000000000046',
+  '0x3c74c4ed512050eb843d89fb9dcd5ebb4668eb6d0002000000000000000000cc',
+
+  // fantom
+  '0xc0064b291bd3d4ba0e44ccfc81bf8e7f7a579cd200000000000000000000042c',
+  '0x6e6dc948ce85c62125ff7a1e543d761a88f0a4cb000000000000000000000743',
+  '0x78ab08bf98f90f29a09c9b1d85b3b549369b03a3000100000000000000000354',
+  '0x302b8b64795b064cadc32f74993a6372498608070001000000000000000003e0',
+  '0x5ddb92a5340fd0ead3987d3661afcd6104c3b757000000000000000000000187',
+  '0xdfc65c1f15ad3507754ef0fd4ba67060c108db7e000000000000000000000406',
+  '0x6da14f5acd58dd5c8e486cfa1dc1c550f5c61c1c0000000000000000000003cf',
+  '0x592fa9f9d58065096f2b7838709c116957d7b5cf00020000000000000000043c',
+  '0xf47f4d59c863c02cbfa3eefe6771b9c9fbe7b97800000000000000000000072b',
+  '0xff2753aaba51c9f84689b9bd0a21b3cf380a1cff00000000000000000000072e',
+  '0x10441785a928040b456a179691141c48356eb3a50001000000000000000002fa',
+  '0x64b301e21d640f9bef90458b0987d81fb4cf1b9e00020000000000000000022e',
+  '0xba0e9aea8a7fa1daab4edf244191f2387a4e472b000100000000000000000737',
+  '0x1e2576344d49779bdbb71b1b76193d27e6f996b700020000000000000000032d',
+  '0xa10285f445bcb521f1d623300dc4998b02f11c8f00000000000000000000043b',
+
+  // zkevm
+  '0x6f34a44fce1506352a171232163e7716dd073ade000200000000000000000015',
+  '0xe274c9deb6ed34cfe4130f8d0a8a948dea5bb28600000000000000000000000d',
+  /* END:2023-08-mitigation */
+];
+
 const fetchAllPools = `query ($count: Int) {
   pools: pools(
     first: $count
@@ -102,7 +166,7 @@ const fetchAllPools = `query ($count: Int) {
       totalLiquidity_gt: ${MIN_USD_LIQUIDITY_TO_FETCH.toString()},
       totalShares_not_in: ["0", "0.000000000001"],
       id_not_in: [
-        "0xbd482ffb3e6e50dc1c437557c3bea2b68f3683ee0000000000000000000003c6"
+        ${disabledPoolIds.map(p => `"${p}"`).join(', ')}
       ],
        address_not_in: [
         "0x0afbd58beca09545e4fb67772faf3858e610bcd0",

package/src/dex/generic-rfq/example-api.test.ts

@@ -157,7 +157,7 @@ export const startTestServer = (account: ethers.Wallet) => {
           new BigNumber(_prices.asks![0][0]),
         );
       } else {
-        const reversedPrices = _prices.bids!.map(price =>
+        const reversedPrices = _prices.asks!.map(price =>
           reversePrice([new BigNumber(price[0]), new BigNumber(price[1])]),
         );
         value = new BigNumber(payload.makerAmount).times(

package/src/lib/decoders.ts

@@ -50,6 +50,18 @@ export const uint256ToBigInt = (
   return generalDecoder(result, ['uint256'], 0n, value => value[0].toBigInt());
 };
 
+export const uint128ToBigInt = (
+  result: MultiResult<BytesLike> | BytesLike,
+): bigint => {
+  return generalDecoder(result, ['uint128'], 0n, value => value[0].toBigInt());
+};
+
+export const int24ToBigInt = (
+  result: MultiResult<BytesLike> | BytesLike,
+): bigint => {
+  return generalDecoder(result, ['int24'], 0n, value => BigInt(value[0]));
+};
+
 export const uint256ArrayDecode = (
   result: MultiResult<BytesLike> | BytesLike,
 ): bigint => {

package/src/stateful-event-subscriber.ts

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

package/.idea/codeStyles/codeStyleConfig.xml

@@ -1,5 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <state>
-    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
-  </state>
-</component>

package/.idea/misc.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectRootManager">
-    <output url="file://$PROJECT_DIR$/out" />
-  </component>
-</project>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/paraswap-dex-lib.iml" filepath="$PROJECT_DIR$/paraswap-dex-lib.iml" />
-    </modules>
-  </component>
-</project>