@paraswap/dex-lib 3.4.0 → 3.4.1

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

@@ -46,7 +46,6 @@ export const UniswapForksWithNetwork = transformToNetworkMap({
 
 export const UniswapV2Alias: { [network: number]: string } = {
   [Network.MAINNET]: 'uniswapv2',
-  [Network.ROPSTEN]: 'uniswapv2',
   [Network.BSC]: 'uniswapv2',
   [Network.POLYGON]: 'uniswapv2',
   [Network.AVALANCHE]: 'uniswapv2',

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

@@ -1119,278 +1119,6 @@ describe('UniswapV2 E2E Avalanche', () => {
     });
   });
 
-  describe('Thorus', () => {
-    const dexKey = 'Thorus';
-
-    describe('simpleSwap', () => {
-      it('AVAX -> THO', async () => {
-        await testE2E(
-          tokens.AVAX,
-          tokens.THO,
-          holders.AVAX,
-          '10000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('THO -> AVAX', async () => {
-        await testE2E(
-          tokens.THO,
-          tokens.AVAX,
-          holders.THO,
-          '30000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('THO -> USDCe', async () => {
-        await testE2E(
-          tokens.THO,
-          tokens.USDCe,
-          holders.THO,
-          '300000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-    });
-
-    describe('multiSwap', () => {
-      it('AVAX -> THO', async () => {
-        await testE2E(
-          tokens.AVAX,
-          tokens.THO,
-          holders.AVAX,
-          '3000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('THO -> AVAX', async () => {
-        await testE2E(
-          tokens.THO,
-          tokens.AVAX,
-          holders.THO,
-          '30000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('THO -> USDCe', async () => {
-        await testE2E(
-          tokens.THO,
-          tokens.USDCe,
-          holders.THO,
-          '300000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-    });
-
-    describe('megaSwap', () => {
-      it('AVAX -> THO', async () => {
-        await testE2E(
-          tokens.AVAX,
-          tokens.THO,
-          holders.AVAX,
-          '3000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.megaSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('THO -> AVAX', async () => {
-        await testE2E(
-          tokens.THO,
-          tokens.AVAX,
-          holders.THO,
-          '30000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.megaSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('THO -> USDCe', async () => {
-        await testE2E(
-          tokens.THO,
-          tokens.USDCe,
-          holders.THO,
-          '300000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.megaSwap,
-          network,
-          provider,
-        );
-      });
-    });
-  });
-
-  describe('Olive', () => {
-    const dexKey = 'Olive';
-
-    describe('simpleSwap', () => {
-      it('AVAX -> ETH', async () => {
-        await testE2E(
-          tokens.AVAX,
-          tokens.ETH,
-          holders.AVAX,
-          '300000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('ETH -> AVAX', async () => {
-        await testE2E(
-          tokens.ETH,
-          tokens.AVAX,
-          holders.ETH,
-          '30000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('USDT.e -> DAI.e', async () => {
-        await testE2E(
-          tokens.USDTe,
-          tokens.DAIE,
-          holders.USDTe,
-          '100000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-    });
-
-    describe('multiSwap', () => {
-      it('AVAX -> ETH', async () => {
-        await testE2E(
-          tokens.AVAX,
-          tokens.ETH,
-          holders.AVAX,
-          '300000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('ETH -> AVAX', async () => {
-        await testE2E(
-          tokens.ETH,
-          tokens.AVAX,
-          holders.ETH,
-          '30000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('USDT.e -> DAI.e', async () => {
-        await testE2E(
-          tokens.USDTe,
-          tokens.DAIE,
-          holders.USDTe,
-          '100000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-    });
-
-    describe('megaSwap', () => {
-      it('AVAX -> ETH', async () => {
-        await testE2E(
-          tokens.AVAX,
-          tokens.ETH,
-          holders.AVAX,
-          '300000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.megaSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('ETH -> AVAX', async () => {
-        await testE2E(
-          tokens.ETH,
-          tokens.AVAX,
-          holders.ETH,
-          '30000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.megaSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('USDT.e -> DAI.e', async () => {
-        await testE2E(
-          tokens.USDTe,
-          tokens.DAIE,
-          holders.USDTe,
-          '100000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.megaSwap,
-          network,
-          provider,
-        );
-      });
-    });
-  });
-
   describe('YetiSwap', () => {
     const dexKey = 'YetiSwap';
 

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

@@ -39,10 +39,4 @@ constructE2ETests('UniswapV2 E2E Base', Network.BASE, {
       { name: 'USDbC', sellAmount: '100000', buyAmount: '4000' },
     ],
   ],
-  ElkFinance: [
-    [
-      { name: 'WETH', sellAmount: '700000000000', buyAmount: '1000' },
-      { name: 'USDbC', sellAmount: '100000', buyAmount: '4000' },
-    ],
-  ],
 });

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

@@ -325,42 +325,6 @@ describe('UniswapV2 E2E BSC', () => {
     // });
   });
 
-  describe('Street Swap', () => {
-    const dexKey = 'StreetSwap';
-
-    describe('Simpleswap', () => {
-      it('Token -> TOKEN', async () => {
-        await testE2E(
-          tokens.DAI,
-          tokens.WBNB,
-          holders.DAI,
-          '70000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-    });
-
-    describe('Multiswap', () => {
-      it('Token -> TOKEN', async () => {
-        await testE2E(
-          tokens.DAI,
-          tokens.WBNB,
-          holders.DAI,
-          '70000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-    });
-  });
-
   describe('PantherSwap', () => {
     const dexKey = 'PantherSwap';
 
@@ -745,152 +709,6 @@ describe('UniswapV2 E2E BSC', () => {
     });
   });
 
-  describe('RadioShack', () => {
-    const dexKey = 'RadioShack';
-
-    describe('Simpleswap', () => {
-      it('BNB -> TOKEN', async () => {
-        await testE2E(
-          tokens.BNB,
-          tokens.RADIO,
-          holders.BNB,
-          '100000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-      it('Token -> TOKEN', async () => {
-        await testE2E(
-          tokens.BUSD,
-          tokens.RADIO,
-          holders.BUSD,
-          '1000000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-      it('Token -> BNB', async () => {
-        await testE2E(
-          tokens.RADIO,
-          tokens.BNB,
-          holders.RADIO,
-          '1000000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-    });
-
-    describe('BUY', () => {
-      it('BNB -> TOKEN', async () => {
-        await testE2E(
-          tokens.BNB,
-          tokens.RADIO,
-          holders.BNB,
-          '100000000000000000000',
-          SwapSide.BUY,
-          dexKey,
-          ContractMethod.simpleBuy,
-          network,
-          provider,
-        );
-      });
-      it('Token -> TOKEN', async () => {
-        await testE2E(
-          tokens.BUSD,
-          tokens.RADIO,
-          holders.BUSD,
-          '1000000000000000000000',
-          SwapSide.BUY,
-          dexKey,
-          ContractMethod.simpleBuy,
-          network,
-          provider,
-        );
-      });
-      it('Token -> BNB', async () => {
-        await testE2E(
-          tokens.RADIO,
-          tokens.BNB,
-          holders.RADIO,
-          '10000000000000000000',
-          SwapSide.BUY,
-          dexKey,
-          ContractMethod.simpleBuy,
-          network,
-          provider,
-        );
-      });
-    });
-
-    describe('Multiswap', () => {
-      it('BNB -> TOKEN', async () => {
-        await testE2E(
-          tokens.BNB,
-          tokens.RADIO,
-          holders.BNB,
-          '100000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-      it('Token -> TOKEN', async () => {
-        await testE2E(
-          tokens.BUSD,
-          tokens.RADIO,
-          holders.BUSD,
-          '1000000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-      it('Token -> BNB', async () => {
-        await testE2E(
-          tokens.RADIO,
-          tokens.BNB,
-          holders.RADIO,
-          '1000000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-    });
-
-    describe('Megapath', () => {
-      it('Token -> TOKEN', async () => {
-        await testE2E(
-          tokens.BUSD,
-          tokens.RADIO,
-          holders.BUSD,
-          '1000000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.megaSwap,
-          network,
-          provider,
-        );
-      });
-    });
-  });
-
   describe('WaultFinance', () => {
     const dexKey = 'WaultFinance';
 
@@ -1208,149 +1026,6 @@ describe('UniswapV2 E2E BSC', () => {
     });
   });
 
-  describe('JetSwap', () => {
-    const dexKey = 'JetSwap';
-
-    describe('Simpleswap', () => {
-      it('BNB -> BUSD', async () => {
-        await testE2E(
-          tokens.BNB,
-          tokens.BUSD,
-          holders.BNB,
-          '10000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-      it('USDT -> BUSD', async () => {
-        await testE2E(
-          tokens.USDT,
-          tokens.BUSD,
-          holders.USDT,
-          '100000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-      it('BUSD -> BNB', async () => {
-        await testE2E(
-          tokens.BUSD,
-          tokens.BNB,
-          holders.BUSD,
-          '100000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('SimpleBuy', () => {
-      it('BNB -> BUSD', async () => {
-        await testE2E(
-          tokens.BNB,
-          tokens.BUSD,
-          holders.BNB,
-          '10000000000000000000',
-          SwapSide.BUY,
-          dexKey,
-          ContractMethod.simpleBuy,
-          network,
-          provider,
-        );
-      });
-      it('USDT -> BUSD', async () => {
-        await testE2E(
-          tokens.USDT,
-          tokens.BUSD,
-          holders.USDT,
-          '100000000000000000000',
-          SwapSide.BUY,
-          dexKey,
-          ContractMethod.simpleBuy,
-          network,
-          provider,
-        );
-      });
-      it('BUSD -> BNB', async () => {
-        await testE2E(
-          tokens.BUSD,
-          tokens.BNB,
-          holders.BUSD,
-          '10000000000000000000',
-          SwapSide.BUY,
-          dexKey,
-          ContractMethod.simpleBuy,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('MultiSwap', () => {
-      it('BNB -> BUSD', async () => {
-        await testE2E(
-          tokens.BNB,
-          tokens.BUSD,
-          holders.BNB,
-          '10000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-      it('USDT -> BUSD', async () => {
-        await testE2E(
-          tokens.USDT,
-          tokens.BUSD,
-          holders.USDT,
-          '100000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-      it('BUSD -> BNB', async () => {
-        await testE2E(
-          tokens.BUSD,
-          tokens.BNB,
-          holders.BUSD,
-          '100000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('MegaSwap', () => {
-      it('USDT -> BUSD', async () => {
-        await testE2E(
-          tokens.USDT,
-          tokens.BUSD,
-          holders.USDT,
-          '100000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.megaSwap,
-          network,
-          provider,
-        );
-      });
-    });
-  });
-
   describe('CheeseSwap', () => {
     const dexKey = 'CheeseSwap';