@paraswap/dex-lib 2.45.0 → 3.0.0

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

@@ -6,6 +6,7 @@ import { Tokens, Holders } from '../../../tests/constants-e2e';
 import { Network, ContractMethod, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { generateConfig } from '../../config';
+import { UniswapV2FunctionsV6 } from './types';
 
 describe('UniswapV2 E2E Mainnet', () => {
   const network = Network.MAINNET;
@@ -19,8 +20,21 @@ describe('UniswapV2 E2E Mainnet', () => {
   describe('UniswapV2', () => {
     const dexKey = 'UniswapV2';
 
-    describe('Simpleswap', () => {
-      it('ETH -> TOKEN', async () => {
+    describe('UniswapV2 Simpleswap', () => {
+      it('USDC -> USDT', async () => {
+        await testE2E(
+          tokens.USDC,
+          tokens.USDT,
+          holders.USDC,
+          '1000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.simpleSwap,
+          network,
+          provider,
+        );
+      });
+      it('ETH -> USDC', async () => {
         await testE2E(
           tokens.ETH,
           tokens.USDC,
@@ -33,7 +47,7 @@ describe('UniswapV2 E2E Mainnet', () => {
           provider,
         );
       });
-      it('TOKEN -> ETH', async () => {
+      it('USDC -> ETH', async () => {
         await testE2E(
           tokens.USDC,
           tokens.ETH,
@@ -46,10 +60,10 @@ describe('UniswapV2 E2E Mainnet', () => {
           provider,
         );
       });
-      it('TOKEN -> TOKEN', async () => {
+      it('WBTC -> USDT', async () => {
         await testE2E(
           tokens.WBTC,
-          tokens.BADGER,
+          tokens.USDT,
           holders.WBTC,
           '20000000',
           SwapSide.SELL,
@@ -61,6 +75,171 @@ describe('UniswapV2 E2E Mainnet', () => {
       });
     });
 
+    describe('UniswapV2_special', () => {
+      describe('SELL_V6', () => {
+        it('EX1: USDC -> USDT', async () => {
+          await testE2E(
+            tokens.USDC,
+            tokens.USDT,
+            holders.USDC,
+            '1000000',
+            SwapSide.SELL,
+            dexKey,
+            ContractMethod.swapExactAmountIn,
+            network,
+            provider,
+          );
+        });
+        it('EX1: ETH -> USDC', async () => {
+          await testE2E(
+            tokens.ETH,
+            tokens.USDC,
+            holders.ETH,
+            '700000000000000000',
+            SwapSide.SELL,
+            dexKey,
+            ContractMethod.swapExactAmountIn,
+            network,
+            provider,
+          );
+        });
+        it('EX1: USDC -> ETH', async () => {
+          await testE2E(
+            tokens.USDC,
+            tokens.ETH,
+            holders.USDC,
+            '2000000000',
+            SwapSide.SELL,
+            dexKey,
+            ContractMethod.swapExactAmountIn,
+            network,
+            provider,
+          );
+        });
+        it('EX1: WBTC -> USDT', async () => {
+          await testE2E(
+            tokens.WBTC,
+            tokens.USDT,
+            holders.WBTC,
+            '20000000',
+            SwapSide.SELL,
+            dexKey,
+            ContractMethod.swapExactAmountIn,
+            network,
+            provider,
+          );
+        });
+        it('EX1: PSP -> WETH -> USDT', async () => {
+          await testE2E(
+            tokens.PSP,
+            tokens.USDT,
+            holders.PSP,
+            '1000000000000000000',
+            SwapSide.SELL,
+            dexKey,
+            ContractMethod.multiSwap,
+            network,
+            provider,
+          );
+        });
+        // TODO: Update: goes through balancer only
+        // it('EX2: USDT -> USDC', async () => {
+        //   await testE2E(
+        //     tokens.USDT,
+        //     tokens.USDC,
+        //     holders.USDT,
+        //     '1000000000000',
+        //     SwapSide.SELL,
+        //     [dexKey, 'BalancerV2' /* , 'TraderJoeV2.1'  'SolidlyV3'*/],
+        //     ContractMethod.multiSwap,
+        //     network,
+        //     provider,
+        //   );
+        // });
+      });
+      describe('BUY_V6', () => {
+        it('EX3: USDC -> USDT', async () => {
+          await testE2E(
+            tokens.USDC,
+            tokens.USDT,
+            holders.USDC,
+            '1000000',
+            SwapSide.BUY,
+            dexKey,
+            ContractMethod.swapExactAmountOut,
+            network,
+            provider,
+          );
+        });
+        it('EX3: ETH -> DAI', async () => {
+          await testE2E(
+            tokens.ETH,
+            tokens.DAI,
+            holders.ETH,
+            '7000000000000000',
+            SwapSide.BUY,
+            dexKey,
+            ContractMethod.swapExactAmountOut,
+            network,
+            provider,
+          );
+        });
+        it('EX3: USDC -> ETH', async () => {
+          await testE2E(
+            tokens.USDC,
+            tokens.ETH,
+            holders.USDC,
+            '2000000000',
+            SwapSide.BUY,
+            dexKey,
+            ContractMethod.swapExactAmountOut,
+            network,
+            provider,
+          );
+        });
+        it('EX3: WBTC -> USDT', async () => {
+          await testE2E(
+            tokens.WBTC,
+            tokens.USDT,
+            holders.WBTC,
+            '20000000',
+            SwapSide.BUY,
+            dexKey,
+            ContractMethod.swapExactAmountOut,
+            network,
+            provider,
+          );
+        });
+        // it('EX3: PSP -> WETH -> USDT', async () => {
+        //   await testE2E(
+        //     tokens.PSP,
+        //     tokens.USDT,
+        //     holders.PSP,
+        //     '1000000000000000000',
+        //     SwapSide.BUY,
+        //     dexKey,
+        //     ContractMethod.multiSwap,
+        //     network,
+        //     provider,
+        //   );
+        // });
+        // TODO: Update: goes through balancer only
+        // it('EX2: USDT -> USDC', async () => {
+        //   await testE2E(
+        //     tokens.USDT,
+        //     tokens.USDC,
+        //     holders.USDT,
+        //     '1000000000000',
+        //     SwapSide.BUY,
+        //     [dexKey, 'BalancerV2' /* , 'TraderJoeV2.1'  'SolidlyV3'*/],
+        //     ContractMethod.multiSwap,
+        //     network,
+        //     provider,
+        //   );
+        // });
+      });
+    });
+
     describe('Multiswap', () => {
       it('ETH -> TOKEN', async () => {
         await testE2E(
@@ -561,6 +740,246 @@ describe('UniswapV2 E2E Mainnet', () => {
         );
       });
     });
+
+    describe('V6_swapExactAmountInOnUniswapV2', () => {
+      it('WETH -> WBTC', async () => {
+        await testE2E(
+          tokens.WETH,
+          tokens.WBTC,
+          holders.WETH,
+          '7000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountInOnUniswapV2,
+          network,
+          provider,
+        );
+      });
+      it('WETH (amountIn=1000000000000) -> WBTC', async () => {
+        await testE2E(
+          tokens.WETH,
+          tokens.WBTC,
+          holders.WETH,
+          '1000000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountInOnUniswapV2,
+          network,
+          provider,
+        );
+      });
+      it('WBTC -> WETH', async () => {
+        await testE2E(
+          tokens.WBTC,
+          tokens.WETH,
+          holders.WBTC,
+          '100000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountInOnUniswapV2,
+          network,
+          provider,
+        );
+      });
+      it('ETH -> WBTC', async () => {
+        await testE2E(
+          tokens.ETH,
+          tokens.WBTC,
+          holders.ETH,
+          '7000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountInOnUniswapV2,
+          network,
+          provider,
+        );
+      });
+      it('WBTC -> ETH', async () => {
+        await testE2E(
+          tokens.WBTC,
+          tokens.ETH,
+          holders.WBTC,
+          '100000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountInOnUniswapV2,
+          network,
+          provider,
+        );
+      });
+      it('USDC -> WBTC', async () => {
+        await testE2E(
+          tokens.USDC,
+          tokens.WBTC,
+          holders.USDC,
+          '200000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountInOnUniswapV2,
+          network,
+          provider,
+        );
+      });
+      it('WBTC -> USDC', async () => {
+        await testE2E(
+          tokens.WBTC,
+          tokens.USDC,
+          holders.WBTC,
+          '100000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountInOnUniswapV2,
+          network,
+          provider,
+        );
+      });
+      it('USDT -> USDC', async () => {
+        await testE2E(
+          tokens.USDT,
+          tokens.USDC,
+          holders.USDT,
+          '100000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountInOnUniswapV2,
+          network,
+          provider,
+        );
+      });
+      it('USDC -> USDT', async () => {
+        await testE2E(
+          tokens.USDC,
+          tokens.USDT,
+          holders.USDC,
+          '100000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountInOnUniswapV2,
+          network,
+          provider,
+        );
+      });
+    });
+
+    describe('V6_swapExactAmountOutOnUniswapV2', () => {
+      it('WETH -> WBTC', async () => {
+        await testE2E(
+          tokens.WETH,
+          tokens.WBTC,
+          holders.WETH,
+          '1000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOutOnUniswapV2,
+          network,
+          provider,
+        );
+      });
+      it('WBTC -> WETH', async () => {
+        await testE2E(
+          tokens.WBTC,
+          tokens.WETH,
+          holders.WBTC,
+          '7000000000000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOutOnUniswapV2,
+          network,
+          provider,
+        );
+      });
+      it('WBTC -> WETH (amountOut=1000000)', async () => {
+        await testE2E(
+          tokens.WBTC,
+          tokens.WETH,
+          holders.WBTC,
+          '7000000000000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOutOnUniswapV2,
+          network,
+          provider,
+        );
+      });
+      it('ETH -> WBTC', async () => {
+        await testE2E(
+          tokens.ETH,
+          tokens.WBTC,
+          holders.ETH,
+          '1000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOutOnUniswapV2,
+          network,
+          provider,
+        );
+      });
+      it('WBTC -> ETH ', async () => {
+        await testE2E(
+          tokens.WBTC,
+          tokens.ETH,
+          holders.WBTC,
+          '7000000000000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOutOnUniswapV2,
+          network,
+          provider,
+        );
+      });
+      it('USDC -> WBTC', async () => {
+        await testE2E(
+          tokens.USDC,
+          tokens.WBTC,
+          holders.USDC,
+          '20000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOutOnUniswapV2,
+          network,
+          provider,
+        );
+      });
+      it('WBTC -> USDC', async () => {
+        await testE2E(
+          tokens.WBTC,
+          tokens.USDC,
+          holders.WBTC,
+          '1000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOutOnUniswapV2,
+          network,
+          provider,
+        );
+      });
+      it('USDT -> USDC', async () => {
+        await testE2E(
+          tokens.USDT,
+          tokens.USDC,
+          holders.USDT,
+          '1000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOutOnUniswapV2,
+          network,
+          provider,
+        );
+      });
+      it('USDC -> USDT', async () => {
+        await testE2E(
+          tokens.USDC,
+          tokens.USDT,
+          holders.USDC,
+          '1000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOutOnUniswapV2,
+          network,
+          provider,
+        );
+      });
+    });
   });
 
   describe('SushiSwap', () => {

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

@@ -16,6 +16,105 @@ describe('UniswapV2 E2E Polygon', () => {
     network,
   );
 
+  describe('QuickSwap_V6', () => {
+    const dexKey = 'QuickSwap';
+
+    describe('SELL', () => {
+      it('MATIC -> WETH', async () => {
+        await testE2E(
+          tokens.MATIC,
+          tokens.WETH,
+          holders.MATIC,
+          '70000000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+      it('WETH -> MATIC', async () => {
+        await testE2E(
+          tokens.WETH,
+          tokens.MATIC,
+          holders.WETH,
+          '10000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+      it('DAI -> USDC', async () => {
+        await testE2E(
+          tokens.DAI,
+          tokens.USDC,
+          holders.DAI,
+          '100000000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+      it('AAVE -> PSP', async () => {
+        await testE2E(
+          tokens.AAVE,
+          tokens.PSP,
+          holders.AAVE,
+          '100000000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+    });
+    describe('BUY', () => {
+      it('MATIC -> WETH', async () => {
+        await testE2E(
+          tokens.MATIC,
+          tokens.WETH,
+          holders.MATIC,
+          '70000000000000000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOut,
+          network,
+          provider,
+        );
+      });
+      it('WETH -> MATIC', async () => {
+        await testE2E(
+          tokens.WETH,
+          tokens.MATIC,
+          holders.WETH,
+          '10000000000000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOut,
+          network,
+          provider,
+        );
+      });
+      it('USDT -> USDC', async () => {
+        await testE2E(
+          tokens.USDT,
+          tokens.USDC,
+          holders.USDT,
+          '100000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOut,
+          network,
+          provider,
+        );
+      });
+    });
+  });
   describe('SafeSwap', () => {
     const dexKey = 'SafeSwap';
 
@@ -232,10 +331,10 @@ describe('UniswapV2 E2E Polygon', () => {
     });
   });
 
-  describe('Dfyn', () => {
+  describe('Dfyn_V6', () => {
     const dexKey = 'Dfyn';
 
-    describe('Simpleswap', () => {
+    describe('swapExactAmountIn', () => {
       it('Dfyn MATIC -> TOKEN', async () => {
         await testE2E(
           tokens.MATIC,
@@ -244,7 +343,7 @@ describe('UniswapV2 E2E Polygon', () => {
           '7000000000000000000',
           SwapSide.SELL,
           dexKey,
-          ContractMethod.simpleSwap,
+          ContractMethod.swapExactAmountIn,
           network,
           provider,
         );
@@ -257,7 +356,7 @@ describe('UniswapV2 E2E Polygon', () => {
           '7000000000000000000',
           SwapSide.SELL,
           dexKey,
-          ContractMethod.simpleSwap,
+          ContractMethod.swapExactAmountIn,
           network,
           provider,
         );
@@ -270,54 +369,54 @@ describe('UniswapV2 E2E Polygon', () => {
           '7000000000000000000',
           SwapSide.SELL,
           dexKey,
-          ContractMethod.simpleSwap,
+          ContractMethod.swapExactAmountIn,
           network,
           provider,
         );
       });
     });
 
-    describe('Multiswap', () => {
-      it('Dfyn MATIC -> TOKEN', async () => {
-        await testE2E(
-          tokens.MATIC,
-          tokens.WETH,
-          holders.MATIC,
-          '7000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-      it('Dfyn TOKEN -> MATIC', async () => {
-        await testE2E(
-          tokens.DAI,
-          tokens.MATIC,
-          holders.DAI,
-          '70000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-      it('Dfyn TOKEN -> TOKEN', async () => {
-        await testE2E(
-          tokens.DAI,
-          tokens.USDT,
-          holders.DAI,
-          '70000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-    });
+    // describe('Multiswap', () => {
+    //   it('Dfyn MATIC -> TOKEN', async () => {
+    //     await testE2E(
+    //       tokens.MATIC,
+    //       tokens.WETH,
+    //       holders.MATIC,
+    //       '7000000000000000000',
+    //       SwapSide.SELL,
+    //       dexKey,
+    //       ContractMethod.multiSwap,
+    //       network,
+    //       provider,
+    //     );
+    //   });
+    //   it('Dfyn TOKEN -> MATIC', async () => {
+    //     await testE2E(
+    //       tokens.DAI,
+    //       tokens.MATIC,
+    //       holders.DAI,
+    //       '70000000000000000000',
+    //       SwapSide.SELL,
+    //       dexKey,
+    //       ContractMethod.multiSwap,
+    //       network,
+    //       provider,
+    //     );
+    //   });
+    //   it('Dfyn TOKEN -> TOKEN', async () => {
+    //     await testE2E(
+    //       tokens.DAI,
+    //       tokens.USDT,
+    //       holders.DAI,
+    //       '70000000000000000000',
+    //       SwapSide.SELL,
+    //       dexKey,
+    //       ContractMethod.multiSwap,
+    //       network,
+    //       provider,
+    //     );
+    //   });
+    // });
   });
 
   describe('ComethSwap', () => {