@paraswap/dex-lib 2.45.0 → 3.0.0

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

@@ -105,6 +105,37 @@ describe('Nerve', () => {
         );
       });
     });
+    describe('V6', () => {
+      describe(ContractMethod.swapExactAmountIn, () => {
+        const contractMethod = ContractMethod.swapExactAmountIn;
+        it('SELL BUSD -> USDC', async () => {
+          await testE2E(
+            tokens.BUSD,
+            tokens.USDC,
+            holders.BUSD,
+            '11000000000000000000',
+            SwapSide.SELL,
+            dexKey,
+            contractMethod,
+            network,
+            provider,
+          );
+        });
+        it('SELL BTCB -> anyBTC', async () => {
+          await testE2E(
+            tokens.bBTC,
+            tokens.anyBTC,
+            holders.bBTC,
+            '11000000000000000000',
+            SwapSide.SELL,
+            dexKey,
+            contractMethod,
+            network,
+            provider,
+          );
+        });
+      });
+    });
   });
 });
 
@@ -119,8 +150,9 @@ describe('Axial', () => {
       generateConfig(network).privateHttpProvider,
       network,
     );
+    const contractMethod = ContractMethod.swapExactAmountIn;
     describe('simpleSwap', () => {
-      const contractMethod = ContractMethod.simpleSwap;
+      // const contractMethod = ContractMethod.simpleSwap;
       it('SELL newFRAX -> MIM', async () => {
         await testE2E(
           tokens.newFRAX,
@@ -136,7 +168,7 @@ describe('Axial', () => {
       });
     });
     describe('multiSwap', () => {
-      const contractMethod = ContractMethod.multiSwap;
+      // const contractMethod = ContractMethod.multiSwap;
       it('SELL MIM -> USDCe', async () => {
         await testE2E(
           tokens.MIM,
@@ -199,7 +231,7 @@ describe('Axial', () => {
 describe('IronV2', () => {
   const dexKey = 'IronV2';
 
-  describe('Polygon', () => {
+  describe('Polygon_V6', () => {
     const network = Network.POLYGON;
     const tokens = Tokens[network];
     const holders = Holders[network];
@@ -207,54 +239,79 @@ describe('IronV2', () => {
       generateConfig(network).privateHttpProvider,
       network,
     );
-    describe('simpleSwap', () => {
-      const contractMethod = ContractMethod.simpleSwap;
+    describe('swapExactAmountIn', () => {
       it('SELL DAI -> USDC', async () => {
         await testE2E(
           tokens.DAI,
           tokens.USDC,
           holders.DAI,
-          '11000000000000000000',
+          '1100000000000000',
           SwapSide.SELL,
           dexKey,
-          contractMethod,
+          ContractMethod.swapExactAmountIn,
           network,
           provider,
         );
       });
-    });
-    describe('multiSwap', () => {
-      const contractMethod = ContractMethod.multiSwap;
-      it('SELL DAI -> USDC', async () => {
+      it('SELL MATIC -> USDC', async () => {
         await testE2E(
-          tokens.DAI,
+          tokens.MATIC,
           tokens.USDC,
-          holders.DAI,
-          '11000000000000000000',
+          holders.MATIC,
+          '1100000000000000',
           SwapSide.SELL,
           dexKey,
-          contractMethod,
+          ContractMethod.swapExactAmountIn,
           network,
           provider,
         );
       });
-    });
-    describe('megaSwap', () => {
-      const contractMethod = ContractMethod.megaSwap;
-      it('SELL DAI -> USDC', async () => {
+      it('SELL USDC -> MATIC', async () => {
         await testE2E(
-          tokens.DAI,
           tokens.USDC,
-          holders.DAI,
-          '11000000000000000000',
+          tokens.MATIC,
+          holders.USDC,
+          '1100000000000000',
           SwapSide.SELL,
           dexKey,
-          contractMethod,
+          ContractMethod.swapExactAmountIn,
           network,
           provider,
         );
       });
     });
+    // describe('multiSwap', () => {
+    //   const contractMethod = ContractMethod.multiSwap;
+    //   it('SELL DAI -> USDC', async () => {
+    //     await testE2E(
+    //       tokens.DAI,
+    //       tokens.USDC,
+    //       holders.DAI,
+    //       '11000000000000000000',
+    //       SwapSide.SELL,
+    //       dexKey,
+    //       contractMethod,
+    //       network,
+    //       provider,
+    //     );
+    //   });
+    // });
+    // describe('megaSwap', () => {
+    //   const contractMethod = ContractMethod.megaSwap;
+    //   it('SELL DAI -> USDC', async () => {
+    //     await testE2E(
+    //       tokens.DAI,
+    //       tokens.USDC,
+    //       holders.DAI,
+    //       '11000000000000000000',
+    //       SwapSide.SELL,
+    //       dexKey,
+    //       contractMethod,
+    //       network,
+    //       provider,
+    //     );
+    //   });
+    // });
   });
   describe('Avalanche', () => {
     const network = Network.AVALANCHE;
@@ -797,13 +854,13 @@ describe('Synapse', () => {
       network,
     );
     describe('simpleSwap', () => {
-      const contractMethod = ContractMethod.simpleSwap;
+      const contractMethod = ContractMethod.swapExactAmountIn;
       it('SELL USDC -> USDT', async () => {
         await testE2E(
           tokens.USDC,
           tokens.USDT,
           holders.USDC,
-          '111000000',
+          '1110000',
           SwapSide.SELL,
           dexKey,
           contractMethod,
@@ -812,39 +869,39 @@ describe('Synapse', () => {
         );
       });
     });
-    describe('multiSwap', () => {
-      const contractMethod = ContractMethod.multiSwap;
+    // describe('multiSwap', () => {
+    //   const contractMethod = ContractMethod.multiSwap;
 
-      it('SELL USDC -> USDT', async () => {
-        await testE2E(
-          tokens.USDC,
-          tokens.USDT,
-          holders.USDC,
-          '111000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('megaSwap', () => {
-      const contractMethod = ContractMethod.megaSwap;
-      it('SELL USDC -> USDT', async () => {
-        await testE2E(
-          tokens.USDC,
-          tokens.USDT,
-          holders.USDC,
-          '111000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
+    //   it('SELL USDC -> USDT', async () => {
+    //     await testE2E(
+    //       tokens.USDC,
+    //       tokens.USDT,
+    //       holders.USDC,
+    //       '111000000',
+    //       SwapSide.SELL,
+    //       dexKey,
+    //       contractMethod,
+    //       network,
+    //       provider,
+    //     );
+    //   });
+    // });
+    // describe('megaSwap', () => {
+    //   const contractMethod = ContractMethod.megaSwap;
+    //   it('SELL USDC -> USDT', async () => {
+    //     await testE2E(
+    //       tokens.USDC,
+    //       tokens.USDT,
+    //       holders.USDC,
+    //       '111000000',
+    //       SwapSide.SELL,
+    //       dexKey,
+    //       contractMethod,
+    //       network,
+    //       provider,
+    //     );
+    //   });
+    // });
   });
 
   describe('Fantom', () => {

package/src/dex/nerve/nerve.ts

@@ -9,6 +9,8 @@ import {
   SimpleExchangeParam,
   PoolLiquidity,
   Logger,
+  NumberAsString,
+  DexExchangeParam,
 } from '../../types';
 import nervePoolABIDefault from '../../abi/nerve/nerve-pool.json';
 import { SwapSide, Network } from '../../constants';
@@ -349,6 +351,40 @@ export class Nerve
     );
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: OptimizedNerveData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+
+    const { exchange, i, j, deadline } = data;
+
+    const swapFunctionParam: NervePoolSwapParams = [
+      i,
+      j,
+      srcAmount,
+      this.minConversionRate,
+      deadline,
+    ];
+
+    const swapData = this.nervePoolIface.encodeFunctionData(
+      NervePoolFunctions.swap,
+      swapFunctionParam,
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData: swapData,
+      targetExchange: exchange,
+    };
+  }
+
   async getTopPoolsForToken(
     tokenAddress: Address,
     limit: number,

package/src/dex/{onebit.ts → onebit/onebit.ts}

@@ -1,26 +1,18 @@
 import { Interface, JsonFragment } from '@ethersproject/abi';
 import { Provider } from '@ethersproject/providers';
-import { SwapSide } from '../constants';
-import { AdapterExchangeParam, Address, SimpleExchangeParam } from '../types';
-import { IDexTxBuilder } from './idex';
-import { SimpleExchange } from './simple-exchange';
-import OnebitABI from '../abi/Onebit.json';
-import Web3 from 'web3';
-import { IDexHelper } from '../dex-helper';
-
-export type OnebitData = {
-  router: Address;
-};
-type OnebitParam = [
-  srcToken: string,
-  destToken: string,
-  srcAmount: string,
-  destAmountMin: string,
-  to: string,
-];
-enum OnebitFunctions {
-  swapTokensWithTrust = 'swapTokensWithTrust',
-}
+import { SwapSide } from '../../constants';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  NumberAsString,
+  SimpleExchangeParam,
+} from '../../types';
+import { IDexTxBuilder } from '../idex';
+import { SimpleExchange } from '../simple-exchange';
+import OnebitABI from '../../abi/Onebit.json';
+import { IDexHelper } from '../../dex-helper';
+import { OnebitData, OnebitFunctions, OnebitParam } from './types';
 
 export class Onebit
   extends SimpleExchange
@@ -80,4 +72,34 @@ export class Onebit
       data.router,
     );
   }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: OnebitData,
+    _side: SwapSide,
+  ): DexExchangeParam {
+    const swapFunction = OnebitFunctions.swapTokensWithTrust;
+    const swapFunctionParams: OnebitParam = [
+      srcToken,
+      destToken,
+      srcAmount,
+      destAmount,
+      recipient,
+    ];
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: data.router,
+    };
+  }
 }

package/src/dex/onebit/types.ts

@@ -0,0 +1,17 @@
+import { Address } from '@paraswap/core';
+
+export type OnebitData = {
+  router: Address;
+};
+
+export type OnebitParam = [
+  srcToken: string,
+  destToken: string,
+  srcAmount: string,
+  destAmountMin: string,
+  to: string,
+];
+
+export enum OnebitFunctions {
+  swapTokensWithTrust = 'swapTokensWithTrust',
+}

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

@@ -323,7 +323,7 @@ describe('PancakeswapV3 E2E', () => {
     );
   });
 
-  describe('PancakeswapV3 Arbitrum', () => {
+  describe('PancakeswapV3 Arbitrum_V6', () => {
     const network = Network.ARBITRUM;
     const tokens = Tokens[network];
     const holders = Holders[network];
@@ -336,12 +336,14 @@ describe('PancakeswapV3 E2E', () => {
       [
         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]],
     ]);
 
     const pairs: { name: string; sellAmount: string; buyAmount: string }[][] = [
@@ -357,6 +359,18 @@ describe('PancakeswapV3 E2E', () => {
           buyAmount: '1000000000000000',
         },
       ],
+      [
+        {
+          name: 'USDT',
+          sellAmount: '5000000',
+          buyAmount: '5000000',
+        },
+        {
+          name: 'USDC',
+          sellAmount: '5000000',
+          buyAmount: '5000000',
+        },
+      ],
     ];
 
     sideToContractMethods.forEach((contractMethods, side) =>

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

@@ -11,6 +11,7 @@ import {
   Logger,
   NumberAsString,
   PoolPrices,
+  DexExchangeParam,
 } from '../../types';
 import { SwapSide, Network, CACHE_PREFIX } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
@@ -850,6 +851,51 @@ export class PancakeswapV3
     );
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: UniswapV3Data,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const swapFunction =
+      side === SwapSide.SELL
+        ? UniswapV3Functions.exactInput
+        : UniswapV3Functions.exactOutput;
+
+    const path = this._encodePath(data.path, side);
+
+    const swapFunctionParams: UniswapV3SimpleSwapParams =
+      side === SwapSide.SELL
+        ? {
+            recipient,
+            deadline: getLocalDeadlineAsFriendlyPlaceholder(),
+            amountIn: srcAmount,
+            amountOutMinimum: destAmount,
+            path,
+          }
+        : {
+            recipient,
+            deadline: getLocalDeadlineAsFriendlyPlaceholder(),
+            amountOut: destAmount,
+            amountInMaximum: srcAmount,
+            path,
+          };
+
+    const exchangeData = this.routerIface.encodeFunctionData(swapFunction, [
+      swapFunctionParams,
+    ]);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData,
+      targetExchange: this.config.router,
+    };
+  }
+
   async getTopPoolsForToken(
     tokenAddress: Address,
     limit: number,

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

@@ -13,6 +13,8 @@ import {
   OptimalSwapExchange,
   ExchangeTxInfo,
   PreprocessTransactionOptions,
+  NumberAsString,
+  DexExchangeParam,
 } from '../../types';
 import { SwapSide, Network, LIMIT_ORDER_PROVIDERS } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
@@ -367,6 +369,38 @@ export class ParaSwapLimitOrders
     );
   }
 
+  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}_getAdapterParam payload is not received. It may be because of` +
+          `not calling preProcessTransaction before`,
+      );
+    }
+
+    const isSell = side === SwapSide.SELL;
+    const swapData = this.rfqIface.encodeFunctionData(
+      isSell ? 'tryBatchFillOrderTakerAmount' : 'tryBatchFillOrderMakerAmount',
+      [orderInfos, isSell ? srcAmount : destAmount, recipient],
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: this.augustusRFQAddress,
+    };
+  }
+
   async getTopPoolsForToken(
     tokenAddress: Address,
     limit: number,

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

@@ -52,6 +52,7 @@ export type ParaSwapOrderBook = {
 export type ParaSwapLimitOrdersData = {
   orderInfos: OrderInfo[] | null;
   maxOrdersCount?: number;
+  isApproved?: boolean;
 };
 
 export type DexParams = {

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

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

package/src/dex/platypus/platypus.ts

@@ -9,6 +9,8 @@ import {
   PoolLiquidity,
   Logger,
   MultiCallInput,
+  NumberAsString,
+  DexExchangeParam,
 } from '../../types';
 import { SwapSide, Network } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
@@ -486,6 +488,47 @@ export class Platypus extends SimpleExchange implements IDex<PlatypusData> {
     );
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: PlatypusData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const swapData = isETHAddress(srcToken)
+      ? Platypus.avaxPoolInterface.encodeFunctionData('swapFromETH', [
+          destToken,
+          1,
+          recipient,
+          getLocalDeadlineAsFriendlyPlaceholder(),
+        ])
+      : isETHAddress(destToken)
+      ? Platypus.avaxPoolInterface.encodeFunctionData('swapToETH', [
+          srcToken,
+          srcAmount,
+          1,
+          recipient,
+          getLocalDeadlineAsFriendlyPlaceholder(),
+        ])
+      : Platypus.poolInterface.encodeFunctionData('swap', [
+          srcToken,
+          destToken,
+          srcAmount,
+          1,
+          recipient,
+          getLocalDeadlineAsFriendlyPlaceholder(),
+        ]);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: data.pool,
+    };
+  }
+
   // This is called once before getTopPoolsForToken is
   // called for multiple tokens. This can be helpful to
   // update common state required for calculating

package/src/dex/polygon-migrator/polygon-migrator-e2e.test.ts

@@ -26,12 +26,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.swapExactAmountOut]],
+    // [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
   ]);
 
   describe(`${network}`, () => {
@@ -75,7 +77,7 @@ function testForNetwork(
 describe('PolygonMigrator E2E', () => {
   const dexKey = 'PolygonMigrator';
 
-  describe('Mainnet', () => {
+  describe('Mainnet_V6', () => {
     const network = Network.MAINNET;
 
     const tokenASymbol: string = 'POL';