@paraswap/dex-lib 3.8.1 → 3.8.3

package/src/dex/aave-v3/aave-v3-e2e.test.ts

@@ -21,7 +21,7 @@ describe('AaveV3 E2E', () => {
 
   beforeAll(async () => {
     let results: Promise<void>[] = [];
-    for (const networkEntry in Network) {
+    for (const networkEntry of Object.values(Network)) {
       if (isNaN(Number(networkEntry))) {
         break;
       }
@@ -446,15 +446,10 @@ describe('AaveV3 E2E', () => {
     );
 
     const pairs = [
-      {
-        tokenSymbol: 'USDC',
-        aTokenSymbol: 'aEthUSDC',
-        amount: '10000',
-      },
       {
         tokenSymbol: 'ETH',
         aTokenSymbol: 'aEthWETH',
-        amount: '100000000',
+        amount: '1000000000000000000',
       },
       {
         tokenSymbol: 'WETH',
@@ -481,7 +476,7 @@ describe('AaveV3 E2E', () => {
           describe(`${contractMethod}`, () => {
             it(pair.aTokenSymbol + ' -> ' + pair.tokenSymbol, async () => {
               await testE2E(
-                getTokenFromASymbol(network, pair.aTokenSymbol)!,
+                tokens[pair.aTokenSymbol],
                 tokens[pair.tokenSymbol],
                 holders[pair.aTokenSymbol],
                 pair.amount,
@@ -496,7 +491,7 @@ describe('AaveV3 E2E', () => {
             it(pair.tokenSymbol + ' -> ' + pair.aTokenSymbol, async () => {
               await testE2E(
                 tokens[pair.tokenSymbol],
-                getTokenFromASymbol(network, pair.aTokenSymbol)!,
+                tokens[pair.aTokenSymbol],
                 holders[pair.tokenSymbol],
                 pair.amount,
                 side,

package/src/dex/aave-v3/aave-v3.ts

@@ -246,6 +246,7 @@ export class AaveV3 extends SimpleExchange implements IDex<Data, Param> {
       exchangeData,
       targetExchange: swapCallee,
       returnAmountPos: undefined,
+      skipApproval: data.fromAToken,
     };
   }
 
@@ -308,6 +309,10 @@ export class AaveV3 extends SimpleExchange implements IDex<Data, Param> {
       destAmount,
       swapData,
       swapCallee,
+      undefined,
+      undefined,
+      undefined,
+      data.fromAToken,
     );
   }
 

package/src/dex/aave-v3-stata/aave-v3-stata.ts

@@ -427,6 +427,7 @@ export class AaveV3Stata
       exchangeData: swapData,
       targetExchange: exchange,
       returnAmountPos,
+      skipApproval: srcType === TokenType.STATA_TOKEN,
     };
   }
 

package/src/dex/angle-staked-stable/angle-staked-stable.ts

@@ -215,6 +215,7 @@ export class AngleStakedStable
               this.augustusAddress,
             ],
           );
+    const skipApproval = srcToken.toLowerCase() !== this.config.agToken;
 
     return this.buildSimpleParamWithoutWETHConversion(
       srcToken,
@@ -223,6 +224,10 @@ export class AngleStakedStable
       destAmount,
       swapData,
       exchange,
+      undefined,
+      undefined,
+      undefined,
+      skipApproval,
     );
   }
 
@@ -254,12 +259,15 @@ export class AngleStakedStable
             ],
           );
 
+    const skipApproval = srcToken.toLowerCase() !== this.config.agToken;
+
     return {
       needWrapNative: this.needWrapNative,
       dexFuncHasRecipient: true,
       exchangeData: swapData,
       targetExchange: exchange,
       returnAmountPos: undefined,
+      skipApproval,
     };
   }
 

package/src/dex/compound/compound.ts

@@ -76,6 +76,10 @@ export class Compound
       destAmount,
       swapData,
       cToken,
+      undefined,
+      undefined,
+      undefined,
+      data.fromCToken,
     );
   }
 
@@ -102,6 +106,7 @@ export class Compound
       exchangeData: swapData,
       targetExchange: cToken,
       returnAmountPos: undefined,
+      skipApproval: data.fromCToken,
     };
   }
 }

package/src/dex/etherfi.ts

@@ -127,6 +127,7 @@ export class EtherFi
 
     // if src token is WETH, we need to withdraw from weth and pass eth value on call. For other cases, we need to approve and perform call
     const isSrcTokenWeth = this.isWETH(srcToken);
+    const skipApproval = this.is_weETH(srcToken) && this.is_eETH(destToken);
 
     return this.buildSimpleParamWithoutWETHConversion(
       isSrcTokenWeth ? ETHER_ADDRESS : srcToken,
@@ -148,6 +149,7 @@ export class EtherFi
             values: ['0'],
           }
         : undefined,
+      skipApproval,
     );
   }
 
@@ -206,6 +208,8 @@ export class EtherFi
       swapFunctionParams,
     );
 
+    const skipApproval = this.is_weETH(srcToken) && this.is_eETH(destToken);
+
     return {
       needWrapNative: this.needWrapNative,
       dexFuncHasRecipient: false,
@@ -219,6 +223,7 @@ export class EtherFi
           ])
         : undefined,
       returnAmountPos: extractReturnAmountPosition(Interface, swapFunction),
+      skipApproval,
     };
   }
 

package/src/dex/idle-dao/idle-dao.ts

@@ -350,6 +350,7 @@ export class IdleDao extends SimpleExchange implements IDex<IdleDaoData> {
       exchangeData,
       targetExchange: swapCallee,
       returnAmountPos: side === SwapSide.SELL ? returnAmountPos : undefined,
+      skipApproval: data.fromIdleToken,
     };
   }
 

package/src/dex/paraswap-limit-orders/paraswap-limit-orders-e2e.test.ts

@@ -2,7 +2,7 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 import { testE2E } from '../../../tests/utils-e2e';
-import { Tokens } from '../../../tests/constants-e2e';
+import { Holders, Tokens } from '../../../tests/constants-e2e';
 import { Network, ContractMethod, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { ParaSwapOrderResponse, ParaSwapOrderBookResponse } from './types';
@@ -12,87 +12,168 @@ import { generateConfig } from '../../config';
 describe('ParaSwapLimitOrders E2E', () => {
   const dexKey = 'ParaSwapLimitOrders';
 
-  describe('ParaSwapLimitOrders MAINNET', () => {
-    const network = Network.MAINNET;
+  // describe('ParaSwapLimitOrders MAINNET', () => {
+  //   const network = Network.MAINNET;
+  //   const tokens = Tokens[network];
+  //   const provider = new StaticJsonRpcProvider(
+  //     generateConfig(network).privateHttpProvider,
+  //     network,
+  //   );
+  //
+  //   const tokenASymbol: string = 'DAI';
+  //   const tokenBSymbol: string = 'WETH';
+  //
+  //   // Do not change arbitrarily. Need to adjust the orders amounts too
+  //   const tokenAAmount: string = '50000000000000000000';
+  //   const tokenBAmount: string = '110000000000000000';
+  //
+  //   const sideToContractMethods = new Map([
+  //     [
+  //       SwapSide.SELL,
+  //       [
+  //         ContractMethod.simpleSwap,
+  //         ContractMethod.multiSwap,
+  //         ContractMethod.megaSwap,
+  //       ],
+  //     ],
+  //     [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+  //   ]);
+  //   const maker = '0xc3643bC869DC0dcd2Df8729fC3cb768d4F86F57a';
+  //   const taker = '0xCf8C4a46816b146Ed613d23f6D22e1711915d653';
+  //
+  //   const ordersToUse: ParaSwapOrderResponse[] = [
+  //     {
+  //       order: {
+  //         nonceAndMeta:
+  //           '6845735429342786815130681271919807714789080615235334578045452288',
+  //         expiry: '0',
+  //         makerAsset: tokens[tokenASymbol].address,
+  //         takerAsset: tokens[tokenBSymbol].address,
+  //         maker,
+  //         taker: '0x0000000000000000000000000000000000000000',
+  //         makerAmount: '10000000000000000000',
+  //         takerAmount: '20000000000000000',
+  //       },
+  //       signature:
+  //         '0xa75880885e92ed7d46c842d3d20138c60c33c411642ec33a82b73216c508b5503bc57a3ec4fcc2f8ece2477c9eb9716850ae8b97f64d86afac56d3dace8f9f701b',
+  //       takerTokenFillAmount: '20000000000000000',
+  //       permitTakerAsset: '0x',
+  //       permitMakerAsset: '0x',
+  //     },
+  //     {
+  //       order: {
+  //         nonceAndMeta:
+  //           '11585127861177800418865894644506682666974354234368387567816015872',
+  //         expiry: '0',
+  //         makerAsset: tokens[tokenASymbol].address,
+  //         takerAsset: tokens[tokenBSymbol].address,
+  //         maker,
+  //         taker: '0x0000000000000000000000000000000000000000',
+  //         makerAmount: '50000000000000000000',
+  //         takerAmount: '110000000000000000',
+  //       },
+  //       signature:
+  //         '0x33ce6d9a609190d3d936c0cac2609ab13ad9aaa64d79917d32064003903105302cb80dcf0133e102d513a45c61d9b813a9c85b2f627aec7fed53d858dad90df61c',
+  //       takerTokenFillAmount: '110000000000000000',
+  //       permitTakerAsset: '0x',
+  //       permitMakerAsset: '0x',
+  //     },
+  //     {
+  //       order: {
+  //         nonceAndMeta:
+  //           '11375705433687422051822427911677732183148366573414372269099057152',
+  //         expiry: '0',
+  //         makerAsset: tokens[tokenASymbol].address,
+  //         takerAsset: tokens[tokenBSymbol].address,
+  //         maker,
+  //         taker: '0x0000000000000000000000000000000000000000',
+  //         makerAmount: '70000000000000000000',
+  //         takerAmount: '170000000000000000',
+  //       },
+  //       signature:
+  //         '0x989eec978c60b1104c7133beae1da691353d138f1fe32862e75a9fc36d294e92655e327fcaa83b6506c6712268ea03423249714308418955dfcc067583fd823a1b',
+  //       takerTokenFillAmount: '170000000000000000',
+  //       permitTakerAsset: '0x',
+  //       permitMakerAsset: '0x',
+  //     },
+  //   ];
+  //
+  //   const orderBookToUse: ParaSwapOrderBookResponse[] = ordersToUse.map(o => ({
+  //     swappableMakerBalance: o.order.makerAmount,
+  //     swappableTakerBalance: o.order.takerAmount,
+  //   }));
+  //
+  //   const dummyLimitOrderProvider = new DummyLimitOrderProvider();
+  //   dummyLimitOrderProvider.setOrdersToExecute(network, ordersToUse);
+  //   dummyLimitOrderProvider.setOrderBook(
+  //     network,
+  //     tokens[tokenBSymbol].address,
+  //     tokens[tokenASymbol].address,
+  //     orderBookToUse,
+  //   );
+  //
+  //   sideToContractMethods.forEach((contractMethods, side) =>
+  //     contractMethods.forEach((contractMethod: ContractMethod) => {
+  //       describe(`${contractMethod}`, () => {
+  //         it(`${network} ${side} ${contractMethod} ${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+  //           await testE2E(
+  //             tokens[tokenBSymbol],
+  //             tokens[tokenASymbol],
+  //             taker,
+  //             side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
+  //             side,
+  //             dexKey,
+  //             contractMethod,
+  //             network,
+  //             provider,
+  //             undefined,
+  //             dummyLimitOrderProvider,
+  //           );
+  //         });
+  //       });
+  //     }),
+  //   );
+  // });
+
+  describe('USDC -> DAI.e', () => {
+    const network = Network.AVALANCHE;
     const tokens = Tokens[network];
+    const holders = Holders[network];
+
     const provider = new StaticJsonRpcProvider(
       generateConfig(network).privateHttpProvider,
       network,
     );
 
-    const tokenASymbol: string = 'DAI';
-    const tokenBSymbol: string = 'WETH';
-
-    // Do not change arbitrarily. Need to adjust the orders amounts too
-    const tokenAAmount: string = '50000000000000000000';
-    const tokenBAmount: string = '110000000000000000';
-
     const sideToContractMethods = new Map([
-      [
-        SwapSide.SELL,
-        [
-          ContractMethod.simpleSwap,
-          ContractMethod.multiSwap,
-          ContractMethod.megaSwap,
-        ],
-      ],
-      [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+      [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+      [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
     ]);
-    const maker = '0xc3643bC869DC0dcd2Df8729fC3cb768d4F86F57a';
-    const taker = '0xCf8C4a46816b146Ed613d23f6D22e1711915d653';
+
+    const tokenASymbol: string = 'USDC';
+    const tokenBSymbol: string = 'DAIE';
+
+    const tokenAAmount: string = '2200000';
+    const tokenBAmount: string = '2000000000000000000';
+
+    const maker = '0x450C01300B83bE379113256038b4Dd3b45d23B5e';
+    const taker = '0x187b6Ab771482CCFEE7cD2C35176080631082368';
 
     const ordersToUse: ParaSwapOrderResponse[] = [
       {
         order: {
           nonceAndMeta:
-            '6845735429342786815130681271919807714789080615235334578045452288',
+            '1970736690787950733482238420044572595585384097365282143164432384',
           expiry: '0',
-          makerAsset: tokens[tokenASymbol].address,
-          takerAsset: tokens[tokenBSymbol].address,
+          makerAsset: '0xd586e7f844cea2f87f50152665bcbc2c279d8d70',
+          takerAsset: '0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
           maker,
           taker: '0x0000000000000000000000000000000000000000',
-          makerAmount: '10000000000000000000',
-          takerAmount: '20000000000000000',
+          makerAmount: '2000000000000000000',
+          takerAmount: '2200000',
         },
-        signature:
-          '0xa75880885e92ed7d46c842d3d20138c60c33c411642ec33a82b73216c508b5503bc57a3ec4fcc2f8ece2477c9eb9716850ae8b97f64d86afac56d3dace8f9f701b',
-        takerTokenFillAmount: '20000000000000000',
-        permitTakerAsset: '0x',
-        permitMakerAsset: '0x',
-      },
-      {
-        order: {
-          nonceAndMeta:
-            '11585127861177800418865894644506682666974354234368387567816015872',
-          expiry: '0',
-          makerAsset: tokens[tokenASymbol].address,
-          takerAsset: tokens[tokenBSymbol].address,
-          maker,
-          taker: '0x0000000000000000000000000000000000000000',
-          makerAmount: '50000000000000000000',
-          takerAmount: '110000000000000000',
-        },
-        signature:
-          '0x33ce6d9a609190d3d936c0cac2609ab13ad9aaa64d79917d32064003903105302cb80dcf0133e102d513a45c61d9b813a9c85b2f627aec7fed53d858dad90df61c',
-        takerTokenFillAmount: '110000000000000000',
-        permitTakerAsset: '0x',
-        permitMakerAsset: '0x',
-      },
-      {
-        order: {
-          nonceAndMeta:
-            '11375705433687422051822427911677732183148366573414372269099057152',
-          expiry: '0',
-          makerAsset: tokens[tokenASymbol].address,
-          takerAsset: tokens[tokenBSymbol].address,
-          maker,
-          taker: '0x0000000000000000000000000000000000000000',
-          makerAmount: '70000000000000000000',
-          takerAmount: '170000000000000000',
-        },
-        signature:
-          '0x989eec978c60b1104c7133beae1da691353d138f1fe32862e75a9fc36d294e92655e327fcaa83b6506c6712268ea03423249714308418955dfcc067583fd823a1b',
-        takerTokenFillAmount: '170000000000000000',
+        signature: '0x',
+        takerTokenFillAmount: '2200000',
         permitTakerAsset: '0x',
         permitMakerAsset: '0x',
       },
@@ -101,6 +182,9 @@ describe('ParaSwapLimitOrders E2E', () => {
     const orderBookToUse: ParaSwapOrderBookResponse[] = ordersToUse.map(o => ({
       swappableMakerBalance: o.order.makerAmount,
       swappableTakerBalance: o.order.takerAmount,
+      makerAmount: o.order.makerAmount,
+      takerAmount: o.order.takerAmount,
+      isFillOrKill: true,
     }));
 
     const dummyLimitOrderProvider = new DummyLimitOrderProvider();
@@ -117,10 +201,10 @@ describe('ParaSwapLimitOrders E2E', () => {
         describe(`${contractMethod}`, () => {
           it(`${network} ${side} ${contractMethod} ${tokenASymbol} -> ${tokenBSymbol}`, async () => {
             await testE2E(
-              tokens[tokenBSymbol],
               tokens[tokenASymbol],
-              taker,
-              side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
+              tokens[tokenBSymbol],
+              holders[tokenASymbol],
+              side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
               side,
               dexKey,
               contractMethod,

package/src/dex/paraswap-limit-orders/paraswap-limit-orders.ts

@@ -38,6 +38,7 @@ import {
   ONE_ORDER_GASCOST,
 } from './constant';
 import BigNumber from 'bignumber.js';
+import { SpecialDex } from '../../executor/types';
 
 const BLACKLIST_CACHE_PREFIX = `lo_blacklist`;
 
@@ -397,7 +398,9 @@ export class ParaSwapLimitOrders
       needWrapNative: this.needWrapNative,
       dexFuncHasRecipient: true,
       exchangeData: swapData,
+      specialDexFlag: SpecialDex.SWAP_ON_AUGUSTUS_RFQ,
       targetExchange: this.augustusRFQAddress,
+      specialDexSupportsInsertFromAmount: true,
       returnAmountPos: undefined,
     };
   }

package/src/dex/simple-exchange.ts

@@ -110,12 +110,12 @@ export class SimpleExchange {
     spender?: Address,
     networkFee: NumberAsString = '0',
     preCalls?: Omit<SimpleExchangeParam, 'networkFee'>,
+    skipApproval?: boolean,
   ): Promise<SimpleExchangeParam> {
-    const approveParam = await this.getApproveSimpleParam(
-      src,
-      spender || swapCallee,
-      srcAmount,
-    );
+    const approveParam = skipApproval
+      ? { callees: [], calldata: [], values: [], networkFee: '0' }
+      : await this.getApproveSimpleParam(src, spender || swapCallee, srcAmount);
+
     const swapValue = (
       BigInt(networkFee) + (isETHAddress(src) ? BigInt(srcAmount) : 0n)
     ).toString();

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

@@ -29,9 +29,17 @@ function testForNetwork(
         ContractMethod.simpleSwap,
         ContractMethod.multiSwap,
         ContractMethod.megaSwap,
+        ContractMethod.swapExactAmountIn,
+      ],
+    ],
+    [
+      SwapSide.BUY,
+      [
+        ContractMethod.simpleBuy,
+        ContractMethod.buy,
+        ContractMethod.swapExactAmountOut,
       ],
     ],
-    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
   ]);
 
   describe(`${network}`, () => {

package/src/dex/spark/spark.ts

@@ -207,6 +207,10 @@ export class Spark
       destAmount,
       swapData,
       exchange,
+      undefined,
+      undefined,
+      undefined,
+      isSell && this.isDai(destToken),
     );
   }
 
@@ -251,6 +255,7 @@ export class Spark
             this.isDai(srcToken) ? 'shares' : 'assets',
           )
         : undefined,
+      skipApproval: isSell && this.isDai(destToken),
     };
   }
 

package/src/executor/Executor01BytecodeBuilder.ts

@@ -268,6 +268,7 @@ export class Executor01BytecodeBuilder extends ExecutorBytecodeBuilder<
       (!isETHAddress(swap.srcToken) ||
         (isETHAddress(swap.srcToken) && index !== 0)) &&
       !curExchangeParam.transferSrcTokenBeforeSwap &&
+      !curExchangeParam.skipApproval &&
       curExchangeParam.approveData
     ) {
       const approveCallData = this.buildApproveCallData(
@@ -290,7 +291,8 @@ export class Executor01BytecodeBuilder extends ExecutorBytecodeBuilder<
           let approveWethCalldata = '0x';
           if (
             curExchangeParam.approveData &&
-            !curExchangeParam.transferSrcTokenBeforeSwap
+            !curExchangeParam.transferSrcTokenBeforeSwap &&
+            !curExchangeParam.skipApproval
           ) {
             approveWethCalldata = this.buildApproveCallData(
               curExchangeParam.approveData.target,

package/src/executor/Executor02BytecodeBuilder.ts

@@ -606,6 +606,7 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder<
     if (
       !isETHAddress(swap.srcToken) &&
       !curExchangeParam.transferSrcTokenBeforeSwap &&
+      !curExchangeParam.skipApproval &&
       curExchangeParam.approveData
     ) {
       const approveCallData = this.buildApproveCallData(
@@ -622,7 +623,8 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder<
         let approveWethCalldata = '0x';
         if (
           curExchangeParam.approveData &&
-          !curExchangeParam.transferSrcTokenBeforeSwap
+          !curExchangeParam.transferSrcTokenBeforeSwap &&
+          !curExchangeParam.skipApproval
         ) {
           approveWethCalldata = this.buildApproveCallData(
             curExchangeParam.approveData.target,

package/src/executor/Executor03BytecodeBuilder.ts

@@ -147,6 +147,7 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
     if (
       flags.dexes[index] % 4 !== 1 && // not sendEth
       !isETHAddress(swap.srcToken) &&
+      !curExchangeParam.skipApproval &&
       curExchangeParam.approveData
     ) {
       // TODO: as we give approve for MAX_UINT and approve for current targetExchange was given
@@ -163,6 +164,7 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
     if (
       maybeWethCallData?.deposit &&
       isETHAddress(swap.srcToken) &&
+      !curExchangeParam.skipApproval &&
       curExchangeParam.needWrapNative
       // do deposit only for the first path with wrapping
       // exchangeParams.findIndex(p => p.needWrapNative) === index

package/src/executor/ExecutorBytecodeBuilder.ts

@@ -358,6 +358,8 @@ export abstract class ExecutorBytecodeBuilder<S = {}, D = {}> {
     swap: OptimalSwap,
     exchangeParam: DexExchangeParam,
   ): { target: string; token: Address } | null {
+    if (exchangeParam.skipApproval) return null;
+
     const target = exchangeParam.spender || exchangeParam.targetExchange;
 
     if (

package/src/executor/executor01-bytecode-builder-e2e.test.ts

@@ -102,6 +102,31 @@ describe('Executor01ByteCodeBuilder e2e tests', () => {
     const network = Network.MAINNET;
 
     describe('SimpleSwap', () => {
+      describe('AngleStakedStableUSD', () => {
+        const dexKey = 'AngleStakedStableUSD';
+
+        const tokens = Tokens[network];
+        const holders = Holders[network];
+        const provider = new StaticJsonRpcProvider(
+          generateConfig(network).privateHttpProvider,
+          network,
+        );
+
+        it('SimpleSwap stUSD -> USDA', async () => {
+          await testE2E(
+            tokens['stUSD'],
+            tokens['USDA'],
+            holders['stUSD'],
+            '1000000000000',
+            SwapSide.SELL,
+            dexKey,
+            ContractMethod.simpleSwap,
+            network,
+            provider,
+          );
+        });
+      });
+
       describe('UniswapV3', () => {
         const dexKey = 'UniswapV3';
 

package/src/executor/executor02-bytecode-builder-e2e.test.ts

@@ -23,6 +23,35 @@ describe('Executor02ByteCodeBuilder e2e tests', () => {
     describe('SimpleSwap', () => {
       const contractMethod = ContractMethod.simpleSwap;
 
+      describe('stUSD -> USDA via Angle Staked Stable USD', () => {
+        const dexKeys = ['AngleStakedStableUSD'];
+
+        const tokenASymbol: string = 'stUSD';
+        const tokenBSymbol: string = 'USDA';
+        const tokenAAmount: string = '60000000000000000000';
+
+        const side = SwapSide.SELL;
+
+        it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+          await testE2E(
+            tokens[tokenASymbol],
+            tokens[tokenBSymbol],
+            holders[tokenASymbol],
+            tokenAAmount,
+            side,
+            dexKeys,
+            contractMethod,
+            network,
+            provider,
+            undefined,
+            undefined,
+            undefined,
+            200,
+            2000,
+          );
+        });
+      });
+
       describe('ETH -> SUSHI via SushiSwapV3 and UniswapV3', () => {
         const dexKeys = ['SushiSwapV3', 'UniswapV3'];
 

package/src/types.ts

@@ -159,6 +159,7 @@ export type AdapterExchangeParam = {
 
 export type DexExchangeParam = {
   needWrapNative: boolean;
+  skipApproval?: boolean;
   wethAddress?: string;
   exchangeData: string;
   targetExchange: string;