@paraswap/dex-lib 2.45.0 → 3.0.0

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

@@ -23,14 +23,31 @@ describe('Camelot E2E', () => {
       [
         SwapSide.SELL,
         [
-          ContractMethod.simpleSwap,
-          ContractMethod.multiSwap,
-          ContractMethod.megaSwap,
+          ContractMethod.swapExactAmountIn,
+          // ContractMethod.simpleSwap,
+          // ContractMethod.multiSwap,
+          // ContractMethod.megaSwap,
         ],
       ],
     ]);
 
-    const pairs: { name: string; sellAmount: string }[][] = [
+    type TestingPair = {
+      name: string;
+      sellAmount: string;
+    };
+    // To be tested against E2E endpoint
+    type TestingOptions = {
+      srcTokenTransferFee: number;
+      destTokenTransferFee: number;
+      srcTokenDexTransferFee: number;
+      destTokenDexTransferFee: number;
+      slippage: number;
+    };
+    type TestingParams =
+      | [TestingPair, TestingPair, TestingOptions]
+      | [TestingPair, TestingPair];
+
+    const pairs: TestingParams[] = [
       [
         { name: 'ETH', sellAmount: '700000000000' },
         { name: 'USDC', sellAmount: '1000000' },
@@ -51,6 +68,49 @@ describe('Camelot E2E', () => {
         { name: 'USDC', sellAmount: '100000' },
         { name: 'USDT', sellAmount: '100000' },
       ],
+      // Tax token without config
+      [
+        { name: 'RDPX', sellAmount: '100000000' },
+        { name: 'ETH', sellAmount: '1000000000' },
+        {
+          srcTokenTransferFee: 0,
+          destTokenTransferFee: 0,
+          srcTokenDexTransferFee: 1000,
+          destTokenDexTransferFee: 0,
+          slippage: 1000,
+        },
+      ],
+      [
+        { name: 'RDPX', sellAmount: '100000000' },
+        { name: 'WETH', sellAmount: '100000000' },
+        {
+          srcTokenTransferFee: 0,
+          destTokenTransferFee: 0,
+          srcTokenDexTransferFee: 1000,
+          destTokenDexTransferFee: 0,
+          slippage: 1000,
+        },
+      ],
+      [
+        { name: 'RDPX', sellAmount: '100000000' },
+        { name: 'DAI', sellAmount: '100000000' },
+        {
+          srcTokenTransferFee: 0,
+          destTokenTransferFee: 0,
+          srcTokenDexTransferFee: 1000,
+          destTokenDexTransferFee: 0,
+          slippage: 1000,
+        },
+      ],
+      // Tax token with config
+      [
+        { name: 'SEN', sellAmount: '100000000000000000' },
+        { name: 'ETH', sellAmount: '100000000000000000' },
+      ],
+      [
+        { name: 'SEN', sellAmount: '100000000000000000' },
+        { name: 'WETH', sellAmount: '100000000000000000' },
+      ],
     ];
 
     sideToContractMethods.forEach((contractMethods, side) =>
@@ -69,6 +129,10 @@ describe('Camelot E2E', () => {
                   contractMethod,
                   network,
                   provider,
+                  undefined,
+                  undefined,
+                  (pair[2] ? pair[2] : undefined) as any,
+                  (pair[2] ? pair[2].slippage : undefined) as any,
                 );
               });
               it(`${pair[1].name} -> ${pair[0].name}`, async () => {
@@ -82,6 +146,10 @@ describe('Camelot E2E', () => {
                   contractMethod,
                   network,
                   provider,
+                  undefined,
+                  undefined,
+                  (pair[2] ? pair[2] : undefined) as any,
+                  (pair[2] ? pair[2].slippage : undefined) as any,
                 );
               });
             });

package/src/dex/camelot/camelot.ts

@@ -8,6 +8,7 @@ import {
 import {
   AdapterExchangeParam,
   Address,
+  DexExchangeParam,
   ExchangePrices,
   Log,
   Logger,
@@ -48,6 +49,15 @@ import {
   OnPoolCreatedCallback,
   UniswapV2Factory,
 } from '../uniswap-v2/uniswap-v2-factory';
+import {
+  hexDataLength,
+  hexlify,
+  hexZeroPad,
+  id,
+  solidityPack,
+} from 'ethers/lib/utils';
+import { BigNumber } from 'ethers';
+import { Flag, SpecialDex } from '../../executor/types';
 
 const DefaultCamelotPoolGasCost = 90 * 1000;
 
@@ -167,6 +177,7 @@ export class Camelot
   feeFactor = 100000;
   factory: Contract;
 
+  needWrapNative = true;
   routerInterface: Interface;
   exchangeRouterInterface: Interface;
 
@@ -819,4 +830,43 @@ export class Camelot
       data.router,
     );
   }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: SolidlyData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    if (side === SwapSide.BUY) throw new Error('Buy not supported');
+    let exchangeDataTypes = ['bytes4', 'bytes32'];
+
+    let exchangeDataToPack = [
+      hexZeroPad(hexlify(0), 4),
+      hexZeroPad(hexlify(data.pools.length), 32),
+    ];
+
+    const pools = encodePools(data.pools, this.feeFactor);
+    pools.forEach(pool => {
+      exchangeDataTypes.push('bytes32');
+      exchangeDataToPack.push(hexZeroPad(hexlify(BigNumber.from(pool)), 32));
+    });
+
+    const exchangeData = solidityPack(exchangeDataTypes, exchangeDataToPack);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData,
+      targetExchange: recipient,
+      specialDexFlag: data.isFeeTokenInRoute
+        ? SpecialDex.SWAP_ON_DYSTOPIA_UNISWAP_V2_FORK_WITH_FEE
+        : SpecialDex.SWAP_ON_DYSTOPIA_UNISWAP_V2_FORK,
+      transferSrcTokenBeforeSwap: data.isFeeTokenInRoute
+        ? undefined
+        : data.pools[0].address,
+    };
+  }
 }

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

@@ -0,0 +1,91 @@
+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 = 'compound';
+
+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: 'CETH',
+        amount: '1000000000000000000000',
+      },
+      {
+        symbol: 'WETH',
+        amount: '1000000000000000000000',
+      },
+    ],
+  ];
+
+  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('Compound E2E', () => {
+  describe('Mainnet V6', () => {
+    const swapMap = new Map<SwapSide, ContractMethod[]>([
+      [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    ]);
+
+    testForNetwork(Network.MAINNET, swapMap);
+  });
+});

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

@@ -1,21 +1,18 @@
 import { Interface, JsonFragment } from '@ethersproject/abi';
-import { SwapSide, NULL_ADDRESS } from '../constants';
-import { AdapterExchangeParam, Address, SimpleExchangeParam } from '../types';
-import { IDexTxBuilder } from './idex';
-import { SimpleExchange } from './simple-exchange';
-import Ceth from '../abi/Compound_CETH.json'; // CETH abi
-import { isETHAddress } from '../utils';
-import Web3 from 'web3';
-import { IDexHelper } from '../dex-helper';
-
-export type CompoundData = {
-  fromCToken: boolean;
-};
-type CompoundParam = [srcAmount: string];
-enum CompoundFunctions {
-  redeem = 'redeem',
-  mint = 'mint',
-}
+import { SwapSide, NULL_ADDRESS } from '../../constants';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  NumberAsString,
+  SimpleExchangeParam,
+} from '../../types';
+import { IDexTxBuilder } from '../idex';
+import { SimpleExchange } from '../simple-exchange';
+import Ceth from '../../abi/Compound_CETH.json'; // CETH abi
+import { isETHAddress } from '../../utils';
+import { IDexHelper } from '../../dex-helper';
+import { CompoundData, CompoundFunctions, CompoundParam } from './types';
 
 export class Compound
   extends SimpleExchange
@@ -81,4 +78,29 @@ export class Compound
       cToken,
     );
   }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    _destAmount: NumberAsString,
+    _recipient: Address,
+    data: CompoundData,
+    _side: SwapSide,
+  ): DexExchangeParam {
+    const cToken = data.fromCToken ? srcToken : destToken;
+    const swapData = isETHAddress(srcToken)
+      ? this.cethInterface.encodeFunctionData(CompoundFunctions.mint)
+      : this.erc20Interface.encodeFunctionData(
+          data.fromCToken ? CompoundFunctions.redeem : CompoundFunctions.mint,
+          [srcAmount],
+        );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData: swapData,
+      targetExchange: cToken,
+    };
+  }
 }

package/src/dex/compound/types.ts

@@ -0,0 +1,10 @@
+export type CompoundData = {
+  fromCToken: boolean;
+};
+
+export type CompoundParam = [srcAmount: string];
+
+export enum CompoundFunctions {
+  redeem = 'redeem',
+  mint = 'mint',
+}

package/src/dex/curve-v1/constants.ts

@@ -3,6 +3,7 @@ import { SwerveConfig } from './forks/swerve/config';
 import { CurveForksConfig } from './forks/curve-forks/config';
 
 export const DIRECT_METHOD_NAME = 'directCurveV1Swap';
+export const DIRECT_METHOD_NAME_V6 = 'swapExactAmountInOnCurveV1';
 
 export const AllCurveForks = [
   ...Object.keys(CurveV1Config),

package/src/dex/curve-v1/curve-v1-e2e.test.ts

@@ -10,6 +10,7 @@ import {
 import { Network, ContractMethod, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { generateConfig } from '../../config';
+import { DIRECT_METHOD_NAME_V6 } from './constants';
 
 describe('CurveV1 E2E', () => {
   const dexKey = 'CurveV1';
@@ -26,7 +27,7 @@ describe('CurveV1 E2E', () => {
     const tokensToTest = [
       [
         {
-          symbol: 'USDT',
+          symbol: 'USDC',
           amount: (10 ** 8).toString(),
         },
         {
@@ -50,15 +51,16 @@ describe('CurveV1 E2E', () => {
       [
         SwapSide.SELL,
         [
-          ContractMethod.simpleSwap,
-          ContractMethod.multiSwap,
-          ContractMethod.megaSwap,
+          // ContractMethod.simpleSwap,
+          // ContractMethod.multiSwap,
+          // ContractMethod.megaSwap,
+          ContractMethod.swapExactAmountInOnCurveV1,
         ],
       ],
     ]);
 
     sideToContractMethods.forEach((contractMethods, side) =>
-      contractMethods.forEach((contractMethod: ContractMethod) => {
+      contractMethods.forEach((contractMethod: string) => {
         tokensToTest.forEach(pair => {
           describe(`${contractMethod}`, () => {
             it(`${pair[0].symbol} -> ${pair[1].symbol}`, async () => {
@@ -69,7 +71,7 @@ describe('CurveV1 E2E', () => {
                 side === SwapSide.SELL ? pair[0].amount : pair[1].amount,
                 side,
                 dexKey,
-                contractMethod,
+                contractMethod as any,
                 network,
                 provider,
               );
@@ -78,62 +80,95 @@ describe('CurveV1 E2E', () => {
         });
       }),
     );
-    it('simpleSwap DAI -> USDT', async () => {
-      await testE2E(
-        tokens['DAI'],
-        tokens['USDT'],
-        holders['DAI'],
-        '100000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.simpleSwap,
-        network,
-        provider,
-      );
-    });
-    describe('FeeOnTransfer', () => {
-      describe('sell', () => {
-        const contractMethod = ContractMethod.megaSwap;
-        describe('megaSwap', () => {
-          it('stETH -> ETH', async () => {
-            await testE2E(
-              tokens['STETH'],
-              tokens['ETH'],
-              holders['STETH'],
-              '1000000000000000000',
-              SwapSide.SELL,
-              dexKey,
-              contractMethod,
-              network,
-              provider,
-              undefined,
-              undefined,
-              { srcFee: 1, destFee: 0, srcDexFee: 1, destDexFee: 0 },
-            );
-          });
-
-          it('ETH -> stETH', async () => {
-            await testE2E(
-              tokens['ETH'],
-              tokens['STETH'],
-              holders['ETH'],
-              '1000000000000000000',
-              SwapSide.SELL,
-              dexKey,
-              contractMethod,
-              network,
-              provider,
-              undefined,
-              undefined,
-              { srcFee: 0, destFee: 1, srcDexFee: 0, destDexFee: 1 },
-            );
-          });
-        });
-      });
-    });
+    // it('simpleSwap DAI -> USDT', async () => {
+    //   await testE2E(
+    //     tokens['DAI'],
+    //     tokens['USDT'],
+    //     holders['DAI'],
+    //     '100000000000000000000',
+    //     SwapSide.SELL,
+    //     dexKey,
+    //     ContractMethod.simpleSwap,
+    //     network,
+    //     provider,
+    //   );
+    // });
+
+    // it('USDC -> USDT', async () => {
+    //   await testE2E(
+    //     tokens['USDC'],
+    //     tokens['USDT'],
+    //     holders['USDC'],
+    //     '100000000',
+    //     SwapSide.SELL,
+    //     dexKey,
+    //     ContractMethod.simpleSwap,
+    //     network,
+    //     provider,
+    //   );
+    // });
+
+    // it('DAI -> GUSD', async () => {
+    //   await testE2E(
+    //     tokens['DAI'],
+    //     tokens['GUSD'],
+    //     holders['DAI'],
+    //     '100000000000000000000',
+    //     SwapSide.SELL,
+    //     dexKey,
+    //     ContractMethod.simpleSwap,
+    //     network,
+    //     provider,
+    //     null,
+    //     undefined,
+    //     undefined,
+    //     1000,
+    //   );
+    // });
+
+    // describe('FeeOnTransfer', () => {
+    //   describe('sell', () => {
+    //     const contractMethod = ContractMethod.megaSwap;
+    //     describe('megaSwap', () => {
+    //       it('stETH -> ETH', async () => {
+    //         await testE2E(
+    //           tokens['STETH'],
+    //           tokens['ETH'],
+    //           holders['STETH'],
+    //           '1000000000000000000',
+    //           SwapSide.SELL,
+    //           dexKey,
+    //           contractMethod,
+    //           network,
+    //           provider,
+    //           undefined,
+    //           undefined,
+    //           { srcFee: 1, destFee: 0, srcDexFee: 1, destDexFee: 0 },
+    //         );
+    //       });
+
+    //       it('ETH -> stETH', async () => {
+    //         await testE2E(
+    //           tokens['ETH'],
+    //           tokens['STETH'],
+    //           holders['ETH'],
+    //           '1000000000000000000',
+    //           SwapSide.SELL,
+    //           dexKey,
+    //           contractMethod,
+    //           network,
+    //           provider,
+    //           undefined,
+    //           undefined,
+    //           { srcFee: 0, destFee: 1, srcDexFee: 0, destDexFee: 1 },
+    //         );
+    //       });
+    //     });
+    //   });
+    // });
   });
 
-  describe('CurveV1 POLYGON', () => {
+  describe('CurveV1 POLYGON_V6', () => {
     const network = Network.POLYGON;
     const tokens = Tokens[network];
     const holders = Holders[network];
@@ -153,16 +188,28 @@ describe('CurveV1 E2E', () => {
           amount: (10 ** 8).toString(),
         },
       ],
+      [
+        {
+          symbol: 'ETH',
+          amount: (10 ** 16).toString(),
+        },
+        {
+          symbol: 'DAI',
+          amount: (10 ** 8).toString(),
+        },
+      ],
     ];
 
     const sideToContractMethods = new Map([
       [
         SwapSide.SELL,
         [
-          ContractMethod.simpleSwap,
-          ContractMethod.multiSwap,
-          ContractMethod.megaSwap,
-          ContractMethod.directCurveV1Swap,
+          // ContractMethod.simpleSwap,
+          // ContractMethod.multiSwap,
+          // ContractMethod.megaSwap,
+          // ContractMethod.directCurveV1Swap,
+          ContractMethod.swapExactAmountIn,
+          ContractMethod.swapExactAmountInOnCurveV1,
         ],
       ],
     ]);
@@ -184,6 +231,19 @@ describe('CurveV1 E2E', () => {
                 provider,
               );
             });
+            it(`${pair[1].symbol} -> ${pair[0].symbol}`, async () => {
+              await testE2E(
+                tokens[pair[1].symbol],
+                tokens[pair[0].symbol],
+                holders[pair[1].symbol],
+                side === SwapSide.SELL ? pair[1].amount : pair[0].amount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
           });
         });
       }),