@paraswap/dex-lib 3.4.2-balancer-v2-single-swap.0 → 3.4.2

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

@@ -1,1701 +1,1669 @@
-import { Interface } from '@ethersproject/abi';
-import { assert, DeepReadonly } from 'ts-essentials';
-import _, { keyBy } from 'lodash';
-import {
-  AdapterExchangeParam,
-  Address,
-  DexExchangeParam,
-  ExchangePrices,
-  ExchangeTxInfo,
-  Log,
-  Logger,
-  PoolLiquidity,
-  PoolPrices,
-  PreprocessTransactionOptions,
-  SimpleExchangeParam,
-  Token,
-  TxInfo,
-} from '../../types';
-import {
-  ETHER_ADDRESS,
-  MAX_INT,
-  Network,
-  NULL_ADDRESS,
-  SUBGRAPH_TIMEOUT,
-  SwapSide,
-} from '../../constants';
-import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
-import { StablePool } from './pools/stable/StablePool';
-import { WeightedPool } from './pools/weighted/WeightedPool';
-import { PhantomStablePool } from './pools/phantom-stable/PhantomStablePool';
-import { LinearPool } from './pools/linear/LinearPool';
-import { Gyro3Pool } from './pools/gyro/Gyro3Pool';
-import { GyroEPool } from './pools/gyro/GyroEPool';
-import VaultABI from '../../abi/balancer-v2/vault.json';
-import DirectSwapABI from '../../abi/DirectSwap.json';
-import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
-import {
-  getBigIntPow,
-  getDexKeysWithNetwork,
-  uuidToBytes16,
-} from '../../utils';
-import { Context, IDex } from '../../dex/idex';
-import { IDexHelper } from '../../dex-helper';
-import {
-  BalancerV2BatchSwapParam,
-  BalancerPoolTypes,
-  BalancerSwap,
-  BalancerV2Data,
-  BalancerV2DirectParam,
-  OptimizedBalancerV2Data,
-  PoolState,
-  PoolStateCache,
-  PoolStateMap,
-  SubgraphPoolAddressDictionary,
-  SubgraphPoolBase,
-  SwapTypes,
-  BalancerV2DirectParamV6,
-  BalancerV2DirectParamV6Swap,
-  BalancerV2SwapParam,
-  BalancerV2SingleSwap,
-} from './types';
-import {
-  getLocalDeadlineAsFriendlyPlaceholder,
-  SimpleExchange,
-} from '../simple-exchange';
-import { Adapters, BalancerConfig } from './config';
-import {
-  getAllPoolsUsedInPaths,
-  isSameAddress,
-  poolGetMainTokens,
-  poolGetPathForTokenInOut,
-} from './utils';
-import {
-  DirectMethods,
-  DirectMethodsV6,
-  MIN_USD_LIQUIDITY_TO_FETCH,
-  STABLE_GAS_COST,
-  VARIABLE_GAS_COST_PER_CYCLE,
-} from './constants';
-import { NumberAsString, OptimalSwapExchange } from '@paraswap/core';
-import { hexConcat, hexlify, hexZeroPad, solidityPack } from 'ethers/lib/utils';
-import BalancerVaultABI from '../../abi/balancer-v2/vault.json';
-import { BigNumber } from 'ethers';
-import { SpecialDex } from '../../executor/types';
-import { S } from '@bgd-labs/aave-address-book/dist/AaveV2Ethereum-timF4kft';
-import { extractReturnAmountPosition } from '../../executor/utils';
-
-// If you disable some pool, don't forget to clear the cache, otherwise changes won't be applied immediately
-const enabledPoolTypes = [
-  // 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.AaveLinear,
-  BalancerPoolTypes.ERC4626Linear,
-  BalancerPoolTypes.Linear,
-  BalancerPoolTypes.ComposableStable,
-  BalancerPoolTypes.BeefyLinear,
-  BalancerPoolTypes.GearboxLinear,
-  BalancerPoolTypes.MidasLinear,
-  BalancerPoolTypes.ReaperLinear,
-  BalancerPoolTypes.SiloLinear,
-  BalancerPoolTypes.TetuLinear,
-  BalancerPoolTypes.YearnLinear,
-  BalancerPoolTypes.GyroE,
-  BalancerPoolTypes.Gyro3,
-];
-
-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',
-  '0xe7b1d394f3b40abeaa0b64a545dbcf89da1ecb3f00010000000000000000009a',
-
-  // 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
-    orderBy: totalLiquidity
-    orderDirection: desc
-    where: {
-      totalLiquidity_gt: ${MIN_USD_LIQUIDITY_TO_FETCH.toString()},
-      totalShares_not_in: ["0", "0.000000000001"],
-      id_not_in: [
-        ${disabledPoolIds.map(p => `"${p}"`).join(', ')}
-      ],
-       address_not_in: [
-        "0x0afbd58beca09545e4fb67772faf3858e610bcd0",
-        "0x2ff1a9dbdacd55297452cfd8a4d94724bc22a5f7",
-        "0xbc0f2372008005471874e426e86ccfae7b4de79d",
-        "0xdba274b4d04097b90a72b62467d828cefd708037",
-        "0xf22ff21e17157340575158ad7394e068048dd98b",
-        "0xf71d0774b214c4cf51e33eb3d30ef98132e4dbaa",
-      ],
-      swapEnabled: true,
-      poolType_in: [
-        ${enabledPoolTypes.map(p => `"${p}"`).join(', ')}
-      ]
-    }
-  ) {
-    id
-    address
-    poolType
-    poolTypeVersion
-    tokens (orderBy: index) {
-      address
-      decimals
-    }
-    mainIndex
-    wrappedIndex
-
-    root3Alpha
-  }
-}`;
-// skipping low liquidity composableStablePool (0xbd482ffb3e6e50dc1c437557c3bea2b68f3683ee0000000000000000000003c6) with oracle issues. Experimental.
-
-const fetchWeightUpdating = `query ($count: Int, $timestampPast: Int, $timestampFuture: Int) {
-  gradualWeightUpdates(
-    first: $count,
-    where: {startTimestamp_lt: $timestampFuture, endTimestamp_gt: $timestampPast }
-  ) {
-    poolId {
-      address
-    }
-  }
-}`;
-
-const MAX_POOL_CNT = 1000; // Taken from SOR
-const POOL_CACHE_TTL = 60 * 60; // 1 hr
-const POOL_EVENT_DISABLED_TTL = 5 * 60; // 5 min
-const POOL_EVENT_REENABLE_DELAY = 7 * 24 * 60 * 60; // 1 week
-
-function typecastReadOnlyPoolState(pool: DeepReadonly<PoolState>): PoolState {
-  return _.cloneDeep(pool) as PoolState;
-}
-
-export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
-  public vaultInterface: Interface;
-
-  handlers: {
-    [event: string]: (event: any, pool: PoolState, log: Log) => PoolState;
-  } = {};
-
-  pools: {
-    [type: string]:
-      | WeightedPool
-      | StablePool
-      | LinearPool
-      | PhantomStablePool
-      | Gyro3Pool
-      | GyroEPool;
-  };
-
-  public allPools: SubgraphPoolBase[] = [];
-  vaultDecoder: (log: Log) => any;
-
-  buySupportedPoolTypes: Set<BalancerPoolTypes> = new Set([
-    BalancerPoolTypes.Weighted,
-    BalancerPoolTypes.GyroE,
-  ]);
-
-  eventSupportedPoolTypes: BalancerPoolTypes[] = [
-    BalancerPoolTypes.Stable,
-    BalancerPoolTypes.Weighted,
-    BalancerPoolTypes.LiquidityBootstrapping,
-    BalancerPoolTypes.Investment,
-
-    // Need to check if we can support these pools with event base
-    // BalancerPoolTypes.ComposableStable,
-    // BalancerPoolTypes.Linear,
-    // BalancerPoolTypes.MetaStable,
-    // BalancerPoolTypes.AaveLinear,
-    // BalancerPoolTypes.ERC4626Linear,
-
-    // If this pool is enabled as event supported, it is failing BeetsFi: can not decode getRate()
-    // BalancerPoolTypes.StablePhantom,
-  ];
-
-  eventRemovedPools = (
-    [
-      // Gradual weight changes are not currently handled in event system
-      // This pool keeps changing weights and is causing pricing issue
-      // But should now be handled by eventDisabledPools so don't need here!
-      //'0x34809aEDF93066b49F638562c42A9751eDb36DF5',
-    ] as Address[]
-  ).map(s => s.toLowerCase());
-
-  constructor(
-    parentName: string,
-    protected network: number,
-    public vaultAddress: Address,
-    protected subgraphURL: string,
-    protected dexHelper: IDexHelper,
-    logger: Logger,
-  ) {
-    super(parentName, vaultAddress, dexHelper, logger);
-    this.vaultInterface = new Interface(VaultABI);
-    const weightedPool = new WeightedPool(
-      this.vaultAddress,
-      this.vaultInterface,
-    );
-    const stablePool = new StablePool(this.vaultAddress, this.vaultInterface);
-    const stablePhantomPool = new PhantomStablePool(
-      this.vaultAddress,
-      this.vaultInterface,
-    );
-    /*
-    ComposableStable has same maths as StablePhantom.
-    The main difference is that ComposableStables have join/exit functions when StablePhantom did not.
-    The difference of note for swaps is ComposableStable must use 'actualSupply' instead of VirtualSupply.
-    VirtualSupply could be calculated easily whereas actualSupply cannot hence the use of onchain call.
-    */
-    const composableStable = new PhantomStablePool(
-      this.vaultAddress,
-      this.vaultInterface,
-      true,
-    );
-    const linearPool = new LinearPool(this.vaultAddress, this.vaultInterface);
-    const gyro3Pool = new Gyro3Pool(this.vaultAddress, this.vaultInterface);
-    const gyroEPool = new GyroEPool(this.vaultAddress, this.vaultInterface);
-
-    this.pools = {};
-    this.pools[BalancerPoolTypes.Weighted] = weightedPool;
-    this.pools[BalancerPoolTypes.Stable] = stablePool;
-    this.pools[BalancerPoolTypes.MetaStable] = stablePool;
-    this.pools[BalancerPoolTypes.LiquidityBootstrapping] = weightedPool;
-    this.pools[BalancerPoolTypes.Investment] = weightedPool;
-    this.pools[BalancerPoolTypes.StablePhantom] = stablePhantomPool;
-    this.pools[BalancerPoolTypes.ComposableStable] = composableStable;
-    // All these Linear pool have same maths and ABI as AaveLinear but have different factories
-    this.pools[BalancerPoolTypes.AaveLinear] = linearPool;
-    this.pools[BalancerPoolTypes.ERC4626Linear] = linearPool;
-    this.pools[BalancerPoolTypes.GearboxLinear] = linearPool;
-    this.pools[BalancerPoolTypes.MidasLinear] = linearPool;
-    this.pools[BalancerPoolTypes.ReaperLinear] = linearPool;
-    this.pools[BalancerPoolTypes.SiloLinear] = linearPool;
-    this.pools[BalancerPoolTypes.TetuLinear] = linearPool;
-    this.pools[BalancerPoolTypes.YearnLinear] = linearPool;
-    this.pools[BalancerPoolTypes.BeefyLinear] = linearPool;
-    // Beets uses "Linear" generically for all linear pool types
-    this.pools[BalancerPoolTypes.Linear] = linearPool;
-
-    this.pools[BalancerPoolTypes.Gyro3] = gyro3Pool;
-    this.pools[BalancerPoolTypes.GyroE] = gyroEPool;
-
-    this.vaultDecoder = (log: Log) => this.vaultInterface.parseLog(log);
-    this.addressesSubscribed = [vaultAddress];
-
-    // Add default handlers
-    this.handlers['Swap'] = this.handleSwap.bind(this);
-    this.handlers['PoolBalanceChanged'] =
-      this.handlePoolBalanceChanged.bind(this);
-  }
-
-  protected processLog(
-    state: DeepReadonly<PoolStateMap>,
-    log: Readonly<Log>,
-  ): DeepReadonly<PoolStateMap> | null {
-    const _state: PoolStateMap = {};
-    for (const [address, pool] of Object.entries(state))
-      _state[address] = typecastReadOnlyPoolState(pool);
-
-    try {
-      const event = this.vaultDecoder(log);
-      if (event.name in this.handlers) {
-        const poolAddress = event.args.poolId.slice(0, 42).toLowerCase();
-        // Only update the _state if we are tracking the pool
-        if (poolAddress in _state) {
-          _state[poolAddress] = this.handlers[event.name](
-            event,
-            _state[poolAddress],
-            log,
-          );
-        }
-      }
-      return _state;
-    } catch (e) {
-      this.logger.error(
-        `Error_${this.parentName}_processLog could not parse the log with topic ${log.topics}:`,
-        e,
-      );
-      return null;
-    }
-  }
-
-  async fetchAllSubgraphPools(): Promise<SubgraphPoolBase[]> {
-    const cacheKey = 'BalancerV2SubgraphPools2';
-    const cachedPools = await this.dexHelper.cache.get(
-      this.parentName,
-      this.network,
-      cacheKey,
-    );
-    if (cachedPools) {
-      const allPools = JSON.parse(cachedPools);
-      this.logger.info(
-        `Got ${allPools.length} ${this.parentName}_${this.network} pools from cache`,
-      );
-      return allPools;
-    }
-
-    this.logger.info(
-      `Fetching ${this.parentName}_${this.network} Pools from subgraph`,
-    );
-
-    const variables = {
-      count: MAX_POOL_CNT,
-    };
-    const { data } = await this.dexHelper.httpRequest.post(
-      this.subgraphURL,
-      { query: fetchAllPools, variables },
-      SUBGRAPH_TIMEOUT,
-    );
-
-    if (!(data && data.pools))
-      throw new Error('Unable to fetch pools from the subgraph');
-
-    const poolsMap = keyBy(data.pools, 'address');
-    const allPools: SubgraphPoolBase[] = data.pools.map(
-      (pool: Omit<SubgraphPoolBase, 'mainTokens'>) => ({
-        ...pool,
-        mainTokens: poolGetMainTokens(pool, poolsMap),
-        tokensMap: pool.tokens.reduce(
-          (acc, token) => ({ ...acc, [token.address.toLowerCase()]: token }),
-          {},
-        ),
-      }),
-    );
-
-    this.dexHelper.cache.setex(
-      this.parentName,
-      this.network,
-      cacheKey,
-      POOL_CACHE_TTL,
-      JSON.stringify(allPools),
-    );
-
-    this.logger.info(
-      `Got ${allPools.length} ${this.parentName}_${this.network} pools from subgraph`,
-    );
-
-    return allPools;
-  }
-
-  async generateState(blockNumber: number): Promise<Readonly<PoolStateMap>> {
-    const allPools = await this.fetchAllSubgraphPools();
-    this.allPools = allPools;
-
-    const eventSupportedPools = allPools.filter(
-      pool =>
-        this.eventSupportedPoolTypes.includes(pool.poolType) &&
-        !this.eventRemovedPools.includes(pool.address.toLowerCase()),
-    );
-    const allPoolsLatestState = await this.getOnChainState(
-      eventSupportedPools,
-      blockNumber,
-    );
-
-    return allPoolsLatestState;
-  }
-
-  handleSwap(event: any, pool: PoolState, log: Log): PoolState {
-    const tokenIn = event.args.tokenIn.toLowerCase();
-    const amountIn = BigInt(event.args.amountIn.toString());
-    const tokenOut = event.args.tokenOut.toLowerCase();
-    const amountOut = BigInt(event.args.amountOut.toString());
-    pool.tokens[tokenIn].balance += amountIn;
-    pool.tokens[tokenOut].balance -= amountOut;
-    return pool;
-  }
-
-  handlePoolBalanceChanged(event: any, pool: PoolState, log: Log): PoolState {
-    const tokens = event.args.tokens.map((t: string) => t.toLowerCase());
-    const deltas = event.args.deltas.map((d: any) => BigInt(d.toString()));
-    const fees = event.args.protocolFeeAmounts.map((d: any) =>
-      BigInt(d.toString()),
-    ) as bigint[];
-    tokens.forEach((t: string, i: number) => {
-      const diff = deltas[i] - fees[i];
-      pool.tokens[t].balance += diff;
-    });
-    return pool;
-  }
-
-  isSupportedPool(poolType: string): boolean {
-    const supportedPoolTypes: string[] = Object.values(BalancerPoolTypes);
-    return supportedPoolTypes.includes(poolType);
-  }
-
-  getPricesPool(
-    from: Token,
-    to: Token,
-    subgraphPool: SubgraphPoolBase,
-    poolState: PoolState,
-    amounts: bigint[],
-    unitVolume: bigint,
-    side: SwapSide,
-  ): { unit: bigint; prices: bigint[] } | null {
-    if (!this.isSupportedPool(subgraphPool.poolType)) {
-      this.logger.error(`Unsupported Pool Type: ${subgraphPool.poolType}`);
-      return null;
-    }
-
-    if (
-      side === SwapSide.BUY &&
-      !this.buySupportedPoolTypes.has(subgraphPool.poolType)
-    ) {
-      return null;
-    }
-
-    const amountWithoutZero = amounts.slice(1);
-    const pool = this.pools[subgraphPool.poolType];
-
-    const poolPairData = pool.parsePoolPairData(
-      subgraphPool,
-      poolState,
-      from.address,
-      to.address,
-    );
-
-    const swapMaxAmount = pool.getSwapMaxAmount(
-      // Don't like this but don't have time to refactor it properly
-      poolPairData as any,
-      side,
-    );
-
-    const checkedAmounts: bigint[] = new Array(amountWithoutZero.length).fill(
-      0n,
-    );
-    const checkedUnitVolume = pool._nullifyIfMaxAmountExceeded(
-      unitVolume,
-      swapMaxAmount,
-    );
-
-    let nonZeroAmountIndex = 0;
-    for (const [i, amountIn] of amountWithoutZero.entries()) {
-      const checkedOutput = pool._nullifyIfMaxAmountExceeded(
-        amountIn,
-        swapMaxAmount,
-      );
-      if (checkedOutput === 0n) {
-        // Stop earlier because other values are bigger and for sure wont' be tradable
-        break;
-      }
-      nonZeroAmountIndex = i + 1;
-      checkedAmounts[i] = checkedOutput;
-    }
-
-    if (nonZeroAmountIndex === 0) {
-      return null;
-    }
-
-    const unitResult =
-      checkedUnitVolume === 0n
-        ? 0n
-        : side === SwapSide.SELL
-        ? pool.onSell([checkedUnitVolume], poolPairData as any)[0]
-        : pool.onBuy([checkedUnitVolume], poolPairData as any)[0];
-
-    const prices: bigint[] = new Array(amounts.length).fill(0n);
-
-    const outputs =
-      side === SwapSide.SELL
-        ? pool.onSell(
-            amountWithoutZero.slice(0, nonZeroAmountIndex),
-            poolPairData as any,
-          )
-        : pool.onBuy(
-            amountWithoutZero.slice(0, nonZeroAmountIndex),
-            poolPairData as any,
-          );
-
-    assert(
-      outputs.length <= prices.length,
-      `Wrong length logic: outputs.length (${outputs.length}) <= prices.length (${prices.length})`,
-    );
-
-    for (const [i, output] of outputs.entries()) {
-      // Outputs shifted right to one to keep first entry as 0
-      prices[i + 1] = output;
-    }
-
-    return { unit: unitResult, prices };
-  }
-
-  async getOnChainState(
-    subgraphPoolBase: SubgraphPoolBase[],
-    blockNumber: number,
-  ): Promise<PoolStateMap> {
-    const multiCallData = subgraphPoolBase
-      .map(pool => {
-        if (!this.isSupportedPool(pool.poolType)) return [];
-
-        return this.pools[pool.poolType].getOnChainCalls(pool);
-      })
-      .flat();
-
-    // 500 is an arbitrary number chosen based on the blockGasLimit
-    const slicedMultiCallData = _.chunk(multiCallData, 500);
-
-    const returnData = (
-      await Promise.all(
-        slicedMultiCallData.map(async _multiCallData =>
-          this.dexHelper.multiContract.methods
-            .tryAggregate(false, _multiCallData)
-            .call({}, blockNumber),
-        ),
-      )
-    ).flat();
-
-    let i = 0;
-    const onChainStateMap = subgraphPoolBase.reduce(
-      (acc: { [address: string]: PoolState }, pool) => {
-        if (!this.isSupportedPool(pool.poolType)) return acc;
-
-        const [decoded, newIndex] = this.pools[
-          pool.poolType
-        ].decodeOnChainCalls(pool, returnData, i);
-        i = newIndex;
-        acc = { ...acc, ...decoded };
-        return acc;
-      },
-      {},
-    );
-
-    return onChainStateMap;
-  }
-}
-
-export class BalancerV2
-  extends SimpleExchange
-  implements
-    IDex<
-      BalancerV2Data,
-      BalancerV2DirectParam | BalancerV2DirectParamV6Swap,
-      OptimizedBalancerV2Data
-    >
-{
-  public eventPools: BalancerV2EventPool;
-
-  readonly hasConstantPriceLargeAmounts = false;
-  readonly isFeeOnTransferSupported = false;
-  readonly needWrapNative = true; // temporary
-
-  readonly directSwapIface = new Interface(DirectSwapABI);
-  readonly balancerVaultInterface = new Interface(BalancerVaultABI);
-
-  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
-    getDexKeysWithNetwork(BalancerConfig);
-
-  logger: Logger;
-
-  // In memory pool state for non-event pools
-  nonEventPoolStateCache: PoolStateCache;
-
-  eventDisabledPoolsTimer?: NodeJS.Timer;
-  eventDisabledPools: Address[] = [];
-
-  constructor(
-    protected network: Network,
-    dexKey: string,
-    public dexHelper: IDexHelper,
-    public vaultAddress: Address = BalancerConfig[dexKey][network].vaultAddress,
-    protected subgraphURL: string = BalancerConfig[dexKey][network].subgraphURL,
-    protected adapters = Adapters[network],
-  ) {
-    super(dexHelper, dexKey);
-    // Initialise cache - this will hold pool state of non-event pools in memory to be reused if block hasn't expired
-    this.nonEventPoolStateCache = { blockNumber: 0, poolState: {} };
-    this.logger = dexHelper.getLogger(dexKey);
-    this.eventPools = new BalancerV2EventPool(
-      dexKey,
-      network,
-      vaultAddress,
-      subgraphURL,
-      dexHelper,
-      this.logger,
-    );
-  }
-
-  async setupEventPools(blockNumber: number) {
-    await this.eventPools.initialize(blockNumber);
-  }
-
-  async fetchEventDisabledPools() {
-    const cacheKey = 'eventDisabledPools';
-    const poolAddressListFromCache = await this.dexHelper.cache.get(
-      this.dexKey,
-      this.network,
-      cacheKey,
-    );
-    if (poolAddressListFromCache) {
-      this.eventDisabledPools = JSON.parse(poolAddressListFromCache);
-      return;
-    }
-    this.logger.info(
-      `Fetching ${this.dexKey}_${this.network} Weight Updates from subgraph`,
-    );
-    const timeNow = Math.floor(Date.now() / 1000);
-    const variables = {
-      count: MAX_POOL_CNT,
-      timestampPast: timeNow - POOL_EVENT_REENABLE_DELAY,
-      timestampFuture: timeNow + POOL_EVENT_DISABLED_TTL,
-    };
-    const { data } = await this.dexHelper.httpRequest.post(
-      this.subgraphURL,
-      { query: fetchWeightUpdating, variables },
-      SUBGRAPH_TIMEOUT,
-    );
-
-    if (!(data && data.gradualWeightUpdates)) {
-      throw new Error(
-        `${this.dexKey}_${this.network} failed to fetch weight updates from subgraph`,
-      );
-    }
-
-    this.eventDisabledPools = _.uniq(
-      data.gradualWeightUpdates.map(
-        (wu: { poolId: { address: Address } }) => wu.poolId.address,
-      ),
-    );
-    const poolAddressList = JSON.stringify(this.eventDisabledPools);
-    this.logger.info(
-      `Pools blocked from event based on ${this.dexKey}_${this.network}: ${poolAddressList}`,
-    );
-    this.dexHelper.cache.setex(
-      this.dexKey,
-      this.network,
-      cacheKey,
-      POOL_EVENT_DISABLED_TTL,
-      poolAddressList,
-    );
-  }
-
-  async initializePricing(blockNumber: number) {
-    if (!this.eventDisabledPoolsTimer) {
-      await this.fetchEventDisabledPools();
-      this.eventDisabledPoolsTimer = setInterval(async () => {
-        try {
-          await this.fetchEventDisabledPools();
-        } catch (e) {
-          this.logger.error(
-            `${this.dexKey}: Failed to update event disabled pools:`,
-            e,
-          );
-        }
-      }, POOL_EVENT_DISABLED_TTL * 1000);
-    }
-    await this.setupEventPools(blockNumber);
-  }
-
-  releaseResources(): void {
-    if (this.eventDisabledPoolsTimer) {
-      clearInterval(this.eventDisabledPoolsTimer);
-      this.eventDisabledPoolsTimer = undefined;
-      this.logger.info(
-        `${this.dexKey}: cleared eventDisabledPoolsTimer before shutting down`,
-      );
-    }
-  }
-
-  getPoolsWithTokenPair(from: Token, to: Token): SubgraphPoolBase[] {
-    const pools = this.eventPools.allPools.filter(p => {
-      const fromMain = p.mainTokens.find(
-        token => token.address.toLowerCase() === from.address.toLowerCase(),
-      );
-      const toMain = p.mainTokens.find(
-        token => token.address.toLowerCase() === to.address.toLowerCase(),
-      );
-
-      return (
-        fromMain &&
-        toMain &&
-        // filter instances similar to the following:
-        // USDC -> DAI in a pool where bbaUSD is nested (ie: MAI / bbaUSD)
-        !(fromMain.isDeeplyNested && toMain.isDeeplyNested)
-      );
-    });
-
-    return pools.slice(0, 10);
-  }
-
-  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
-    return this.adapters[side] ? this.adapters[side] : null;
-  }
-
-  async getPoolIdentifiers(
-    from: Token,
-    to: Token,
-    side: SwapSide,
-    blockNumber: number,
-  ): Promise<string[]> {
-    const _from = this.dexHelper.config.wrapETH(from);
-    const _to = this.dexHelper.config.wrapETH(to);
-
-    const pools = this.getPoolsWithTokenPair(_from, _to);
-
-    return pools.map(
-      ({ address }) => `${this.dexKey}_${address.toLowerCase()}`,
-    );
-  }
-
-  /**
-   * Returns cached poolState if blockNumber matches cached value. Resets if not.
-   */
-  private getNonEventPoolStateCache(blockNumber: number): PoolStateMap {
-    if (this.nonEventPoolStateCache.blockNumber !== blockNumber)
-      this.nonEventPoolStateCache.poolState = {};
-    return this.nonEventPoolStateCache.poolState;
-  }
-
-  /**
-   * Update poolState cache.
-   * If same blockNumber as current cache then update with new pool state.
-   * If different blockNumber overwrite cache with latest.
-   */
-  private updateNonEventPoolStateCache(
-    poolState: PoolStateMap,
-    blockNumber: number,
-  ): PoolStateMap {
-    if (this.nonEventPoolStateCache.blockNumber !== blockNumber) {
-      this.nonEventPoolStateCache.blockNumber = blockNumber;
-      this.nonEventPoolStateCache.poolState = poolState;
-    } else
-      this.nonEventPoolStateCache.poolState = {
-        ...this.nonEventPoolStateCache.poolState,
-        ...poolState,
-      };
-    return this.nonEventPoolStateCache.poolState;
-  }
-
-  async getPricesVolume(
-    from: Token,
-    to: Token,
-    amounts: bigint[],
-    side: SwapSide,
-    blockNumber: number,
-    limitPools?: string[],
-  ): Promise<null | ExchangePrices<BalancerV2Data>> {
-    try {
-      const _from = this.dexHelper.config.wrapETH(from);
-      const _to = this.dexHelper.config.wrapETH(to);
-
-      if (_from.address === _to.address) {
-        return null;
-      }
-
-      const allPools = this.getPoolsWithTokenPair(_from, _to);
-
-      const allowedPools = limitPools
-        ? allPools.filter(({ address }) =>
-            limitPools.includes(`${this.dexKey}_${address.toLowerCase()}`),
-          )
-        : allPools;
-
-      if (!allowedPools.length) return null;
-
-      const eventPoolStatesRO = await this.eventPools.getState(blockNumber);
-      if (!eventPoolStatesRO) {
-        this.logger.error(`getState returned null`);
-      }
-      const eventPoolStates = { ...(eventPoolStatesRO || {}) };
-      for (const addr of this.eventDisabledPools) delete eventPoolStates[addr];
-
-      // Fetch previously cached non-event pool states
-      let nonEventPoolStates = this.getNonEventPoolStateCache(blockNumber);
-
-      //get all pools that would be used in the paths, nested pools included
-      const poolsFlattened = getAllPoolsUsedInPaths(
-        _from.address,
-        _to.address,
-        allowedPools,
-        this.poolAddressMap,
-        side,
-      );
-
-      // Missing pools are pools that don't already exist in event or non-event
-      const missingPools = poolsFlattened.filter(
-        pool =>
-          !(
-            pool.address.toLowerCase() in eventPoolStates ||
-            pool.address.toLowerCase() in nonEventPoolStates
-          ),
-      );
-
-      // Retrieve onchain state for any missing pools
-      if (missingPools.length > 0) {
-        const missingPoolsStateMap = await this.eventPools.getOnChainState(
-          missingPools,
-          blockNumber,
-        );
-        // Update non-event pool state cache with newly retrieved data so it can be reused in future
-        nonEventPoolStates = this.updateNonEventPoolStateCache(
-          missingPoolsStateMap,
-          blockNumber,
-        );
-      }
-
-      const poolPrices = allowedPools
-        .map((pool: SubgraphPoolBase) => {
-          try {
-            const poolAddress = pool.address.toLowerCase();
-
-            const path = poolGetPathForTokenInOut(
-              _from.address,
-              _to.address,
-              pool,
-              this.poolAddressMap,
-              side,
-            );
-
-            let pathAmounts = amounts;
-            let resOut: { unit: bigint; prices: bigint[] } | null = null;
-
-            for (let i = 0; i < path.length; i++) {
-              const poolAddress = path[i].pool.address.toLowerCase();
-              const poolState = (eventPoolStates[poolAddress] ||
-                nonEventPoolStates[poolAddress]) as PoolState | undefined;
-              if (!poolState) {
-                this.logger.error(
-                  `Unable to find the poolState ${poolAddress}`,
-                );
-                return null;
-              }
-
-              const unitVolume = getBigIntPow(
-                (side === SwapSide.SELL ? path[i].tokenIn : path[i].tokenOut)
-                  .decimals,
-              );
-
-              const res = this.eventPools.getPricesPool(
-                path[i].tokenIn,
-                path[i].tokenOut,
-                path[i].pool,
-                poolState,
-                pathAmounts,
-                unitVolume,
-                side,
-              );
-
-              if (!res) {
-                return null;
-              }
-
-              pathAmounts = res.prices;
-
-              if (i === path.length - 1) {
-                resOut = res;
-              }
-            }
-
-            if (!resOut) {
-              return null;
-            }
-
-            return {
-              unit: resOut.unit,
-              prices: resOut.prices,
-              data: {
-                poolId: pool.id,
-              },
-              poolAddresses: [poolAddress],
-              exchange: this.dexKey,
-              gasCost:
-                STABLE_GAS_COST + VARIABLE_GAS_COST_PER_CYCLE * path.length,
-              poolIdentifier: `${this.dexKey}_${poolAddress}`,
-            };
-
-            // TODO: re-check what should be the current block time stamp
-          } catch (e) {
-            this.logger.warn(
-              `Error_getPrices ${from.symbol || from.address}, ${
-                to.symbol || to.address
-              }, ${side}, ${pool.address}:`,
-              e,
-            );
-
-            return;
-          }
-        })
-        .filter(p => !!p);
-      return poolPrices as ExchangePrices<BalancerV2Data>;
-    } catch (e) {
-      this.logger.error(
-        `Error_getPrices ${from.symbol || from.address}, ${
-          to.symbol || to.address
-        }, ${side}:`,
-        e,
-      );
-      return null;
-    }
-  }
-
-  // Returns estimated gas cost of calldata for this DEX in multiSwap
-  getCalldataGasCost(
-    poolPrices: PoolPrices<BalancerV2Data>,
-  ): number | number[] {
-    return (
-      CALLDATA_GAS_COST.DEX_OVERHEAD +
-      CALLDATA_GAS_COST.LENGTH_LARGE +
-      // ParentStruct header
-      CALLDATA_GAS_COST.OFFSET_SMALL +
-      // ParentStruct -> swaps[] header
-      CALLDATA_GAS_COST.OFFSET_LARGE +
-      // ParentStruct -> assets[] header
-      CALLDATA_GAS_COST.OFFSET_LARGE +
-      // ParentStruct -> funds
-      CALLDATA_GAS_COST.ADDRESS +
-      CALLDATA_GAS_COST.BOOL +
-      CALLDATA_GAS_COST.ADDRESS +
-      CALLDATA_GAS_COST.BOOL +
-      // ParentStruct -> limits[] header
-      CALLDATA_GAS_COST.OFFSET_LARGE +
-      // ParentStruct -> deadline
-      CALLDATA_GAS_COST.TIMESTAMP +
-      // ParentStruct -> swaps[]
-      CALLDATA_GAS_COST.LENGTH_SMALL +
-      // ParentStruct -> swaps[0] header
-      CALLDATA_GAS_COST.OFFSET_SMALL +
-      // ParentStruct -> swaps[0] -> poolId
-      CALLDATA_GAS_COST.FULL_WORD +
-      // ParentStruct -> swaps[0] -> assetInIndex
-      CALLDATA_GAS_COST.INDEX +
-      // ParentStruct -> swaps[0] -> assetOutIndex
-      CALLDATA_GAS_COST.INDEX +
-      // ParentStruct -> swaps[0] -> amount
-      CALLDATA_GAS_COST.AMOUNT +
-      // ParentStruct -> swaps[0] -> userData header
-      CALLDATA_GAS_COST.OFFSET_SMALL +
-      // ParentStruct -> swaps[0] -> userData
-      CALLDATA_GAS_COST.ZERO +
-      // ParentStruct -> assets[]
-      CALLDATA_GAS_COST.LENGTH_SMALL +
-      // ParentStruct -> assets[0:2]
-      CALLDATA_GAS_COST.ADDRESS * 2 +
-      // ParentStruct -> limits[]
-      CALLDATA_GAS_COST.LENGTH_SMALL +
-      // ParentStruct -> limits[0:2]
-      CALLDATA_GAS_COST.FULL_WORD * 2
-    );
-  }
-
-  getAdapterParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
-    data: OptimizedBalancerV2Data,
-    side: SwapSide,
-  ): AdapterExchangeParam {
-    const params = this.getBalancerV2BatchSwapParam(
-      srcToken,
-      destToken,
-      data,
-      side,
-      this.dexHelper.config.data.augustusAddress!,
-      this.dexHelper.config.data.augustusAddress!,
-    );
-
-    const payload = this.abiCoder.encodeParameter(
-      {
-        ParentStruct: {
-          'swaps[]': {
-            poolId: 'bytes32',
-            assetInIndex: 'uint256',
-            assetOutIndex: 'uint256',
-            amount: 'uint256',
-            userData: 'bytes',
-          },
-          assets: 'address[]',
-          funds: {
-            sender: 'address',
-            fromInternalBalance: 'bool',
-            recipient: 'address',
-            toInternalBalance: 'bool',
-          },
-          limits: 'int256[]',
-          deadline: 'uint256',
-        },
-      },
-      {
-        swaps: params[1],
-        assets: params[2],
-        funds: params[3],
-        limits: params[4],
-        deadline: params[5],
-      },
-    );
-
-    return {
-      targetExchange: this.vaultAddress,
-      payload,
-      networkFee: '0',
-    };
-  }
-
-  public getBalancerV2SwapParam(
-    srcToken: string,
-    destToken: string,
-    data: OptimizedBalancerV2Data,
-    side: SwapSide,
-    recipient: string,
-    sender: string,
-  ): BalancerV2SwapParam {
-    assert(data.swaps.length === 1, 'should have exactly one pool');
-
-    const singleSwap: BalancerV2SingleSwap = {
-      poolId: data.swaps[0].poolId,
-      kind:
-        side === SwapSide.SELL ? SwapTypes.SwapExactIn : SwapTypes.SwapExactOut,
-      assetIn:
-        srcToken.toLowerCase() === ETHER_ADDRESS ? NULL_ADDRESS : srcToken,
-      assetOut:
-        destToken.toLowerCase() === ETHER_ADDRESS ? NULL_ADDRESS : destToken,
-      amount: data.swaps[0].amount,
-      userData: '0x',
-    };
-
-    const funds = {
-      sender,
-      recipient,
-      fromInternalBalance: false,
-      toInternalBalance: false,
-    };
-
-    const params: BalancerV2SwapParam = [
-      singleSwap,
-      funds,
-      side === SwapSide.SELL ? '1' : MAX_INT,
-      getLocalDeadlineAsFriendlyPlaceholder(),
-    ];
-
-    return params;
-  }
-
-  /*
-      Algorithm to determine balancer (sender, recipient) params:
-
-      if version = 5
-          sender = recipient = augustusV5
-      else (so V6)
-        if direct swap
-            sender = recipient = augustusV6
-        else (so generic swaps)
-          if sell
-            if swap.destToken = priceRoute.destToken <> ETH (need withdraw for eth currently, need fix in future)
-                  sender = executor and recipient = augustusV6 (skip 1 extra transfer)
-              else
-                  sender = recipient = executor
-              # note: we pass sender=null then the address of the executor is inferred contract side
-          else (so buy)
-              sender = recipient = executor
-*/
-  public getBalancerV2BatchSwapParam(
-    srcToken: string,
-    destToken: string,
-    data: OptimizedBalancerV2Data,
-    side: SwapSide,
-    recipient: string,
-    sender: string,
-    shouldWalkAssetsBackward?: boolean, // should do for all buy but prefer keep it under control
-  ): BalancerV2BatchSwapParam {
-    let swapOffset = 0;
-    let swaps: BalancerSwap[] = [];
-    let assets: string[] = [];
-    let limits: string[] = [];
-
-    for (const swapData of data.swaps) {
-      const pool = this.poolIdMap[swapData.poolId];
-      const hasEth = [srcToken.toLowerCase(), destToken.toLowerCase()].includes(
-        ETHER_ADDRESS.toLowerCase(),
-      );
-      const _srcToken = this.dexHelper.config.wrapETH({
-        address: srcToken,
-        decimals: 18,
-      }).address;
-      const _destToken = this.dexHelper.config.wrapETH({
-        address: destToken,
-        decimals: 18,
-      }).address;
-
-      let path = poolGetPathForTokenInOut(
-        _srcToken,
-        _destToken,
-        pool,
-        this.poolAddressMap,
-        side,
-      );
-
-      if (side === SwapSide.BUY) {
-        path = path.reverse();
-      }
-
-      const _swaps = path.map((hop, index) => {
-        const assetInIndex = shouldWalkAssetsBackward
-          ? swapOffset + path.length - index
-          : swapOffset + index;
-
-        const assetOutIndex = shouldWalkAssetsBackward
-          ? swapOffset + path.length - index - 1
-          : swapOffset + index + 1;
-
-        const amount =
-          (side === SwapSide.SELL && index === 0) ||
-          (side === SwapSide.BUY && index === path.length - 1)
-            ? swapData.amount
-            : '0';
-
-        if (assetInIndex < 0 || assetOutIndex < 0) {
-          const error = new Error(`Invalid indices in balancer`);
-          this.logger.error(error.message, error);
-          throw error;
-        }
-
-        return {
-          poolId: hop.pool.id,
-          assetInIndex,
-          assetOutIndex,
-          amount,
-          userData: '0x',
-        };
-      });
-
-      swapOffset += path.length + 1;
-
-      // BalancerV2 Uses Address(0) as ETH
-      const _assets = [_srcToken, ...path.map(hop => hop.tokenOut.address)].map(
-        t => (hasEth && this.dexHelper.config.isWETH(t) ? NULL_ADDRESS : t),
-      );
-
-      const _limits = _assets.map(_ => MAX_INT);
-
-      swaps = swaps.concat(_swaps);
-      assets = assets.concat(_assets);
-      limits = limits.concat(_limits);
-    }
-
-    const funds = {
-      sender,
-      recipient,
-      fromInternalBalance: false,
-      toInternalBalance: false,
-    };
-
-    const params: BalancerV2BatchSwapParam = [
-      side === SwapSide.SELL ? SwapTypes.SwapExactIn : SwapTypes.SwapExactOut,
-      side === SwapSide.SELL ? swaps : swaps.reverse(),
-      shouldWalkAssetsBackward ? assets.reverse() : assets,
-      funds,
-      limits,
-      getLocalDeadlineAsFriendlyPlaceholder(),
-    ];
-
-    return params;
-  }
-
-  static getDirectFunctionName(): string[] {
-    return [DirectMethods.directSell, DirectMethods.directBuy];
-  }
-
-  getTokenFromAddress(address: Address): Token {
-    // In this Dex decimals are not used
-    return { address, decimals: 0 };
-  }
-
-  async preProcessTransaction(
-    optimalSwapExchange: OptimalSwapExchange<OptimizedBalancerV2Data>,
-    srcToken: Token,
-    _0: Token,
-    _1: SwapSide,
-    options: PreprocessTransactionOptions,
-  ): Promise<[OptimalSwapExchange<OptimizedBalancerV2Data>, ExchangeTxInfo]> {
-    if (!options.isDirectMethod) {
-      return [
-        optimalSwapExchange,
-        {
-          deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
-        },
-      ];
-    }
-
-    assert(
-      optimalSwapExchange.data !== undefined,
-      `preProcessTransaction: data field is missing`,
-    );
-
-    let isApproved: boolean | undefined;
-
-    try {
-      isApproved = await this.dexHelper.augustusApprovals.hasApproval(
-        options.executionContractAddress,
-        this.dexHelper.config.wrapETH(srcToken).address,
-        this.vaultAddress,
-      );
-    } catch (e) {
-      this.logger.error(
-        `preProcessTransaction failed to retrieve allowance info: `,
-        e,
-      );
-    }
-
-    return [
-      {
-        ...optimalSwapExchange,
-        data: {
-          ...optimalSwapExchange.data,
-          isApproved,
-        },
-      },
-      {
-        deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
-      },
-    ];
-  }
-
-  getDirectParam(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    expectedAmount: NumberAsString,
-    data: OptimizedBalancerV2Data,
-    side: SwapSide,
-    permit: string,
-    uuid: string,
-    feePercent: NumberAsString,
-    deadline: NumberAsString,
-    partner: string,
-    beneficiary: string,
-    contractMethod?: string,
-  ): TxInfo<BalancerV2DirectParam> {
-    if (
-      contractMethod !== DirectMethods.directSell &&
-      contractMethod !== DirectMethods.directBuy
-    ) {
-      throw new Error(`Invalid contract method ${contractMethod}`);
-    }
-
-    let isApproved: boolean = !!data.isApproved;
-    if (data.isApproved === undefined) {
-      this.logger.warn(`isApproved is undefined, defaulting to false`);
-    }
-
-    const [, swaps, assets, funds, limits, _deadline] =
-      this.getBalancerV2BatchSwapParam(
-        srcToken,
-        destToken,
-        data,
-        side,
-        this.dexHelper.config.data.augustusAddress!,
-        this.dexHelper.config.data.augustusAddress!,
-      );
-
-    const swapParams: BalancerV2DirectParam = [
-      swaps,
-      assets,
-      funds,
-      limits,
-      srcAmount,
-      destAmount,
-      expectedAmount,
-      _deadline,
-      feePercent,
-      this.vaultAddress,
-      partner,
-      isApproved,
-      beneficiary,
-      permit,
-      uuidToBytes16(uuid),
-    ];
-
-    const encoder = (...params: BalancerV2DirectParam) => {
-      return this.directSwapIface.encodeFunctionData(
-        side === SwapSide.SELL
-          ? DirectMethods.directSell
-          : DirectMethods.directBuy,
-        [params],
-      );
-    };
-
-    return {
-      params: swapParams,
-      encoder,
-      networkFee: '0',
-    };
-  }
-
-  getDirectParamV6(
-    srcToken: Address,
-    destToken: Address,
-    fromAmount: NumberAsString,
-    toAmount: NumberAsString,
-    quotedAmount: NumberAsString,
-    data: OptimizedBalancerV2Data,
-    side: SwapSide,
-    permit: string,
-    uuid: string,
-    partnerAndFee: string,
-    beneficiary: string,
-    blockNumber: number,
-    contractMethod?: string,
-  ) {
-    if (!contractMethod) throw new Error(`contractMethod need to be passed`);
-
-    if (!BalancerV2.getDirectFunctionNameV6().includes(contractMethod!)) {
-      throw new Error(`Invalid contract method ${contractMethod}`);
-    }
-
-    const metadata = hexConcat([
-      hexZeroPad(uuidToBytes16(uuid), 16),
-      hexZeroPad(hexlify(blockNumber), 16),
-    ]);
-
-    const balancerBatchSwapParam = this.getBalancerV2BatchSwapParam(
-      srcToken,
-      destToken,
-      data,
-      side,
-      this.dexHelper.config.data.augustusV6Address!,
-      this.dexHelper.config.data.augustusV6Address!,
-      side === SwapSide.BUY,
-    );
-
-    // after getBalancerV2BatchSwapParam runs we may get more swaps so we can't decide on single vs batch before resolving it
-    const [, swaps] = balancerBatchSwapParam;
-    const isSingleSwap = swaps.length === 1;
-
-    const balancerParams = isSingleSwap
-      ? this.getBalancerV2SwapParam(
-          srcToken,
-          destToken,
-          data,
-          side,
-          this.dexHelper.config.data.augustusV6Address!,
-          this.dexHelper.config.data.augustusV6Address!,
-        )
-      : balancerBatchSwapParam;
-
-    const swapParams: BalancerV2DirectParamV6 = [
-      fromAmount,
-      toAmount,
-      quotedAmount,
-      metadata,
-      this.encodeBeneficiaryAndApproveFlag(beneficiary, !data.isApproved),
-    ];
-
-    const encodeParams: BalancerV2DirectParamV6Swap = [
-      swapParams,
-      partnerAndFee,
-      permit,
-      balancerParams.length === 4 // TODO: upgrade ts to use isSingleSwap
-        ? this.encodeBalancerV2SwapParam(balancerParams)
-        : this.encodeBalancerV2BatchSwapParam(balancerParams),
-    ];
-
-    const encoder = (...params: BalancerV2DirectParamV6Swap) => {
-      return this.augustusV6Interface.encodeFunctionData(
-        side === SwapSide.SELL
-          ? DirectMethodsV6.directSell
-          : DirectMethodsV6.directBuy,
-        [...params],
-      );
-    };
-
-    return {
-      encoder,
-      params: encodeParams,
-      networkFee: '0',
-    };
-  }
-
-  private encodeBeneficiaryAndApproveFlag(
-    beneficiary: Address,
-    approveFlag: boolean,
-  ) {
-    const addressBN = BigNumber.from(beneficiary);
-    const flagBN = approveFlag ? BigNumber.from(1).shl(255) : BigNumber.from(0);
-
-    return addressBN.or(flagBN).toString();
-  }
-
-  private encodeBalancerV2SwapParam(param: BalancerV2SwapParam): string {
-    const [singleSwap, funds, limit, deadline] = param;
-
-    const encoded = this.balancerVaultInterface.encodeFunctionData('swap', [
-      singleSwap,
-      funds,
-      limit,
-      deadline,
-    ]);
-
-    return encoded;
-  }
-
-  private encodeBalancerV2BatchSwapParam(
-    param: BalancerV2BatchSwapParam,
-  ): string {
-    const [kind, swaps, assets, funds, limits, deadline] = param;
-
-    const encoded = this.balancerVaultInterface.encodeFunctionData(
-      'batchSwap',
-      [kind, swaps, assets, funds, limits, deadline],
-    );
-    return encoded;
-  }
-
-  static getDirectFunctionNameV6(): string[] {
-    return [DirectMethodsV6.directSell, DirectMethodsV6.directBuy];
-  }
-
-  async getSimpleParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
-    data: OptimizedBalancerV2Data,
-    side: SwapSide,
-  ): Promise<SimpleExchangeParam> {
-    const params = this.getBalancerV2BatchSwapParam(
-      srcToken,
-      destToken,
-      data,
-      side,
-      this.dexHelper.config.data.augustusAddress!,
-      this.dexHelper.config.data.augustusAddress!,
-    );
-
-    const swapData = this.eventPools.vaultInterface.encodeFunctionData(
-      'batchSwap',
-      params,
-    );
-
-    return this.buildSimpleParamWithoutWETHConversion(
-      srcToken,
-      srcAmount,
-      destToken,
-      destAmount,
-      swapData,
-      this.vaultAddress,
-    );
-  }
-
-  getDexParam(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    recipient: Address,
-    data: OptimizedBalancerV2Data,
-    side: SwapSide,
-    context: Context,
-    executor: Address,
-  ): DexExchangeParam {
-    const balancerBatchSwapParam = this.getBalancerV2BatchSwapParam(
-      srcToken,
-      destToken,
-      data,
-      side,
-      recipient,
-      side === SwapSide.SELL ? NULL_ADDRESS : executor,
-    );
-
-    const [, swaps] = balancerBatchSwapParam;
-    const isSingleSwap = swaps.length === 1;
-
-    if (isSingleSwap) {
-      const balancerSwapParam = this.getBalancerV2SwapParam(
-        srcToken,
-        destToken,
-        data,
-        side,
-        recipient,
-        executor,
-      );
-
-      const exchangeData = this.eventPools.vaultInterface.encodeFunctionData(
-        'swap',
-        balancerSwapParam,
-      );
-
-      return {
-        needWrapNative: this.needWrapNative,
-        dexFuncHasRecipient: true,
-        exchangeData,
-        targetExchange: this.vaultAddress,
-        returnAmountPos:
-          side === SwapSide.SELL
-            ? extractReturnAmountPosition(
-                this.balancerVaultInterface,
-                'swap',
-                'amountCalculated',
-              )
-            : undefined,
-      };
-    }
-
-    let exchangeData = this.eventPools.vaultInterface.encodeFunctionData(
-      'batchSwap',
-      balancerBatchSwapParam,
-    );
-    let specialDexFlag = SpecialDex.DEFAULT;
-
-    if (side === SwapSide.SELL) {
-      const totalAmount = swaps.reduce<BigNumber>((acc, swap) => {
-        return acc.add(swap.amount);
-      }, BigNumber.from(0));
-
-      exchangeData = solidityPack(
-        ['bytes32', 'bytes'],
-        [hexZeroPad(hexlify(totalAmount), 32), exchangeData],
-      );
-      specialDexFlag = SpecialDex.SWAP_ON_BALANCER_V2;
-    }
-
-    return {
-      needWrapNative: this.needWrapNative,
-      dexFuncHasRecipient: true,
-      exchangeData,
-      specialDexFlag,
-      targetExchange: this.vaultAddress,
-      returnAmountPos: undefined,
-    };
-  }
-
-  async updatePoolState(): Promise<void> {
-    this.eventPools.allPools = await this.eventPools.fetchAllSubgraphPools();
-  }
-
-  async getTopPoolsForToken(
-    tokenAddress: Address,
-    count: number,
-  ): Promise<PoolLiquidity[]> {
-    const poolsWithToken = this.eventPools.allPools.filter(pool =>
-      pool.mainTokens.some(mainToken =>
-        isSameAddress(mainToken.address, tokenAddress),
-      ),
-    );
-
-    const variables = {
-      poolIds: poolsWithToken.map(pool => pool.id),
-      count,
-    };
-
-    const query = `query ($poolIds: [String!]!, $count: Int) {
-      pools (first: $count, orderBy: totalLiquidity, orderDirection: desc,
-           where: {id_in: $poolIds,
-                   swapEnabled: true,
-                   totalLiquidity_gt: ${MIN_USD_LIQUIDITY_TO_FETCH.toString()}}) {
-        address
-        totalLiquidity
-        tokens {
-          address
-          decimals
-        }
-      }
-    }`;
-    const { data } = await this.dexHelper.httpRequest.post<{
-      data: {
-        pools: {
-          address: string;
-          totalLiquidity: string;
-          tokens: { address: string; decimals: number }[];
-        }[];
-      };
-    }>(
-      this.subgraphURL,
-      {
-        query,
-        variables,
-      },
-      SUBGRAPH_TIMEOUT,
-    );
-
-    if (!(data && data.pools))
-      throw new Error(
-        `Error_${this.dexKey}_Subgraph: couldn't fetch the pools from the subgraph`,
-      );
-
-    return _.map(data.pools, pool => {
-      const subgraphPool = poolsWithToken.find(poolWithToken =>
-        isSameAddress(poolWithToken.address, pool.address),
-      )!;
-
-      return {
-        exchange: this.dexKey,
-        address: pool.address.toLowerCase(),
-        connectorTokens: subgraphPool.mainTokens.filter(
-          token => !isSameAddress(tokenAddress, token.address),
-        ),
-        liquidityUSD: parseFloat(pool.totalLiquidity),
-      };
-    });
-  }
-
-  private get poolAddressMap(): SubgraphPoolAddressDictionary {
-    return keyBy(this.eventPools.allPools, 'address');
-  }
-
-  private get poolIdMap(): { [poolId: string]: SubgraphPoolBase } {
-    return keyBy(this.eventPools.allPools, 'id');
-  }
-}
+import { Interface } from '@ethersproject/abi';
+import { assert, DeepReadonly } from 'ts-essentials';
+import _, { keyBy } from 'lodash';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  ExchangePrices,
+  ExchangeTxInfo,
+  Log,
+  Logger,
+  PoolLiquidity,
+  PoolPrices,
+  PreprocessTransactionOptions,
+  SimpleExchangeParam,
+  Token,
+  TxInfo,
+} from '../../types';
+import {
+  ETHER_ADDRESS,
+  MAX_INT,
+  MAX_UINT,
+  Network,
+  NULL_ADDRESS,
+  SUBGRAPH_TIMEOUT,
+  SwapSide,
+} from '../../constants';
+import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import { StablePool } from './pools/stable/StablePool';
+import { WeightedPool } from './pools/weighted/WeightedPool';
+import { PhantomStablePool } from './pools/phantom-stable/PhantomStablePool';
+import { LinearPool } from './pools/linear/LinearPool';
+import { Gyro3Pool } from './pools/gyro/Gyro3Pool';
+import { GyroEPool } from './pools/gyro/GyroEPool';
+import VaultABI from '../../abi/balancer-v2/vault.json';
+import DirectSwapABI from '../../abi/DirectSwap.json';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import {
+  getBigIntPow,
+  getDexKeysWithNetwork,
+  uuidToBytes16,
+} from '../../utils';
+import { Context, IDex } from '../../dex/idex';
+import { IDexHelper } from '../../dex-helper';
+import {
+  BalancerV2BatchSwapParam,
+  BalancerPoolTypes,
+  BalancerSwap,
+  BalancerV2Data,
+  BalancerV2DirectParam,
+  OptimizedBalancerV2Data,
+  PoolState,
+  PoolStateCache,
+  PoolStateMap,
+  SubgraphPoolAddressDictionary,
+  SubgraphPoolBase,
+  SwapTypes,
+  BalancerV2DirectParamV6,
+  BalancerV2DirectParamV6Swap,
+  BalancerV2SwapParam,
+  BalancerV2SingleSwap,
+} from './types';
+import {
+  getLocalDeadlineAsFriendlyPlaceholder,
+  SimpleExchange,
+} from '../simple-exchange';
+import { Adapters, BalancerConfig } from './config';
+import {
+  getAllPoolsUsedInPaths,
+  isSameAddress,
+  poolGetMainTokens,
+  poolGetPathForTokenInOut,
+} from './utils';
+import {
+  DirectMethods,
+  DirectMethodsV6,
+  MIN_USD_LIQUIDITY_TO_FETCH,
+  STABLE_GAS_COST,
+  VARIABLE_GAS_COST_PER_CYCLE,
+} from './constants';
+import { NumberAsString, OptimalSwapExchange } from '@paraswap/core';
+import { hexConcat, hexlify, hexZeroPad, solidityPack } from 'ethers/lib/utils';
+import BalancerVaultABI from '../../abi/balancer-v2/vault.json';
+import { BigNumber, utils } from 'ethers';
+import { Executors, SpecialDex } from '../../executor/types';
+import { S } from '@bgd-labs/aave-address-book/dist/AaveV2Ethereum-timF4kft';
+
+// If you disable some pool, don't forget to clear the cache, otherwise changes won't be applied immediately
+const enabledPoolTypes = [
+  // 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.AaveLinear,
+  BalancerPoolTypes.ERC4626Linear,
+  BalancerPoolTypes.Linear,
+  BalancerPoolTypes.ComposableStable,
+  BalancerPoolTypes.BeefyLinear,
+  BalancerPoolTypes.GearboxLinear,
+  BalancerPoolTypes.MidasLinear,
+  BalancerPoolTypes.ReaperLinear,
+  BalancerPoolTypes.SiloLinear,
+  BalancerPoolTypes.TetuLinear,
+  BalancerPoolTypes.YearnLinear,
+  BalancerPoolTypes.GyroE,
+  BalancerPoolTypes.Gyro3,
+];
+
+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',
+  '0xe7b1d394f3b40abeaa0b64a545dbcf89da1ecb3f00010000000000000000009a',
+
+  // 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
+    orderBy: totalLiquidity
+    orderDirection: desc
+    where: {
+      totalLiquidity_gt: ${MIN_USD_LIQUIDITY_TO_FETCH.toString()},
+      totalShares_not_in: ["0", "0.000000000001"],
+      id_not_in: [
+        ${disabledPoolIds.map(p => `"${p}"`).join(', ')}
+      ],
+       address_not_in: [
+        "0x0afbd58beca09545e4fb67772faf3858e610bcd0",
+        "0x2ff1a9dbdacd55297452cfd8a4d94724bc22a5f7",
+        "0xbc0f2372008005471874e426e86ccfae7b4de79d",
+        "0xdba274b4d04097b90a72b62467d828cefd708037",
+        "0xf22ff21e17157340575158ad7394e068048dd98b",
+        "0xf71d0774b214c4cf51e33eb3d30ef98132e4dbaa",
+      ],
+      swapEnabled: true,
+      poolType_in: [
+        ${enabledPoolTypes.map(p => `"${p}"`).join(', ')}
+      ]
+    }
+  ) {
+    id
+    address
+    poolType
+    poolTypeVersion
+    tokens (orderBy: index) {
+      address
+      decimals
+    }
+    mainIndex
+    wrappedIndex
+
+    root3Alpha
+  }
+}`;
+// skipping low liquidity composableStablePool (0xbd482ffb3e6e50dc1c437557c3bea2b68f3683ee0000000000000000000003c6) with oracle issues. Experimental.
+
+const fetchWeightUpdating = `query ($count: Int, $timestampPast: Int, $timestampFuture: Int) {
+  gradualWeightUpdates(
+    first: $count,
+    where: {startTimestamp_lt: $timestampFuture, endTimestamp_gt: $timestampPast }
+  ) {
+    poolId {
+      address
+    }
+  }
+}`;
+
+const MAX_POOL_CNT = 1000; // Taken from SOR
+const POOL_CACHE_TTL = 60 * 60; // 1 hr
+const POOL_EVENT_DISABLED_TTL = 5 * 60; // 5 min
+const POOL_EVENT_REENABLE_DELAY = 7 * 24 * 60 * 60; // 1 week
+
+function typecastReadOnlyPoolState(pool: DeepReadonly<PoolState>): PoolState {
+  return _.cloneDeep(pool) as PoolState;
+}
+
+export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
+  public vaultInterface: Interface;
+
+  handlers: {
+    [event: string]: (event: any, pool: PoolState, log: Log) => PoolState;
+  } = {};
+
+  pools: {
+    [type: string]:
+      | WeightedPool
+      | StablePool
+      | LinearPool
+      | PhantomStablePool
+      | Gyro3Pool
+      | GyroEPool;
+  };
+
+  public allPools: SubgraphPoolBase[] = [];
+  vaultDecoder: (log: Log) => any;
+
+  buySupportedPoolTypes: Set<BalancerPoolTypes> = new Set([
+    BalancerPoolTypes.Weighted,
+    BalancerPoolTypes.GyroE,
+  ]);
+
+  eventSupportedPoolTypes: BalancerPoolTypes[] = [
+    BalancerPoolTypes.Stable,
+    BalancerPoolTypes.Weighted,
+    BalancerPoolTypes.LiquidityBootstrapping,
+    BalancerPoolTypes.Investment,
+
+    // Need to check if we can support these pools with event base
+    // BalancerPoolTypes.ComposableStable,
+    // BalancerPoolTypes.Linear,
+    // BalancerPoolTypes.MetaStable,
+    // BalancerPoolTypes.AaveLinear,
+    // BalancerPoolTypes.ERC4626Linear,
+
+    // If this pool is enabled as event supported, it is failing BeetsFi: can not decode getRate()
+    // BalancerPoolTypes.StablePhantom,
+  ];
+
+  eventRemovedPools = (
+    [
+      // Gradual weight changes are not currently handled in event system
+      // This pool keeps changing weights and is causing pricing issue
+      // But should now be handled by eventDisabledPools so don't need here!
+      //'0x34809aEDF93066b49F638562c42A9751eDb36DF5',
+    ] as Address[]
+  ).map(s => s.toLowerCase());
+
+  constructor(
+    parentName: string,
+    protected network: number,
+    public vaultAddress: Address,
+    protected subgraphURL: string,
+    protected dexHelper: IDexHelper,
+    logger: Logger,
+  ) {
+    super(parentName, vaultAddress, dexHelper, logger);
+    this.vaultInterface = new Interface(VaultABI);
+    const weightedPool = new WeightedPool(
+      this.vaultAddress,
+      this.vaultInterface,
+    );
+    const stablePool = new StablePool(this.vaultAddress, this.vaultInterface);
+    const stablePhantomPool = new PhantomStablePool(
+      this.vaultAddress,
+      this.vaultInterface,
+    );
+    /*
+    ComposableStable has same maths as StablePhantom.
+    The main difference is that ComposableStables have join/exit functions when StablePhantom did not.
+    The difference of note for swaps is ComposableStable must use 'actualSupply' instead of VirtualSupply.
+    VirtualSupply could be calculated easily whereas actualSupply cannot hence the use of onchain call.
+    */
+    const composableStable = new PhantomStablePool(
+      this.vaultAddress,
+      this.vaultInterface,
+      true,
+    );
+    const linearPool = new LinearPool(this.vaultAddress, this.vaultInterface);
+    const gyro3Pool = new Gyro3Pool(this.vaultAddress, this.vaultInterface);
+    const gyroEPool = new GyroEPool(this.vaultAddress, this.vaultInterface);
+
+    this.pools = {};
+    this.pools[BalancerPoolTypes.Weighted] = weightedPool;
+    this.pools[BalancerPoolTypes.Stable] = stablePool;
+    this.pools[BalancerPoolTypes.MetaStable] = stablePool;
+    this.pools[BalancerPoolTypes.LiquidityBootstrapping] = weightedPool;
+    this.pools[BalancerPoolTypes.Investment] = weightedPool;
+    this.pools[BalancerPoolTypes.StablePhantom] = stablePhantomPool;
+    this.pools[BalancerPoolTypes.ComposableStable] = composableStable;
+    // All these Linear pool have same maths and ABI as AaveLinear but have different factories
+    this.pools[BalancerPoolTypes.AaveLinear] = linearPool;
+    this.pools[BalancerPoolTypes.ERC4626Linear] = linearPool;
+    this.pools[BalancerPoolTypes.GearboxLinear] = linearPool;
+    this.pools[BalancerPoolTypes.MidasLinear] = linearPool;
+    this.pools[BalancerPoolTypes.ReaperLinear] = linearPool;
+    this.pools[BalancerPoolTypes.SiloLinear] = linearPool;
+    this.pools[BalancerPoolTypes.TetuLinear] = linearPool;
+    this.pools[BalancerPoolTypes.YearnLinear] = linearPool;
+    this.pools[BalancerPoolTypes.BeefyLinear] = linearPool;
+    // Beets uses "Linear" generically for all linear pool types
+    this.pools[BalancerPoolTypes.Linear] = linearPool;
+
+    this.pools[BalancerPoolTypes.Gyro3] = gyro3Pool;
+    this.pools[BalancerPoolTypes.GyroE] = gyroEPool;
+
+    this.vaultDecoder = (log: Log) => this.vaultInterface.parseLog(log);
+    this.addressesSubscribed = [vaultAddress];
+
+    // Add default handlers
+    this.handlers['Swap'] = this.handleSwap.bind(this);
+    this.handlers['PoolBalanceChanged'] =
+      this.handlePoolBalanceChanged.bind(this);
+  }
+
+  protected processLog(
+    state: DeepReadonly<PoolStateMap>,
+    log: Readonly<Log>,
+  ): DeepReadonly<PoolStateMap> | null {
+    const _state: PoolStateMap = {};
+    for (const [address, pool] of Object.entries(state))
+      _state[address] = typecastReadOnlyPoolState(pool);
+
+    try {
+      const event = this.vaultDecoder(log);
+      if (event.name in this.handlers) {
+        const poolAddress = event.args.poolId.slice(0, 42).toLowerCase();
+        // Only update the _state if we are tracking the pool
+        if (poolAddress in _state) {
+          _state[poolAddress] = this.handlers[event.name](
+            event,
+            _state[poolAddress],
+            log,
+          );
+        }
+      }
+      return _state;
+    } catch (e) {
+      this.logger.error(
+        `Error_${this.parentName}_processLog could not parse the log with topic ${log.topics}:`,
+        e,
+      );
+      return null;
+    }
+  }
+
+  async fetchAllSubgraphPools(): Promise<SubgraphPoolBase[]> {
+    const cacheKey = 'BalancerV2SubgraphPools2';
+    const cachedPools = await this.dexHelper.cache.get(
+      this.parentName,
+      this.network,
+      cacheKey,
+    );
+    if (cachedPools) {
+      const allPools = JSON.parse(cachedPools);
+      this.logger.info(
+        `Got ${allPools.length} ${this.parentName}_${this.network} pools from cache`,
+      );
+      return allPools;
+    }
+
+    this.logger.info(
+      `Fetching ${this.parentName}_${this.network} Pools from subgraph`,
+    );
+
+    const variables = {
+      count: MAX_POOL_CNT,
+    };
+    const { data } = await this.dexHelper.httpRequest.post(
+      this.subgraphURL,
+      { query: fetchAllPools, variables },
+      SUBGRAPH_TIMEOUT,
+    );
+
+    if (!(data && data.pools))
+      throw new Error('Unable to fetch pools from the subgraph');
+
+    const poolsMap = keyBy(data.pools, 'address');
+    const allPools: SubgraphPoolBase[] = data.pools.map(
+      (pool: Omit<SubgraphPoolBase, 'mainTokens'>) => ({
+        ...pool,
+        mainTokens: poolGetMainTokens(pool, poolsMap),
+        tokensMap: pool.tokens.reduce(
+          (acc, token) => ({ ...acc, [token.address.toLowerCase()]: token }),
+          {},
+        ),
+      }),
+    );
+
+    this.dexHelper.cache.setex(
+      this.parentName,
+      this.network,
+      cacheKey,
+      POOL_CACHE_TTL,
+      JSON.stringify(allPools),
+    );
+
+    this.logger.info(
+      `Got ${allPools.length} ${this.parentName}_${this.network} pools from subgraph`,
+    );
+
+    return allPools;
+  }
+
+  async generateState(blockNumber: number): Promise<Readonly<PoolStateMap>> {
+    const allPools = await this.fetchAllSubgraphPools();
+    this.allPools = allPools;
+
+    const eventSupportedPools = allPools.filter(
+      pool =>
+        this.eventSupportedPoolTypes.includes(pool.poolType) &&
+        !this.eventRemovedPools.includes(pool.address.toLowerCase()),
+    );
+    const allPoolsLatestState = await this.getOnChainState(
+      eventSupportedPools,
+      blockNumber,
+    );
+
+    return allPoolsLatestState;
+  }
+
+  handleSwap(event: any, pool: PoolState, log: Log): PoolState {
+    const tokenIn = event.args.tokenIn.toLowerCase();
+    const amountIn = BigInt(event.args.amountIn.toString());
+    const tokenOut = event.args.tokenOut.toLowerCase();
+    const amountOut = BigInt(event.args.amountOut.toString());
+    pool.tokens[tokenIn].balance += amountIn;
+    pool.tokens[tokenOut].balance -= amountOut;
+    return pool;
+  }
+
+  handlePoolBalanceChanged(event: any, pool: PoolState, log: Log): PoolState {
+    const tokens = event.args.tokens.map((t: string) => t.toLowerCase());
+    const deltas = event.args.deltas.map((d: any) => BigInt(d.toString()));
+    const fees = event.args.protocolFeeAmounts.map((d: any) =>
+      BigInt(d.toString()),
+    ) as bigint[];
+    tokens.forEach((t: string, i: number) => {
+      const diff = deltas[i] - fees[i];
+      pool.tokens[t].balance += diff;
+    });
+    return pool;
+  }
+
+  isSupportedPool(poolType: string): boolean {
+    const supportedPoolTypes: string[] = Object.values(BalancerPoolTypes);
+    return supportedPoolTypes.includes(poolType);
+  }
+
+  getPricesPool(
+    from: Token,
+    to: Token,
+    subgraphPool: SubgraphPoolBase,
+    poolState: PoolState,
+    amounts: bigint[],
+    unitVolume: bigint,
+    side: SwapSide,
+  ): { unit: bigint; prices: bigint[] } | null {
+    if (!this.isSupportedPool(subgraphPool.poolType)) {
+      this.logger.error(`Unsupported Pool Type: ${subgraphPool.poolType}`);
+      return null;
+    }
+
+    if (
+      side === SwapSide.BUY &&
+      !this.buySupportedPoolTypes.has(subgraphPool.poolType)
+    ) {
+      return null;
+    }
+
+    const amountWithoutZero = amounts.slice(1);
+    const pool = this.pools[subgraphPool.poolType];
+
+    const poolPairData = pool.parsePoolPairData(
+      subgraphPool,
+      poolState,
+      from.address,
+      to.address,
+    );
+
+    const swapMaxAmount = pool.getSwapMaxAmount(
+      // Don't like this but don't have time to refactor it properly
+      poolPairData as any,
+      side,
+    );
+
+    const checkedAmounts: bigint[] = new Array(amountWithoutZero.length).fill(
+      0n,
+    );
+    const checkedUnitVolume = pool._nullifyIfMaxAmountExceeded(
+      unitVolume,
+      swapMaxAmount,
+    );
+
+    let nonZeroAmountIndex = 0;
+    for (const [i, amountIn] of amountWithoutZero.entries()) {
+      const checkedOutput = pool._nullifyIfMaxAmountExceeded(
+        amountIn,
+        swapMaxAmount,
+      );
+      if (checkedOutput === 0n) {
+        // Stop earlier because other values are bigger and for sure wont' be tradable
+        break;
+      }
+      nonZeroAmountIndex = i + 1;
+      checkedAmounts[i] = checkedOutput;
+    }
+
+    if (nonZeroAmountIndex === 0) {
+      return null;
+    }
+
+    const unitResult =
+      checkedUnitVolume === 0n
+        ? 0n
+        : side === SwapSide.SELL
+        ? pool.onSell([checkedUnitVolume], poolPairData as any)[0]
+        : pool.onBuy([checkedUnitVolume], poolPairData as any)[0];
+
+    const prices: bigint[] = new Array(amounts.length).fill(0n);
+
+    const outputs =
+      side === SwapSide.SELL
+        ? pool.onSell(
+            amountWithoutZero.slice(0, nonZeroAmountIndex),
+            poolPairData as any,
+          )
+        : pool.onBuy(
+            amountWithoutZero.slice(0, nonZeroAmountIndex),
+            poolPairData as any,
+          );
+
+    assert(
+      outputs.length <= prices.length,
+      `Wrong length logic: outputs.length (${outputs.length}) <= prices.length (${prices.length})`,
+    );
+
+    for (const [i, output] of outputs.entries()) {
+      // Outputs shifted right to one to keep first entry as 0
+      prices[i + 1] = output;
+    }
+
+    return { unit: unitResult, prices };
+  }
+
+  async getOnChainState(
+    subgraphPoolBase: SubgraphPoolBase[],
+    blockNumber: number,
+  ): Promise<PoolStateMap> {
+    const multiCallData = subgraphPoolBase
+      .map(pool => {
+        if (!this.isSupportedPool(pool.poolType)) return [];
+
+        return this.pools[pool.poolType].getOnChainCalls(pool);
+      })
+      .flat();
+
+    // 500 is an arbitrary number chosen based on the blockGasLimit
+    const slicedMultiCallData = _.chunk(multiCallData, 500);
+
+    const returnData = (
+      await Promise.all(
+        slicedMultiCallData.map(async _multiCallData =>
+          this.dexHelper.multiContract.methods
+            .tryAggregate(false, _multiCallData)
+            .call({}, blockNumber),
+        ),
+      )
+    ).flat();
+
+    let i = 0;
+    const onChainStateMap = subgraphPoolBase.reduce(
+      (acc: { [address: string]: PoolState }, pool) => {
+        if (!this.isSupportedPool(pool.poolType)) return acc;
+
+        const [decoded, newIndex] = this.pools[
+          pool.poolType
+        ].decodeOnChainCalls(pool, returnData, i);
+        i = newIndex;
+        acc = { ...acc, ...decoded };
+        return acc;
+      },
+      {},
+    );
+
+    return onChainStateMap;
+  }
+}
+
+export class BalancerV2
+  extends SimpleExchange
+  implements
+    IDex<
+      BalancerV2Data,
+      BalancerV2DirectParam | BalancerV2DirectParamV6Swap,
+      OptimizedBalancerV2Data
+    >
+{
+  public eventPools: BalancerV2EventPool;
+
+  readonly hasConstantPriceLargeAmounts = false;
+  readonly isFeeOnTransferSupported = false;
+  readonly needWrapNative = true; // temporary
+
+  readonly directSwapIface = new Interface(DirectSwapABI);
+  readonly balancerVaultInterface = new Interface(BalancerVaultABI);
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(BalancerConfig);
+
+  logger: Logger;
+
+  // In memory pool state for non-event pools
+  nonEventPoolStateCache: PoolStateCache;
+
+  eventDisabledPoolsTimer?: NodeJS.Timer;
+  eventDisabledPools: Address[] = [];
+
+  constructor(
+    protected network: Network,
+    dexKey: string,
+    public dexHelper: IDexHelper,
+    public vaultAddress: Address = BalancerConfig[dexKey][network].vaultAddress,
+    protected subgraphURL: string = BalancerConfig[dexKey][network].subgraphURL,
+    protected adapters = Adapters[network],
+  ) {
+    super(dexHelper, dexKey);
+    // Initialise cache - this will hold pool state of non-event pools in memory to be reused if block hasn't expired
+    this.nonEventPoolStateCache = { blockNumber: 0, poolState: {} };
+    this.logger = dexHelper.getLogger(dexKey);
+    this.eventPools = new BalancerV2EventPool(
+      dexKey,
+      network,
+      vaultAddress,
+      subgraphURL,
+      dexHelper,
+      this.logger,
+    );
+  }
+
+  async setupEventPools(blockNumber: number) {
+    await this.eventPools.initialize(blockNumber);
+  }
+
+  async fetchEventDisabledPools() {
+    const cacheKey = 'eventDisabledPools';
+    const poolAddressListFromCache = await this.dexHelper.cache.get(
+      this.dexKey,
+      this.network,
+      cacheKey,
+    );
+    if (poolAddressListFromCache) {
+      this.eventDisabledPools = JSON.parse(poolAddressListFromCache);
+      return;
+    }
+    this.logger.info(
+      `Fetching ${this.dexKey}_${this.network} Weight Updates from subgraph`,
+    );
+    const timeNow = Math.floor(Date.now() / 1000);
+    const variables = {
+      count: MAX_POOL_CNT,
+      timestampPast: timeNow - POOL_EVENT_REENABLE_DELAY,
+      timestampFuture: timeNow + POOL_EVENT_DISABLED_TTL,
+    };
+    const { data } = await this.dexHelper.httpRequest.post(
+      this.subgraphURL,
+      { query: fetchWeightUpdating, variables },
+      SUBGRAPH_TIMEOUT,
+    );
+
+    if (!(data && data.gradualWeightUpdates)) {
+      throw new Error(
+        `${this.dexKey}_${this.network} failed to fetch weight updates from subgraph`,
+      );
+    }
+
+    this.eventDisabledPools = _.uniq(
+      data.gradualWeightUpdates.map(
+        (wu: { poolId: { address: Address } }) => wu.poolId.address,
+      ),
+    );
+    const poolAddressList = JSON.stringify(this.eventDisabledPools);
+    this.logger.info(
+      `Pools blocked from event based on ${this.dexKey}_${this.network}: ${poolAddressList}`,
+    );
+    this.dexHelper.cache.setex(
+      this.dexKey,
+      this.network,
+      cacheKey,
+      POOL_EVENT_DISABLED_TTL,
+      poolAddressList,
+    );
+  }
+
+  async initializePricing(blockNumber: number) {
+    if (!this.eventDisabledPoolsTimer) {
+      await this.fetchEventDisabledPools();
+      this.eventDisabledPoolsTimer = setInterval(async () => {
+        try {
+          await this.fetchEventDisabledPools();
+        } catch (e) {
+          this.logger.error(
+            `${this.dexKey}: Failed to update event disabled pools:`,
+            e,
+          );
+        }
+      }, POOL_EVENT_DISABLED_TTL * 1000);
+    }
+    await this.setupEventPools(blockNumber);
+  }
+
+  releaseResources(): void {
+    if (this.eventDisabledPoolsTimer) {
+      clearInterval(this.eventDisabledPoolsTimer);
+      this.eventDisabledPoolsTimer = undefined;
+      this.logger.info(
+        `${this.dexKey}: cleared eventDisabledPoolsTimer before shutting down`,
+      );
+    }
+  }
+
+  getPoolsWithTokenPair(from: Token, to: Token): SubgraphPoolBase[] {
+    const pools = this.eventPools.allPools.filter(p => {
+      const fromMain = p.mainTokens.find(
+        token => token.address.toLowerCase() === from.address.toLowerCase(),
+      );
+      const toMain = p.mainTokens.find(
+        token => token.address.toLowerCase() === to.address.toLowerCase(),
+      );
+
+      return (
+        fromMain &&
+        toMain &&
+        // filter instances similar to the following:
+        // USDC -> DAI in a pool where bbaUSD is nested (ie: MAI / bbaUSD)
+        !(fromMain.isDeeplyNested && toMain.isDeeplyNested)
+      );
+    });
+
+    return pools.slice(0, 10);
+  }
+
+  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
+    return this.adapters[side] ? this.adapters[side] : null;
+  }
+
+  async getPoolIdentifiers(
+    from: Token,
+    to: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    const _from = this.dexHelper.config.wrapETH(from);
+    const _to = this.dexHelper.config.wrapETH(to);
+
+    const pools = this.getPoolsWithTokenPair(_from, _to);
+
+    return pools.map(
+      ({ address }) => `${this.dexKey}_${address.toLowerCase()}`,
+    );
+  }
+
+  /**
+   * Returns cached poolState if blockNumber matches cached value. Resets if not.
+   */
+  private getNonEventPoolStateCache(blockNumber: number): PoolStateMap {
+    if (this.nonEventPoolStateCache.blockNumber !== blockNumber)
+      this.nonEventPoolStateCache.poolState = {};
+    return this.nonEventPoolStateCache.poolState;
+  }
+
+  /**
+   * Update poolState cache.
+   * If same blockNumber as current cache then update with new pool state.
+   * If different blockNumber overwrite cache with latest.
+   */
+  private updateNonEventPoolStateCache(
+    poolState: PoolStateMap,
+    blockNumber: number,
+  ): PoolStateMap {
+    if (this.nonEventPoolStateCache.blockNumber !== blockNumber) {
+      this.nonEventPoolStateCache.blockNumber = blockNumber;
+      this.nonEventPoolStateCache.poolState = poolState;
+    } else
+      this.nonEventPoolStateCache.poolState = {
+        ...this.nonEventPoolStateCache.poolState,
+        ...poolState,
+      };
+    return this.nonEventPoolStateCache.poolState;
+  }
+
+  async getPricesVolume(
+    from: Token,
+    to: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+  ): Promise<null | ExchangePrices<BalancerV2Data>> {
+    try {
+      const _from = this.dexHelper.config.wrapETH(from);
+      const _to = this.dexHelper.config.wrapETH(to);
+
+      if (_from.address === _to.address) {
+        return null;
+      }
+
+      const allPools = this.getPoolsWithTokenPair(_from, _to);
+
+      const allowedPools = limitPools
+        ? allPools.filter(({ address }) =>
+            limitPools.includes(`${this.dexKey}_${address.toLowerCase()}`),
+          )
+        : allPools;
+
+      if (!allowedPools.length) return null;
+
+      const eventPoolStatesRO = await this.eventPools.getState(blockNumber);
+      if (!eventPoolStatesRO) {
+        this.logger.error(`getState returned null`);
+      }
+      const eventPoolStates = { ...(eventPoolStatesRO || {}) };
+      for (const addr of this.eventDisabledPools) delete eventPoolStates[addr];
+
+      // Fetch previously cached non-event pool states
+      let nonEventPoolStates = this.getNonEventPoolStateCache(blockNumber);
+
+      //get all pools that would be used in the paths, nested pools included
+      const poolsFlattened = getAllPoolsUsedInPaths(
+        _from.address,
+        _to.address,
+        allowedPools,
+        this.poolAddressMap,
+        side,
+      );
+
+      // Missing pools are pools that don't already exist in event or non-event
+      const missingPools = poolsFlattened.filter(
+        pool =>
+          !(
+            pool.address.toLowerCase() in eventPoolStates ||
+            pool.address.toLowerCase() in nonEventPoolStates
+          ),
+      );
+
+      // Retrieve onchain state for any missing pools
+      if (missingPools.length > 0) {
+        const missingPoolsStateMap = await this.eventPools.getOnChainState(
+          missingPools,
+          blockNumber,
+        );
+        // Update non-event pool state cache with newly retrieved data so it can be reused in future
+        nonEventPoolStates = this.updateNonEventPoolStateCache(
+          missingPoolsStateMap,
+          blockNumber,
+        );
+      }
+
+      const poolPrices = allowedPools
+        .map((pool: SubgraphPoolBase) => {
+          try {
+            const poolAddress = pool.address.toLowerCase();
+
+            const path = poolGetPathForTokenInOut(
+              _from.address,
+              _to.address,
+              pool,
+              this.poolAddressMap,
+              side,
+            );
+
+            let pathAmounts = amounts;
+            let resOut: { unit: bigint; prices: bigint[] } | null = null;
+
+            for (let i = 0; i < path.length; i++) {
+              const poolAddress = path[i].pool.address.toLowerCase();
+              const poolState = (eventPoolStates[poolAddress] ||
+                nonEventPoolStates[poolAddress]) as PoolState | undefined;
+              if (!poolState) {
+                this.logger.error(
+                  `Unable to find the poolState ${poolAddress}`,
+                );
+                return null;
+              }
+
+              const unitVolume = getBigIntPow(
+                (side === SwapSide.SELL ? path[i].tokenIn : path[i].tokenOut)
+                  .decimals,
+              );
+
+              const res = this.eventPools.getPricesPool(
+                path[i].tokenIn,
+                path[i].tokenOut,
+                path[i].pool,
+                poolState,
+                pathAmounts,
+                unitVolume,
+                side,
+              );
+
+              if (!res) {
+                return null;
+              }
+
+              pathAmounts = res.prices;
+
+              if (i === path.length - 1) {
+                resOut = res;
+              }
+            }
+
+            if (!resOut) {
+              return null;
+            }
+
+            return {
+              unit: resOut.unit,
+              prices: resOut.prices,
+              data: {
+                poolId: pool.id,
+              },
+              poolAddresses: [poolAddress],
+              exchange: this.dexKey,
+              gasCost:
+                STABLE_GAS_COST + VARIABLE_GAS_COST_PER_CYCLE * path.length,
+              poolIdentifier: `${this.dexKey}_${poolAddress}`,
+            };
+
+            // TODO: re-check what should be the current block time stamp
+          } catch (e) {
+            this.logger.warn(
+              `Error_getPrices ${from.symbol || from.address}, ${
+                to.symbol || to.address
+              }, ${side}, ${pool.address}:`,
+              e,
+            );
+
+            return;
+          }
+        })
+        .filter(p => !!p);
+      return poolPrices as ExchangePrices<BalancerV2Data>;
+    } catch (e) {
+      this.logger.error(
+        `Error_getPrices ${from.symbol || from.address}, ${
+          to.symbol || to.address
+        }, ${side}:`,
+        e,
+      );
+      return null;
+    }
+  }
+
+  // Returns estimated gas cost of calldata for this DEX in multiSwap
+  getCalldataGasCost(
+    poolPrices: PoolPrices<BalancerV2Data>,
+  ): number | number[] {
+    return (
+      CALLDATA_GAS_COST.DEX_OVERHEAD +
+      CALLDATA_GAS_COST.LENGTH_LARGE +
+      // ParentStruct header
+      CALLDATA_GAS_COST.OFFSET_SMALL +
+      // ParentStruct -> swaps[] header
+      CALLDATA_GAS_COST.OFFSET_LARGE +
+      // ParentStruct -> assets[] header
+      CALLDATA_GAS_COST.OFFSET_LARGE +
+      // ParentStruct -> funds
+      CALLDATA_GAS_COST.ADDRESS +
+      CALLDATA_GAS_COST.BOOL +
+      CALLDATA_GAS_COST.ADDRESS +
+      CALLDATA_GAS_COST.BOOL +
+      // ParentStruct -> limits[] header
+      CALLDATA_GAS_COST.OFFSET_LARGE +
+      // ParentStruct -> deadline
+      CALLDATA_GAS_COST.TIMESTAMP +
+      // ParentStruct -> swaps[]
+      CALLDATA_GAS_COST.LENGTH_SMALL +
+      // ParentStruct -> swaps[0] header
+      CALLDATA_GAS_COST.OFFSET_SMALL +
+      // ParentStruct -> swaps[0] -> poolId
+      CALLDATA_GAS_COST.FULL_WORD +
+      // ParentStruct -> swaps[0] -> assetInIndex
+      CALLDATA_GAS_COST.INDEX +
+      // ParentStruct -> swaps[0] -> assetOutIndex
+      CALLDATA_GAS_COST.INDEX +
+      // ParentStruct -> swaps[0] -> amount
+      CALLDATA_GAS_COST.AMOUNT +
+      // ParentStruct -> swaps[0] -> userData header
+      CALLDATA_GAS_COST.OFFSET_SMALL +
+      // ParentStruct -> swaps[0] -> userData
+      CALLDATA_GAS_COST.ZERO +
+      // ParentStruct -> assets[]
+      CALLDATA_GAS_COST.LENGTH_SMALL +
+      // ParentStruct -> assets[0:2]
+      CALLDATA_GAS_COST.ADDRESS * 2 +
+      // ParentStruct -> limits[]
+      CALLDATA_GAS_COST.LENGTH_SMALL +
+      // ParentStruct -> limits[0:2]
+      CALLDATA_GAS_COST.FULL_WORD * 2
+    );
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: OptimizedBalancerV2Data,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    const params = this.getBalancerV2BatchSwapParam(
+      srcToken,
+      destToken,
+      data,
+      side,
+      this.dexHelper.config.data.augustusAddress!,
+      this.dexHelper.config.data.augustusAddress!,
+    );
+
+    const payload = this.abiCoder.encodeParameter(
+      {
+        ParentStruct: {
+          'swaps[]': {
+            poolId: 'bytes32',
+            assetInIndex: 'uint256',
+            assetOutIndex: 'uint256',
+            amount: 'uint256',
+            userData: 'bytes',
+          },
+          assets: 'address[]',
+          funds: {
+            sender: 'address',
+            fromInternalBalance: 'bool',
+            recipient: 'address',
+            toInternalBalance: 'bool',
+          },
+          limits: 'int256[]',
+          deadline: 'uint256',
+        },
+      },
+      {
+        swaps: params[1],
+        assets: params[2],
+        funds: params[3],
+        limits: params[4],
+        deadline: params[5],
+      },
+    );
+
+    return {
+      targetExchange: this.vaultAddress,
+      payload,
+      networkFee: '0',
+    };
+  }
+
+  public getBalancerV2SwapParam(
+    srcToken: string,
+    destToken: string,
+    data: OptimizedBalancerV2Data,
+    side: SwapSide,
+    recipient: string,
+    sender: string,
+  ): BalancerV2SwapParam {
+    assert(data.swaps.length === 1, 'should have exactly one pool');
+
+    const singleSwap: BalancerV2SingleSwap = {
+      poolId: data.swaps[0].poolId,
+      kind:
+        side === SwapSide.SELL ? SwapTypes.SwapExactIn : SwapTypes.SwapExactOut,
+      assetIn:
+        srcToken.toLowerCase() === ETHER_ADDRESS ? NULL_ADDRESS : srcToken,
+      assetOut:
+        destToken.toLowerCase() === ETHER_ADDRESS ? NULL_ADDRESS : destToken,
+      amount: data.swaps[0].amount,
+      userData: '0x',
+    };
+
+    const funds = {
+      sender,
+      recipient,
+      fromInternalBalance: false,
+      toInternalBalance: false,
+    };
+
+    const params: BalancerV2SwapParam = [
+      singleSwap,
+      funds,
+      side === SwapSide.SELL ? '1' : MAX_INT,
+      getLocalDeadlineAsFriendlyPlaceholder(),
+    ];
+
+    return params;
+  }
+
+  /*
+      Algorithm to determine balancer (sender, recipient) params:
+
+      if version = 5
+          sender = recipient = augustusV5
+      else (so V6)
+        if direct swap
+            sender = recipient = augustusV6
+        else (so generic swaps)
+          if sell
+            if swap.destToken = priceRoute.destToken <> ETH (need withdraw for eth currently, need fix in future)
+                  sender = executor and recipient = augustusV6 (skip 1 extra transfer)
+              else
+                  sender = recipient = executor
+              # note: we pass sender=null then the address of the executor is inferred contract side
+          else (so buy)
+              sender = recipient = executor
+*/
+  public getBalancerV2BatchSwapParam(
+    srcToken: string,
+    destToken: string,
+    data: OptimizedBalancerV2Data,
+    side: SwapSide,
+    recipient: string,
+    sender: string,
+    shouldWalkAssetsBackward?: boolean, // should do for all buy but prefer keep it under control
+  ): BalancerV2BatchSwapParam {
+    let swapOffset = 0;
+    let swaps: BalancerSwap[] = [];
+    let assets: string[] = [];
+    let limits: string[] = [];
+
+    for (const swapData of data.swaps) {
+      const pool = this.poolIdMap[swapData.poolId];
+      const hasEth = [srcToken.toLowerCase(), destToken.toLowerCase()].includes(
+        ETHER_ADDRESS.toLowerCase(),
+      );
+      const _srcToken = this.dexHelper.config.wrapETH({
+        address: srcToken,
+        decimals: 18,
+      }).address;
+      const _destToken = this.dexHelper.config.wrapETH({
+        address: destToken,
+        decimals: 18,
+      }).address;
+
+      let path = poolGetPathForTokenInOut(
+        _srcToken,
+        _destToken,
+        pool,
+        this.poolAddressMap,
+        side,
+      );
+
+      if (side === SwapSide.BUY) {
+        path = path.reverse();
+      }
+
+      const _swaps = path.map((hop, index) => {
+        const assetInIndex = shouldWalkAssetsBackward
+          ? swapOffset + path.length - index
+          : swapOffset + index;
+
+        const assetOutIndex = shouldWalkAssetsBackward
+          ? swapOffset + path.length - index - 1
+          : swapOffset + index + 1;
+
+        const amount =
+          (side === SwapSide.SELL && index === 0) ||
+          (side === SwapSide.BUY && index === path.length - 1)
+            ? swapData.amount
+            : '0';
+
+        if (assetInIndex < 0 || assetOutIndex < 0) {
+          const error = new Error(`Invalid indices in balancer`);
+          this.logger.error(error.message, error);
+          throw error;
+        }
+
+        return {
+          poolId: hop.pool.id,
+          assetInIndex,
+          assetOutIndex,
+          amount,
+          userData: '0x',
+        };
+      });
+
+      swapOffset += path.length + 1;
+
+      // BalancerV2 Uses Address(0) as ETH
+      const _assets = [_srcToken, ...path.map(hop => hop.tokenOut.address)].map(
+        t => (hasEth && this.dexHelper.config.isWETH(t) ? NULL_ADDRESS : t),
+      );
+
+      const _limits = _assets.map(_ => MAX_INT);
+
+      swaps = swaps.concat(_swaps);
+      assets = assets.concat(_assets);
+      limits = limits.concat(_limits);
+    }
+
+    const funds = {
+      sender,
+      recipient,
+      fromInternalBalance: false,
+      toInternalBalance: false,
+    };
+
+    const params: BalancerV2BatchSwapParam = [
+      side === SwapSide.SELL ? SwapTypes.SwapExactIn : SwapTypes.SwapExactOut,
+      side === SwapSide.SELL ? swaps : swaps.reverse(),
+      shouldWalkAssetsBackward ? assets.reverse() : assets,
+      funds,
+      limits,
+      getLocalDeadlineAsFriendlyPlaceholder(),
+    ];
+
+    return params;
+  }
+
+  static getDirectFunctionName(): string[] {
+    return [DirectMethods.directSell, DirectMethods.directBuy];
+  }
+
+  getTokenFromAddress(address: Address): Token {
+    // In this Dex decimals are not used
+    return { address, decimals: 0 };
+  }
+
+  async preProcessTransaction(
+    optimalSwapExchange: OptimalSwapExchange<OptimizedBalancerV2Data>,
+    srcToken: Token,
+    _0: Token,
+    _1: SwapSide,
+    options: PreprocessTransactionOptions,
+  ): Promise<[OptimalSwapExchange<OptimizedBalancerV2Data>, ExchangeTxInfo]> {
+    if (!options.isDirectMethod) {
+      return [
+        optimalSwapExchange,
+        {
+          deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
+        },
+      ];
+    }
+
+    assert(
+      optimalSwapExchange.data !== undefined,
+      `preProcessTransaction: data field is missing`,
+    );
+
+    let isApproved: boolean | undefined;
+
+    try {
+      isApproved = await this.dexHelper.augustusApprovals.hasApproval(
+        options.executionContractAddress,
+        this.dexHelper.config.wrapETH(srcToken).address,
+        this.vaultAddress,
+      );
+    } catch (e) {
+      this.logger.error(
+        `preProcessTransaction failed to retrieve allowance info: `,
+        e,
+      );
+    }
+
+    return [
+      {
+        ...optimalSwapExchange,
+        data: {
+          ...optimalSwapExchange.data,
+          isApproved,
+        },
+      },
+      {
+        deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
+      },
+    ];
+  }
+
+  getDirectParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    expectedAmount: NumberAsString,
+    data: OptimizedBalancerV2Data,
+    side: SwapSide,
+    permit: string,
+    uuid: string,
+    feePercent: NumberAsString,
+    deadline: NumberAsString,
+    partner: string,
+    beneficiary: string,
+    contractMethod?: string,
+  ): TxInfo<BalancerV2DirectParam> {
+    if (
+      contractMethod !== DirectMethods.directSell &&
+      contractMethod !== DirectMethods.directBuy
+    ) {
+      throw new Error(`Invalid contract method ${contractMethod}`);
+    }
+
+    let isApproved: boolean = !!data.isApproved;
+    if (data.isApproved === undefined) {
+      this.logger.warn(`isApproved is undefined, defaulting to false`);
+    }
+
+    const [, swaps, assets, funds, limits, _deadline] =
+      this.getBalancerV2BatchSwapParam(
+        srcToken,
+        destToken,
+        data,
+        side,
+        this.dexHelper.config.data.augustusAddress!,
+        this.dexHelper.config.data.augustusAddress!,
+      );
+
+    const swapParams: BalancerV2DirectParam = [
+      swaps,
+      assets,
+      funds,
+      limits,
+      srcAmount,
+      destAmount,
+      expectedAmount,
+      _deadline,
+      feePercent,
+      this.vaultAddress,
+      partner,
+      isApproved,
+      beneficiary,
+      permit,
+      uuidToBytes16(uuid),
+    ];
+
+    const encoder = (...params: BalancerV2DirectParam) => {
+      return this.directSwapIface.encodeFunctionData(
+        side === SwapSide.SELL
+          ? DirectMethods.directSell
+          : DirectMethods.directBuy,
+        [params],
+      );
+    };
+
+    return {
+      params: swapParams,
+      encoder,
+      networkFee: '0',
+    };
+  }
+
+  getDirectParamV6(
+    srcToken: Address,
+    destToken: Address,
+    fromAmount: NumberAsString,
+    toAmount: NumberAsString,
+    quotedAmount: NumberAsString,
+    data: OptimizedBalancerV2Data,
+    side: SwapSide,
+    permit: string,
+    uuid: string,
+    partnerAndFee: string,
+    beneficiary: string,
+    blockNumber: number,
+    contractMethod?: string,
+  ) {
+    if (!contractMethod) throw new Error(`contractMethod need to be passed`);
+
+    if (!BalancerV2.getDirectFunctionNameV6().includes(contractMethod!)) {
+      throw new Error(`Invalid contract method ${contractMethod}`);
+    }
+
+    const metadata = hexConcat([
+      hexZeroPad(uuidToBytes16(uuid), 16),
+      hexZeroPad(hexlify(blockNumber), 16),
+    ]);
+
+    const balancerBatchSwapParam = this.getBalancerV2BatchSwapParam(
+      srcToken,
+      destToken,
+      data,
+      side,
+      this.dexHelper.config.data.augustusV6Address!,
+      this.dexHelper.config.data.augustusV6Address!,
+      side === SwapSide.BUY,
+    );
+
+    // after getBalancerV2BatchSwapParam runs we may get more swaps so we can't decide on single vs batch before resolving it
+    const [, swaps] = balancerBatchSwapParam;
+    const isSingleSwap = swaps.length === 1;
+
+    const balancerParams = isSingleSwap
+      ? this.getBalancerV2SwapParam(
+          srcToken,
+          destToken,
+          data,
+          side,
+          this.dexHelper.config.data.augustusV6Address!,
+          this.dexHelper.config.data.augustusV6Address!,
+        )
+      : balancerBatchSwapParam;
+
+    const swapParams: BalancerV2DirectParamV6 = [
+      fromAmount,
+      toAmount,
+      quotedAmount,
+      metadata,
+      this.encodeBeneficiaryAndApproveFlag(beneficiary, !data.isApproved),
+    ];
+
+    const encodeParams: BalancerV2DirectParamV6Swap = [
+      swapParams,
+      partnerAndFee,
+      permit,
+      balancerParams.length === 4 // TODO: upgrade ts to use isSingleSwap
+        ? this.encodeBalancerV2SwapParam(balancerParams)
+        : this.encodeBalancerV2BatchSwapParam(balancerParams),
+    ];
+
+    const encoder = (...params: BalancerV2DirectParamV6Swap) => {
+      return this.augustusV6Interface.encodeFunctionData(
+        side === SwapSide.SELL
+          ? DirectMethodsV6.directSell
+          : DirectMethodsV6.directBuy,
+        [...params],
+      );
+    };
+
+    return {
+      encoder,
+      params: encodeParams,
+      networkFee: '0',
+    };
+  }
+
+  private encodeBeneficiaryAndApproveFlag(
+    beneficiary: Address,
+    approveFlag: boolean,
+  ) {
+    const addressBN = BigNumber.from(beneficiary);
+    const flagBN = approveFlag ? BigNumber.from(1).shl(255) : BigNumber.from(0);
+
+    return addressBN.or(flagBN).toString();
+  }
+
+  private encodeBalancerV2SwapParam(param: BalancerV2SwapParam): string {
+    const [singleSwap, funds, limit, deadline] = param;
+
+    const encoded = this.balancerVaultInterface.encodeFunctionData('swap', [
+      singleSwap,
+      funds,
+      limit,
+      deadline,
+    ]);
+
+    return encoded;
+  }
+
+  private encodeBalancerV2BatchSwapParam(
+    param: BalancerV2BatchSwapParam,
+  ): string {
+    const [kind, swaps, assets, funds, limits, deadline] = param;
+
+    const encoded = this.balancerVaultInterface.encodeFunctionData(
+      'batchSwap',
+      [kind, swaps, assets, funds, limits, deadline],
+    );
+    return encoded;
+  }
+
+  static getDirectFunctionNameV6(): string[] {
+    return [DirectMethodsV6.directSell, DirectMethodsV6.directBuy];
+  }
+
+  async getSimpleParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: OptimizedBalancerV2Data,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    const params = this.getBalancerV2BatchSwapParam(
+      srcToken,
+      destToken,
+      data,
+      side,
+      this.dexHelper.config.data.augustusAddress!,
+      this.dexHelper.config.data.augustusAddress!,
+    );
+
+    const swapData = this.eventPools.vaultInterface.encodeFunctionData(
+      'batchSwap',
+      params,
+    );
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      this.vaultAddress,
+    );
+  }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: OptimizedBalancerV2Data,
+    side: SwapSide,
+    context: Context,
+  ): DexExchangeParam {
+    const params = this.getBalancerV2BatchSwapParam(
+      srcToken,
+      destToken,
+      data,
+      side,
+      recipient,
+      side === SwapSide.BUY
+        ? this.dexHelper.config.data.executorsAddresses![Executors.THREE]
+        : NULL_ADDRESS,
+    );
+
+    let exchangeData = this.eventPools.vaultInterface.encodeFunctionData(
+      'batchSwap',
+      params,
+    );
+    let specialDexFlag = SpecialDex.DEFAULT;
+
+    if (side === SwapSide.SELL) {
+      const swaps = params[1];
+      const totalAmount = swaps.reduce<BigNumber>((acc, swap) => {
+        return acc.add(swap.amount);
+      }, BigNumber.from(0));
+
+      exchangeData = solidityPack(
+        ['bytes32', 'bytes'],
+        [hexZeroPad(hexlify(totalAmount), 32), exchangeData],
+      );
+      specialDexFlag = SpecialDex.SWAP_ON_BALANCER_V2;
+    }
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData,
+      specialDexFlag,
+      targetExchange: this.vaultAddress,
+      returnAmountPos: undefined,
+    };
+  }
+
+  async updatePoolState(): Promise<void> {
+    this.eventPools.allPools = await this.eventPools.fetchAllSubgraphPools();
+  }
+
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    count: number,
+  ): Promise<PoolLiquidity[]> {
+    const poolsWithToken = this.eventPools.allPools.filter(pool =>
+      pool.mainTokens.some(mainToken =>
+        isSameAddress(mainToken.address, tokenAddress),
+      ),
+    );
+
+    const variables = {
+      poolIds: poolsWithToken.map(pool => pool.id),
+      count,
+    };
+
+    const query = `query ($poolIds: [String!]!, $count: Int) {
+      pools (first: $count, orderBy: totalLiquidity, orderDirection: desc,
+           where: {id_in: $poolIds,
+                   swapEnabled: true,
+                   totalLiquidity_gt: ${MIN_USD_LIQUIDITY_TO_FETCH.toString()}}) {
+        address
+        totalLiquidity
+        tokens {
+          address
+          decimals
+        }
+      }
+    }`;
+    const { data } = await this.dexHelper.httpRequest.post<{
+      data: {
+        pools: {
+          address: string;
+          totalLiquidity: string;
+          tokens: { address: string; decimals: number }[];
+        }[];
+      };
+    }>(
+      this.subgraphURL,
+      {
+        query,
+        variables,
+      },
+      SUBGRAPH_TIMEOUT,
+    );
+
+    if (!(data && data.pools))
+      throw new Error(
+        `Error_${this.dexKey}_Subgraph: couldn't fetch the pools from the subgraph`,
+      );
+
+    return _.map(data.pools, pool => {
+      const subgraphPool = poolsWithToken.find(poolWithToken =>
+        isSameAddress(poolWithToken.address, pool.address),
+      )!;
+
+      return {
+        exchange: this.dexKey,
+        address: pool.address.toLowerCase(),
+        connectorTokens: subgraphPool.mainTokens.filter(
+          token => !isSameAddress(tokenAddress, token.address),
+        ),
+        liquidityUSD: parseFloat(pool.totalLiquidity),
+      };
+    });
+  }
+
+  private get poolAddressMap(): SubgraphPoolAddressDictionary {
+    return keyBy(this.eventPools.allPools, 'address');
+  }
+
+  private get poolIdMap(): { [poolId: string]: SubgraphPoolBase } {
+    return keyBy(this.eventPools.allPools, 'id');
+  }
+}