@paraswap/dex-lib 4.1.6 → 4.1.7-mwrappedm.0

package/src/dex/balancer-v3/balancer-v3-integration.test.ts

@@ -2,9 +2,9 @@
 import dotenv from 'dotenv';
 dotenv.config();
 
-import { checkOnChainPricingNonMulti } from './balancer-test-helpers';
+import { Interface, Result } from '@ethersproject/abi';
 import { DummyDexHelper } from '../../dex-helper/index';
-import { Network, SwapSide } from '../../constants';
+import { Network, NULL_ADDRESS, SwapSide } from '../../constants';
 import { BI_POWS } from '../../bigint-constants';
 import { BalancerV3 } from './balancer-v3';
 import {
@@ -13,6 +13,201 @@ import {
   checkPoolsLiquidity,
 } from '../../../tests/utils';
 import { Tokens } from '../../../tests/constants-e2e';
+import { BalancerV3Config } from './config';
+import { BalancerV3Data, Step } from './types';
+import { Address, ExchangePrices, PoolPrices } from '../../types';
+import balancerBatchRouterAbi from '../../abi/balancer-v3/batch-router.json';
+import balancerRouterAbi from '../../abi/balancer-v3/router.json';
+
+function getQuerySwapSingleTokenCalldata(
+  routerAddress: Address,
+  routerInterface: Interface,
+  amounts: bigint[],
+  step: Step,
+  side: SwapSide,
+) {
+  return amounts
+    .filter(amount => amount !== 0n)
+    .map(amount => {
+      return {
+        target: routerAddress,
+        callData: routerInterface.encodeFunctionData(
+          side === SwapSide.SELL
+            ? `querySwapSingleTokenExactIn`
+            : `querySwapSingleTokenExactOut`,
+          [
+            step.pool,
+            step.swapInput.tokenIn,
+            step.swapInput.tokenOut,
+            amount,
+            NULL_ADDRESS,
+            '0x',
+          ],
+        ),
+      };
+    });
+}
+
+function getQuerySwapMultiTokenCalldata(
+  routerAddress: Address,
+  routerInterface: Interface,
+  amounts: bigint[],
+  steps: Step[],
+  side: SwapSide,
+) {
+  const tokenIn = steps[0].swapInput.tokenIn;
+  const stepsNew = steps.map(s => ({
+    pool: s.pool,
+    tokenOut: s.swapInput.tokenOut,
+    isBuffer: s.isBuffer,
+  }));
+  return amounts
+    .filter(amount => amount !== 0n)
+    .map(amount => {
+      let args: any[] = [];
+      if (side === SwapSide.SELL)
+        args = [
+          {
+            tokenIn,
+            steps: stepsNew,
+            exactAmountIn: amount,
+            minAmountOut: 0n,
+          },
+        ];
+      else
+        args = [
+          {
+            tokenIn,
+            steps: stepsNew,
+            exactAmountOut: amount,
+            maxAmountIn: 0n,
+          },
+        ];
+      return {
+        target: routerAddress,
+        callData: routerInterface.encodeFunctionData(
+          side === SwapSide.SELL ? `querySwapExactIn` : `querySwapExactOut`,
+          [args, NULL_ADDRESS, '0x'],
+        ),
+      };
+    });
+}
+
+async function querySinglePathPrices(
+  network: number,
+  side: SwapSide,
+  balancerV3: BalancerV3,
+  blockNumber: number,
+  price: PoolPrices<BalancerV3Data>,
+  amounts: bigint[],
+) {
+  const balancerRouter = new Interface(balancerRouterAbi);
+  const readerCallData = getQuerySwapSingleTokenCalldata(
+    BalancerV3Config.BalancerV3[network].balancerRouterAddress,
+    balancerRouter,
+    amounts,
+    price.data.steps[0],
+    side,
+  );
+
+  const expectedPrices = [0n];
+  for (const call of readerCallData) {
+    try {
+      const result = await balancerV3.dexHelper.provider.call(
+        {
+          to: call.target,
+          data: call.callData,
+        },
+        blockNumber,
+      );
+      const parsed = balancerRouter.decodeFunctionResult(
+        side === SwapSide.SELL
+          ? `querySwapSingleTokenExactIn`
+          : `querySwapSingleTokenExactOut`,
+        result,
+      );
+      expectedPrices.push(BigInt(parsed[0]._hex));
+    } catch (error) {
+      console.log('Error in querySinglePathPrices', error);
+      expectedPrices.push(0n);
+    }
+  }
+  return expectedPrices;
+}
+
+async function queryMultiPathPrices(
+  network: number,
+  side: SwapSide,
+  balancerV3: BalancerV3,
+  blockNumber: number,
+  price: PoolPrices<BalancerV3Data>,
+  amounts: bigint[],
+) {
+  const balancerBatchRouter = new Interface(balancerBatchRouterAbi);
+  const readerCallData = getQuerySwapMultiTokenCalldata(
+    BalancerV3Config.BalancerV3[network].balancerBatchRouterAddress,
+    balancerBatchRouter,
+    amounts,
+    price.data.steps,
+    side,
+  );
+
+  const expectedPrices = [0n];
+  for (const call of readerCallData) {
+    try {
+      const result = await balancerV3.dexHelper.provider.call(
+        {
+          to: call.target,
+          data: call.callData,
+        },
+        blockNumber,
+      );
+      const parsed = balancerBatchRouter.decodeFunctionResult(
+        side === SwapSide.SELL ? `querySwapExactIn` : `querySwapExactOut`,
+        result,
+      );
+      expectedPrices.push(BigInt(parsed[2][0]._hex));
+    } catch (error) {
+      console.log('Error in queryMultiPathPrices', error);
+      expectedPrices.push(0n);
+    }
+  }
+  return expectedPrices;
+}
+
+// Note - this is currently needed because queries won't work with multicall but should be updated in future
+async function checkOnChainPricingNonMulti(
+  network: number,
+  side: SwapSide,
+  balancerV3: BalancerV3,
+  blockNumber: number,
+  prices: ExchangePrices<BalancerV3Data>,
+  amounts: bigint[],
+) {
+  // test match for each returned price
+  for (const price of prices) {
+    let expectedPrices: bigint[] = [];
+    if (price.data.steps.length === 1 && !price.data.steps[0].isBuffer)
+      expectedPrices = await querySinglePathPrices(
+        network,
+        side,
+        balancerV3,
+        blockNumber,
+        price,
+        amounts,
+      );
+    else
+      expectedPrices = await queryMultiPathPrices(
+        network,
+        side,
+        balancerV3,
+        blockNumber,
+        price,
+        amounts,
+      );
+    expect(price.prices).toEqual(expectedPrices);
+  }
+}
 
 async function testPricingOnNetwork(
   balancerV3: BalancerV3,
@@ -639,9 +834,9 @@ describe('BalancerV3', function () {
 
     describe('Buffer, Nested Rate', () => {
       /*
-      The Gnosis pool, 0x272d6be442e30d7c87390edeb9b96f1e84cecd8d uses a rate provider that is nested.
-      So unwrap rate does not equal rate between aave wsteth and eth.
-      This particular case the rate provider accounts for growth of wsteth in terms of weth and the additional aave yield.
+      The Gnosis pool, 0x272d6be442e30d7c87390edeb9b96f1e84cecd8d uses a rate provider that is nested. 
+      So unwrap rate does not equal rate between aave wsteth and eth. 
+      This particular case the rate provider accounts for growth of wsteth in terms of weth and the additional aave yield. 
       This highlighted that rateProvider can not be used for buffer wrap/unwrap which instead should use erc4626 rate.
       */
       const dexHelper = new DummyDexHelper(network);
@@ -703,10 +898,10 @@ describe('BalancerV3', function () {
     describe('Token/Underlying With Different Decimals', () => {
       /*
       Mainnet Pool, 0x5dd88b3aa3143173eb26552923922bdf33f50949 has an ERC4626 token with 18 decimals that uses a 6 decimal underlying.
-      Note for maths: Instead of manually adding support for each ERC4626 implementation (e.g. stata with Ray maths) we always use an
+      Note for maths: Instead of manually adding support for each ERC4626 implementation (e.g. stata with Ray maths) we always use an 
       18 decimal scaled rate and do 18 decimal maths to convert. We may end up loosing 100% accuracy but thats deemed acceptable.
       */
-      describe('Buffer wrap 6decimal>18decimal', () => {
+      describe.only('Buffer wrap 6decimal>18decimal', () => {
         const dexHelper = new DummyDexHelper(network);
 
         const tokens = Tokens[network];
@@ -865,102 +1060,6 @@ describe('BalancerV3', function () {
       });
     });
   });
-
-  describe('Base', () => {
-    const network = Network.BASE;
-
-    describe('Stable Pool', () => {
-      const dexHelper = new DummyDexHelper(network);
-
-      const tokens = Tokens[network];
-      const srcTokenSymbol = 'wstETH';
-      const destTokenSymbol = 'WETH';
-
-      const amountsForSell = [
-        0n,
-        1n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        2n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        3n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        4n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        5n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        6n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        7n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        8n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        9n * BI_POWS[tokens[srcTokenSymbol].decimals],
-        10n * BI_POWS[tokens[srcTokenSymbol].decimals],
-      ];
-
-      const amountsForBuy = [
-        0n,
-        1n * BI_POWS[tokens[destTokenSymbol].decimals],
-        2n * BI_POWS[tokens[destTokenSymbol].decimals],
-        3n * BI_POWS[tokens[destTokenSymbol].decimals],
-        4n * BI_POWS[tokens[destTokenSymbol].decimals],
-        5n * BI_POWS[tokens[destTokenSymbol].decimals],
-        6n * BI_POWS[tokens[destTokenSymbol].decimals],
-        7n * BI_POWS[tokens[destTokenSymbol].decimals],
-        8n * BI_POWS[tokens[destTokenSymbol].decimals],
-        9n * BI_POWS[tokens[destTokenSymbol].decimals],
-        10n * BI_POWS[tokens[destTokenSymbol].decimals],
-      ];
-
-      beforeAll(async () => {
-        blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
-        balancerV3 = new BalancerV3(network, dexKey, dexHelper);
-        if (balancerV3.initializePricing) {
-          await balancerV3.initializePricing(blockNumber);
-        }
-      });
-
-      it('getPoolIdentifiers and getPricesVolume SELL', async function () {
-        await testPricingOnNetwork(
-          balancerV3,
-          network,
-          dexKey,
-          blockNumber,
-          srcTokenSymbol,
-          destTokenSymbol,
-          SwapSide.SELL,
-          amountsForSell,
-        );
-      });
-
-      it('getPoolIdentifiers and getPricesVolume BUY', async function () {
-        await testPricingOnNetwork(
-          balancerV3,
-          network,
-          dexKey,
-          blockNumber,
-          srcTokenSymbol,
-          destTokenSymbol,
-          SwapSide.BUY,
-          amountsForBuy,
-        );
-      });
-
-      it('getTopPoolsForToken', async function () {
-        // We have to check without calling initializePricing, because
-        // pool-tracker is not calling that function
-        const newBalancerV3 = new BalancerV3(network, dexKey, dexHelper);
-        if (newBalancerV3.updatePoolState) {
-          await newBalancerV3.updatePoolState();
-        }
-        const poolLiquidity = await newBalancerV3.getTopPoolsForToken(
-          tokens[srcTokenSymbol].address,
-          10,
-        );
-        console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
-
-        if (!newBalancerV3.hasConstantPriceLargeAmounts) {
-          checkPoolsLiquidity(
-            poolLiquidity,
-            Tokens[network][srcTokenSymbol].address,
-            dexKey,
-          );
-        }
-      });
-    });
-  });
 });
 
 // Add back once multicall queries are working

package/src/dex/balancer-v3/balancer-v3-pool.ts

@@ -29,11 +29,6 @@ import {
   isStableMutableState,
 } from './stablePool';
 import { BI_POWS } from '../../bigint-constants';
-import {
-  HookStateMap,
-  HooksConfigMap,
-} from './hooks/balancer-hook-event-subscriber';
-import { StableSurge, StableSurgeHookState } from './hooks/stableSurgeHook';
 
 export const WAD = BI_POWS[18];
 
@@ -53,8 +48,8 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
   interfaces: {
     [name: string]: Interface;
   };
+
   vault: Vault;
-  hooksConfigMap: HooksConfigMap = {};
 
   constructor(
     readonly parentName: string,
@@ -101,10 +96,6 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
     this.vault = new Vault();
   }
 
-  setHooksConfigMap(hooksConfigMap: HooksConfigMap) {
-    this.hooksConfigMap = hooksConfigMap;
-  }
-
   /**
    * The function is called every time any of the subscribed
    * addresses release log. The function accepts the current
@@ -143,11 +134,7 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
     blockNumber: number,
   ): Promise<DeepReadonly<PoolStateMap>> {
     const block = await this.dexHelper.provider.getBlock(blockNumber);
-    const apiPoolStateMap = await getPoolsApi(
-      this.network,
-      this.hooksConfigMap,
-      block.timestamp,
-    );
+    const apiPoolStateMap = await getPoolsApi(this.network, block.timestamp);
     const allOnChainPools = await getOnChainState(
       this.network,
       apiPoolStateMap,
@@ -173,10 +160,7 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
     existingPoolState: DeepReadonly<PoolStateMap>,
   ): Promise<DeepReadonly<PoolStateMap> | null> {
     // Get all latest pools from API
-    const apiPoolStateMap = await getPoolsApi(
-      this.network,
-      this.hooksConfigMap,
-    );
+    const apiPoolStateMap = await getPoolsApi(this.network);
 
     // Filter out pools that already exist in existing state
     const newApiPools = Object.entries(apiPoolStateMap).reduce(
@@ -202,10 +186,19 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
       this.interfaces,
     );
 
+    // Filter out pools with hooks and paused pools from new state
+    // TODO this won't be necessary once API has this filter option
+    const filteredNewPools = Object.entries(newOnChainPools)
+      .filter(([_, pool]) => !(pool.hasHook || pool.isPoolPaused))
+      .reduce((acc, [address, pool]) => {
+        acc[address] = pool;
+        return acc;
+      }, {} as PoolStateMap);
+
     // Merge existing pools with new pools
     return {
       ...existingPoolState,
-      ...newOnChainPools,
+      ...filteredNewPools,
     };
   }
 
@@ -225,12 +218,10 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
       i < newState[poolAddress].balancesLiveScaled18.length;
       i++
     ) {
-      newState[poolAddress].balancesLiveScaled18[i] +=
-        this.toScaled18ApplyRateRoundDown(
-          BigInt(event.args.amountsAddedRaw[i]),
-          newState[poolAddress].scalingFactors[i],
-          newState[poolAddress].tokenRates[i] || WAD,
-        );
+      newState[poolAddress].balancesLiveScaled18[i] += this.toScaled18(
+        BigInt(event.args.amountsAddedRaw[i]),
+        newState[poolAddress].scalingFactors[i],
+      );
     }
     newState[poolAddress].totalSupply = BigInt(event.args.totalSupply);
 
@@ -253,12 +244,10 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
       i < newState[poolAddress].balancesLiveScaled18.length;
       i++
     ) {
-      newState[poolAddress].balancesLiveScaled18[i] -=
-        this.toScaled18ApplyRateRoundDown(
-          BigInt(event.args.amountsRemovedRaw[i]),
-          newState[poolAddress].scalingFactors[i],
-          newState[poolAddress].tokenRates[i] || WAD,
-        );
+      newState[poolAddress].balancesLiveScaled18[i] -= this.toScaled18(
+        BigInt(event.args.amountsRemovedRaw[i]),
+        newState[poolAddress].scalingFactors[i],
+      );
     }
     newState[poolAddress].totalSupply = BigInt(event.args.totalSupply);
 
@@ -286,17 +275,14 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
       this.logger.error(`swapEvent - token index not found in pool state`);
       return null;
     }
-    newState[poolAddress].balancesLiveScaled18[tokenInIndex] +=
-      this.toScaled18ApplyRateRoundDown(
-        BigInt(event.args.amountIn),
-        newState[poolAddress].scalingFactors[tokenInIndex],
-        newState[poolAddress].tokenRates[tokenInIndex] || WAD,
-      );
+    newState[poolAddress].balancesLiveScaled18[tokenInIndex] += this.toScaled18(
+      BigInt(event.args.amountIn),
+      newState[poolAddress].scalingFactors[tokenInIndex],
+    );
     newState[poolAddress].balancesLiveScaled18[tokenOutIndex] -=
-      this.toScaled18ApplyRateRoundDown(
+      this.toScaled18(
         BigInt(event.args.amountOut),
         newState[poolAddress].scalingFactors[tokenOutIndex],
-        newState[poolAddress].tokenRates[tokenOutIndex] || WAD,
       );
 
     return newState;
@@ -405,7 +391,6 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
     amountRaw: bigint,
     swapKind: SwapKind,
     timestamp: number,
-    hookStateMap: HookStateMap,
   ): bigint {
     if (amountRaw === 0n) return 0n;
 
@@ -419,19 +404,6 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
     let outputAmountRaw = 0n;
     for (const i of indices) {
       const step = steps[i];
-
-      // If the pool has a hook we fetch latest hook state for use in maths
-      let hookState = undefined;
-      if ('hookAddress' in step.poolState && step.poolState.hookAddress) {
-        hookState = hookStateMap[step.poolState.hookAddress];
-        if (!hookState) {
-          this.logger.error(
-            `getSwapResult hookState not found ${step.poolState.hookAddress}`,
-          );
-          return 0n;
-        }
-      }
-
       // If its a Stable Pool with an updating Amp factor calculate current Amp value
       if (
         step.poolState.poolType === 'STABLE' &&
@@ -446,24 +418,7 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
             BigInt(timestamp),
           );
         }
-        // StableSurge hook uses Amp as part of maths
-        if (step.poolState.hookType === StableSurge.type && hookState) {
-          const poolHookState = (hookState as StableSurgeHookState)[
-            step.poolState.poolAddress.toLowerCase()
-          ];
-          if (!poolHookState) {
-            this.logger.error(
-              `getSwapResult StableSurge hookState not found ${step.poolState.hookAddress}`,
-            );
-            return 0n;
-          }
-          hookState = {
-            ...poolHookState,
-            amp: step.poolState.amp,
-          };
-        }
       }
-
       outputAmountRaw = this.vault.swap(
         {
           ...step.swapInput,
@@ -471,7 +426,6 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
           swapKind,
         },
         step.poolState,
-        hookState,
       );
       // Next step uses output from previous step as input
       amount = outputAmountRaw;
@@ -743,19 +697,6 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
   }
 
   toScaled18(amount: bigint, scalingFactor: bigint): bigint {
-    // (amount * scalingFactor).mulUp(tokenRate);
     return (amount * scalingFactor * WAD) / WAD;
   }
-
-  toScaled18ApplyRateRoundDown(
-    amount: bigint,
-    scalingFactor: bigint,
-    tokenRate: bigint,
-  ): bigint {
-    return this.mulDown(amount * scalingFactor, tokenRate);
-  }
-
-  mulDown(a: bigint, b: bigint): bigint {
-    return (a * b) / WAD;
-  }
 }

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

@@ -27,13 +27,11 @@ import balancerRouterAbi from '../../abi/balancer-v3/router.json';
 import balancerBatchRouterAbi from '../../abi/balancer-v3/batch-router.json';
 import { getGasCost } from './getGasCost';
 import { Block } from '@ethersproject/abstract-provider';
-import { BalancerEventHook } from './hooks/balancer-hook-event-subscriber';
 
 const MAX_UINT256 =
   '115792089237316195423570985008687907853269984665640564039457584007913129639935';
-const POOL_UPDATE_TTL = 1 * 60; // 1min
+const POOL_UPDATE_TTL = 5 * 60; // 5mins
 const RATE_UPDATE_TTL = 1 * 60; // 1min
-const HOOK_UPDATE_TTL = 5 * 60; // 5min
 
 type DeepMutable<T> = {
   -readonly [P in keyof T]: T[P] extends object ? DeepMutable<T[P]> : T[P];
@@ -41,7 +39,6 @@ type DeepMutable<T> = {
 
 export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
   protected eventPools: BalancerV3EventPool;
-  protected eventHooks: BalancerEventHook;
 
   readonly hasConstantPriceLargeAmounts = false;
   // Vault can handle native
@@ -57,7 +54,6 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
   balancerBatchRouter: Interface;
   updateNewPoolsTimer?: NodeJS.Timeout;
   updateRatesTimer?: NodeJS.Timeout;
-  updateHooksTimer?: NodeJS.Timeout;
 
   latestBlock?: Block;
 
@@ -68,12 +64,6 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
   ) {
     super(dexHelper, dexKey);
     this.logger = dexHelper.getLogger(dexKey);
-    this.eventHooks = new BalancerEventHook(
-      dexKey,
-      network,
-      dexHelper,
-      this.logger,
-    );
     this.eventPools = new BalancerV3EventPool(
       dexKey,
       network,
@@ -89,8 +79,6 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
   // for pricing requests. It is optional for a DEX to
   // implement this function
   async initializePricing(blockNumber: number) {
-    await this.eventHooks.initialize(blockNumber);
-    this.eventPools.setHooksConfigMap(this.eventHooks.hooksConfigMap);
     await this.eventPools.initialize(blockNumber);
 
     // This will periodically query API and add any new pools to pool state
@@ -114,17 +102,6 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
         }
       }, RATE_UPDATE_TTL * 1000);
     }
-
-    // This will periodically update any hook state that can't be tracked by events
-    if (!this.updateHooksTimer) {
-      this.updateHooksTimer = setInterval(async () => {
-        try {
-          await this.updateHooksState();
-        } catch (e) {
-          this.logger.error(`${this.dexKey}: Failed to update hook state:`, e);
-        }
-      }, HOOK_UPDATE_TTL * 1000);
-    }
   }
 
   getAdapters(side: SwapSide): null {
@@ -284,7 +261,6 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
               unitAmount,
               swapKind,
               block.timestamp,
-              this.eventHooks.getState(blockNumber) || {},
             );
 
           const poolExchangePrice: PoolPrices<BalancerV3Data> = {
@@ -307,7 +283,6 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
                 amounts[j],
                 swapKind,
                 block.timestamp,
-                this.eventHooks.getState(blockNumber) || {},
               );
             }
           }
@@ -584,10 +559,6 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
     await this.eventPools.updateStatePools();
   }
 
-  async updateHooksState(): Promise<void> {
-    await this.eventHooks.updateHookState();
-  }
-
   // Returns list of top pools based on liquidity. Max
   // limit number pools should be returned.
   async getTopPoolsForToken(
@@ -600,12 +571,7 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
       })
       .map(([address]) => address);
 
-    const topPools = await getTopPoolsApi(
-      this.network,
-      poolsWithToken,
-      count,
-      this.eventHooks.hooksConfigMap,
-    );
+    const topPools = await getTopPoolsApi(this.network, poolsWithToken, count);
 
     return topPools.map(pool => {
       const tokens = pool.poolTokens
@@ -644,12 +610,5 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
         `${this.dexKey}: cleared updateRatesTimer before shutting down`,
       );
     }
-    if (this.updateHooksTimer) {
-      clearInterval(this.updateHooksTimer);
-      this.updateHooksTimer = undefined;
-      this.logger.info(
-        `${this.dexKey}: cleared updateHooksTimer before shutting down`,
-      );
-    }
   }
 }