@paraswap/dex-lib 2.45.0 → 3.0.0

package/src/dex/generic-rfq/generic-rfq.ts

@@ -7,6 +7,7 @@ import {
   Config,
   PoolLiquidity,
   Address,
+  DexExchangeParam,
 } from '../../types';
 import { Network, SwapSide } from '../../constants';
 import { IDexHelper } from '../../dex-helper';
@@ -18,10 +19,20 @@ import { RateFetcher } from './rate-fetcher';
 import {
   PriceAndAmountBigNumber,
   RFQConfig,
+  RFQDirectPayload,
+  RFQParams,
   SlippageCheckError,
 } from './types';
-import { OptimalSwapExchange } from '@paraswap/core';
+import {
+  ContractMethodV6,
+  NumberAsString,
+  OptimalSwapExchange,
+  ParaSwapVersion,
+} from '@paraswap/core';
 import { BI_MAX_UINT256 } from '../../bigint-constants';
+import { SpecialDex } from '../../executor/types';
+import { hexConcat, hexZeroPad, hexlify } from 'ethers/lib/utils';
+import { isETHAddress, uuidToBytes16 } from '../../utils';
 
 export const OVERORDER_BPS = 100;
 export const BPS_MAX_VALUE = 10000n;
@@ -193,6 +204,106 @@ export class GenericRFQ extends ParaSwapLimitOrders {
     ];
   }
 
+  static getDirectFunctionNameV6(): string[] {
+    return [ContractMethodV6.swapExactAmountInOutOnAugustusRFQTryBatchFill];
+  }
+
+  getDirectParamV6(
+    srcToken: Address,
+    destToken: Address,
+    fromAmount: NumberAsString,
+    toAmount: NumberAsString,
+    quotedAmount: NumberAsString,
+    data: ParaSwapLimitOrdersData,
+    side: SwapSide,
+    permit: string,
+    uuid: string,
+    partnerAndFee: string,
+    beneficiary: string,
+    blockNumber: number,
+    contractMethod?: string,
+  ) {
+    if (!contractMethod) throw new Error(`contractMethod need to be passed`);
+    if (!GenericRFQ.getDirectFunctionNameV6().includes(contractMethod!)) {
+      throw new Error(`Invalid contract method ${contractMethod}`);
+    }
+    if (data.orderInfos === null) {
+      throw new Error(
+        `Error_${this.dexKey}_getDirectParamV6 payload is not received. It may be because of` +
+          `not calling preProcessTransaction before`,
+      );
+    }
+
+    // 2 if dest is ETH, 1 if src is ETH, 0 if none
+    const wrap = isETHAddress(destToken) ? 2 : isETHAddress(srcToken) ? 1 : 0;
+
+    // 1 if need approve, 0 if not
+    const approve = data.isApproved ? 0 : 1;
+
+    // 0 for SELL, 1 for BUY
+    const direction = side === SwapSide.SELL ? 0 : 1;
+
+    const wrapApproveDirection = (direction << 3) | (approve << 2) | wrap;
+
+    const metadata = hexConcat([
+      hexZeroPad(uuidToBytes16(uuid), 16),
+      hexZeroPad(hexlify(blockNumber), 16),
+    ]);
+
+    const params: RFQParams = [
+      fromAmount,
+      toAmount,
+      wrapApproveDirection.toString(),
+      metadata,
+      beneficiary,
+    ];
+
+    const payload: RFQDirectPayload = [params, data.orderInfos, permit];
+
+    const encoder = (...params: (string | RFQDirectPayload)[]) => {
+      return this.augustusV6Interface.encodeFunctionData(
+        ContractMethodV6.swapExactAmountInOutOnAugustusRFQTryBatchFill,
+        [...params],
+      );
+    };
+
+    return { params: payload, encoder, networkFee: '0' };
+  }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: ParaSwapLimitOrdersData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const { orderInfos } = data;
+
+    if (orderInfos === null) {
+      throw new Error(
+        `Error_${this.dexKey}_getDexParam payload is not received. It may be because of` +
+          `not calling preProcessTransaction before`,
+      );
+    }
+
+    const isSell = side === SwapSide.SELL;
+
+    const specialDexExchangeData = this.rfqIface.encodeFunctionData(
+      isSell ? 'tryBatchFillOrderTakerAmount' : 'tryBatchFillOrderMakerAmount',
+      [orderInfos, isSell ? srcAmount : destAmount, recipient],
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: specialDexExchangeData,
+      specialDexFlag: SpecialDex.SWAP_ON_AUGUSTUS_RFQ,
+      targetExchange: this.augustusRFQAddress,
+    };
+  }
+
   async preProcessTransaction?(
     optimalSwapExchange: OptimalSwapExchange<ParaSwapLimitOrdersData>,
     srcToken: Token,
@@ -209,7 +320,7 @@ export class GenericRFQ extends ParaSwapLimitOrders {
         ? overOrder(optimalSwapExchange.srcAmount, OVERORDER_BPS)
         : overOrder(optimalSwapExchange.destAmount, 1),
       side,
-      this.augustusAddress,
+      options.executionContractAddress,
       options.txOrigin,
       options.partner,
     );
@@ -261,16 +372,22 @@ export class GenericRFQ extends ParaSwapLimitOrders {
       }
     }
 
+    let isApproved = false;
+
+    // isApproved is only used in direct method and available only for v6, then no need to check approve for v5
+    // because it's either done in getSimpleParam or approve call in the adapter smart contract
+    if (options.version === ParaSwapVersion.V6 && options.isDirectMethod) {
+      isApproved = await this.dexHelper.augustusApprovals.hasApproval(
+        options.executionContractAddress,
+        // ETH always need to be wrapped for RFQ
+        this.dexHelper.config.wrapETH(srcToken).address,
+        this.augustusRFQAddress,
+      );
+    }
+
     return [
-      {
-        ...optimalSwapExchange,
-        data: {
-          orderInfos: [order],
-        },
-      },
-      {
-        deadline: minDeadline,
-      },
+      { ...optimalSwapExchange, data: { orderInfos: [order], isApproved } },
+      { deadline: minDeadline },
     ];
   }
 

package/src/dex/generic-rfq/rate-fetcher.ts

@@ -25,7 +25,7 @@ import {
 import { checkOrder } from './utils';
 import {
   blacklistResponseValidator,
-  firmRateResponseValidator,
+  firmRateWithTakerValidator,
   pairsResponseValidator,
   pricesResponse,
   tokensResponseValidator,
@@ -420,14 +420,13 @@ export class RateFetcher {
       );
       const firmRateResp = validateAndCast<RFQFirmRateResponse>(
         data,
-        firmRateResponseValidator,
+        firmRateWithTakerValidator(takerAddress),
       );
 
       await checkOrder(
         this.dexHelper.config.data.network,
         this.dexHelper.config.data.augustusRFQAddress,
         this.dexHelper.multiWrapper,
-        takerAddress,
         firmRateResp.order,
         this.verifierContract,
       );

package/src/dex/generic-rfq/types.ts

@@ -1,7 +1,10 @@
 import BigNumber from 'bignumber.js';
 import { RequestConfig } from '../../dex-helper/irequest-wrapper';
-import { Address, Token } from '../../types';
-import { AugustusOrderWithString } from '../paraswap-limit-orders/types';
+import { Address, NumberAsString, Token } from '../../types';
+import {
+  AugustusOrderWithString,
+  OrderInfo,
+} from '../paraswap-limit-orders/types';
 
 export type Pair = {
   base: string;
@@ -100,3 +103,17 @@ export type RFQFirmRateResponse = {
 export class SlippageCheckError extends Error {}
 
 export class TooStrictSlippageCheckError extends Error {}
+
+export type RFQParams = [
+  fromAmount: NumberAsString,
+  toAmount: NumberAsString,
+  wrapApproveDirection: NumberAsString,
+  metadata: string,
+  beneficiary: Address,
+];
+
+export type RFQDirectPayload = [
+  params: RFQParams,
+  orders: OrderInfo[],
+  permit: string,
+];

package/src/dex/generic-rfq/utils.ts

@@ -16,15 +16,9 @@ export const checkOrder = async (
   network: Network,
   augustusRFQAddress: Address,
   multiWrapper: MultiWrapper,
-  takerAddress: Address,
   order: AugustusOrderWithStringAndSignature,
   verifierContract?: ERC1271Contract,
 ) => {
-  if (order.taker.toLowerCase() !== takerAddress.toLowerCase()) {
-    throw new Error(
-      `Taker mismatch, expected ${takerAddress} but signed order got ${order.taker}`,
-    );
-  }
   const hash = calculateOrderHash(network, order, augustusRFQAddress);
 
   if (verifierContract) {
@@ -69,12 +63,12 @@ export const checkOrder = async (
     );
   }
 
-  const takerBalance = BigInt(
+  const makerAllowance = BigInt(
     balance.allowances[DEFAULT_ID_ERC20_AS_STRING][augustusRFQAddress],
   );
-  if (takerBalance <= makerAmountBigInt) {
+  if (makerAllowance <= makerAmountBigInt) {
     throw new Error(
-      `maker does not have enough allowance (request ${makerAmountBigInt} value ${takerBalance}`,
+      `maker does not have enough allowance (request ${makerAmountBigInt} value ${makerAllowance}`,
     );
   }
 };

package/src/dex/generic-rfq/validators.ts

@@ -149,26 +149,12 @@ const stringStartWithHex0x = (
   return value;
 };
 
-const mustBeAllowedTaker = (
-  value: string,
-  helpers: CustomHelpers,
-): string | ErrorReport => {
-  const allowedTakers = [
-    '0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57'.toLowerCase(),
-  ];
-  return allowedTakers.includes(value.toLowerCase())
-    ? value
-    : helpers.message({
-        custom: `"order.taker" must be any of ${JSON.stringify(allowedTakers)}`,
-      });
-};
-
 export const orderWithSignatureValidator = joi
   .object({
     nonceAndMeta: joi.string().custom(stringPositiveBigIntValidator),
     expiry: joi.number().min(0),
     maker: addressSchema.required(),
-    taker: addressSchema.required().custom(mustBeAllowedTaker),
+    taker: addressSchema.required(),
     makerAsset: addressSchema.required(),
     takerAsset: addressSchema.required(),
     makerAmount: joi
@@ -190,3 +176,14 @@ export const firmRateResponseValidator = joi
     order: orderWithSignatureValidator.required(),
   })
   .unknown(true);
+
+export const firmRateWithTakerValidator = (taker: string) =>
+  firmRateResponseValidator.fork(['order.taker'], _ =>
+    _.required().custom((val, helpers) => {
+      const { value } = addressSchema.validate(val);
+      if (value !== taker.toLowerCase())
+        return helpers.message({ custom: `taker must be ${taker}` });
+
+      return value;
+    }),
+  );

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

@@ -35,9 +35,10 @@ describe('GMX E2E', () => {
       [
         SwapSide.SELL,
         [
-          ContractMethod.simpleSwap,
-          ContractMethod.multiSwap,
-          ContractMethod.megaSwap,
+          ContractMethod.swapExactAmountIn,
+          // ContractMethod.simpleSwap,
+          // ContractMethod.multiSwap,
+          // ContractMethod.megaSwap,
         ],
       ],
     ]);
@@ -89,7 +90,7 @@ describe('GMX E2E', () => {
     );
   });
 
-  describe('GMX ARBITRUM', () => {
+  describe('GMX ARBITRUM_V6', () => {
     const network = Network.ARBITRUM;
     const tokens = Tokens[network];
     const holders = Holders[network];
@@ -98,7 +99,8 @@ describe('GMX E2E', () => {
       network,
     );
 
-    const tokenASymbol: string = 'USDC';
+    // const tokenASymbol: string = 'USDC';
+    const tokenASymbol: string = 'USDT';
     const tokenBSymbol: string = 'WETH';
     const nativeTokenSymbol = NativeTokenSymbols[network];
 
@@ -110,9 +112,10 @@ describe('GMX E2E', () => {
       [
         SwapSide.SELL,
         [
-          ContractMethod.simpleSwap,
-          ContractMethod.multiSwap,
-          ContractMethod.megaSwap,
+          // ContractMethod.simpleSwap,
+          // ContractMethod.multiSwap,
+          // ContractMethod.megaSwap,
+          ContractMethod.swapExactAmountIn,
         ],
       ],
     ]);

package/src/dex/gmx/gmx.ts

@@ -8,6 +8,8 @@ import {
   SimpleExchangeParam,
   PoolLiquidity,
   Logger,
+  NumberAsString,
+  DexExchangeParam,
 } from '../../types';
 import { SwapSide, Network } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
@@ -207,6 +209,31 @@ export class GMX extends SimpleExchange implements IDex<GMXData> {
     };
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: GMXData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const exchangeData = Vault.interface.encodeFunctionData('swap', [
+      srcToken,
+      destToken,
+      recipient,
+    ]);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      transferSrcTokenBeforeSwap: this.params.vault,
+      swappedAmountNotPresentInExchangeData: true,
+      exchangeData,
+      targetExchange: this.params.vault,
+    };
+  }
+
   async updatePoolState(): Promise<void> {
     if (!this.supportedTokens.length) {
       const tokenAddresses = await GMXEventPool.getWhitelistedTokens(

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

@@ -36,12 +36,14 @@ function testForNetwork(
     [
       SwapSide.SELL,
       [
-        ContractMethod.simpleSwap,
-        ContractMethod.multiSwap,
-        ContractMethod.megaSwap,
+        ContractMethod.swapExactAmountIn,
+        // ContractMethod.simpleSwap,
+        // ContractMethod.multiSwap,
+        // ContractMethod.megaSwap,
       ],
     ],
-    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+    // [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
   ]);
 
   describe(`${network}`, () => {
@@ -190,7 +192,7 @@ describe('Hashflow E2E', () => {
       nativeTokenAmount,
     );
   });
-  describe('Polygon', () => {
+  describe('Polygon_V6', () => {
     const network = Network.POLYGON;
 
     const tokenASymbol: string = 'USDC';

package/src/dex/hashflow/hashflow.ts

@@ -23,9 +23,11 @@ import { IDex } from '../../dex/idex';
 import {
   AdapterExchangeParam,
   Address,
+  DexExchangeParam,
   ExchangePrices,
   ExchangeTxInfo,
   Logger,
+  NumberAsString,
   OptimalSwapExchange,
   PoolLiquidity,
   PoolPrices,
@@ -574,6 +576,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     let rfq: RfqResponse;
     try {
       rfq = await this.api.requestQuote({
+        // sender is not passed, so for now ignore executionContractAddress
         baseChain: chain,
         baseToken: normalizedSrcToken.address,
         quoteToken: normalizedDestToken.address,
@@ -582,7 +585,8 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
               baseTokenAmount: optimalSwapExchange.srcAmount,
             }
           : { quoteTokenAmount: optimalSwapExchange.destAmount }),
-        wallet: this.augustusAddress.toLowerCase(),
+        // receiver address
+        wallet: options.recipient.toLowerCase(),
         effectiveTrader: options.txOrigin.toLowerCase(),
         marketMakers: [mm],
       });
@@ -890,6 +894,49 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     );
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: HashflowData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const { quoteData, signature } = data;
+
+    assert(
+      quoteData !== undefined,
+      `${this.dexKey}-${this.network}: quoteData undefined`,
+    );
+
+    // Encode here the transaction arguments
+    const exchangeData = this.routerInterface.encodeFunctionData('tradeRFQT', [
+      [
+        quoteData.pool,
+        quoteData.externalAccount ?? ZERO_ADDRESS,
+        quoteData.trader,
+        quoteData.effectiveTrader ?? quoteData.trader,
+        quoteData.baseToken,
+        quoteData.quoteToken,
+        quoteData.baseTokenAmount,
+        quoteData.baseTokenAmount,
+        quoteData.quoteTokenAmount,
+        quoteData.quoteExpiry,
+        quoteData.nonce ?? 0,
+        quoteData.txid,
+        signature,
+      ],
+    ]);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData,
+      targetExchange: this.routerAddress,
+    };
+  }
+
   extractQuoteToken = (pair: {
     baseToken: string;
     baseTokenName: string;

package/src/dex/idex.ts

@@ -3,6 +3,7 @@ import {
   Address,
   SimpleExchangeParam,
   AdapterExchangeParam,
+  DexExchangeParam,
   TxInfo,
   NumberAsString,
   Token,
@@ -18,6 +19,11 @@ import {
 import { SwapSide, Network } from '../constants';
 import { IDexHelper } from '../dex-helper/idex-helper';
 
+export type Context = {
+  isGlobalSrcToken: boolean;
+  isGlobalDestToken: boolean;
+};
+
 export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
   needWrapNative: boolean;
   needsSequentialPreprocessing?: boolean;
@@ -68,6 +74,17 @@ export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
     side: SwapSide,
   ): AsyncOrSync<SimpleExchangeParam>;
 
+  getDexParam?(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: ExchangeData,
+    side: SwapSide,
+    context: Context,
+  ): AsyncOrSync<DexExchangeParam>;
+
   // Returns params required by direct swap method.
   // Only Dexes which have a direct method should implement this
   // Used if there is a possibility for direct swap (Eg. UniswapV2,
@@ -88,6 +105,23 @@ export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
     beneficiary: string,
     contractMethod?: string,
   ): TxInfo<DirectParam>;
+
+  // Same as above but for V6
+  getDirectParamV6?(
+    srcToken: Address,
+    destToken: Address,
+    fromAmount: NumberAsString,
+    toAmount: NumberAsString,
+    quotedAmount: NumberAsString,
+    data: ExchangeData,
+    side: SwapSide,
+    permit: string,
+    uuid: string,
+    partnerAndFee: string,
+    beneficiary: string,
+    blockNumber: number,
+    contractMethod?: string,
+  ): TxInfo<DirectParam>;
 }
 
 export interface IDexPricing<ExchangeData> {

package/src/dex/index.ts

@@ -1,10 +1,10 @@
 import _ from 'lodash';
 import { UnoptimizedRate } from '../types';
-import { CurveV2 } from './curve-v2';
+import { CurveV2 } from './curve-v2/curve-v2';
 import { IDexTxBuilder, DexContructor, IDex, IRouteOptimizer } from './idex';
 import { Jarvis } from './jarvis';
 import { JarvisV6 } from './jarvis-v6/jarvis-v6';
-import { StablePool } from './stable-pool';
+import { StablePool } from './stable-pool/stable-pool';
 import { Weth } from './weth/weth';
 import { PolygonMigrator } from './polygon-migrator/polygon-migrator';
 import { ZeroX } from './zerox';
@@ -17,24 +17,24 @@ import { uniswapMerge } from './uniswap-v2/optimizer';
 import { BiSwap } from './uniswap-v2/biswap';
 import { MDEX } from './uniswap-v2/mdex';
 import { Dfyn } from './uniswap-v2/dfyn';
-import { Bancor } from './bancor';
-import { BProtocol } from './bProtocol';
+import { Bancor } from './bancor/bancor';
+import { BProtocol } from './bProtocol/bProtocol';
 import { MStable } from './mStable';
 import { Shell } from './shell';
-import { Onebit } from './onebit';
-import { Compound } from './compound';
+import { Onebit } from './onebit/onebit';
+import { Compound } from './compound/compound';
 import { AaveV1 } from './aave-v1/aave-v1';
 import { AaveV2 } from './aave-v2/aave-v2';
 import { AaveV3 } from './aave-v3/aave-v3';
 import { OneInchLp } from './OneInchLp';
-import { DodoV1 } from './dodo-v1';
+import { DodoV1 } from './dodo-v1/dodo-v1';
 import { DodoV2 } from './dodo-v2';
-import { Smoothy } from './smoothy';
+import { Smoothy } from './smoothy/smoothy';
 import { Nerve } from './nerve/nerve';
 import { IDexHelper } from '../dex-helper';
 import { SwapSide } from '../constants';
 import { Adapters } from '../types';
-import { Lido } from './lido';
+import { Lido } from './lido/lido';
 import { Excalibur } from './uniswap-v2/excalibur';
 import { MakerPsm } from './maker-psm/maker-psm';
 import { KyberDmm } from './kyberdmm/kyberdmm';
@@ -76,7 +76,7 @@ import { ThenaFusion } from './quickswap/thena-fusion';
 import { TraderJoeV2 } from './trader-joe-v2';
 import { SwaapV2 } from './swaap-v2/swaap-v2';
 import { SpiritSwapV3 } from './quickswap/spiritswap-v3';
-import { TraderJoeV21 } from './trader-joe-v2.1';
+import { TraderJoeV21 } from './trader-joe-v2.1/trader-joe-v2.1';
 import { PancakeswapV3 } from './pancakeswap-v3/pancakeswap-v3';
 import { Algebra } from './algebra/algebra';
 import { QuickPerps } from './quick-perps/quick-perps';
@@ -175,6 +175,7 @@ export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<
 
 interface IGetDirectFunctionName {
   getDirectFunctionName?(): string[];
+  getDirectFunctionNameV6?(): string[];
 }
 
 export class DexAdapterService {
@@ -182,6 +183,7 @@ export class DexAdapterService {
     [key: string]: LegacyDexConstructor | DexContructor<any, any, any>;
   } = {};
   directFunctionsNames: string[];
+  directFunctionsNamesV6: string[];
   dexInstances: {
     [key: string]: IDexTxBuilder<any, any> | IDex<any, any, any>;
   } = {};
@@ -266,6 +268,17 @@ export class DexAdapterService {
       .filter(x => !!x)
       .map(v => v.toLowerCase());
 
+    // include GenericRFQ, because it has direct method for v6
+    this.directFunctionsNamesV6 = [...LegacyDexes, ...Dexes, GenericRFQ]
+      .flatMap(dexAdapter => {
+        const _dexAdapter = dexAdapter as IGetDirectFunctionName;
+        return _dexAdapter.getDirectFunctionNameV6
+          ? _dexAdapter.getDirectFunctionNameV6()
+          : [];
+      })
+      .filter(x => !!x)
+      .map(v => v.toLowerCase());
+
     this.uniswapV2Alias =
       this.network in UniswapV2Alias
         ? UniswapV2Alias[this.network].toLowerCase()
@@ -294,6 +307,10 @@ export class DexAdapterService {
     return this.directFunctionsNames.includes(functionName.toLowerCase());
   }
 
+  isDirectFunctionNameV6(functionName: string): boolean {
+    return this.directFunctionsNamesV6.includes(functionName.toLowerCase());
+  }
+
   getAllDexKeys() {
     return _.uniq(this.dexKeys);
   }

package/src/dex/jarvis-v6/jarvis-v6-e2e.test.ts

@@ -49,7 +49,7 @@ import { generateConfig } from '../../config';
 describe('JarvisV6 E2E', () => {
   const dexKey = 'JarvisV6';
 
-  describe('JarvisV6 MAINNET', () => {
+  describe('POLYGON', () => {
     const network = Network.POLYGON;
     const tokens = Tokens[network];
     const holders = Holders[network];
@@ -68,9 +68,10 @@ describe('JarvisV6 E2E', () => {
       [
         SwapSide.SELL,
         [
-          ContractMethod.simpleSwap,
-          ContractMethod.multiSwap,
-          ContractMethod.megaSwap,
+          ContractMethod.swapExactAmountIn,
+          // ContractMethod.simpleSwap,
+          // ContractMethod.multiSwap,
+          // ContractMethod.megaSwap,
         ],
       ],
     ]);