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

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

@@ -1,166 +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';
-
-  describe('Mainnet', () => {
-    const network = Network.MAINNET;
-    const dexHelper = new DummyDexHelper(network);
-    const logger = dexHelper.getLogger(dexKey);
-    let balancerEventHook: BalancerEventHook;
-
-    // hook -> EventMappings
-    const eventsToTest: Record<Address, EventMappings> = {
-      ['StableSurgeHook']: {
-        ThresholdSurgePercentageChanged: {
-          blockNumbers: [
-            21824387, 21825432, 21825615, 21825831, 21830728, 21830728,
-          ],
-          hookAddress: ['0xb18fA0cb5DE8cecB8899AAE6e38b1B7ed77885dA'],
-        },
-        MaxSurgeFeePercentageChanged: {
-          blockNumbers: [
-            21824387, 21825432, 21825615, 21825831, 21830728, 21830728,
-          ],
-          hookAddress: ['0xb18fA0cb5DE8cecB8899AAE6e38b1B7ed77885dA'],
-        },
-      },
-    };
-
-    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[0],
-                        ),
-                      blockNumber,
-                      `${dexKey}_${hookAddress}`,
-                      dexHelper.provider,
-                    );
-                  });
-                });
-              });
-            },
-          );
-        });
-      },
-    );
-  });
-
-  describe('SEPOLIA', () => {
-    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,212 +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 directionalFeeHookAbi 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>,
-      logger: Logger,
-    ) => 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(directionalFeeHookAbi),
-      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, this.logger);
-      }
-    } 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,
-          );
-        }
-      }),
-    );
-
-    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);
-  };
-}