@paraswap/dex-lib 2.33.4-balancer-v2-multihop.2 → 2.34.0

package/src/dex/algebra/algebra-pool-v1_1.ts

@@ -9,31 +9,47 @@ import {
 } from '../../stateful-event-subscriber';
 import { IDexHelper } from '../../dex-helper/idex-helper';
 import {
+  DecodedGlobalStateV1_1,
   PoolStateV1_1,
   TickBitMapMappingsWithBigNumber,
   TickInfoMappingsWithBigNumber,
+  TickInfoWithBigNumber,
 } from './types';
-import { ethers } from 'ethers';
+import { BigNumber, ethers } from 'ethers';
 import { Contract } from 'web3-eth-contract';
 import AlgebraABI from '../../abi/algebra/AlgebraPool-v1_1.abi.json';
+import FactoryABI from '../../abi/algebra/AlgebraFactory-v1_1.abi.json';
 import { DecodedStateMultiCallResultWithRelativeBitmapsV1_1 } from './types';
 import {
   OUT_OF_RANGE_ERROR_POSTFIX,
   TICK_BITMAP_BUFFER,
   TICK_BITMAP_TO_USE,
 } from '../uniswap-v3/constants';
-import { uint256ToBigInt } from '../../lib/decoders';
+import {
+  addressDecode,
+  uint256ToBigInt,
+  uint128ToBigNumber,
+  int24ToNumber,
+} from '../../lib/decoders';
 import { MultiCallParams } from '../../lib/multi-wrapper';
-import { decodeStateMultiCallResultWithRelativeBitmapsV1_1 } from './utils';
+import {
+  decodeGlobalStateV1_1,
+  decodeStateMultiCallResultWithRelativeBitmapsV1_1,
+  decodeTicksV1_1,
+} from './utils';
 import { AlgebraMath } from './lib/AlgebraMath';
 import {
   _reduceTickBitmap,
   _reduceTicks,
 } from '../uniswap-v3/contract-math/utils';
 import { Constants } from './lib/Constants';
-import { Network } from '../../constants';
+import { Network, NULL_ADDRESS } from '../../constants';
 import { TickTable } from './lib/TickTable';
 
+const BN_ZERO = BigNumber.from(0);
+const MAX_BATCH_SIZE = 100;
+const MAX_NUMBER_OF_BATCH_REQUEST_HALVING = 3;
+
 export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1> {
   handlers: {
     [event: string]: (
@@ -53,6 +69,13 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
   readonly token1: Address;
 
   public readonly poolIface = new Interface(AlgebraABI);
+  public readonly factoryIface = new Interface(FactoryABI);
+
+  private readonly cachedStateMultiCalls: MultiCallParams<
+    string | bigint | BigNumber | number | DecodedGlobalStateV1_1
+  >[];
+
+  private optimalTickRequestBatchSize?: number;
 
   public initFailed = false;
   public initRetryAttemptCount = 0;
@@ -69,6 +92,7 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
     mapKey: string = '',
     readonly poolInitCodeHash: string,
     readonly poolDeployer: string,
+    private readonly forceManualStateGeneration: boolean = false,
   ) {
     super(parentName, `${token0}_${token1}`, dexHelper, logger, true, mapKey);
     this.token0 = token0.toLowerCase();
@@ -84,6 +108,8 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
     this.handlers['Flash'] = this.handleFlashEvent.bind(this);
     this.handlers['Collect'] = this.handleCollectEvent.bind(this);
     this.handlers['CommunityFee'] = this.handleCommunityFee.bind(this);
+
+    this.cachedStateMultiCalls = this._getStateMulticall();
   }
 
   get poolAddress() {
@@ -174,7 +200,7 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
     return TICK_BITMAP_TO_USE + TICK_BITMAP_BUFFER;
   }
 
-  private async _fetchPoolStateSingleStep(
+  async fetchPoolStateSingleStep(
     blockNumber: number,
   ): Promise<
     [bigint, bigint, DecodedStateMultiCallResultWithRelativeBitmapsV1_1]
@@ -336,7 +362,7 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
     [bigint, bigint, DecodedStateMultiCallResultWithRelativeBitmapsV1_1]
   > {
     try {
-      return await this._fetchPoolStateSingleStep(blockNumber);
+      return await this.fetchPoolStateSingleStep(blockNumber);
     } catch (e) {
       if (e instanceof Error && e.message.includes('Pool does not exist'))
         throw e;
@@ -347,9 +373,234 @@ export class AlgebraEventPoolV1_1 extends StatefulEventSubscriber<PoolStateV1_1>
     }
   }
 
+  private _getStateMulticall(): MultiCallParams<
+    string | bigint | BigNumber | number | DecodedGlobalStateV1_1
+  >[] {
+    return [
+      {
+        target: this.factoryAddress,
+        callData: this.factoryIface.encodeFunctionData('poolByPair', [
+          this.token0,
+          this.token1,
+        ]),
+        decodeFunction: addressDecode,
+      },
+      {
+        target: this.token0,
+        callData: this.erc20Interface.encodeFunctionData('balanceOf', [
+          this.poolAddress,
+        ]),
+        decodeFunction: uint256ToBigInt,
+      },
+      {
+        target: this.token1,
+        callData: this.erc20Interface.encodeFunctionData('balanceOf', [
+          this.poolAddress,
+        ]),
+        decodeFunction: uint256ToBigInt,
+      },
+      {
+        target: this.poolAddress,
+        callData: this.poolIface.encodeFunctionData('liquidity', []),
+        decodeFunction: uint128ToBigNumber,
+      },
+      {
+        target: this.poolAddress,
+        callData: this.poolIface.encodeFunctionData('tickSpacing', []),
+        decodeFunction: int24ToNumber,
+      },
+      {
+        target: this.poolAddress,
+        callData: this.poolIface.encodeFunctionData('maxLiquidityPerTick', []),
+        decodeFunction: uint128ToBigNumber,
+      },
+      {
+        target: this.poolAddress,
+        callData: this.poolIface.encodeFunctionData('globalState', []),
+        decodeFunction: decodeGlobalStateV1_1,
+      },
+    ];
+  }
+
+  async fetchStateManually(
+    blockNumber: number,
+  ): Promise<
+    [bigint, bigint, DecodedStateMultiCallResultWithRelativeBitmapsV1_1]
+  > {
+    // Unfortunately I can not unite this call with the next one. For some reason even if pool does not exist
+    // call succeeds and makes decoding function to throw. Otherwise, I should rewrite decoders in different which
+    // require some time
+    const [poolAddress] = (await this.dexHelper.multiWrapper.aggregate<
+      string | bigint | BigNumber | number | DecodedGlobalStateV1_1
+    >(this.cachedStateMultiCalls.slice(0, 1), blockNumber, MAX_BATCH_SIZE)) as [
+      string,
+    ];
+
+    if (poolAddress === NULL_ADDRESS) {
+      throw new Error('Pool does not exist');
+    }
+
+    const [
+      balance0,
+      balance1,
+      liquidity,
+      tickSpacing,
+      maxLiquidityPerTick,
+      globalState,
+    ] = (await this.dexHelper.multiWrapper.aggregate<
+      string | bigint | BigNumber | number | DecodedGlobalStateV1_1
+    >(this.cachedStateMultiCalls.slice(1), blockNumber, MAX_BATCH_SIZE)) as [
+      bigint,
+      bigint,
+      BigNumber,
+      number,
+      BigNumber,
+      DecodedGlobalStateV1_1,
+    ];
+
+    assert(
+      poolAddress.toLowerCase() === this.poolAddress.toLowerCase(),
+      `Pool address mismatch: ${poolAddress.toLowerCase()} != ${this.poolAddress.toLowerCase()}`,
+    );
+
+    const currentBitMapIndex = TickTable.position(
+      BigInt(BigInt(globalState.tick) / BigInt(tickSpacing)),
+    )[0];
+
+    const leftBitMapIndex = currentBitMapIndex - this.getBitmapRangeToRequest();
+    const rightBitMapIndex =
+      currentBitMapIndex + this.getBitmapRangeToRequest();
+
+    const allTickBitMaps = await this.dexHelper.multiWrapper.aggregate(
+      _.range(Number(leftBitMapIndex), Number(rightBitMapIndex + 1n)).map(
+        index => {
+          return {
+            target: poolAddress,
+            callData: this.poolIface.encodeFunctionData('tickTable', [
+              int16(BigInt(index)),
+            ]),
+            decodeFunction: uint256ToBigInt,
+          };
+        },
+      ),
+      blockNumber,
+      MAX_BATCH_SIZE,
+    );
+
+    const tickBitmap: TickBitMapMappingsWithBigNumber[] = [];
+
+    let globalIndex = 0;
+    for (let i = leftBitMapIndex; i <= rightBitMapIndex; i++) {
+      const index = Number(int16(i));
+      const bitmap = allTickBitMaps[globalIndex];
+      globalIndex++;
+      if (bitmap == 0n) continue;
+      tickBitmap.push({ index: Number(index), value: BigNumber.from(bitmap) });
+    }
+
+    const tickIndexes: bigint[] = [];
+
+    const tickRequests = tickBitmap
+      .map(tb => {
+        const allBits: MultiCallParams<TickInfoWithBigNumber>[] = [];
+        if (tb.value === BN_ZERO) return allBits;
+
+        _.range(0, 256).forEach(j => {
+          if ((tb.value.toBigInt() & (1n << BigInt(j))) > 0n) {
+            const populatedTick =
+              (BigInt.asIntN(16, BigInt(tb.index) << 8n) + BigInt(j)) *
+              BigInt(tickSpacing);
+
+            tickIndexes.push(populatedTick);
+            allBits.push({
+              target: poolAddress,
+              callData: this.poolIface.encodeFunctionData('ticks', [
+                populatedTick,
+              ]),
+              decodeFunction: decodeTicksV1_1,
+            });
+          }
+        });
+        return allBits;
+      })
+      .flat();
+
+    let ticksValues: TickInfoWithBigNumber[] = [];
+    if (this.optimalTickRequestBatchSize) {
+      ticksValues = await this.dexHelper.multiWrapper.aggregate(
+        tickRequests,
+        blockNumber,
+        this.optimalTickRequestBatchSize,
+      );
+      // If we don't know what is optimal number of requests for this pool, we want to try it experimentally and save it
+      // Maybe later to consider distant caching
+    } else {
+      for (const i of _.range(0, MAX_NUMBER_OF_BATCH_REQUEST_HALVING)) {
+        const currentBatchSize = MAX_BATCH_SIZE / (+i + 1);
+        try {
+          // Some of the pools fails with 100 batch size, for them we want to try additionally with reduced batch size
+          ticksValues = await this.dexHelper.multiWrapper.aggregate(
+            tickRequests,
+            blockNumber,
+            currentBatchSize,
+          );
+          this.optimalTickRequestBatchSize = currentBatchSize;
+          break;
+        } catch (e) {
+          if (+i + 1 === MAX_NUMBER_OF_BATCH_REQUEST_HALVING) {
+            this.logger.warn(
+              `Failed to fetch ticks for pool ${poolAddress} (${this.token0}_${this.token1}) with batch size ${currentBatchSize}`,
+              e,
+            );
+            throw e;
+          }
+        }
+      }
+    }
+
+    assert(
+      tickIndexes.length === ticksValues.length,
+      `Tick indexes mismatch: ${tickIndexes.length} != ${ticksValues.length}`,
+    );
+
+    const ticks: TickInfoMappingsWithBigNumber[] = new Array(
+      tickIndexes.length,
+    );
+
+    tickIndexes.forEach((tickIndex, index) => {
+      ticks[index] = {
+        index: Number(tickIndex),
+        value: ticksValues[index],
+      };
+    });
+
+    return [
+      balance0,
+      balance1,
+      {
+        pool: poolAddress,
+        blockTimestamp: BigNumber.from(Date.now()),
+        globalState,
+        liquidity,
+        tickSpacing,
+        maxLiquidityPerTick,
+        tickBitmap,
+        ticks,
+      },
+    ];
+  }
+
   async generateState(blockNumber: number): Promise<Readonly<PoolStateV1_1>> {
-    const [balance0, balance1, _state] =
-      await this._fetchInitStateMultiStrategies(blockNumber);
+    let balance0 = 0n;
+    let balance1 = 0n;
+    let _state: DecodedStateMultiCallResultWithRelativeBitmapsV1_1;
+    if (this.forceManualStateGeneration) {
+      [balance0, balance1, _state] = await this.fetchStateManually(blockNumber);
+    } else {
+      [balance0, balance1, _state] = await this._fetchInitStateMultiStrategies(
+        blockNumber,
+      );
+    }
 
     const tickBitmap = {};
     const ticks = {};

package/src/dex/algebra/algebra.ts

@@ -160,14 +160,15 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
         if (this.network !== Network.ZKEVM) return pool;
 
         if (
-          pool.getState(blockNumber) === null &&
-          blockNumber - pool.getStateBlockNumber() >
-            MAX_STALE_STATE_BLOCK_AGE[this.network]
+          pool.getStaleState() === null ||
+          (pool.getState(blockNumber) === null &&
+            blockNumber - pool.getStateBlockNumber() >
+              MAX_STALE_STATE_BLOCK_AGE[this.network])
         ) {
           /* reload state, on zkEVM this would most likely timeout during request life
            * but would allow to rely on staleState for couple of min for next requests
            */
-          await pool.initialize(blockNumber);
+          await pool.initialize(blockNumber, { forceRegenerate: true });
         }
 
         return pool;
@@ -226,6 +227,7 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
         this.cacheStateKey,
         this.config.initHash,
         this.config.deployer,
+        this.config.forceManualStateGenerate,
       );
 
     try {
@@ -255,10 +257,10 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
           e,
         );
       } else {
-        // on unkown error mark as failed and increase retryCount for retry init strategy
+        // on unknown error mark as failed and increase retryCount for retry init strategy
         // note: state would be null by default which allows to fallback
         this.logger.warn(
-          `${this.dexKey}: Can not generate pool state for srcAddress=${srcAddress}, destAddress=${destAddress}pool fallback to rpc and retry every ${this.config.initRetryFrequency} times, initRetryAttemptCount=${pool.initRetryAttemptCount}`,
+          `${this.dexKey}: Can not generate pool state for srcAddress=${srcAddress}, destAddress=${destAddress} pool fallback to rpc and retry every ${this.config.initRetryFrequency} times, initRetryAttemptCount=${pool.initRetryAttemptCount}`,
           e,
         );
         pool.initFailed = true;
@@ -790,6 +792,7 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
       subgraphURL: this.config.subgraphURL,
       version: this.config.version,
       forceRPC: this.config.forceRPC,
+      forceManualStateGenerate: this.config.forceManualStateGenerate,
     };
     return newConfig;
   }

package/src/dex/algebra/config.ts

@@ -33,6 +33,7 @@ export const AlgebraConfig: DexConfigMap<DexParams> = {
       uniswapMulticall: '0x61530d6E1c7A47BBB3e48e8b8EdF7569DcFeE121',
       deployer: '0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270',
       version: 'v1.1',
+      forceManualStateGenerate: true,
     },
   },
   ZyberSwapV3: {

package/src/dex/algebra/types.ts

@@ -2,7 +2,7 @@ import { BigNumber } from 'ethers';
 import { Address, NumberAsString } from '../../types';
 import { TickInfo } from '../uniswap-v3/types';
 
-type GlobalStateV1_1 = {
+export type GlobalStateV1_1 = {
   price: bigint; // The square root of the current price in Q64.96 format
   tick: bigint; // The current tick
   fee: bigint; // The current fee in hundredths of a bip, i.e. 1e-6
@@ -72,6 +72,7 @@ export type DexParams = {
   initHash: string;
   version: 'v1.1' | 'v1.9';
   forceRPC?: boolean;
+  forceManualStateGenerate?: boolean;
 };
 
 export type IAlgebraPoolState = PoolStateV1_1 | PoolState_v1_9;
@@ -95,7 +96,7 @@ export type TickInfoMappingsWithBigNumber = {
   value: TickInfoWithBigNumber;
 };
 
-type DecodedGlobalStateV1_1 = {
+export type DecodedGlobalStateV1_1 = {
   price: BigNumber;
   tick: number;
   fee: number;

package/src/dex/algebra/utils.ts

@@ -1,11 +1,12 @@
-import { BytesLike, ethers } from 'ethers';
+import { BigNumber, BytesLike, ethers } from 'ethers';
 import { assert } from 'ts-essentials';
 import { extractSuccessAndValue } from '../../lib/decoders';
 import { MultiResult } from '../../lib/multi-wrapper';
 import {
-  DecodedGlobalStateV1_9,
+  DecodedGlobalStateV1_1,
   DecodedStateMultiCallResultWithRelativeBitmapsV1_1,
   DecodedStateMultiCallResultWithRelativeBitmapsV1_9,
+  TickInfoWithBigNumber,
 } from './types';
 
 export function decodeStateMultiCallResultWithRelativeBitmapsV1_1(
@@ -134,3 +135,83 @@ export function decodeStateMultiCallResultWithRelativeBitmapsV1_9(
   // But I typed only the ones that are used later
   return decoded as DecodedStateMultiCallResultWithRelativeBitmapsV1_9;
 }
+
+export function decodeGlobalStateV1_1(
+  result: MultiResult<BytesLike> | BytesLike,
+): DecodedGlobalStateV1_1 {
+  const [isSuccess, toDecode] = extractSuccessAndValue(result);
+
+  assert(
+    isSuccess && toDecode !== '0x',
+    `decodeGlobalStateV1_1 failed to get decodable result: ${result}`,
+  );
+
+  const results: DecodedGlobalStateV1_1 = {
+    price: BigNumber.from(0),
+    tick: 0,
+    fee: 0,
+    communityFeeToken0: 0,
+    communityFeeToken1: 0,
+  };
+
+  [
+    results.price,
+    results.tick,
+    results.fee,
+    ,
+    results.communityFeeToken0,
+    results.communityFeeToken1,
+  ] = ethers.utils.defaultAbiCoder.decode(
+    [`uint160`, `int24`, `uint16`, `uint16`, `uint8`, `uint8`, `bool`],
+    toDecode,
+  );
+  // This conversion is not precise, because when we decode, we have more values
+  // But used later
+  return results;
+}
+
+export function decodeTicksV1_1(
+  result: MultiResult<BytesLike> | BytesLike,
+): TickInfoWithBigNumber {
+  const [isSuccess, toDecode] = extractSuccessAndValue(result);
+
+  assert(
+    isSuccess && toDecode !== '0x',
+    `decodeGlobalStateV1_1 failed to get decodable result: ${result}`,
+  );
+
+  const results: TickInfoWithBigNumber = {
+    liquidityNet: BigNumber.from(0),
+    liquidityGross: BigNumber.from(0),
+    secondsOutside: 0,
+    secondsPerLiquidityOutsideX128: BigNumber.from(0),
+    tickCumulativeOutside: BigNumber.from(0),
+    initialized: false,
+  };
+
+  [
+    results.liquidityGross,
+    results.liquidityNet,
+    ,
+    ,
+    results.tickCumulativeOutside,
+    results.secondsPerLiquidityOutsideX128,
+    results.secondsOutside,
+    results.initialized,
+  ] = ethers.utils.defaultAbiCoder.decode(
+    [
+      `uint128`,
+      `int128`,
+      `uint256`,
+      `uint256`,
+      `int256`,
+      `uint160`,
+      `uint32`,
+      `bool`,
+    ],
+    toDecode,
+  );
+  // This conversion is not precise, because when we decode, we have more values
+  // But used later
+  return results;
+}

package/src/dex/balancer-v2/optimizer.ts

@@ -3,20 +3,22 @@ import { BalancerSwapV2 } from './types';
 import { SwapSide } from '../../constants';
 import { BalancerConfig } from './config';
 
-export const AllBalancerV2Forks = Object.keys(BalancerConfig);
+const MAX_UINT256 =
+  '115792089237316195423570985008687907853269984665640564039457584007913129639935';
+
+const AllBalancerV2Forks = Object.keys(BalancerConfig);
 
 export function balancerV2Merge(or: UnoptimizedRate): UnoptimizedRate {
   const fixSwap = (
     rawSwap: OptimalSwapExchange<any>[],
-    accumulatedBalancers: { [key: string]: OptimalSwapExchange<any> },
     side: SwapSide,
   ): OptimalSwapExchange<any>[] => {
-    let optimizedSwap = new Array<OptimalSwapExchange<any>>();
     const newBalancers: { [key: string]: OptimalSwapExchange<any> } = {};
+    let optimizedSwap = new Array<OptimalSwapExchange<any>>();
     rawSwap.forEach((s: OptimalSwapExchange<any>) => {
       const exchangeKey = s.exchange.toLowerCase();
       if (AllBalancerV2Forks.some(d => d.toLowerCase() === exchangeKey)) {
-        if (!(exchangeKey in accumulatedBalancers)) {
+        if (!(exchangeKey in newBalancers)) {
           newBalancers[exchangeKey] = {
             exchange: s.exchange,
             srcAmount: '0',
@@ -28,33 +30,27 @@ export function balancerV2Merge(or: UnoptimizedRate): UnoptimizedRate {
               gasUSD: '0',
             },
           };
-          accumulatedBalancers[exchangeKey] = newBalancers[exchangeKey];
         }
-        accumulatedBalancers[exchangeKey].srcAmount = (
-          BigInt(accumulatedBalancers[exchangeKey].srcAmount) +
-          BigInt(s.srcAmount)
+        newBalancers[exchangeKey].srcAmount = (
+          BigInt(newBalancers[exchangeKey].srcAmount) + BigInt(s.srcAmount)
         ).toString();
 
-        accumulatedBalancers[exchangeKey].destAmount = (
-          BigInt(accumulatedBalancers[exchangeKey].destAmount) +
-          BigInt(s.destAmount)
+        newBalancers[exchangeKey].destAmount = (
+          BigInt(newBalancers[exchangeKey].destAmount) + BigInt(s.destAmount)
         ).toString();
 
-        accumulatedBalancers[exchangeKey].percent += s.percent;
-        accumulatedBalancers[exchangeKey].data.exchangeProxy =
-          s.data.exchangeProxy;
-        accumulatedBalancers[exchangeKey].data.gasUSD = (
-          parseFloat(accumulatedBalancers[exchangeKey].data.gasUSD) +
+        newBalancers[exchangeKey].percent += s.percent;
+        newBalancers[exchangeKey].data.exchangeProxy = s.data.exchangeProxy;
+        newBalancers[exchangeKey].data.gasUSD = (
+          parseFloat(newBalancers[exchangeKey].data.gasUSD) +
           parseFloat(s.data.gasUSD)
         ).toFixed(6);
 
-        accumulatedBalancers[exchangeKey].data.swaps.push({
+        newBalancers[exchangeKey].data.swaps.push({
           poolId: s.data.poolId,
           amount: side === SwapSide.SELL ? s.srcAmount : s.destAmount,
         });
-        accumulatedBalancers[exchangeKey].poolAddresses!.push(
-          s.poolAddresses![0],
-        );
+        newBalancers[exchangeKey].poolAddresses!.push(s.poolAddresses![0]);
       } else {
         optimizedSwap.push(s);
       }
@@ -63,23 +59,12 @@ export function balancerV2Merge(or: UnoptimizedRate): UnoptimizedRate {
     return optimizedSwap;
   };
 
-  or.bestRoute = or.bestRoute.map(r => {
-    const accumulatedBalancers: {
-      [key: string]: OptimalSwapExchange<any>;
-    } = {};
-    return {
-      ...r,
-      swaps: r.swaps
-        .map(s => ({
-          ...s,
-          swapExchanges: fixSwap(
-            s.swapExchanges,
-            accumulatedBalancers,
-            or.side,
-          ),
-        }))
-        .filter(s => s.swapExchanges.length > 0),
-    };
-  });
+  or.bestRoute = or.bestRoute.map(r => ({
+    ...r,
+    swaps: r.swaps.map(s => ({
+      ...s,
+      swapExchanges: fixSwap(s.swapExchanges, or.side),
+    })),
+  }));
   return or;
 }

package/src/dex/solidly/forks-override/velodromeV2.ts

@@ -24,7 +24,6 @@ const VelodromeV2FactoryABI = [
 const velodromeV2FactoryIface = new Interface(VelodromeV2FactoryABI);
 
 export class VelodromeV2 extends Solidly {
-
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
     getDexKeysWithNetwork(_.pick(SolidlyConfig, ['VelodromeV2']));
 
@@ -44,7 +43,10 @@ export class VelodromeV2 extends Solidly {
   protected getFeesMultiCallData(pair: SolidlyPair) {
     const callEntry = {
       target: this.factoryAddress,
-      callData: velodromeV2FactoryIface.encodeFunctionData('getFee', [pair.exchange, pair.stable]),
+      callData: velodromeV2FactoryIface.encodeFunctionData('getFee', [
+        pair.exchange,
+        pair.stable,
+      ]),
     };
     const callDecoder = (values: any[]) =>
       parseInt(

package/src/dex/uniswap-v2/nomiswap-v2.ts

@@ -15,7 +15,8 @@ export const NomiswapV2Config: DexConfigMap<DexParams> = {
         '0x83eb759f5ea0525124f03d4ac741bb4af0bb1c703d5f694bd42a8bd72e495a01',
       poolGasCost: 120 * 1000,
       feeCode: 0, // this is ignored as Nomiswap uses dynamic fees,
-      subgraphURL: 'https://api.thegraph.com/subgraphs/name/nominex/nomiswap-exchange-subgraph',
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/nominex/nomiswap-exchange-subgraph',
     },
   },
 };

package/src/dex/uniswap-v2/uniswap-v2-e2e-bsc.test.ts

@@ -2,7 +2,11 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 import { testE2E } from '../../../tests/utils-e2e';
-import { Tokens, Holders, NativeTokenSymbols } from '../../../tests/constants-e2e';
+import {
+  Tokens,
+  Holders,
+  NativeTokenSymbols,
+} from '../../../tests/constants-e2e';
 import { Network, ContractMethod, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { generateConfig } from '../../config';
@@ -34,13 +38,7 @@ function testForNetwork(
         ContractMethod.megaSwap,
       ],
     ],
-    [
-      SwapSide.BUY,
-      [
-        ContractMethod.simpleBuy,
-        ContractMethod.buy,
-      ],
-    ],
+    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
   ]);
 
   describe(`${network}`, () => {