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

package/src/dex/balancer-v3/balancer-hooks-events.test.ts

@@ -0,0 +1,99 @@
+// npx jest src/dex/balancer-v3/balancer-hooks-events.test.ts
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+import _ from 'lodash';
+import { Network } from '../../constants';
+import { Address } from '../../types';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { testEventSubscriber } from '../../../tests/utils-events';
+import {
+  BalancerEventHook,
+  HookStateMap,
+} from './hooks/balancer-hook-event-subscriber';
+
+jest.setTimeout(50 * 1000);
+
+async function fetchHookState(
+  balancerEventHook: BalancerEventHook,
+  blockNumber: number,
+  hookAddress: string,
+): Promise<HookStateMap> {
+  const hookStateMap = await balancerEventHook.generateState(blockNumber);
+  // Filter to hook of interest
+  return Object.entries(_.cloneDeep(hookStateMap) as HookStateMap)
+    .filter(([address]) => {
+      return address.toLowerCase() === hookAddress.toLowerCase();
+    })
+    .reduce((acc, [address, pool]) => {
+      acc[address] = pool;
+      return acc;
+    }, {} as HookStateMap);
+}
+
+// eventName -> blockNumbers
+type EventMappings = Record<string, EventData>;
+type EventData = { blockNumbers: number[]; hookAddress: string[] };
+
+describe('BalancerEventHook', function () {
+  const dexKey = 'BalancerV3';
+  const network = Network.SEPOLIA;
+  const dexHelper = new DummyDexHelper(network);
+  const logger = dexHelper.getLogger(dexKey);
+  let balancerEventHook: BalancerEventHook;
+
+  // hook -> EventMappings
+  const eventsToTest: Record<Address, EventMappings> = {
+    ['StableSurgeHook']: {
+      // https://sepolia.etherscan.io/tx/0xa8d363d9c78b7b66e6f93c4417de67e636c13691437aecf85a631987b200abd8
+      ThresholdSurgePercentageChanged: {
+        blockNumbers: [7596856],
+        hookAddress: ['0xC0cbcdD6b823A4f22aA6BbDDe44C17e754266AEF'],
+      },
+      // https://sepolia.etherscan.io/tx/0xd1a9e40ed3c3d32bf8f2264daa4c66879ac5eae1f4029ae9993badd653b26bad
+      MaxSurgeFeePercentageChanged: {
+        blockNumbers: [7596855],
+        hookAddress: ['0xC0cbcdD6b823A4f22aA6BbDDe44C17e754266AEF'],
+      },
+    },
+  };
+
+  beforeEach(async () => {
+    balancerEventHook = new BalancerEventHook(
+      dexKey,
+      network,
+      dexHelper,
+      logger,
+    );
+  });
+
+  Object.entries(eventsToTest).forEach(
+    ([hookAddress, events]: [string, EventMappings]) => {
+      describe(`Events for Hook: ${hookAddress}`, () => {
+        Object.entries(events).forEach(
+          ([eventName, eventData]: [string, EventData]) => {
+            describe(`${eventName}`, () => {
+              eventData.blockNumbers.forEach((blockNumber: number, i) => {
+                it(`Hook: ${eventData.hookAddress[i]} State after ${blockNumber}`, async function () {
+                  await testEventSubscriber(
+                    balancerEventHook,
+                    balancerEventHook.addressesSubscribed,
+                    (_blockNumber: number) =>
+                      fetchHookState(
+                        balancerEventHook,
+                        _blockNumber,
+                        eventData.hookAddress[i],
+                      ),
+                    blockNumber,
+                    `${dexKey}_${hookAddress}`,
+                    dexHelper.provider,
+                  );
+                });
+              });
+            });
+          },
+        );
+      });
+    },
+  );
+});

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

@@ -0,0 +1,110 @@
+// npx jest src/dex/balancer-v3/balancer-stableSurge.test.ts
+import dotenv from 'dotenv';
+dotenv.config();
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { DummyDexHelper } from '../../dex-helper';
+import { BalancerV3 } from './balancer-v3';
+import { checkOnChainPricingNonMulti } from './balancer-test-helpers';
+import { ExchangePrices, Token } from '../../types';
+import { BalancerV3Data } from './types';
+
+const dexKey = 'BalancerV3';
+const blockNumber = 7651340;
+let balancerV3: BalancerV3;
+const network = Network.SEPOLIA;
+const dexHelper = new DummyDexHelper(network);
+const tokens = Tokens[network];
+const bal = tokens['bal'];
+const weth = tokens['WETH'];
+// https://sepolia.etherscan.io/address/0x132F4bAa39330d9062fC52d81dF72F601DF8C01f
+const stableSurgePool =
+  '0x132F4bAa39330d9062fC52d81dF72F601DF8C01f'.toLowerCase();
+
+describe('BalancerV3 stableSurge hook tests', function () {
+  beforeAll(async () => {
+    balancerV3 = new BalancerV3(network, dexKey, dexHelper);
+    if (balancerV3.initializePricing) {
+      await balancerV3.initializePricing(blockNumber);
+    }
+  });
+
+  describe('pool with stableSurge hook should be returned', function () {
+    it('getPoolIdentifiers', async function () {
+      const pools = await balancerV3.getPoolIdentifiers(
+        bal,
+        weth,
+        SwapSide.SELL,
+        blockNumber,
+      );
+      expect(pools.some(pool => pool === stableSurgePool)).toBe(true);
+    });
+
+    it('getTopPoolsForToken', async function () {
+      const pools = await balancerV3.getTopPoolsForToken(weth.address, 10);
+      expect(pools.some(pool => pool.address === stableSurgePool)).toBe(true);
+    });
+  });
+
+  describe('should match onchain pricing', function () {
+    describe('using staticFee', function () {
+      it('SELL', async function () {
+        const amounts = [0n, 10000000000000000n];
+        const side = SwapSide.SELL;
+        await testPricesVsOnchain(amounts, weth, bal, side, blockNumber, [
+          stableSurgePool,
+        ]);
+      });
+      it('BUY', async function () {
+        const amounts = [0n, 500000000000000000n];
+        const side = SwapSide.BUY;
+        await testPricesVsOnchain(amounts, weth, bal, side, blockNumber, [
+          stableSurgePool,
+        ]);
+      });
+    });
+    describe('using surge fee', function () {
+      it('SELL', async function () {
+        const amounts = [0n, 8000000000000000000n];
+        const side = SwapSide.SELL;
+        await testPricesVsOnchain(amounts, bal, weth, side, blockNumber, [
+          stableSurgePool,
+        ]);
+      });
+      it('BUY', async function () {
+        const amounts = [0n, 4000000000000000n];
+        const side = SwapSide.BUY;
+        await testPricesVsOnchain(amounts, bal, weth, side, blockNumber, [
+          stableSurgePool,
+        ]);
+      });
+    });
+  });
+});
+
+async function testPricesVsOnchain(
+  amounts: bigint[],
+  srcToken: Token,
+  dstToken: Token,
+  side: SwapSide,
+  blockNumber: number,
+  limitPools: string[],
+) {
+  const prices = await balancerV3.getPricesVolume(
+    srcToken,
+    dstToken,
+    amounts,
+    side,
+    blockNumber,
+    limitPools,
+  );
+  expect(prices).not.toBeNull();
+  await checkOnChainPricingNonMulti(
+    network,
+    side,
+    balancerV3,
+    blockNumber,
+    prices as ExchangePrices<BalancerV3Data>,
+    amounts,
+  );
+}

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

@@ -0,0 +1,199 @@
+/* eslint-disable no-console */
+// Note - this is currently needed because queries won't work with multicall but should be updated in future
+export 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 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;
+}
+
+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',
+          ],
+        ),
+      };
+    });
+}
+/* eslint-disable no-console */
+import { Interface } from '@ethersproject/abi';
+import { NULL_ADDRESS, SwapSide } from '../../constants';
+import { BalancerV3 } from './balancer-v3';
+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 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'],
+        ),
+      };
+    });
+}

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

@@ -385,6 +385,26 @@ 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 { Interface, Result } from '@ethersproject/abi';
+import { checkOnChainPricingNonMulti } from './balancer-test-helpers';
 import { DummyDexHelper } from '../../dex-helper/index';
-import { Network, NULL_ADDRESS, SwapSide } from '../../constants';
+import { Network, SwapSide } from '../../constants';
 import { BI_POWS } from '../../bigint-constants';
 import { BalancerV3 } from './balancer-v3';
 import {
@@ -13,201 +13,6 @@ 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,