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

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

@@ -29,6 +29,11 @@ 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];
 
@@ -48,8 +53,8 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
   interfaces: {
     [name: string]: Interface;
   };
-
   vault: Vault;
+  hooksConfigMap: HooksConfigMap = {};
 
   constructor(
     readonly parentName: string,
@@ -96,6 +101,10 @@ 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
@@ -134,7 +143,11 @@ 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, block.timestamp);
+    const apiPoolStateMap = await getPoolsApi(
+      this.network,
+      this.hooksConfigMap,
+      block.timestamp,
+    );
     const allOnChainPools = await getOnChainState(
       this.network,
       apiPoolStateMap,
@@ -160,7 +173,10 @@ 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);
+    const apiPoolStateMap = await getPoolsApi(
+      this.network,
+      this.hooksConfigMap,
+    );
 
     // Filter out pools that already exist in existing state
     const newApiPools = Object.entries(apiPoolStateMap).reduce(
@@ -186,19 +202,10 @@ 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,
-      ...filteredNewPools,
+      ...newOnChainPools,
     };
   }
 
@@ -398,6 +405,7 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
     amountRaw: bigint,
     swapKind: SwapKind,
     timestamp: number,
+    hookStateMap: HookStateMap,
   ): bigint {
     if (amountRaw === 0n) return 0n;
 
@@ -411,6 +419,12 @@ 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' &&
@@ -425,7 +439,16 @@ 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,
@@ -433,6 +456,7 @@ 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,11 +27,13 @@ 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];
@@ -39,6 +41,7 @@ type DeepMutable<T> = {
 
 export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
   protected eventPools: BalancerV3EventPool;
+  protected eventHooks: BalancerEventHook;
 
   readonly hasConstantPriceLargeAmounts = false;
   // Vault can handle native
@@ -54,6 +57,7 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
   balancerBatchRouter: Interface;
   updateNewPoolsTimer?: NodeJS.Timeout;
   updateRatesTimer?: NodeJS.Timeout;
+  updateHooksTimer?: NodeJS.Timeout;
 
   latestBlock?: Block;
 
@@ -64,6 +68,12 @@ 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,
@@ -79,6 +89,8 @@ 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
@@ -102,6 +114,17 @@ 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 {
@@ -261,6 +284,7 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
               unitAmount,
               swapKind,
               block.timestamp,
+              this.eventHooks.getState(blockNumber) || {},
             );
 
           const poolExchangePrice: PoolPrices<BalancerV3Data> = {
@@ -283,6 +307,7 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
                 amounts[j],
                 swapKind,
                 block.timestamp,
+                this.eventHooks.getState(blockNumber) || {},
               );
             }
           }
@@ -559,6 +584,10 @@ 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(
@@ -571,7 +600,12 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
       })
       .map(([address]) => address);
 
-    const topPools = await getTopPoolsApi(this.network, poolsWithToken, count);
+    const topPools = await getTopPoolsApi(
+      this.network,
+      poolsWithToken,
+      count,
+      this.eventHooks.hooksConfigMap,
+    );
 
     return topPools.map(pool => {
       const tokens = pool.poolTokens
@@ -610,5 +644,12 @@ 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,30 +25,69 @@ 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';
 
-interface callData {
+export interface callData {
   target: string;
   callData: string;
 }
@@ -161,9 +161,6 @@ const poolOnChain: Record<
           (r: string) => BigInt(r),
         ),
         isPoolPaused: resultIsPoolPaused[0],
-        hasHook:
-          resultHooksConfig[0].hooksContract !==
-          '0x0000000000000000000000000000000000000000',
       };
     },
   },

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

@@ -7,6 +7,7 @@ import {
 } from './config';
 import { CommonImmutablePoolState, ImmutablePoolStateMap } from './types';
 import { parseUnits } from 'ethers/lib/utils';
+import { HooksConfigMap } from './hooks/balancer-hook-event-subscriber';
 
 interface PoolToken {
   address: string;
@@ -21,6 +22,9 @@ interface Pool {
   id: string;
   type: string;
   poolTokens: PoolToken[];
+  hook: {
+    address: string;
+  } | null;
 }
 
 interface QueryResponse {
@@ -44,7 +48,6 @@ function createQuery(
   const whereClause = {
     chainIn: networkString,
     protocolVersionIn: 3,
-    hasHook: false,
     poolTypeIn: `[${poolTypesString}]`,
     ...(timestamp && { createTime: `{lt: ${timestamp}}` }),
     ...(disabledPoolIdsString && { idNotIn: `[${disabledPoolIdsString}]` }),
@@ -69,37 +72,53 @@ function createQuery(
             address
           }
         }
+        hook {
+          address
+        }
       }
     }
   `;
 }
 
-function toImmutablePoolStateMap(pools: Pool[]): ImmutablePoolStateMap {
-  return pools.reduce((map, pool) => {
-    const immutablePoolState: CommonImmutablePoolState = {
-      poolAddress: pool.id,
-      tokens: pool.poolTokens.map(t => t.address),
-      tokensUnderlying: pool.poolTokens.map(t =>
-        t.underlyingToken ? t.underlyingToken.address : null,
-      ),
-      weights: pool.poolTokens.map(t =>
-        t.weight ? parseUnits(t.weight, 18).toBigInt() : 0n,
-      ),
-      poolType: pool.type,
-      // TODO add scalingFactors once API provides them
-      // scalingFactors: pool.poolTokens.map(t => parseUnits('1', 18).toBigInt()),
-      // TODO Hook support will be added in future PR
-      hookType: undefined,
-    };
-
-    map[pool.id] = immutablePoolState;
-    return map;
-  }, {} as ImmutablePoolStateMap);
+function toImmutablePoolStateMap(
+  pools: Pool[],
+  hooksConfigMap: HooksConfigMap,
+): ImmutablePoolStateMap {
+  return (
+    pools
+      // First filter out pools with hooks that aren't in hooksMap
+      .filter(
+        pool =>
+          !pool.hook ||
+          (pool.hook && pool.hook.address.toLowerCase() in hooksConfigMap),
+      )
+      .reduce((map, pool) => {
+        const immutablePoolState: CommonImmutablePoolState = {
+          poolAddress: pool.id,
+          tokens: pool.poolTokens.map(t => t.address),
+          tokensUnderlying: pool.poolTokens.map(t =>
+            t.underlyingToken ? t.underlyingToken.address : null,
+          ),
+          weights: pool.poolTokens.map(t =>
+            t.weight ? parseUnits(t.weight, 18).toBigInt() : 0n,
+          ),
+          poolType: pool.type,
+          hookAddress: pool.hook ? pool.hook.address.toLowerCase() : undefined,
+          hookType: pool.hook
+            ? hooksConfigMap[pool.hook.address.toLowerCase()].type
+            : undefined,
+          supportsUnbalancedLiquidity: true,
+        };
+        map[pool.id] = immutablePoolState;
+        return map;
+      }, {} as ImmutablePoolStateMap)
+  );
 }
 
 // Any data from API will be immutable. Mutable data such as balances, etc will be fetched via onchain/event state.
 export async function getPoolsApi(
   network: number,
+  hooksConfigMap: HooksConfigMap,
   timestamp?: number,
 ): Promise<ImmutablePoolStateMap> {
   try {
@@ -121,7 +140,7 @@ export async function getPoolsApi(
     );
 
     const pools = response.data.data.poolGetAggregatorPools;
-    return toImmutablePoolStateMap(pools);
+    return toImmutablePoolStateMap(pools, hooksConfigMap);
   } catch (error) {
     // console.error('Error executing GraphQL query:', error);
     throw error;

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

@@ -1,5 +1,6 @@
 import axios from 'axios';
 import { apiUrl, BalancerV3Config, disabledPoolIds } from './config';
+import { HooksConfigMap } from './hooks/balancer-hook-event-subscriber';
 
 interface PoolToken {
   address: string;
@@ -16,6 +17,9 @@ export interface Pool {
   dynamicData: {
     totalLiquidity: string;
   };
+  hook: {
+    address: string;
+  } | null;
 }
 
 interface QueryResponse {
@@ -39,7 +43,6 @@ function createQuery(
   const whereClause = {
     chainIn: networkString,
     protocolVersionIn: 3,
-    hasHook: false,
     idIn: `[${poolIdString}]`,
     ...(disabledPoolIdsString && { idNotIn: `[${disabledPoolIdsString}]` }),
   };
@@ -68,6 +71,9 @@ function createQuery(
         dynamicData {
           totalLiquidity
         }
+        hook {
+          address
+        }
       }
     }
   `;
@@ -77,6 +83,7 @@ export async function getTopPoolsApi(
   networkId: number,
   poolsFilter: string[],
   count: number,
+  hooksTypeMap: HooksConfigMap,
 ): Promise<Pool[]> {
   try {
     const query = createQuery(networkId, poolsFilter, count);
@@ -92,7 +99,11 @@ export async function getTopPoolsApi(
       },
     );
 
-    const pools = response.data.data.poolGetAggregatorPools;
+    const pools = response.data.data.poolGetAggregatorPools.filter(
+      pool =>
+        !pool.hook ||
+        (pool.hook && pool.hook.address.toLowerCase() in hooksTypeMap),
+    );
     return pools;
   } catch (error) {
     // console.error('Error executing GraphQL query:', error);