@paraswap/dex-lib 2.42.19 → 2.42.20-hashflow-v3

package/src/config.ts

@@ -281,7 +281,7 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_42161`]?.split(',') || [],
     adapterAddresses: {
       ArbitrumAdapter01: '0xD8134ACfc9c71Ab51452b5bA23A31354F4739032',
-      ArbitrumAdapter02: '0x7b0c7f946c845bb0d43ad41ece7027e1fc11bea7',
+      ArbitrumAdapter02: '0x248009f6F78b5AcD5EA2fc86d56b77A7AeEe2eFc',
       ArbitrumBuyAdapter: '0xEECA9223063bD13e8ca77ed9e39a07f2BD1923E6',
     },
     uniswapV2ExchangeRouterAddress:

package/src/dex/algebra/algebra-e2e.test.ts

@@ -11,7 +11,6 @@ import {
 import { Network, ContractMethod, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { generateConfig } from '../../config';
-import { TransferFeeParams } from '../../types';
 
 /*
   README
@@ -60,12 +59,6 @@ function testForNetwork(
   tokenAAmount: string,
   tokenBAmount: string,
   nativeTokenAmount: string,
-  transferFees: TransferFeeParams = {
-    srcFee: 0,
-    destFee: 0,
-    srcDexFee: 0,
-    destDexFee: 0,
-  },
 ) {
   const provider = new StaticJsonRpcProvider(
     generateConfig(network).privateHttpProvider,
@@ -87,7 +80,6 @@ function testForNetwork(
     ],
     // TODO: If buy is not supported remove the buy contract methods
     [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
-    // [SwapSide.BUY, [ContractMethod.simpleBuy]],
   ]);
 
   describe(`${network}`, () => {
@@ -95,81 +87,43 @@ function testForNetwork(
       describe(`${side}`, () => {
         contractMethods.forEach((contractMethod: ContractMethod) => {
           describe(`${contractMethod}`, () => {
-            // if src token is tax token and BUY side, then should fail (skip)
-            if (!!transferFees?.srcDexFee && side === SwapSide.BUY) return;
-
-            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+            it(`${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
               await testE2E(
+                tokens[nativeTokenSymbol],
                 tokens[tokenASymbol],
-                tokens[tokenBSymbol],
-                holders[tokenASymbol],
-                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                holders[nativeTokenSymbol],
+                side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
                 side,
                 dexKey,
                 contractMethod,
                 network,
                 provider,
-                undefined,
-                undefined,
-                transferFees,
               );
             });
-            it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+            it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
               await testE2E(
-                tokens[tokenBSymbol],
                 tokens[tokenASymbol],
-                holders[tokenBSymbol],
-                side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
-                side,
-                dexKey,
-                contractMethod,
-                network,
-                provider,
-                undefined,
-                undefined,
-                // switch src and dest fee when tax token is dest token
-                {
-                  ...transferFees,
-                  srcDexFee: transferFees.destDexFee,
-                  destDexFee: transferFees.srcDexFee,
-                },
-              );
-            });
-            it(`${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
-              await testE2E(
                 tokens[nativeTokenSymbol],
-                tokens[tokenASymbol],
-                holders[nativeTokenSymbol],
-                side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
                 side,
                 dexKey,
                 contractMethod,
                 network,
                 provider,
-                undefined,
-                undefined,
-                // switch src and dest fee when tax token is dest token
-                {
-                  ...transferFees,
-                  srcDexFee: transferFees.destDexFee,
-                  destDexFee: transferFees.srcDexFee,
-                },
               );
             });
-            it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
               await testE2E(
                 tokens[tokenASymbol],
-                tokens[nativeTokenSymbol],
+                tokens[tokenBSymbol],
                 holders[tokenASymbol],
-                side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
                 side,
                 dexKey,
                 contractMethod,
                 network,
                 provider,
-                undefined,
-                undefined,
-                transferFees,
               );
             });
           });
@@ -250,35 +204,10 @@ describe('Algebra', () => {
 
   describe('CamelotV3', () => {
     const dexKey = 'CamelotV3';
-    const network = Network.ARBITRUM;
-
-    describe('Arbitrum: Tax Tokens', () => {
-      const tokenASymbol: string = 'RDPX';
-      const tokenBSymbol: string = 'WETH';
-
-      const tokenAAmount: string = '100000000000000000000';
-      const tokenBAmount: string = '100000000000000000';
-      const nativeTokenAmount = '1000000000000000000';
-
-      testForNetwork(
-        network,
-        dexKey,
-        tokenASymbol,
-        tokenBSymbol,
-        tokenAAmount,
-        tokenBAmount,
-        nativeTokenAmount,
-        {
-          srcFee: 0,
-          destFee: 0,
-          srcDexFee: 1000,
-          destDexFee: 0,
-        },
-      );
-    });
 
-    describe('Arbitrum: Non-Tax tokens', () => {
-      const tokenASymbol: string = 'USDCe';
+    describe('Arbitrum', () => {
+      const network = Network.ARBITRUM;
+      const tokenASymbol: string = 'USDC';
       const tokenBSymbol: string = 'USDT';
 
       const tokenAAmount: string = '1000000000';

package/src/dex/algebra/algebra.ts

@@ -4,34 +4,21 @@ import { AbiItem } from 'web3-utils';
 import { pack } from '@ethersproject/solidity';
 import _ from 'lodash';
 import {
+  Token,
+  Address,
   ExchangePrices,
   PoolPrices,
   AdapterExchangeParam,
   SimpleExchangeParam,
-  Logger,
-  TransferFeeParams,
-  Address,
   PoolLiquidity,
-  Token,
+  Logger,
 } from '../../types';
 import { SwapSide, Network, CACHE_PREFIX } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
-import {
-  _require,
-  getBigIntPow,
-  getDexKeysWithNetwork,
-  interpolate,
-  isDestTokenTransferFeeToBeExchanged,
-  isSrcTokenTransferFeeToBeExchanged,
-} from '../../utils';
+import { getBigIntPow, getDexKeysWithNetwork, interpolate } from '../../utils';
 import { IDex } from '../../dex/idex';
 import { IDexHelper } from '../../dex-helper/idex-helper';
-import {
-  AlgebraData,
-  AlgebraFunctions,
-  DexParams,
-  IAlgebraPoolState,
-} from './types';
+import { AlgebraData, DexParams, IAlgebraPoolState } from './types';
 import {
   SimpleExchange,
   getLocalDeadlineAsFriendlyPlaceholder,
@@ -39,16 +26,19 @@ import {
 import { AlgebraConfig, Adapters } from './config';
 import { Contract } from 'web3-eth-contract';
 import { Interface } from 'ethers/lib/utils';
-import SwapRouter from '../../abi/algebra/SwapRouter.json';
+import UniswapV3RouterABI from '../../abi/uniswap-v3/UniswapV3Router.abi.json';
 import AlgebraQuoterABI from '../../abi/algebra/AlgebraQuoter.abi.json';
 import UniswapV3MultiABI from '../../abi/uniswap-v3/UniswapMulti.abi.json';
 import AlgebraStateMulticallABI from '../../abi/algebra/AlgebraStateMulticall.abi.json';
-import { OutputResult } from '../uniswap-v3/types';
+import {
+  OutputResult,
+  UniswapV3Functions,
+  UniswapV3SimpleSwapParams,
+} from '../uniswap-v3/types';
 import { AlgebraMath } from './lib/AlgebraMath';
 import { AlgebraEventPoolV1_1 } from './algebra-pool-v1_1';
 import { AlgebraEventPoolV1_9 } from './algebra-pool-v1_9';
 import { AlgebraFactory, OnPoolCreatedCallback } from './algebra-factory';
-import { applyTransferFee } from '../../lib/token-transfer-fee';
 
 type PoolPairsInfo = {
   token0: Address;
@@ -71,7 +61,7 @@ type IAlgebraEventPool = AlgebraEventPoolV1_1 | AlgebraEventPoolV1_9;
 
 export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
   private readonly factory: AlgebraFactory;
-  readonly isFeeOnTransferSupported: boolean = true;
+  readonly isFeeOnTransferSupported: boolean = false;
   protected eventPools: Record<string, IAlgebraEventPool | null> = {};
 
   private newlyCreatedPoolKeys: Set<string> = new Set();
@@ -95,15 +85,12 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
     | typeof AlgebraEventPoolV1_1
     | typeof AlgebraEventPoolV1_9;
 
-  readonly SRC_TOKEN_DEX_TRANSFERS = 1;
-  readonly DEST_TOKEN_DEX_TRANSFERS = 1;
-
   constructor(
     protected network: Network,
     dexKey: string,
     protected dexHelper: IDexHelper,
     protected adapters = Adapters[network] || {},
-    readonly routerIface = new Interface(SwapRouter),
+    readonly routerIface = new Interface(UniswapV3RouterABI), // same abi as uniswapV3
     readonly quoterIface = new Interface(AlgebraQuoterABI),
     readonly config = AlgebraConfig[dexKey][network],
   ) {
@@ -422,12 +409,6 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
     amounts: bigint[],
     side: SwapSide,
     pool: IAlgebraEventPool,
-    transferFees: TransferFeeParams = {
-      srcFee: 0,
-      destFee: 0,
-      srcDexFee: 0,
-      destDexFee: 0,
-    },
   ): Promise<ExchangePrices<AlgebraData> | null> {
     if (!this.config.forceRPC) {
       this.logger.warn(
@@ -435,11 +416,6 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
       );
     }
 
-    const _isSrcTokenTransferFeeToBeExchanged =
-      isSrcTokenTransferFeeToBeExchanged(transferFees);
-    const _isDestTokenTransferFeeToBeExchanged =
-      isDestTokenTransferFeeToBeExchanged(transferFees);
-
     const unitVolume = getBigIntPow(
       (side === SwapSide.SELL ? from : to).decimals,
     );
@@ -454,16 +430,7 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
       ),
     );
 
-    const _amountsWithFee = _isSrcTokenTransferFeeToBeExchanged
-      ? applyTransferFee(
-          _amounts,
-          side,
-          transferFees.srcDexFee,
-          this.SRC_TOKEN_DEX_TRANSFERS,
-        )
-      : _amounts;
-
-    const calldata = _amountsWithFee.map(_amount => ({
+    const calldata = _amounts.map(_amount => ({
       target: this.config.quoter,
       gasLimit: ALGEBRA_QUOTE_GASLIMIT,
       callData:
@@ -504,22 +471,12 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
       : Math.round(totalGasCost / totalSuccessFullSwaps);
 
     let i = 0;
-    const _rates = _amountsWithFee.map(() => decode(i++));
-
-    const _ratesWithFee = _isDestTokenTransferFeeToBeExchanged
-      ? applyTransferFee(
-          _rates,
-          side,
-          transferFees.destDexFee,
-          this.DEST_TOKEN_DEX_TRANSFERS,
-        )
-      : _rates;
-
-    const unit: bigint = _ratesWithFee[0];
+    const _rates = _amounts.map(() => decode(i++));
+    const unit: bigint = _rates[0];
 
     const prices = interpolate(
-      _amountsWithFee.slice(1),
-      _ratesWithFee.slice(1),
+      _amounts.slice(1),
+      _rates.slice(1),
       amounts,
       side,
     );
@@ -529,7 +486,6 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
         prices,
         unit,
         data: {
-          feeOnTransfer: _isSrcTokenTransferFeeToBeExchanged,
           path: [
             {
               tokenIn: from.address,
@@ -552,12 +508,6 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
     side: SwapSide,
     blockNumber: number,
     limitPools?: string[],
-    transferFees: TransferFeeParams = {
-      srcFee: 0,
-      destFee: 0,
-      srcDexFee: 0,
-      destDexFee: 0,
-    },
   ): Promise<null | ExchangePrices<AlgebraData>> {
     try {
       const _srcToken = this.dexHelper.config.wrapETH(srcToken);
@@ -568,11 +518,6 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
         _destToken,
       );
 
-      const _isSrcTokenTransferFeeToBeExchanged =
-        isSrcTokenTransferFeeToBeExchanged(transferFees);
-      const _isDestTokenTransferFeeToBeExchanged =
-        isDestTokenTransferFeeToBeExchanged(transferFees);
-
       if (_srcAddress === _destAddress) return null;
 
       if (
@@ -581,14 +526,8 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
         return null;
 
       const pool = await this.getPool(_srcAddress, _destAddress, blockNumber);
-      if (!pool) return null;
 
-      if (_isSrcTokenTransferFeeToBeExchanged && side == SwapSide.BUY) {
-        this.logger.error(
-          `pool: ${pool.poolAddress} doesn't support buy for tax srcToken ${srcToken.address}`,
-        );
-        return null;
-      }
+      if (!pool) return null;
 
       if (this.config.forceRPC) {
         const rpcPrice = await this.getPricingFromRpc(
@@ -597,7 +536,6 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
           amounts,
           side,
           pool,
-          transferFees,
         );
 
         return rpcPrice;
@@ -632,7 +570,6 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
             amounts,
             side,
             pool,
-            transferFees,
           );
 
           return rpcPrice;
@@ -664,26 +601,16 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
       const balanceDestToken =
         _destAddress === pool.token0 ? state.balance0 : state.balance1;
 
-      const [unitAmountWithFee, ...amountsWithFee] =
-        _isSrcTokenTransferFeeToBeExchanged
-          ? applyTransferFee(
-              [unitAmount, ..._amounts],
-              side,
-              transferFees.srcDexFee,
-              this.SRC_TOKEN_DEX_TRANSFERS,
-            )
-          : [unitAmount, ..._amounts];
-
       const unitResult = this._getOutputs(
         state,
-        [unitAmountWithFee],
+        [unitAmount],
         zeroForOne,
         side,
         balanceDestToken,
       );
       const pricesResult = this._getOutputs(
         state,
-        amountsWithFee,
+        _amounts,
         zeroForOne,
         side,
         balanceDestToken,
@@ -694,20 +621,10 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
         return null;
       }
 
-      const [unitResultWithFee, ...pricesResultWithFee] =
-        _isDestTokenTransferFeeToBeExchanged
-          ? applyTransferFee(
-              [unitResult.outputs[0], ...pricesResult.outputs],
-              side,
-              transferFees.destDexFee,
-              this.DEST_TOKEN_DEX_TRANSFERS,
-            )
-          : [unitResult.outputs[0], ...pricesResult.outputs];
-
-      const prices = [0n, ...pricesResultWithFee];
+      const prices = [0n, ...pricesResult.outputs];
       const gasCost = [
         0,
-        ...pricesResultWithFee.map((p, index) => {
+        ...pricesResult.outputs.map((p, index) => {
           if (p == 0n) {
             return 0;
           } else {
@@ -722,10 +639,9 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
 
       return [
         {
-          unit: unitResultWithFee,
+          unit: unitResult.outputs[0],
           prices,
           data: {
-            feeOnTransfer: _isSrcTokenTransferFeeToBeExchanged,
             path: [
               {
                 tokenIn: _srcAddress,
@@ -758,20 +674,19 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
     data: AlgebraData,
     side: SwapSide,
   ): AdapterExchangeParam {
-    let path = this._encodePath(data.path, side);
+    const { path: rawPath } = data;
+    const path = this._encodePath(rawPath, side);
 
     const payload = this.abiCoder.encodeParameter(
       {
         ParentStruct: {
           path: 'bytes',
           deadline: 'uint256',
-          feeOnTransfer: 'bool',
         },
       },
       {
         path,
         deadline: getLocalDeadlineAsFriendlyPlaceholder(), // FIXME: more gas efficient to pass block.timestamp in adapter
-        feeOnTransfer: data.feeOnTransfer,
       },
     );
 
@@ -815,46 +730,30 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
     data: AlgebraData,
     side: SwapSide,
   ): Promise<SimpleExchangeParam> {
-    let swapFunction;
-    let swapParams;
-
-    if (data.feeOnTransfer) {
-      swapFunction = AlgebraFunctions.exactInputWithFeeToken;
-      swapParams = {
-        limitSqrtPrice: '0',
-        recipient: this.augustusAddress,
-        deadline: getLocalDeadlineAsFriendlyPlaceholder(),
-        amountIn: srcAmount,
-        amountOutMinimum: destAmount,
-        tokenIn: data.path[0].tokenIn,
-        tokenOut: data.path[0].tokenOut,
-      };
-    } else {
-      swapFunction =
-        side === SwapSide.SELL
-          ? AlgebraFunctions.exactInput
-          : AlgebraFunctions.exactOutput;
-      const path = this._encodePath(data.path, side);
-      swapParams =
-        side === SwapSide.SELL
-          ? {
-              recipient: this.augustusAddress,
-              deadline: getLocalDeadlineAsFriendlyPlaceholder(),
-              amountIn: srcAmount,
-              amountOutMinimum: destAmount,
-              path,
-            }
-          : {
-              recipient: this.augustusAddress,
-              deadline: getLocalDeadlineAsFriendlyPlaceholder(),
-              amountOut: destAmount,
-              amountInMaximum: srcAmount,
-              path,
-            };
-    }
-
+    const swapFunction =
+      side === SwapSide.SELL
+        ? UniswapV3Functions.exactInput
+        : UniswapV3Functions.exactOutput;
+
+    const path = this._encodePath(data.path, side);
+    const swapFunctionParams: UniswapV3SimpleSwapParams =
+      side === SwapSide.SELL
+        ? {
+            recipient: this.augustusAddress,
+            deadline: getLocalDeadlineAsFriendlyPlaceholder(),
+            amountIn: srcAmount,
+            amountOutMinimum: destAmount,
+            path,
+          }
+        : {
+            recipient: this.augustusAddress,
+            deadline: getLocalDeadlineAsFriendlyPlaceholder(),
+            amountOut: destAmount,
+            amountInMaximum: srcAmount,
+            path,
+          };
     const swapData = this.routerIface.encodeFunctionData(swapFunction, [
-      swapParams,
+      swapFunctionParams,
     ]);
 
     return this.buildSimpleParamWithoutWETHConversion(

package/src/dex/algebra/config.ts

@@ -98,7 +98,7 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.BUY]: [{ name: 'PolygonZkEvmBuyAdapter', index: 1 }],
   },
   [Network.ARBITRUM]: {
-    [SwapSide.SELL]: [{ name: 'ArbitrumAdapter02', index: 7 }],
+    [SwapSide.SELL]: [{ name: 'ArbitrumAdapter01', index: 3 }],
     [SwapSide.BUY]: [{ name: 'ArbitrumBuyAdapter', index: 2 }],
   },
   [Network.OPTIMISM]: {

package/src/dex/algebra/types.ts

@@ -58,21 +58,9 @@ export type AlgebraData = {
     tokenIn: Address;
     tokenOut: Address;
   }[];
-  feeOnTransfer: boolean;
   isApproved?: boolean;
 };
 
-export type AlgebraDataWithFee = {
-  tokenIn: Address;
-  tokenOut: Address;
-};
-
-export enum AlgebraFunctions {
-  exactInput = 'exactInput',
-  exactOutput = 'exactOutput',
-  exactInputWithFeeToken = 'exactInputSingleSupportingFeeOnTransferTokens',
-}
-
 export type DexParams = {
   router: Address;
   quoter: Address;

package/src/dex/hashflow/config.ts

@@ -1,26 +1,26 @@
-import { DexParams } from './types';
-import { DexConfigMap, AdapterMappings } from '../../types';
 import { Network, SwapSide } from '../../constants';
+import { AdapterMappings, DexConfigMap } from '../../types';
+import { DexParams } from './types';
 
 export const HashflowConfig: DexConfigMap<DexParams> = {
   Hashflow: {
     [Network.MAINNET]: {
-      routerAddress: '0xf6a94dfd0e6ea9ddfdffe4762ad4236576136613',
+      routerAddress: '0x55084eE0fEf03f14a305cd24286359A35D735151',
     },
     [Network.POLYGON]: {
-      routerAddress: '0x72550597dc0b2e0bec24e116add353599eff2e35',
+      routerAddress: '0x55084eE0fEf03f14a305cd24286359A35D735151',
     },
     [Network.BSC]: {
-      routerAddress: '0x0acffb0fb2cddd9bd35d03d359f3d899e32facc9',
+      routerAddress: '0x55084eE0fEf03f14a305cd24286359A35D735151',
     },
     [Network.ARBITRUM]: {
-      routerAddress: '0x1f772fa3bc263160ea09bb16ce1a6b8fc0fab36a',
+      routerAddress: '0x55084eE0fEf03f14a305cd24286359A35D735151',
     },
     [Network.AVALANCHE]: {
-      routerAddress: '0x64d2f9f44fe26c157d552ae7eaa613ca6587b59e',
+      routerAddress: '0x55084eE0fEf03f14a305cd24286359A35D735151',
     },
     [Network.OPTIMISM]: {
-      routerAddress: '0xb3999f658c0391d94a37f7ff328f3fec942bcadc',
+      routerAddress: '0xCa310B1B942A30Ff4b40a5E1b69AB4607eC79Bc1',
     },
   },
 };

package/src/dex/hashflow/hashflow-e2e.test.ts

@@ -1,15 +1,15 @@
 import dotenv from 'dotenv';
 dotenv.config();
 
-import { testE2E } from '../../../tests/utils-e2e';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import {
-  Tokens,
   Holders,
   NativeTokenSymbols,
+  Tokens,
 } from '../../../tests/constants-e2e';
-import { Network, ContractMethod, SwapSide } from '../../constants';
-import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { testE2E } from '../../../tests/utils-e2e';
 import { generateConfig } from '../../config';
+import { ContractMethod, Network, SwapSide } from '../../constants';
 
 // Give time for rate fetcher to fill the cache
 const sleepMs = 3000;

package/src/dex/hashflow/hashflow-integration.test.ts

@@ -2,16 +2,17 @@
 import dotenv from 'dotenv';
 dotenv.config();
 
-import { DummyDexHelper } from '../../dex-helper/index';
-import { Network, SwapSide } from '../../constants';
-import { BI_POWS } from '../../bigint-constants';
-import { Hashflow } from './hashflow';
+import { Tokens } from '../../../tests/constants-e2e';
 import {
+  checkConstantPoolPrices,
   checkPoolPrices,
   checkPoolsLiquidity,
-  checkConstantPoolPrices,
+  sleep,
 } from '../../../tests/utils';
-import { Tokens } from '../../../tests/constants-e2e';
+import { BI_POWS } from '../../bigint-constants';
+import { Network, SwapSide } from '../../constants';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Hashflow } from './hashflow';
 
 async function testPricingOnNetwork(
   hashflow: Hashflow,
@@ -104,6 +105,8 @@ describe('Hashflow', function () {
     beforeAll(async () => {
       blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
       hashflow = new Hashflow(network, dexKey, dexHelper);
+      await hashflow.initializePricing(0);
+      await sleep(5000);
     });
 
     it('getPoolIdentifiers and getPricesVolume SELL', async function () {