@paraswap/dex-lib 2.45.0 → 3.0.0

package/src/dex/swell/swell.ts

@@ -3,6 +3,7 @@ import { NumberAsString, SwapSide } from '@paraswap/core';
 import {
   AdapterExchangeParam,
   Address,
+  DexExchangeParam,
   ExchangePrices,
   Logger,
   PoolLiquidity,
@@ -102,8 +103,7 @@ export class Swell
     ).toLowerCase();
 
     return (
-      (isETHAddress(srcTokenAddress) || this.isWETH(srcTokenAddress)) &&
-      destTokenAddress === this.swETHAddress
+      isETHAddress(srcTokenAddress) && destTokenAddress === this.swETHAddress
     );
   }
 
@@ -219,6 +219,31 @@ export class Swell
     };
   }
 
+  // FIXME: Add WETH -> swWETH support
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: SwellData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    this.assertEligibility(srcToken, destToken, side);
+
+    const swapData = this.swETHInterface.encodeFunctionData(
+      swETHFunctions.deposit,
+      [],
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData: swapData,
+      targetExchange: this.swETHAddress,
+    };
+  }
+
   getCalldataGasCost(poolPrices: PoolPrices<SwellData>): number | number[] {
     return CALLDATA_GAS_COST.DEX_OVERHEAD + CALLDATA_GAS_COST.LENGTH_SMALL;
   }

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

@@ -29,9 +29,10 @@ async function testForNetwork(
     [
       SwapSide.SELL,
       [
-        ContractMethod.simpleSwap,
-        ContractMethod.multiSwap,
-        ContractMethod.megaSwap,
+        ContractMethod.swapExactAmountIn,
+        // ContractMethod.simpleSwap,
+        // ContractMethod.multiSwap,
+        // ContractMethod.megaSwap,
       ],
     ],
   ]);
@@ -127,7 +128,7 @@ async function testForNetwork(
 }
 
 describe('Synthetix E2E', () => {
-  describe('Synthetix MAINNET', () => {
+  describe('Synthetix MAINNET_V6', () => {
     const network = Network.MAINNET;
 
     const tokenChainlinkSymbol = 'sETH';

package/src/dex/synthetix/synthetix.ts

@@ -9,6 +9,8 @@ import {
   SimpleExchangeParam,
   PoolLiquidity,
   Logger,
+  NumberAsString,
+  DexExchangeParam,
 } from '../../types';
 import { SwapSide, Network } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
@@ -322,6 +324,42 @@ export class Synthetix extends SimpleExchange implements IDex<SynthetixData> {
     );
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: SynthetixData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+
+    const { exchange, srcKey, destKey } = data;
+
+    const swapData =
+      this.network === Network.OPTIMISM
+        ? this.combinedIface.encodeFunctionData('exchange', [
+            srcKey,
+            srcAmount,
+            destKey,
+          ])
+        : this.combinedIface.encodeFunctionData('exchangeAtomically', [
+            srcKey,
+            srcAmount,
+            destKey,
+            this.config.trackingCode,
+            '1',
+          ]);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData: swapData,
+      targetExchange: exchange,
+    };
+  }
+
   async updatePoolState(): Promise<void> {
     try {
       this.synthetixState.onchainConfigValues;

package/src/dex/trader-joe-v2.1/config.ts

@@ -0,0 +1,9 @@
+import { Address } from '@paraswap/core';
+import { Network } from '../../constants';
+
+export const TRADERJOE_V2_1_ROUTER_ADDRESS: { [network: number]: Address } = {
+  [Network.AVALANCHE]: '0xb4315e873dBcf96Ffd0acd8EA43f689D8c20fB30',
+  [Network.ARBITRUM]: '0xb4315e873dBcf96Ffd0acd8EA43f689D8c20fB30',
+  [Network.BSC]: '0xb4315e873dBcf96Ffd0acd8EA43f689D8c20fB30',
+  [Network.MAINNET]: '0x9A93a421b74F1c5755b83dD2C211614dC419C44b',
+};

package/src/dex/trader-joe-v2.1/trader-joe-v2.1-e2e.test.ts

@@ -0,0 +1,101 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import {
+  Tokens,
+  Holders,
+  NativeTokenSymbols,
+} from '../../../tests/constants-e2e';
+
+import { ContractMethod, Network, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+const dexKey = 'traderjoev2.1';
+
+const testForNetwork = (
+  network: Network,
+  swapMap: Map<SwapSide, ContractMethod[]>,
+) => {
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+
+  const nativeSymbol = NativeTokenSymbols[network];
+
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+
+  const tokensToTest = [
+    [
+      {
+        symbol: 'USDC',
+        amount: (10 ** 8).toString(),
+      },
+      {
+        symbol: 'USDT',
+        amount: (10 ** 8).toString(),
+      },
+    ],
+    [
+      {
+        symbol: 'USDT',
+        amount: (10 ** 8).toString(),
+      },
+      {
+        symbol: 'DAI',
+        amount: (10 ** 8).toString(),
+      },
+    ],
+  ];
+
+  swapMap.forEach((contractMethods, side) =>
+    contractMethods.forEach((contractMethod: string) => {
+      tokensToTest.forEach(pair => {
+        describe(`${contractMethod}`, () => {
+          it(`${pair[0].symbol} -> ${pair[1].symbol}`, async () => {
+            await testE2E(
+              tokens[pair[0].symbol],
+              tokens[pair[1].symbol],
+              holders[pair[0].symbol],
+              side === SwapSide.SELL ? pair[0].amount : pair[1].amount,
+              side,
+              dexKey,
+              contractMethod as any,
+              network,
+              provider,
+            );
+          });
+
+          it(`${nativeSymbol} -> ${pair[0].symbol}`, async () => {
+            await testE2E(
+              tokens[nativeSymbol],
+              tokens[pair[0].symbol],
+              holders[nativeSymbol],
+              side === SwapSide.SELL ? '1000000000000000000' : pair[0].amount,
+              side,
+              dexKey,
+              contractMethod as any,
+              network,
+              provider,
+            );
+          });
+        });
+      });
+    }),
+  );
+};
+
+// Ensure you have the E2E_ENDPOINT_URL env variable set.
+
+describe('TraderJoe v2.1 E2E', () => {
+  describe('Mainnet V6', () => {
+    const swapMap = new Map<SwapSide, ContractMethod[]>([
+      [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    ]);
+
+    testForNetwork(Network.MAINNET, swapMap);
+  });
+});

package/src/dex/{trader-joe-v2.1.ts → trader-joe-v2.1/trader-joe-v2.1.ts}

@@ -1,58 +1,27 @@
-import { Network, SwapSide } from '../constants';
-import { AdapterExchangeParam, Address, SimpleExchangeParam } from '../types';
-import { IDexTxBuilder } from './idex';
-import { IDexHelper } from '../dex-helper';
+import { SwapSide } from '../../constants';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  SimpleExchangeParam,
+} from '../../types';
+import { IDexTxBuilder } from '../idex';
+import { IDexHelper } from '../../dex-helper';
 import {
   getLocalDeadlineAsFriendlyPlaceholder,
   SimpleExchange,
-} from './simple-exchange';
+} from '../simple-exchange';
 import { NumberAsString } from '@paraswap/core';
 import { AsyncOrSync } from 'ts-essentials';
 import { Interface, JsonFragment } from '@ethersproject/abi';
-import TraderJoeV21RouterABI from '../abi/TraderJoeV21Router.json';
-
-const TRADERJOE_V2_1_ROUTER_ADDRESS: { [network: number]: Address } = {
-  [Network.AVALANCHE]: '0xb4315e873dBcf96Ffd0acd8EA43f689D8c20fB30',
-  [Network.ARBITRUM]: '0xb4315e873dBcf96Ffd0acd8EA43f689D8c20fB30',
-  [Network.BSC]: '0xb4315e873dBcf96Ffd0acd8EA43f689D8c20fB30',
-  [Network.MAINNET]: '0x9A93a421b74F1c5755b83dD2C211614dC419C44b',
-};
-
-type RouterPath = [
-  pairBinSteps: NumberAsString[],
-  versions: NumberAsString[],
-  tokenPath: Address[],
-];
-type TraderJoeV2RouterSellParams = [
-  _amountIn: NumberAsString,
-  _amountOutMin: NumberAsString,
-  _routerPath: RouterPath,
-  to: Address,
-  _deadline: string,
-];
-
-type TraderJoeV2RouterBuyParams = [
-  _amountOut: NumberAsString,
-  _amountInMax: NumberAsString,
-  _routerPath: RouterPath,
-  to: Address,
-  _deadline: string,
-];
-
-type TraderJoeV2RouterParam =
-  | TraderJoeV2RouterSellParams
-  | TraderJoeV2RouterBuyParams;
-
-export type TraderJoeV2Data = {
-  tokenIn: string; // redundant
-  tokenOut: string; // redundant
-  binStep: string;
-};
+import TraderJoeV21RouterABI from '../../abi/TraderJoeV21Router.json';
+import {
+  TraderJoeV2Data,
+  TraderJoeV2RouterFunctions,
+  TraderJoeV2RouterParam,
+} from './types';
+import { TRADERJOE_V2_1_ROUTER_ADDRESS } from './config';
 
-enum TraderJoeV2RouterFunctions {
-  swapExactTokensForTokens = 'swapExactTokensForTokens',
-  swapTokensForExactTokens = 'swapTokensForExactTokens',
-}
 export class TraderJoeV21
   extends SimpleExchange
   implements IDexTxBuilder<TraderJoeV2Data, TraderJoeV2RouterParam>
@@ -153,4 +122,50 @@ export class TraderJoeV21
       this.routerAddress,
     );
   }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: TraderJoeV2Data,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const swapFunction =
+      side === SwapSide.SELL
+        ? TraderJoeV2RouterFunctions.swapExactTokensForTokens
+        : TraderJoeV2RouterFunctions.swapTokensForExactTokens;
+
+    const placeholder = getLocalDeadlineAsFriendlyPlaceholder();
+
+    const swapFunctionParams: TraderJoeV2RouterParam =
+      side === SwapSide.SELL
+        ? [
+            srcAmount,
+            destAmount,
+            [[data.binStep], ['2'], [srcToken, destToken]],
+            recipient,
+            placeholder,
+          ]
+        : [
+            destAmount,
+            srcAmount,
+            [[data.binStep], ['2'], [srcToken, destToken]],
+            recipient,
+            placeholder,
+          ];
+
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: this.routerAddress,
+    };
+  }
 }

package/src/dex/trader-joe-v2.1/types.ts

@@ -0,0 +1,38 @@
+import { NumberAsString } from '@paraswap/core';
+import { Address } from '@paraswap/sdk';
+
+export type RouterPath = [
+  pairBinSteps: NumberAsString[],
+  versions: NumberAsString[],
+  tokenPath: Address[],
+];
+export type TraderJoeV2RouterSellParams = [
+  _amountIn: NumberAsString,
+  _amountOutMin: NumberAsString,
+  _routerPath: RouterPath,
+  to: Address,
+  _deadline: string,
+];
+
+export type TraderJoeV2RouterBuyParams = [
+  _amountOut: NumberAsString,
+  _amountInMax: NumberAsString,
+  _routerPath: RouterPath,
+  to: Address,
+  _deadline: string,
+];
+
+export type TraderJoeV2RouterParam =
+  | TraderJoeV2RouterSellParams
+  | TraderJoeV2RouterBuyParams;
+
+export type TraderJoeV2Data = {
+  tokenIn: string; // redundant
+  tokenOut: string; // redundant
+  binStep: string;
+};
+
+export enum TraderJoeV2RouterFunctions {
+  swapExactTokensForTokens = 'swapExactTokensForTokens',
+  swapTokensForExactTokens = 'swapTokensForExactTokens',
+}

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

@@ -150,6 +150,48 @@ export const UniswapV2Config: DexConfigMap<DexParams> = {
       poolGasCost: 80 * 1000,
       feeCode: 30,
     },
+    [Network.ARBITRUM]: {
+      factoryAddress: '0xf1D7CC64Fb4452F05c498126312eBE29f30Fbcf9',
+      initCode:
+        '0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f',
+      poolGasCost: 80 * 1000,
+      feeCode: 30,
+    },
+    [Network.AVALANCHE]: {
+      factoryAddress: '0x9e5A52f57b3038F1B8EeE45F28b3C1967e22799C',
+      initCode:
+        '0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f',
+      poolGasCost: 80 * 1000,
+      feeCode: 30,
+    },
+    [Network.BSC]: {
+      factoryAddress: '0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6',
+      initCode:
+        '0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f',
+      poolGasCost: 80 * 1000,
+      feeCode: 30,
+    },
+    [Network.BASE]: {
+      factoryAddress: '0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6',
+      initCode:
+        '0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f',
+      poolGasCost: 80 * 1000,
+      feeCode: 30,
+    },
+    [Network.OPTIMISM]: {
+      factoryAddress: '0x0c3c1c532F1e39EdF36BE9Fe0bE1410313E074Bf',
+      initCode:
+        '0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f',
+      poolGasCost: 80 * 1000,
+      feeCode: 30,
+    },
+    [Network.POLYGON]: {
+      factoryAddress: '0x9e5A52f57b3038F1B8EeE45F28b3C1967e22799C',
+      initCode:
+        '0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f',
+      poolGasCost: 80 * 1000,
+      feeCode: 30,
+    },
   },
   ApeSwap: {
     [Network.BSC]: {

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

@@ -44,14 +44,16 @@ export const UniswapForksWithNetwork = transformToNetworkMap({
   ...ExcaliburConfig,
 });
 
-// These are exchanges used for swapOnUniswap method
 export const UniswapV2Alias: { [network: number]: string } = {
   [Network.MAINNET]: 'uniswapv2',
   [Network.ROPSTEN]: 'uniswapv2',
-  [Network.BSC]: 'pancakeswap',
-  [Network.POLYGON]: 'quickswap',
-  [Network.AVALANCHE]: 'pangolinswap',
+  [Network.BSC]: 'uniswapv2',
+  [Network.POLYGON]: 'uniswapv2',
+  [Network.AVALANCHE]: 'uniswapv2',
+  [Network.ARBITRUM]: 'uniswapv2',
+  [Network.OPTIMISM]: 'uniswapv2',
+  [Network.BASE]: 'uniswapv2',
+
+  // use only to handle UniswapForkOptimized build with this dex
   [Network.FANTOM]: 'spookyswap',
-  [Network.ARBITRUM]: 'sushiswap',
-  [Network.OPTIMISM]: 'zipswap',
 };

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

@@ -1,10 +1,17 @@
 import { UniswapV2 } from './uniswap-v2';
 import { Network, ETHER_ADDRESS, SwapSide } from '../../constants';
-import { Address, DexConfigMap, Token, ExchangePrices } from '../../types';
+import {
+  Address,
+  DexConfigMap,
+  Token,
+  ExchangePrices,
+  DexExchangeParam,
+} from '../../types';
 import { IDexHelper } from '../../dex-helper/index';
 import { Interface } from '@ethersproject/abi';
-import { DexParams, UniswapV2Data } from './types';
-import { getDexKeysWithNetwork } from '../../utils';
+import { DexParams, UniswapData, UniswapV2Data } from './types';
+import { getDexKeysWithNetwork, isETHAddress } from '../../utils';
+import { NumberAsString } from '@paraswap/core';
 
 export const DfynConfig: DexConfigMap<DexParams> = {
   Dfyn: {
@@ -84,4 +91,38 @@ export class Dfyn extends UniswapV2 {
       ? prices.map(p => ({ ...p, data: { ...p.data, weth: DfynWETH.address } }))
       : null;
   }
+
+  public getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: UniswapData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const _srcToken =
+      this.isWETH(srcToken) || isETHAddress(srcToken)
+        ? DfynWETH.address
+        : srcToken;
+    const _destToken =
+      this.isWETH(destToken) || isETHAddress(destToken)
+        ? DfynWETH.address
+        : destToken;
+
+    const param = super.getDexParam(
+      _srcToken,
+      _destToken,
+      srcAmount,
+      destAmount,
+      recipient,
+      data,
+      side,
+    );
+
+    return {
+      ...param,
+      wethAddress: DfynWETH.address,
+    };
+  }
 }

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

@@ -28,6 +28,28 @@ export enum UniswapV2Functions {
   buyOnUniswapV2ForkWithPermit = 'buyOnUniswapV2ForkWithPermit',
 }
 
+export enum UniswapV2FunctionsV6 {
+  swap = 'swapExactAmountInOnUniswapV2',
+  buy = 'swapExactAmountOutOnUniswapV2',
+}
+
+export type UniswapV2ParamsDirectBase = [
+  srcToken: Address,
+  destToken: Address,
+  fromAmount: NumberAsString,
+  quotedAmount: NumberAsString,
+  toAmount: NumberAsString,
+  metadata: string,
+  beneficiary: Address,
+  pools: string,
+];
+
+export type UniswapV2ParamsDirect = [
+  params: UniswapV2ParamsDirectBase,
+  partnerAndFee: string,
+  permit: string,
+];
+
 export type SwapOnUniswapParam = [
   amountIn: NumberAsString,
   amountOutMin: NumberAsString,

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

@@ -198,27 +198,30 @@ describe('UniswapV2 E2E Avalanche', () => {
 
   describe('TraderJoe', () => {
     const dexKey = 'TraderJoe';
-
-    describe('simpleSwap', () => {
-      it('AVAX -> USDTe', async () => {
+    describe('TraderJoe: Fail: (Joe: K)', () => {
+      // To run might need to hardcode the price route in e2e utils
+      it('AVAX -> LINK.e', async () => {
+        const dexKeys = ['LydiaFinance', 'PangolinSwap', 'TraderJoe'];
         await testE2E(
-          tokens.AVAX,
-          tokens.USDTe,
-          holders.AVAX,
-          '7000000000000000000',
+          tokens.WAVAX,
+          tokens.LINKe,
+          holders.WAVAX,
+          '37000000000000000000',
           SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
+          dexKeys,
+          ContractMethod.swapExactAmountIn,
           network,
           provider,
         );
       });
+    });
 
-      it('USDTe -> AVAX', async () => {
+    describe('simpleSwap', () => {
+      it('AMPL -> MIM', async () => {
         await testE2E(
-          tokens.USDTe,
-          tokens.AVAX,
-          holders.USDTe,
+          tokens.AMPL,
+          tokens.MIM,
+          holders.AMPL,
           '1000000000',
           SwapSide.SELL,
           dexKey,

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

@@ -276,7 +276,7 @@ describe('UniswapV2 E2E BSC', () => {
   describe('BakerySwap', () => {
     const dexKey = 'BakerySwap';
 
-    describe('Simpleswap', () => {
+    describe('Bakery_V6', () => {
       it('Token -> TOKEN', async () => {
         await testE2E(
           tokens.USDT,
@@ -285,28 +285,44 @@ describe('UniswapV2 E2E BSC', () => {
           '70000000000000000000',
           SwapSide.SELL,
           dexKey,
-          ContractMethod.simpleSwap,
+          ContractMethod.swapExactAmountIn,
           network,
           provider,
         );
       });
     });
 
-    describe('Multiswap', () => {
-      it('Token -> TOKEN', async () => {
-        await testE2E(
-          tokens.USDT,
-          tokens.BUSD,
-          holders.USDT,
-          '70000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-    });
+    // describe('Simpleswap', () => {
+    //   it('Token -> TOKEN', async () => {
+    //     await testE2E(
+    //       tokens.USDT,
+    //       tokens.BUSD,
+    //       holders.USDT,
+    //       '70000000000000000000',
+    //       SwapSide.SELL,
+    //       dexKey,
+    //       ContractMethod.simpleSwap,
+    //       network,
+    //       provider,
+    //     );
+    //   });
+    // });
+
+    // describe('Multiswap', () => {
+    //   it('Token -> TOKEN', async () => {
+    //     await testE2E(
+    //       tokens.USDT,
+    //       tokens.BUSD,
+    //       holders.USDT,
+    //       '70000000000000000000',
+    //       SwapSide.SELL,
+    //       dexKey,
+    //       ContractMethod.multiSwap,
+    //       network,
+    //       provider,
+    //     );
+    //   });
+    // });
   });
 
   describe('Street Swap', () => {