@paraswap/dex-lib 2.50.7 → 2.50.9

package/build/dex/balancer-v2/balancer-v2.js

@@ -1,874 +1,874 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BalancerV2 = exports.BalancerV2EventPool = void 0;
-const abi_1 = require("@ethersproject/abi");
-const ts_essentials_1 = require("ts-essentials");
-const lodash_1 = __importStar(require("lodash"));
-const constants_1 = require("../../constants");
-const CALLDATA_GAS_COST = __importStar(require("../../calldata-gas-cost"));
-const StablePool_1 = require("./pools/stable/StablePool");
-const WeightedPool_1 = require("./pools/weighted/WeightedPool");
-const PhantomStablePool_1 = require("./pools/phantom-stable/PhantomStablePool");
-const LinearPool_1 = require("./pools/linear/LinearPool");
-const Gyro3Pool_1 = require("./pools/gyro/Gyro3Pool");
-const GyroEPool_1 = require("./pools/gyro/GyroEPool");
-const vault_json_1 = __importDefault(require("../../abi/balancer-v2/vault.json"));
-const DirectSwap_json_1 = __importDefault(require("../../abi/DirectSwap.json"));
-const stateful_event_subscriber_1 = require("../../stateful-event-subscriber");
-const utils_1 = require("../../utils");
-const types_1 = require("./types");
-const simple_exchange_1 = require("../simple-exchange");
-const config_1 = require("./config");
-const utils_2 = require("./utils");
-const constants_2 = require("./constants");
-// 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
-    types_1.BalancerPoolTypes.Stable,
-    types_1.BalancerPoolTypes.Weighted,
-    types_1.BalancerPoolTypes.LiquidityBootstrapping,
-    types_1.BalancerPoolTypes.Investment,
-    types_1.BalancerPoolTypes.StablePhantom,
-    types_1.BalancerPoolTypes.AaveLinear,
-    types_1.BalancerPoolTypes.ERC4626Linear,
-    types_1.BalancerPoolTypes.Linear,
-    types_1.BalancerPoolTypes.ComposableStable,
-    types_1.BalancerPoolTypes.BeefyLinear,
-    types_1.BalancerPoolTypes.GearboxLinear,
-    types_1.BalancerPoolTypes.MidasLinear,
-    types_1.BalancerPoolTypes.ReaperLinear,
-    types_1.BalancerPoolTypes.SiloLinear,
-    types_1.BalancerPoolTypes.TetuLinear,
-    types_1.BalancerPoolTypes.YearnLinear,
-    types_1.BalancerPoolTypes.GyroE,
-    types_1.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: ${constants_2.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) {
-    return lodash_1.default.cloneDeep(pool);
-}
-class BalancerV2EventPool extends stateful_event_subscriber_1.StatefulEventSubscriber {
-    constructor(parentName, network, vaultAddress, subgraphURL, dexHelper, logger) {
-        super(parentName, vaultAddress, dexHelper, logger);
-        this.network = network;
-        this.vaultAddress = vaultAddress;
-        this.subgraphURL = subgraphURL;
-        this.dexHelper = dexHelper;
-        this.handlers = {};
-        this.allPools = [];
-        this.buySupportedPoolTypes = new Set([
-            types_1.BalancerPoolTypes.Weighted,
-            types_1.BalancerPoolTypes.GyroE,
-        ]);
-        this.eventSupportedPoolTypes = [
-            types_1.BalancerPoolTypes.Stable,
-            types_1.BalancerPoolTypes.Weighted,
-            types_1.BalancerPoolTypes.LiquidityBootstrapping,
-            types_1.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,
-        ];
-        this.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',
-        ].map(s => s.toLowerCase());
-        this.vaultInterface = new abi_1.Interface(vault_json_1.default);
-        const weightedPool = new WeightedPool_1.WeightedPool(this.vaultAddress, this.vaultInterface);
-        const stablePool = new StablePool_1.StablePool(this.vaultAddress, this.vaultInterface);
-        const stablePhantomPool = new PhantomStablePool_1.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_1.PhantomStablePool(this.vaultAddress, this.vaultInterface, true);
-        const linearPool = new LinearPool_1.LinearPool(this.vaultAddress, this.vaultInterface);
-        const gyro3Pool = new Gyro3Pool_1.Gyro3Pool(this.vaultAddress, this.vaultInterface);
-        const gyroEPool = new GyroEPool_1.GyroEPool(this.vaultAddress, this.vaultInterface);
-        this.pools = {};
-        this.pools[types_1.BalancerPoolTypes.Weighted] = weightedPool;
-        this.pools[types_1.BalancerPoolTypes.Stable] = stablePool;
-        this.pools[types_1.BalancerPoolTypes.MetaStable] = stablePool;
-        this.pools[types_1.BalancerPoolTypes.LiquidityBootstrapping] = weightedPool;
-        this.pools[types_1.BalancerPoolTypes.Investment] = weightedPool;
-        this.pools[types_1.BalancerPoolTypes.StablePhantom] = stablePhantomPool;
-        this.pools[types_1.BalancerPoolTypes.ComposableStable] = composableStable;
-        // All these Linear pool have same maths and ABI as AaveLinear but have different factories
-        this.pools[types_1.BalancerPoolTypes.AaveLinear] = linearPool;
-        this.pools[types_1.BalancerPoolTypes.ERC4626Linear] = linearPool;
-        this.pools[types_1.BalancerPoolTypes.GearboxLinear] = linearPool;
-        this.pools[types_1.BalancerPoolTypes.MidasLinear] = linearPool;
-        this.pools[types_1.BalancerPoolTypes.ReaperLinear] = linearPool;
-        this.pools[types_1.BalancerPoolTypes.SiloLinear] = linearPool;
-        this.pools[types_1.BalancerPoolTypes.TetuLinear] = linearPool;
-        this.pools[types_1.BalancerPoolTypes.YearnLinear] = linearPool;
-        this.pools[types_1.BalancerPoolTypes.BeefyLinear] = linearPool;
-        // Beets uses "Linear" generically for all linear pool types
-        this.pools[types_1.BalancerPoolTypes.Linear] = linearPool;
-        this.pools[types_1.BalancerPoolTypes.Gyro3] = gyro3Pool;
-        this.pools[types_1.BalancerPoolTypes.GyroE] = gyroEPool;
-        this.vaultDecoder = (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);
-    }
-    processLog(state, log) {
-        const _state = {};
-        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() {
-        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 }, constants_1.SUBGRAPH_TIMEOUT);
-        if (!(data && data.pools))
-            throw new Error('Unable to fetch pools from the subgraph');
-        const poolsMap = (0, lodash_1.keyBy)(data.pools, 'address');
-        const allPools = data.pools.map((pool) => ({
-            ...pool,
-            mainTokens: (0, utils_2.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) {
-        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, pool, log) {
-        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, pool, log) {
-        const tokens = event.args.tokens.map((t) => t.toLowerCase());
-        const deltas = event.args.deltas.map((d) => BigInt(d.toString()));
-        const fees = event.args.protocolFeeAmounts.map((d) => BigInt(d.toString()));
-        tokens.forEach((t, i) => {
-            const diff = deltas[i] - fees[i];
-            pool.tokens[t].balance += diff;
-        });
-        return pool;
-    }
-    isSupportedPool(poolType) {
-        const supportedPoolTypes = Object.values(types_1.BalancerPoolTypes);
-        return supportedPoolTypes.includes(poolType);
-    }
-    getPricesPool(from, to, subgraphPool, poolState, amounts, unitVolume, side) {
-        if (!this.isSupportedPool(subgraphPool.poolType)) {
-            this.logger.error(`Unsupported Pool Type: ${subgraphPool.poolType}`);
-            return null;
-        }
-        if (side === constants_1.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, side);
-        const checkedAmounts = 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 === constants_1.SwapSide.SELL
-                ? pool.onSell([checkedUnitVolume], poolPairData)[0]
-                : pool.onBuy([checkedUnitVolume], poolPairData)[0];
-        const prices = new Array(amounts.length).fill(0n);
-        const outputs = side === constants_1.SwapSide.SELL
-            ? pool.onSell(amountWithoutZero.slice(0, nonZeroAmountIndex), poolPairData)
-            : pool.onBuy(amountWithoutZero.slice(0, nonZeroAmountIndex), poolPairData);
-        (0, ts_essentials_1.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, blockNumber) {
-        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 = lodash_1.default.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, 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;
-    }
-}
-exports.BalancerV2EventPool = BalancerV2EventPool;
-class BalancerV2 extends simple_exchange_1.SimpleExchange {
-    constructor(network, dexKey, dexHelper, vaultAddress = config_1.BalancerConfig[dexKey][network].vaultAddress, subgraphURL = config_1.BalancerConfig[dexKey][network].subgraphURL, adapters = config_1.Adapters[network]) {
-        super(dexHelper, dexKey);
-        this.network = network;
-        this.dexHelper = dexHelper;
-        this.vaultAddress = vaultAddress;
-        this.subgraphURL = subgraphURL;
-        this.adapters = adapters;
-        this.hasConstantPriceLargeAmounts = false;
-        this.isFeeOnTransferSupported = false;
-        this.directSwapIface = new abi_1.Interface(DirectSwap_json_1.default);
-        this.eventDisabledPools = [];
-        // 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) {
-        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 }, constants_1.SUBGRAPH_TIMEOUT);
-        if (!(data && data.gradualWeightUpdates)) {
-            throw new Error(`${this.dexKey}_${this.network} failed to fetch weight updates from subgraph`);
-        }
-        this.eventDisabledPools = lodash_1.default.uniq(data.gradualWeightUpdates.map((wu) => 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) {
-        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() {
-        if (this.eventDisabledPoolsTimer) {
-            clearInterval(this.eventDisabledPoolsTimer);
-            this.eventDisabledPoolsTimer = undefined;
-            this.logger.info(`${this.dexKey}: cleared eventDisabledPoolsTimer before shutting down`);
-        }
-    }
-    getPoolsWithTokenPair(from, to) {
-        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) {
-        return this.adapters[side] ? this.adapters[side] : null;
-    }
-    async getPoolIdentifiers(from, to, side, blockNumber) {
-        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.
-     */
-    getNonEventPoolStateCache(blockNumber) {
-        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.
-     */
-    updateNonEventPoolStateCache(poolState, blockNumber) {
-        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, to, amounts, side, blockNumber, limitPools) {
-        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 = (0, utils_2.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) => {
-                try {
-                    const poolAddress = pool.address.toLowerCase();
-                    const path = (0, utils_2.poolGetPathForTokenInOut)(_from.address, _to.address, pool, this.poolAddressMap, side);
-                    let pathAmounts = amounts;
-                    let resOut = null;
-                    for (let i = 0; i < path.length; i++) {
-                        const poolAddress = path[i].pool.address.toLowerCase();
-                        const poolState = (eventPoolStates[poolAddress] ||
-                            nonEventPoolStates[poolAddress]);
-                        if (!poolState) {
-                            this.logger.error(`Unable to find the poolState ${poolAddress}`);
-                            return null;
-                        }
-                        const unitVolume = (0, utils_1.getBigIntPow)((side === constants_1.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: constants_2.STABLE_GAS_COST + constants_2.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;
-        }
-        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) {
-        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, destToken, srcAmount, destAmount, data, side) {
-        const params = this.getBalancerParam(srcToken, destToken, srcAmount, destAmount, data, side);
-        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',
-        };
-    }
-    getBalancerParam(srcToken, destToken, srcAmount, destAmount, data, side) {
-        let swapOffset = 0;
-        let swaps = [];
-        let assets = [];
-        let limits = [];
-        for (const swapData of data.swaps) {
-            const pool = this.poolIdMap[swapData.poolId];
-            const hasEth = [srcToken.toLowerCase(), destToken.toLowerCase()].includes(constants_1.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 = (0, utils_2.poolGetPathForTokenInOut)(_srcToken, _destToken, pool, this.poolAddressMap, side);
-            if (side === constants_1.SwapSide.BUY) {
-                path = path.reverse();
-            }
-            const _swaps = path.map((hop, index) => ({
-                poolId: hop.pool.id,
-                assetInIndex: swapOffset + index,
-                assetOutIndex: swapOffset + index + 1,
-                amount: (side === constants_1.SwapSide.SELL && index === 0) ||
-                    (side === constants_1.SwapSide.BUY && index === path.length - 1)
-                    ? swapData.amount
-                    : '0',
-                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) ? constants_1.NULL_ADDRESS : t));
-            const _limits = _assets.map(_ => constants_1.MAX_INT);
-            swaps = swaps.concat(_swaps);
-            assets = assets.concat(_assets);
-            limits = limits.concat(_limits);
-        }
-        const funds = {
-            sender: this.augustusAddress,
-            recipient: this.augustusAddress,
-            fromInternalBalance: false,
-            toInternalBalance: false,
-        };
-        const params = [
-            side === constants_1.SwapSide.SELL ? types_1.SwapTypes.SwapExactIn : types_1.SwapTypes.SwapExactOut,
-            side === constants_1.SwapSide.SELL ? swaps : swaps.reverse(),
-            assets,
-            funds,
-            limits,
-            constants_1.MAX_UINT,
-        ];
-        return params;
-    }
-    static getDirectFunctionName() {
-        return [constants_2.DirectMethods.directSell, constants_2.DirectMethods.directBuy];
-    }
-    getTokenFromAddress(address) {
-        // In this Dex decimals are not used
-        return { address, decimals: 0 };
-    }
-    async preProcessTransaction(optimalSwapExchange, srcToken, _0, _1, options) {
-        if (!options.isDirectMethod) {
-            return [
-                optimalSwapExchange,
-                {
-                    deadline: BigInt((0, simple_exchange_1.getLocalDeadlineAsFriendlyPlaceholder)()),
-                },
-            ];
-        }
-        (0, ts_essentials_1.assert)(optimalSwapExchange.data !== undefined, `preProcessTransaction: data field is missing`);
-        let isApproved;
-        try {
-            this.erc20Contract.options.address =
-                this.dexHelper.config.wrapETH(srcToken).address;
-            const allowance = await this.erc20Contract.methods
-                .allowance(this.augustusAddress, this.vaultAddress)
-                .call(undefined, 'latest');
-            isApproved =
-                BigInt(allowance.toString()) >= BigInt(optimalSwapExchange.srcAmount);
-        }
-        catch (e) {
-            this.logger.error(`preProcessTransaction failed to retrieve allowance info: `, e);
-        }
-        return [
-            {
-                ...optimalSwapExchange,
-                data: {
-                    ...optimalSwapExchange.data,
-                    isApproved,
-                },
-            },
-            {
-                deadline: BigInt((0, simple_exchange_1.getLocalDeadlineAsFriendlyPlaceholder)()),
-            },
-        ];
-    }
-    getDirectParam(srcToken, destToken, srcAmount, destAmount, expectedAmount, data, side, permit, uuid, feePercent, deadline, partner, beneficiary, contractMethod) {
-        if (contractMethod !== constants_2.DirectMethods.directSell &&
-            contractMethod !== constants_2.DirectMethods.directBuy) {
-            throw new Error(`Invalid contract method ${contractMethod}`);
-        }
-        let isApproved = !!data.isApproved;
-        if (data.isApproved === undefined) {
-            this.logger.warn(`isApproved is undefined, defaulting to false`);
-        }
-        const [, swaps, assets, funds, limits, _deadline] = this.getBalancerParam(srcToken, destToken, srcAmount, destAmount, data, side);
-        const swapParams = [
-            swaps,
-            assets,
-            funds,
-            limits,
-            srcAmount,
-            destAmount,
-            expectedAmount,
-            _deadline,
-            feePercent,
-            this.vaultAddress,
-            partner,
-            isApproved,
-            beneficiary,
-            permit,
-            (0, utils_1.uuidToBytes16)(uuid),
-        ];
-        const encoder = (...params) => {
-            return this.directSwapIface.encodeFunctionData(side === constants_1.SwapSide.SELL
-                ? constants_2.DirectMethods.directSell
-                : constants_2.DirectMethods.directBuy, [params]);
-        };
-        return {
-            params: swapParams,
-            encoder,
-            networkFee: '0',
-        };
-    }
-    async getSimpleParam(srcToken, destToken, srcAmount, destAmount, data, side) {
-        const params = this.getBalancerParam(srcToken, destToken, srcAmount, destAmount, data, side);
-        const swapData = this.eventPools.vaultInterface.encodeFunctionData('batchSwap', params);
-        return this.buildSimpleParamWithoutWETHConversion(srcToken, srcAmount, destToken, destAmount, swapData, this.vaultAddress);
-    }
-    async updatePoolState() {
-        this.eventPools.allPools = await this.eventPools.fetchAllSubgraphPools();
-    }
-    async getTopPoolsForToken(tokenAddress, count) {
-        const poolsWithToken = this.eventPools.allPools.filter(pool => pool.mainTokens.some(mainToken => (0, utils_2.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: ${constants_2.MIN_USD_LIQUIDITY_TO_FETCH.toString()}}) {
-        address
-        totalLiquidity
-        tokens {
-          address
-          decimals
-        }
-      }
-    }`;
-        const { data } = await this.dexHelper.httpRequest.post(this.subgraphURL, {
-            query,
-            variables,
-        }, constants_1.SUBGRAPH_TIMEOUT);
-        if (!(data && data.pools))
-            throw new Error(`Error_${this.dexKey}_Subgraph: couldn't fetch the pools from the subgraph`);
-        return lodash_1.default.map(data.pools, pool => {
-            const subgraphPool = poolsWithToken.find(poolWithToken => (0, utils_2.isSameAddress)(poolWithToken.address, pool.address));
-            return {
-                exchange: this.dexKey,
-                address: pool.address.toLowerCase(),
-                connectorTokens: subgraphPool.mainTokens.filter(token => !(0, utils_2.isSameAddress)(tokenAddress, token.address)),
-                liquidityUSD: parseFloat(pool.totalLiquidity),
-            };
-        });
-    }
-    get poolAddressMap() {
-        return (0, lodash_1.keyBy)(this.eventPools.allPools, 'address');
-    }
-    get poolIdMap() {
-        return (0, lodash_1.keyBy)(this.eventPools.allPools, 'id');
-    }
-}
-exports.BalancerV2 = BalancerV2;
-BalancerV2.dexKeysWithNetwork = (0, utils_1.getDexKeysWithNetwork)(config_1.BalancerConfig);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BalancerV2 = exports.BalancerV2EventPool = void 0;
+const abi_1 = require("@ethersproject/abi");
+const ts_essentials_1 = require("ts-essentials");
+const lodash_1 = __importStar(require("lodash"));
+const constants_1 = require("../../constants");
+const CALLDATA_GAS_COST = __importStar(require("../../calldata-gas-cost"));
+const StablePool_1 = require("./pools/stable/StablePool");
+const WeightedPool_1 = require("./pools/weighted/WeightedPool");
+const PhantomStablePool_1 = require("./pools/phantom-stable/PhantomStablePool");
+const LinearPool_1 = require("./pools/linear/LinearPool");
+const Gyro3Pool_1 = require("./pools/gyro/Gyro3Pool");
+const GyroEPool_1 = require("./pools/gyro/GyroEPool");
+const vault_json_1 = __importDefault(require("../../abi/balancer-v2/vault.json"));
+const DirectSwap_json_1 = __importDefault(require("../../abi/DirectSwap.json"));
+const stateful_event_subscriber_1 = require("../../stateful-event-subscriber");
+const utils_1 = require("../../utils");
+const types_1 = require("./types");
+const simple_exchange_1 = require("../simple-exchange");
+const config_1 = require("./config");
+const utils_2 = require("./utils");
+const constants_2 = require("./constants");
+// 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
+    types_1.BalancerPoolTypes.Stable,
+    types_1.BalancerPoolTypes.Weighted,
+    types_1.BalancerPoolTypes.LiquidityBootstrapping,
+    types_1.BalancerPoolTypes.Investment,
+    types_1.BalancerPoolTypes.StablePhantom,
+    types_1.BalancerPoolTypes.AaveLinear,
+    types_1.BalancerPoolTypes.ERC4626Linear,
+    types_1.BalancerPoolTypes.Linear,
+    types_1.BalancerPoolTypes.ComposableStable,
+    types_1.BalancerPoolTypes.BeefyLinear,
+    types_1.BalancerPoolTypes.GearboxLinear,
+    types_1.BalancerPoolTypes.MidasLinear,
+    types_1.BalancerPoolTypes.ReaperLinear,
+    types_1.BalancerPoolTypes.SiloLinear,
+    types_1.BalancerPoolTypes.TetuLinear,
+    types_1.BalancerPoolTypes.YearnLinear,
+    types_1.BalancerPoolTypes.GyroE,
+    types_1.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: ${constants_2.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) {
+    return lodash_1.default.cloneDeep(pool);
+}
+class BalancerV2EventPool extends stateful_event_subscriber_1.StatefulEventSubscriber {
+    constructor(parentName, network, vaultAddress, subgraphURL, dexHelper, logger) {
+        super(parentName, vaultAddress, dexHelper, logger);
+        this.network = network;
+        this.vaultAddress = vaultAddress;
+        this.subgraphURL = subgraphURL;
+        this.dexHelper = dexHelper;
+        this.handlers = {};
+        this.allPools = [];
+        this.buySupportedPoolTypes = new Set([
+            types_1.BalancerPoolTypes.Weighted,
+            types_1.BalancerPoolTypes.GyroE,
+        ]);
+        this.eventSupportedPoolTypes = [
+            types_1.BalancerPoolTypes.Stable,
+            types_1.BalancerPoolTypes.Weighted,
+            types_1.BalancerPoolTypes.LiquidityBootstrapping,
+            types_1.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,
+        ];
+        this.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',
+        ].map(s => s.toLowerCase());
+        this.vaultInterface = new abi_1.Interface(vault_json_1.default);
+        const weightedPool = new WeightedPool_1.WeightedPool(this.vaultAddress, this.vaultInterface);
+        const stablePool = new StablePool_1.StablePool(this.vaultAddress, this.vaultInterface);
+        const stablePhantomPool = new PhantomStablePool_1.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_1.PhantomStablePool(this.vaultAddress, this.vaultInterface, true);
+        const linearPool = new LinearPool_1.LinearPool(this.vaultAddress, this.vaultInterface);
+        const gyro3Pool = new Gyro3Pool_1.Gyro3Pool(this.vaultAddress, this.vaultInterface);
+        const gyroEPool = new GyroEPool_1.GyroEPool(this.vaultAddress, this.vaultInterface);
+        this.pools = {};
+        this.pools[types_1.BalancerPoolTypes.Weighted] = weightedPool;
+        this.pools[types_1.BalancerPoolTypes.Stable] = stablePool;
+        this.pools[types_1.BalancerPoolTypes.MetaStable] = stablePool;
+        this.pools[types_1.BalancerPoolTypes.LiquidityBootstrapping] = weightedPool;
+        this.pools[types_1.BalancerPoolTypes.Investment] = weightedPool;
+        this.pools[types_1.BalancerPoolTypes.StablePhantom] = stablePhantomPool;
+        this.pools[types_1.BalancerPoolTypes.ComposableStable] = composableStable;
+        // All these Linear pool have same maths and ABI as AaveLinear but have different factories
+        this.pools[types_1.BalancerPoolTypes.AaveLinear] = linearPool;
+        this.pools[types_1.BalancerPoolTypes.ERC4626Linear] = linearPool;
+        this.pools[types_1.BalancerPoolTypes.GearboxLinear] = linearPool;
+        this.pools[types_1.BalancerPoolTypes.MidasLinear] = linearPool;
+        this.pools[types_1.BalancerPoolTypes.ReaperLinear] = linearPool;
+        this.pools[types_1.BalancerPoolTypes.SiloLinear] = linearPool;
+        this.pools[types_1.BalancerPoolTypes.TetuLinear] = linearPool;
+        this.pools[types_1.BalancerPoolTypes.YearnLinear] = linearPool;
+        this.pools[types_1.BalancerPoolTypes.BeefyLinear] = linearPool;
+        // Beets uses "Linear" generically for all linear pool types
+        this.pools[types_1.BalancerPoolTypes.Linear] = linearPool;
+        this.pools[types_1.BalancerPoolTypes.Gyro3] = gyro3Pool;
+        this.pools[types_1.BalancerPoolTypes.GyroE] = gyroEPool;
+        this.vaultDecoder = (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);
+    }
+    processLog(state, log) {
+        const _state = {};
+        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() {
+        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 }, constants_1.SUBGRAPH_TIMEOUT);
+        if (!(data && data.pools))
+            throw new Error('Unable to fetch pools from the subgraph');
+        const poolsMap = (0, lodash_1.keyBy)(data.pools, 'address');
+        const allPools = data.pools.map((pool) => ({
+            ...pool,
+            mainTokens: (0, utils_2.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) {
+        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, pool, log) {
+        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, pool, log) {
+        const tokens = event.args.tokens.map((t) => t.toLowerCase());
+        const deltas = event.args.deltas.map((d) => BigInt(d.toString()));
+        const fees = event.args.protocolFeeAmounts.map((d) => BigInt(d.toString()));
+        tokens.forEach((t, i) => {
+            const diff = deltas[i] - fees[i];
+            pool.tokens[t].balance += diff;
+        });
+        return pool;
+    }
+    isSupportedPool(poolType) {
+        const supportedPoolTypes = Object.values(types_1.BalancerPoolTypes);
+        return supportedPoolTypes.includes(poolType);
+    }
+    getPricesPool(from, to, subgraphPool, poolState, amounts, unitVolume, side) {
+        if (!this.isSupportedPool(subgraphPool.poolType)) {
+            this.logger.error(`Unsupported Pool Type: ${subgraphPool.poolType}`);
+            return null;
+        }
+        if (side === constants_1.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, side);
+        const checkedAmounts = 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 === constants_1.SwapSide.SELL
+                ? pool.onSell([checkedUnitVolume], poolPairData)[0]
+                : pool.onBuy([checkedUnitVolume], poolPairData)[0];
+        const prices = new Array(amounts.length).fill(0n);
+        const outputs = side === constants_1.SwapSide.SELL
+            ? pool.onSell(amountWithoutZero.slice(0, nonZeroAmountIndex), poolPairData)
+            : pool.onBuy(amountWithoutZero.slice(0, nonZeroAmountIndex), poolPairData);
+        (0, ts_essentials_1.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, blockNumber) {
+        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 = lodash_1.default.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, 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;
+    }
+}
+exports.BalancerV2EventPool = BalancerV2EventPool;
+class BalancerV2 extends simple_exchange_1.SimpleExchange {
+    constructor(network, dexKey, dexHelper, vaultAddress = config_1.BalancerConfig[dexKey][network].vaultAddress, subgraphURL = config_1.BalancerConfig[dexKey][network].subgraphURL, adapters = config_1.Adapters[network]) {
+        super(dexHelper, dexKey);
+        this.network = network;
+        this.dexHelper = dexHelper;
+        this.vaultAddress = vaultAddress;
+        this.subgraphURL = subgraphURL;
+        this.adapters = adapters;
+        this.hasConstantPriceLargeAmounts = false;
+        this.isFeeOnTransferSupported = false;
+        this.directSwapIface = new abi_1.Interface(DirectSwap_json_1.default);
+        this.eventDisabledPools = [];
+        // 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) {
+        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 }, constants_1.SUBGRAPH_TIMEOUT);
+        if (!(data && data.gradualWeightUpdates)) {
+            throw new Error(`${this.dexKey}_${this.network} failed to fetch weight updates from subgraph`);
+        }
+        this.eventDisabledPools = lodash_1.default.uniq(data.gradualWeightUpdates.map((wu) => 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) {
+        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() {
+        if (this.eventDisabledPoolsTimer) {
+            clearInterval(this.eventDisabledPoolsTimer);
+            this.eventDisabledPoolsTimer = undefined;
+            this.logger.info(`${this.dexKey}: cleared eventDisabledPoolsTimer before shutting down`);
+        }
+    }
+    getPoolsWithTokenPair(from, to) {
+        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) {
+        return this.adapters[side] ? this.adapters[side] : null;
+    }
+    async getPoolIdentifiers(from, to, side, blockNumber) {
+        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.
+     */
+    getNonEventPoolStateCache(blockNumber) {
+        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.
+     */
+    updateNonEventPoolStateCache(poolState, blockNumber) {
+        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, to, amounts, side, blockNumber, limitPools) {
+        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 = (0, utils_2.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) => {
+                try {
+                    const poolAddress = pool.address.toLowerCase();
+                    const path = (0, utils_2.poolGetPathForTokenInOut)(_from.address, _to.address, pool, this.poolAddressMap, side);
+                    let pathAmounts = amounts;
+                    let resOut = null;
+                    for (let i = 0; i < path.length; i++) {
+                        const poolAddress = path[i].pool.address.toLowerCase();
+                        const poolState = (eventPoolStates[poolAddress] ||
+                            nonEventPoolStates[poolAddress]);
+                        if (!poolState) {
+                            this.logger.error(`Unable to find the poolState ${poolAddress}`);
+                            return null;
+                        }
+                        const unitVolume = (0, utils_1.getBigIntPow)((side === constants_1.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: constants_2.STABLE_GAS_COST + constants_2.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;
+        }
+        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) {
+        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, destToken, srcAmount, destAmount, data, side) {
+        const params = this.getBalancerParam(srcToken, destToken, srcAmount, destAmount, data, side);
+        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',
+        };
+    }
+    getBalancerParam(srcToken, destToken, srcAmount, destAmount, data, side) {
+        let swapOffset = 0;
+        let swaps = [];
+        let assets = [];
+        let limits = [];
+        for (const swapData of data.swaps) {
+            const pool = this.poolIdMap[swapData.poolId];
+            const hasEth = [srcToken.toLowerCase(), destToken.toLowerCase()].includes(constants_1.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 = (0, utils_2.poolGetPathForTokenInOut)(_srcToken, _destToken, pool, this.poolAddressMap, side);
+            if (side === constants_1.SwapSide.BUY) {
+                path = path.reverse();
+            }
+            const _swaps = path.map((hop, index) => ({
+                poolId: hop.pool.id,
+                assetInIndex: swapOffset + index,
+                assetOutIndex: swapOffset + index + 1,
+                amount: (side === constants_1.SwapSide.SELL && index === 0) ||
+                    (side === constants_1.SwapSide.BUY && index === path.length - 1)
+                    ? swapData.amount
+                    : '0',
+                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) ? constants_1.NULL_ADDRESS : t));
+            const _limits = _assets.map(_ => constants_1.MAX_INT);
+            swaps = swaps.concat(_swaps);
+            assets = assets.concat(_assets);
+            limits = limits.concat(_limits);
+        }
+        const funds = {
+            sender: this.augustusAddress,
+            recipient: this.augustusAddress,
+            fromInternalBalance: false,
+            toInternalBalance: false,
+        };
+        const params = [
+            side === constants_1.SwapSide.SELL ? types_1.SwapTypes.SwapExactIn : types_1.SwapTypes.SwapExactOut,
+            side === constants_1.SwapSide.SELL ? swaps : swaps.reverse(),
+            assets,
+            funds,
+            limits,
+            constants_1.MAX_UINT,
+        ];
+        return params;
+    }
+    static getDirectFunctionName() {
+        return [constants_2.DirectMethods.directSell, constants_2.DirectMethods.directBuy];
+    }
+    getTokenFromAddress(address) {
+        // In this Dex decimals are not used
+        return { address, decimals: 0 };
+    }
+    async preProcessTransaction(optimalSwapExchange, srcToken, _0, _1, options) {
+        if (!options.isDirectMethod) {
+            return [
+                optimalSwapExchange,
+                {
+                    deadline: BigInt((0, simple_exchange_1.getLocalDeadlineAsFriendlyPlaceholder)()),
+                },
+            ];
+        }
+        (0, ts_essentials_1.assert)(optimalSwapExchange.data !== undefined, `preProcessTransaction: data field is missing`);
+        let isApproved;
+        try {
+            this.erc20Contract.options.address =
+                this.dexHelper.config.wrapETH(srcToken).address;
+            const allowance = await this.erc20Contract.methods
+                .allowance(this.augustusAddress, this.vaultAddress)
+                .call(undefined, 'latest');
+            isApproved =
+                BigInt(allowance.toString()) >= BigInt(optimalSwapExchange.srcAmount);
+        }
+        catch (e) {
+            this.logger.error(`preProcessTransaction failed to retrieve allowance info: `, e);
+        }
+        return [
+            {
+                ...optimalSwapExchange,
+                data: {
+                    ...optimalSwapExchange.data,
+                    isApproved,
+                },
+            },
+            {
+                deadline: BigInt((0, simple_exchange_1.getLocalDeadlineAsFriendlyPlaceholder)()),
+            },
+        ];
+    }
+    getDirectParam(srcToken, destToken, srcAmount, destAmount, expectedAmount, data, side, permit, uuid, feePercent, deadline, partner, beneficiary, contractMethod) {
+        if (contractMethod !== constants_2.DirectMethods.directSell &&
+            contractMethod !== constants_2.DirectMethods.directBuy) {
+            throw new Error(`Invalid contract method ${contractMethod}`);
+        }
+        let isApproved = !!data.isApproved;
+        if (data.isApproved === undefined) {
+            this.logger.warn(`isApproved is undefined, defaulting to false`);
+        }
+        const [, swaps, assets, funds, limits, _deadline] = this.getBalancerParam(srcToken, destToken, srcAmount, destAmount, data, side);
+        const swapParams = [
+            swaps,
+            assets,
+            funds,
+            limits,
+            srcAmount,
+            destAmount,
+            expectedAmount,
+            _deadline,
+            feePercent,
+            this.vaultAddress,
+            partner,
+            isApproved,
+            beneficiary,
+            permit,
+            (0, utils_1.uuidToBytes16)(uuid),
+        ];
+        const encoder = (...params) => {
+            return this.directSwapIface.encodeFunctionData(side === constants_1.SwapSide.SELL
+                ? constants_2.DirectMethods.directSell
+                : constants_2.DirectMethods.directBuy, [params]);
+        };
+        return {
+            params: swapParams,
+            encoder,
+            networkFee: '0',
+        };
+    }
+    async getSimpleParam(srcToken, destToken, srcAmount, destAmount, data, side) {
+        const params = this.getBalancerParam(srcToken, destToken, srcAmount, destAmount, data, side);
+        const swapData = this.eventPools.vaultInterface.encodeFunctionData('batchSwap', params);
+        return this.buildSimpleParamWithoutWETHConversion(srcToken, srcAmount, destToken, destAmount, swapData, this.vaultAddress);
+    }
+    async updatePoolState() {
+        this.eventPools.allPools = await this.eventPools.fetchAllSubgraphPools();
+    }
+    async getTopPoolsForToken(tokenAddress, count) {
+        const poolsWithToken = this.eventPools.allPools.filter(pool => pool.mainTokens.some(mainToken => (0, utils_2.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: ${constants_2.MIN_USD_LIQUIDITY_TO_FETCH.toString()}}) {
+        address
+        totalLiquidity
+        tokens {
+          address
+          decimals
+        }
+      }
+    }`;
+        const { data } = await this.dexHelper.httpRequest.post(this.subgraphURL, {
+            query,
+            variables,
+        }, constants_1.SUBGRAPH_TIMEOUT);
+        if (!(data && data.pools))
+            throw new Error(`Error_${this.dexKey}_Subgraph: couldn't fetch the pools from the subgraph`);
+        return lodash_1.default.map(data.pools, pool => {
+            const subgraphPool = poolsWithToken.find(poolWithToken => (0, utils_2.isSameAddress)(poolWithToken.address, pool.address));
+            return {
+                exchange: this.dexKey,
+                address: pool.address.toLowerCase(),
+                connectorTokens: subgraphPool.mainTokens.filter(token => !(0, utils_2.isSameAddress)(tokenAddress, token.address)),
+                liquidityUSD: parseFloat(pool.totalLiquidity),
+            };
+        });
+    }
+    get poolAddressMap() {
+        return (0, lodash_1.keyBy)(this.eventPools.allPools, 'address');
+    }
+    get poolIdMap() {
+        return (0, lodash_1.keyBy)(this.eventPools.allPools, 'id');
+    }
+}
+exports.BalancerV2 = BalancerV2;
+BalancerV2.dexKeysWithNetwork = (0, utils_1.getDexKeysWithNetwork)(config_1.BalancerConfig);
 //# sourceMappingURL=balancer-v2.js.map