@paraswap/dex-lib 3.8.37 → 3.8.39-1701-1507

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

@@ -1,6 +1,4 @@
 import dotenv from 'dotenv';
-dotenv.config();
-
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import {
   Holders,
@@ -11,8 +9,10 @@ import { testE2E } from '../../../tests/utils-e2e';
 import { generateConfig } from '../../config';
 import { ContractMethod, Network, SwapSide } from '../../constants';
 
+dotenv.config();
+
 // Give time for rate fetcher to fill the cache
-const sleepMs = 3000;
+const sleepMs = 5000;
 
 function testForNetwork(
   network: Network,
@@ -175,31 +175,281 @@ describe('Hashflow E2E', () => {
   describe('Mainnet', () => {
     const network = Network.MAINNET;
 
-    const tokenASymbol: string = 'USDT';
-    const tokenBSymbol: string = 'USDC';
+    describe('USDT -> USDC', () => {
+      const tokenASymbol: string = 'USDT';
+      const tokenBSymbol: string = 'USDC';
 
-    const tokenAAmount: string = '100000000';
-    const tokenBAmount: string = '100000000';
-    const nativeTokenAmount = '1000000000000000000';
+      const tokenAAmount: string = '100000000';
+      const tokenBAmount: string = '100000000';
+      const nativeTokenAmount = '100000000000000000';
 
-    testForNetwork(
-      network,
-      dexKey,
-      tokenASymbol,
-      tokenBSymbol,
-      tokenAAmount,
-      tokenBAmount,
-      nativeTokenAmount,
-    );
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+      );
+    });
+
+    describe('WETH -> USDC', () => {
+      const tokenASymbol: string = 'WETH';
+      const tokenBSymbol: string = 'USDC';
+
+      const tokenAAmount: string = '100000000000000000';
+      const tokenBAmount: string = '1000000';
+      const nativeTokenAmount = '100000000000000000';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+        true,
+      );
+
+      // it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+      //   await testE2E(
+      //     tokens[tokenASymbol],
+      //     tokens[tokenBSymbol],
+      //     holders[tokenASymbol],
+      //     tokenAAmount,
+      //     SwapSide.SELL,
+      //     dexKey,
+      //     ContractMethod.megaSwap,
+      //     network,
+      //     provider,
+      //     undefined,
+      //     undefined,
+      //     undefined,
+      //     undefined,
+      //     sleepMs,
+      //   );
+      // });
+      //
+      // it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+      //   await testE2E(
+      //     tokens[tokenBSymbol],
+      //     tokens[tokenASymbol],
+      //     holders[tokenBSymbol],
+      //     tokenBAmount,
+      //     SwapSide.SELL,
+      //     dexKey,
+      //     ContractMethod.megaSwap,
+      //     network,
+      //     provider,
+      //     undefined,
+      //     undefined,
+      //     undefined,
+      //     undefined,
+      //     sleepMs,
+      //   );
+      // });
+    });
+
+    describe('DAI -> USDC', () => {
+      const tokenASymbol: string = 'DAI';
+      const tokenBSymbol: string = 'USDC';
+
+      const tokenAAmount: string = '100000000000000000000';
+      const tokenBAmount: string = '100000000';
+      const nativeTokenAmount = '1000000000000000000';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+      );
+    });
+
+    describe('Multiswap', () => {
+      it('USDC -> ETH -> DAI', async () => {
+        const dexKeys = ['Hashflow'];
+        const provider = new StaticJsonRpcProvider(
+          generateConfig(network).privateHttpProvider,
+          network,
+        );
+        const slippage = undefined;
+
+        const tokenASymbol: string = 'USDC';
+        const tokenBSymbol: string = 'DAI';
+
+        const tokenAAmount: string = '22943400';
+
+        const tokens = Tokens[network];
+        const holders = Holders[network];
+        const contractMethod = ContractMethod.swapExactAmountIn;
+        const side = SwapSide.SELL;
+
+        await testE2E(
+          tokens[tokenASymbol],
+          tokens[tokenBSymbol],
+          holders[tokenASymbol],
+          tokenAAmount,
+          side,
+          dexKeys,
+          contractMethod,
+          network,
+          provider,
+          undefined,
+          undefined,
+          undefined,
+          slippage,
+          2000,
+          false,
+          [
+            '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
+            '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', // ETH
+            '0x6B175474E89094C44Da98b954EedeAC495271d0F', // DAI
+          ],
+        );
+      });
+
+      it('DAI -> ETH -> USDC', async () => {
+        const dexKeys = ['Hashflow'];
+        const provider = new StaticJsonRpcProvider(
+          generateConfig(network).privateHttpProvider,
+          network,
+        );
+        const slippage = undefined;
+
+        const tokenASymbol: string = 'DAI';
+        const tokenBSymbol: string = 'ETH';
+
+        const tokenAAmount: string = '22675013677618734169';
+
+        const tokens = Tokens[network];
+        const holders = Holders[network];
+        const contractMethod = ContractMethod.swapExactAmountIn;
+        const side = SwapSide.SELL;
+
+        await testE2E(
+          tokens[tokenASymbol],
+          tokens[tokenBSymbol],
+          holders[tokenASymbol],
+          tokenAAmount,
+          side,
+          dexKeys,
+          contractMethod,
+          network,
+          provider,
+          undefined,
+          undefined,
+          undefined,
+          slippage,
+          2000,
+          false,
+          [
+            '0x6B175474E89094C44Da98b954EedeAC495271d0F', // DAI
+            '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', // ETH
+            '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
+          ],
+        );
+      });
+
+      it('DAI -> USDC -> WETH', async () => {
+        const dexKeys = ['Hashflow'];
+        const provider = new StaticJsonRpcProvider(
+          generateConfig(network).privateHttpProvider,
+          network,
+        );
+        const slippage = undefined;
+
+        const tokenASymbol: string = 'DAI';
+        const tokenBSymbol: string = 'ETH';
+
+        const tokenAAmount: string = '22675013677618734169';
+
+        const tokens = Tokens[network];
+        const holders = Holders[network];
+        const contractMethod = ContractMethod.swapExactAmountIn;
+        const side = SwapSide.SELL;
+
+        await testE2E(
+          tokens[tokenASymbol],
+          tokens[tokenBSymbol],
+          holders[tokenASymbol],
+          tokenAAmount,
+          side,
+          dexKeys,
+          contractMethod,
+          network,
+          provider,
+          undefined,
+          undefined,
+          undefined,
+          slippage,
+          2000,
+          false,
+          [
+            '0x6B175474E89094C44Da98b954EedeAC495271d0F', // DAI
+            '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
+            '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2', // WETH
+          ],
+        );
+      });
+
+      it('WETH -> USDC -> DAI', async () => {
+        const dexKeys = ['Hashflow'];
+        const provider = new StaticJsonRpcProvider(
+          generateConfig(network).privateHttpProvider,
+          network,
+        );
+        const slippage = undefined;
+
+        const tokenASymbol: string = 'WETH';
+        const tokenBSymbol: string = 'DAI';
+
+        const tokenAAmount: string = '8878957204610561';
+
+        const tokens = Tokens[network];
+        const holders = Holders[network];
+        const contractMethod = ContractMethod.swapExactAmountIn;
+        const side = SwapSide.SELL;
+
+        await testE2E(
+          tokens[tokenASymbol],
+          tokens[tokenBSymbol],
+          holders[tokenASymbol],
+          tokenAAmount,
+          side,
+          dexKeys,
+          contractMethod,
+          network,
+          provider,
+          undefined,
+          undefined,
+          undefined,
+          slippage,
+          2000,
+          false,
+          [
+            '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2', // WETH
+            '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
+            '0x6B175474E89094C44Da98b954EedeAC495271d0F', // DAI
+          ],
+        );
+      });
+    });
   });
-  describe('Polygon_V6', () => {
+
+  describe('Polygon', () => {
     const network = Network.POLYGON;
 
-    const tokenASymbol: string = 'USDC';
-    const tokenBSymbol: string = 'DAI';
+    const tokenASymbol: string = 'USDCe';
+    const tokenBSymbol: string = 'USDT';
 
-    const tokenAAmount: string = '1000000000';
-    const tokenBAmount: string = '1000000000000000000000';
+    const tokenAAmount: string = '10000000';
+    const tokenBAmount: string = '10000000';
     const nativeTokenAmount = '100000000000000000000';
 
     testForNetwork(
@@ -210,16 +460,18 @@ describe('Hashflow E2E', () => {
       tokenAAmount,
       tokenBAmount,
       nativeTokenAmount,
+      // true,
     );
   });
+
   describe('BSC', () => {
     const network = Network.BSC;
 
     const tokenASymbol: string = 'USDC';
     const tokenBSymbol: string = 'USDT';
 
-    const tokenAAmount: string = '100000000';
-    const tokenBAmount: string = '100000000';
+    const tokenAAmount: string = '1000000000000000000';
+    const tokenBAmount: string = '1000000000000000000';
     const nativeTokenAmount = '1000000000000000000';
 
     testForNetwork(
@@ -232,14 +484,15 @@ describe('Hashflow E2E', () => {
       nativeTokenAmount,
     );
   });
+
   describe('Arbitrum', () => {
     const network = Network.ARBITRUM;
 
     const tokenASymbol: string = 'USDC';
-    const tokenBSymbol: string = 'WETH';
+    const tokenBSymbol: string = 'USDT';
 
-    const tokenAAmount: string = '100000000';
-    const tokenBAmount: string = '1000000000000000000';
+    const tokenAAmount: string = '10000000';
+    const tokenBAmount: string = '10000000';
     const nativeTokenAmount = '1000000000000000000';
 
     testForNetwork(
@@ -250,9 +503,9 @@ describe('Hashflow E2E', () => {
       tokenAAmount,
       tokenBAmount,
       nativeTokenAmount,
-      true,
     );
   });
+
   describe('Optimism', () => {
     const network = Network.OPTIMISM;