@paraswap/dex-lib 4.1.4-bal-v3-hooks.0 → 4.1.4

package/scripts/run-dex-integration-v3.ts

@@ -48,10 +48,10 @@ async function main() {
 
   await balancerV3.initializePricing(blocknumber);
 
-  // const from = stataUSDC;
-  // const to = stataUSDT;
-  const from = usdcAave;
-  const to = daiAave;
+  const from = stataUSDC;
+  const to = stataUSDT;
+  // const from = daiAave;
+  // const to = usdcAave;
 
   const pools = await balancerV3.getPoolIdentifiers(
     from,

package/src/abi/fluid-dex/resolver.abi.json

@@ -201,6 +201,11 @@
             "name": "fee",
             "type": "uint256"
           },
+          {
+            "internalType": "uint256",
+            "name": "centerPrice",
+            "type": "uint256"
+          },
           {
             "components": [
               {
@@ -395,6 +400,11 @@
             "name": "fee",
             "type": "uint256"
           },
+          {
+            "internalType": "uint256",
+            "name": "centerPrice",
+            "type": "uint256"
+          },
           {
             "components": [
               {
@@ -1192,6 +1202,11 @@
             "name": "fee",
             "type": "uint256"
           },
+          {
+            "internalType": "uint256",
+            "name": "centerPrice",
+            "type": "uint256"
+          },
           {
             "components": [
               {
@@ -1392,6 +1407,11 @@
             "name": "fee",
             "type": "uint256"
           },
+          {
+            "internalType": "uint256",
+            "name": "centerPrice",
+            "type": "uint256"
+          },
           {
             "components": [
               {
@@ -1616,6 +1636,11 @@
             "name": "fee",
             "type": "uint256"
           },
+          {
+            "internalType": "uint256",
+            "name": "centerPrice",
+            "type": "uint256"
+          },
           {
             "components": [
               {
@@ -1816,6 +1841,11 @@
             "name": "fee",
             "type": "uint256"
           },
+          {
+            "internalType": "uint256",
+            "name": "centerPrice",
+            "type": "uint256"
+          },
           {
             "components": [
               {

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

@@ -385,26 +385,6 @@ describe('BalancerV3 E2E', () => {
       );
     });
 
-    describe('StableSurge Hook', () => {
-      const tokenASymbol: string = 'waBasGHO';
-      const tokenBSymbol: string = 'waBasUSDC';
-
-      const tokenAAmount: string = '500000000000000000';
-      const tokenBAmount: string = '500000';
-      const nativeTokenAmount = '0';
-
-      testForNetwork(
-        network,
-        dexKey,
-        tokenASymbol,
-        tokenBSymbol,
-        tokenAAmount,
-        tokenBAmount,
-        nativeTokenAmount,
-        false,
-      );
-    });
-
     // No holders for waBasWETH
     // describe('Boosted Path', () => {
     //   const tokenASymbol: string = 'waBaswstETH';

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,

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,
     };
   }
 
@@ -405,7 +398,6 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
     amountRaw: bigint,
     swapKind: SwapKind,
     timestamp: number,
-    hookStateMap: HookStateMap,
   ): bigint {
     if (amountRaw === 0n) return 0n;
 
@@ -419,12 +411,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 its a Stable Pool with an updating Amp factor calculate current Amp value
       if (
         step.poolState.poolType === 'STABLE' &&
@@ -439,16 +425,7 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
             BigInt(timestamp),
           );
         }
-        // StableSurge hook uses Amp as part of maths
-        if (step.poolState.hookType === StableSurge.type && hookState)
-          hookState = {
-            ...(hookState as StableSurgeHookState)[
-              step.poolState.poolAddress.toLowerCase()
-            ],
-            amp: step.poolState.amp,
-          };
       }
-
       outputAmountRaw = this.vault.swap(
         {
           ...step.swapInput,
@@ -456,7 +433,6 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
           swapKind,
         },
         step.poolState,
-        hookState,
       );
       // Next step uses output from previous step as input
       amount = outputAmountRaw;

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 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`,
-      );
-    }
   }
 }

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

@@ -25,69 +25,30 @@ export const BalancerV3Config: DexConfigMap<DexParams> = {
       apiNetworkName: 'SEPOLIA',
       balancerRouterAddress: '0x0BF61f706105EA44694f2e92986bD01C39930280',
       balancerBatchRouterAddress: '0xC85b652685567C1B074e8c0D4389f83a2E458b1C',
-      hooks: [
-        {
-          type: 'DirectionalFee',
-          address: '0xd68372e85d8a14afa5fdb3d506bf765939aaf382',
-        },
-        {
-          type: 'StableSurge',
-          factory: '0x9eB9867C1d4B6fd3a7D0dAd3101b5A153b1107Ec', // Pools with StableSurge hook will always be deployed from this factory
-          address: '0xc0cbcdd6b823a4f22aa6bbdde44c17e754266aef', // Address of the hook that will be used by pools
-        },
-      ],
     },
     [Network.GNOSIS]: {
       vaultAddress: '0xbA1333333333a1BA1108E8412f11850A5C319bA9',
       apiNetworkName: 'GNOSIS',
       balancerRouterAddress: '0x84813aA3e079A665C0B80F944427eE83cBA63617',
       balancerBatchRouterAddress: '0xe2fa4e1d17725e72dcdAfe943Ecf45dF4B9E285b',
-      hooks: [
-        {
-          type: 'StableSurge',
-          factory: '0x268E2EE1413D768b6e2dc3F5a4ddc9Ae03d9AF42', // Pools with StableSurge hook will always be deployed from this factory
-          address: '0xe4f1878eC9710846E2B529C1b5037F8bA94583b1', // Address of the hook that will be used by pools
-        },
-      ],
     },
     [Network.MAINNET]: {
       vaultAddress: '0xbA1333333333a1BA1108E8412f11850A5C319bA9',
       apiNetworkName: 'MAINNET',
       balancerRouterAddress: '0x5C6fb490BDFD3246EB0bB062c168DeCAF4bD9FDd',
       balancerBatchRouterAddress: '0x136f1EFcC3f8f88516B9E94110D56FDBfB1778d1',
-      hooks: [
-        {
-          type: 'StableSurge',
-          factory: '0xD53F5d8d926fb2a0f7Be614B16e649B8aC102D83', // Pools with StableSurge hook will always be deployed from this factory
-          address: '0xb18fA0cb5DE8cecB8899AAE6e38b1B7ed77885dA', // Address of the hook that will be used by pools
-        },
-      ],
     },
     [Network.ARBITRUM]: {
       vaultAddress: '0xbA1333333333a1BA1108E8412f11850A5C319bA9',
       apiNetworkName: 'ARBITRUM',
       balancerRouterAddress: '0x0f08eEf2C785AA5e7539684aF04755dEC1347b7c',
       balancerBatchRouterAddress: '0xaD89051bEd8d96f045E8912aE1672c6C0bF8a85E',
-      hooks: [
-        {
-          type: 'StableSurge',
-          factory: '0x86e67E115f96DF37239E0479441303De0de7bc2b', // Pools with StableSurge hook will always be deployed from this factory
-          address: '0x0Fa0f9990D7969a7aE6f9961d663E4A201Ed6417', // Address of the hook that will be used by pools
-        },
-      ],
     },
     [Network.BASE]: {
       vaultAddress: '0xbA1333333333a1BA1108E8412f11850A5C319bA9',
       apiNetworkName: 'BASE',
       balancerRouterAddress: '0x76578ecf9a141296Ec657847fb45B0585bCDa3a6',
       balancerBatchRouterAddress: '0x85a80afee867aDf27B50BdB7b76DA70f1E853062',
-      hooks: [
-        {
-          type: 'StableSurge',
-          factory: '0x4fb47126Fa83A8734991E41B942Ac29A3266C968', // Pools with StableSurge hook will always be deployed from this factory
-          address: '0xb2007B8B7E0260042517f635CFd8E6dD2Dd7f007', // Address of the hook that will be used by pools
-        },
-      ],
     },
   },
 };

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

@@ -10,7 +10,7 @@ import { Interface, Result } from '@ethersproject/abi';
 import { IDexHelper } from '../../dex-helper';
 import { WAD } from './balancer-v3-pool';
 
-export interface callData {
+interface callData {
   target: string;
   callData: string;
 }
@@ -161,6 +161,9 @@ const poolOnChain: Record<
           (r: string) => BigInt(r),
         ),
         isPoolPaused: resultIsPoolPaused[0],
+        hasHook:
+          resultHooksConfig[0].hooksContract !==
+          '0x0000000000000000000000000000000000000000',
       };
     },
   },