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

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

@@ -1,99 +0,0 @@
-// 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

@@ -1,110 +0,0 @@
-// 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

@@ -1,199 +0,0 @@
-/* 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/hooks/balancer-hook-event-subscriber.ts

@@ -1,226 +0,0 @@
-import {
-  EventFragment,
-  Fragment,
-  FunctionFragment,
-  Interface,
-} from '@ethersproject/abi';
-import _ from 'lodash';
-import { DeepReadonly } from 'ts-essentials';
-import { Log, Logger } from '../../../types';
-import { catchParseLogError } from '../../../utils';
-import { StatefulEventSubscriber } from '../../../stateful-event-subscriber';
-import { IDexHelper } from '../../../dex-helper/idex-helper';
-import { loadHooksConfig } from './loadHooksConfig';
-import {
-  DirectionalFee,
-  DirectionalFeeConfig,
-  DirectionalFeeHookState,
-  getDirectionalFeeHookState,
-} from './directionalFeeHook';
-import exitFeeHookAbi from '../../../abi/balancer-v3/directionalFeeHook.json';
-import {
-  getStableSurgeHookState,
-  maxSurgeFeePercentageChangedEvent,
-  StableSurge,
-  StableSurgeConfig,
-  StableSurgeHookState,
-  thresholdSurgePercentageChangedEvent,
-} from './stableSurgeHook';
-import stableSurgeHookAbi from '../../../abi/balancer-v3/stableSurgeHook.json';
-
-// Add each supported hook state here
-export type HookState = DirectionalFeeHookState | StableSurgeHookState;
-
-export type HookStateMap = {
-  [address: string]: HookState;
-};
-
-export type HookConfig = DirectionalFeeConfig | StableSurgeConfig;
-
-export type HooksConfigMap = {
-  [hookAddress: string]: HookConfig;
-};
-
-/**
- * This will handle events/state for each supported hook contract. State is used during swap calculations.
- * Each hook should have its own implementation file for state typing, fetching state and handling events.
- */
-export class BalancerEventHook extends StatefulEventSubscriber<HookStateMap> {
-  handlers: {
-    [event: string]: (
-      event: any,
-      state: DeepReadonly<HookStateMap>,
-      log: Readonly<Log>,
-    ) => DeepReadonly<HookStateMap> | null;
-  } = {};
-
-  interfaces: Interface[];
-  logDecoder: (log: Log) => any;
-
-  addressesSubscribed: string[];
-
-  hooksConfigMap: HooksConfigMap;
-
-  constructor(
-    readonly parentName: string,
-    protected network: number,
-    protected dexHelper: IDexHelper,
-    logger: Logger,
-  ) {
-    super(parentName, 'Balancer_Hooks', dexHelper, logger);
-
-    // Load supported hooks from config file
-    this.hooksConfigMap = loadHooksConfig(network);
-
-    // Add each hook ABI here
-    this.interfaces = [
-      new Interface(exitFeeHookAbi),
-      new Interface(stableSurgeHookAbi),
-    ];
-    this.logDecoder = (log: Log) =>
-      this.combineInterfaces(this.interfaces).parseLog(log);
-
-    // Subscribe to all hooks
-    this.addressesSubscribed = Object.keys(this.hooksConfigMap);
-
-    // StableSurgeHook events
-    this.handlers['ThresholdSurgePercentageChanged'] =
-      thresholdSurgePercentageChangedEvent.bind(this);
-    this.handlers['MaxSurgeFeePercentageChanged'] =
-      maxSurgeFeePercentageChangedEvent.bind(this);
-  }
-
-  /**
-   * The function is called every time any of the subscribed
-   * addresses release log. The function accepts the current
-   * state, updates the state according to the log, and returns
-   * the updated state.
-   * @param state - Current state of event subscriber
-   * @param log - Log released by one of the subscribed addresses
-   * @returns Updates state of the event subscriber after the log
-   */
-  protected processLog(
-    state: DeepReadonly<HookStateMap>,
-    log: Readonly<Log>,
-  ): DeepReadonly<HookStateMap> | null {
-    try {
-      const event = this.logDecoder(log);
-      if (event.name in this.handlers) {
-        return this.handlers[event.name](event, state, log);
-      }
-    } catch (e) {
-      catchParseLogError(e, this.logger);
-    }
-
-    return null;
-  }
-
-  /**
-   * The function generates state using on-chain calls. This
-   * function is called to regenerate state if the event based
-   * system fails to fetch events and the local state is no
-   * more correct.
-   * @param blockNumber - Blocknumber for which the state should
-   * should be generated
-   * @returns state of the event subscriber at blocknumber
-   */
-  async generateState(
-    blockNumber: number,
-  ): Promise<DeepReadonly<HookStateMap>> {
-    // Only hooks that are supported will be called
-    const hookState: HookStateMap = {};
-
-    await Promise.all(
-      Object.keys(this.hooksConfigMap).map(async hookAddress => {
-        const hookConfig = this.hooksConfigMap[hookAddress];
-        if (hookConfig.type === DirectionalFee.type) {
-          hookState[hookAddress] = await getDirectionalFeeHookState();
-        } else if (hookConfig.type === StableSurge.type) {
-          hookState[hookAddress] = await getStableSurgeHookState(
-            this.interfaces[1],
-            hookAddress,
-            hookConfig.factory,
-            this.dexHelper,
-            blockNumber,
-          );
-        }
-      }),
-    );
-
-    // for (const hookAddress in this.hooksConfigMap) {
-    //   const hookConfig = this.hooksConfigMap[hookAddress];
-    //   if (hookConfig.type === DirectionalFee.type) {
-    //     hookState[hookAddress] = await getDirectionalFeeHookState();
-    //   } else if (hookConfig.type === StableSurge.type) {
-    //     hookState[hookAddress] = await getStableSurgeHookState(
-    //       this.interfaces[1],
-    //       hookAddress,
-    //       hookConfig.factory,
-    //       this.dexHelper,
-    //       blockNumber,
-    //     );
-    //   }
-    // }
-
-    return hookState;
-  }
-
-  async updateHookState() {
-    // Not all hooks need updated, only ones with settings/state that can't be handled by events
-    const blockNumber = await this.dexHelper.provider.getBlockNumber();
-    const currentState =
-      (_.cloneDeep(this.getStaleState()) as HookStateMap) || {};
-
-    await Promise.all(
-      Object.keys(this.hooksConfigMap).map(async hookAddress => {
-        const hookConfig = this.hooksConfigMap[hookAddress];
-        // StableSurge can have new registered pools with associated hook state
-        if (hookConfig.type === StableSurge.type) {
-          currentState[hookAddress] = await getStableSurgeHookState(
-            this.interfaces[1],
-            hookAddress,
-            hookConfig.factory,
-            this.dexHelper,
-            blockNumber,
-          );
-        }
-      }),
-    );
-
-    this.setState(currentState, blockNumber);
-  }
-
-  combineInterfaces = (interfaces: Interface[]): Interface => {
-    // Use a Map to store unique fragments, keyed by their string representation
-    const uniqueFragments = new Map<string, Fragment>();
-
-    interfaces.forEach((interfaceInstance: Interface) => {
-      interfaceInstance.fragments.forEach((fragment: Fragment) => {
-        let key: string;
-
-        if (fragment instanceof FunctionFragment) {
-          // For functions, use the signature as the key
-          // This includes name and parameter types
-          key = fragment.format();
-        } else if (fragment instanceof EventFragment) {
-          // For events, use the signature as the key
-          key = fragment.format();
-        } else {
-          // For other fragment types (like errors), use their string representation
-          key = fragment.toString();
-        }
-
-        // Only add if we haven't seen this signature before
-        if (!uniqueFragments.has(key)) {
-          uniqueFragments.set(key, fragment);
-        }
-      });
-    });
-
-    // Convert the Map values back to an array
-    const dedupedFragments = Array.from(uniqueFragments.values());
-
-    // Create a new interface with the deduped fragments
-    return new Interface(dedupedFragments);
-  };
-}

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

@@ -1,51 +0,0 @@
-/**
- * Each supported hook should implement its own version of this file making it easy to retrieve required onchain state.
- */
-import _ from 'lodash';
-import { Log } from '../../../types';
-import { DeepReadonly } from 'ts-essentials';
-import { HookStateMap } from './balancer-hook-event-subscriber';
-
-export const DirectionalFee = {
-  type: 'DirectionalFee' as const,
-};
-
-export type DirectionalFeeConfig = {
-  type: typeof DirectionalFee.type;
-  address: string;
-};
-
-export type DirectionalFeeHookState = {
-  test: string; // Note - this is just a dummy example as this specific test hook doesn't have any required state but is used to prove concept
-};
-
-/**
- * Retrieve any initial hook state required.
- * @returns
- */
-export async function getDirectionalFeeHookState(): Promise<DirectionalFeeHookState> {
-  // Note - for other hooks this function would retrieve any initial state using onchain calls
-  return { test: 'initial' };
-}
-
-/**
- * Handles the event emitted when a new hook is registered.
- * @param event
- * @param state
- * @param log
- * @returns
- */
-export function exitFeeHookExampleRegisteredEvent(
-  event: any,
-  state: DeepReadonly<HookStateMap>,
-  log: Readonly<Log>,
-): DeepReadonly<HookStateMap> | null {
-  // Note - This is a non-important event but demos the use case. Other hooks would implement this for any state changes required for swap maths.
-  const hookAddress = event.args.hooksContract.toLowerCase();
-  if (!state[hookAddress]) {
-    return null;
-  }
-  const newState = _.cloneDeep(state) as HookStateMap;
-  newState[hookAddress] = { test: event.args.pool };
-  return newState;
-}

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

@@ -1,12 +0,0 @@
-import { BalancerV3Config } from './../config';
-import { HooksConfigMap } from './balancer-hook-event-subscriber';
-
-export function loadHooksConfig(network: number): HooksConfigMap {
-  const hooks = BalancerV3Config.BalancerV3[network].hooks;
-
-  if (!hooks) return {};
-
-  return Object.fromEntries(
-    hooks.map(hook => [hook.address.toLowerCase(), hook]),
-  );
-}