@paraswap/dex-lib 3.4.0 → 3.4.1

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

@@ -313,415 +313,6 @@ describe('IronV2', () => {
     //   });
     // });
   });
-  describe('Avalanche', () => {
-    const network = Network.AVALANCHE;
-    const tokens = Tokens[network];
-    const holders = Holders[network];
-    const provider = new StaticJsonRpcProvider(
-      generateConfig(network).privateHttpProvider,
-      network,
-    );
-    describe('simpleSwap', () => {
-      const contractMethod = ContractMethod.simpleSwap;
-      it('SELL USDCe -> USDTe', async () => {
-        await testE2E(
-          tokens.USDCe,
-          tokens.USDTe,
-          holders.USDCe,
-          '11000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('multiSwap', () => {
-      const contractMethod = ContractMethod.multiSwap;
-      it('SELL USDCe -> USDTe', async () => {
-        await testE2E(
-          tokens.USDCe,
-          tokens.USDTe,
-          holders.USDCe,
-          '11000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('megaSwap', () => {
-      const contractMethod = ContractMethod.megaSwap;
-      it('SELL USDCe -> USDTe', async () => {
-        await testE2E(
-          tokens.USDCe,
-          tokens.USDTe,
-          holders.USDCe,
-          '11000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-  });
-
-  describe('Fantom', () => {
-    const network = Network.FANTOM;
-    const tokens = Tokens[network];
-    const holders = Holders[network];
-    const provider = new StaticJsonRpcProvider(
-      generateConfig(network).privateHttpProvider,
-      network,
-    );
-    describe('simpleSwap', () => {
-      const contractMethod = ContractMethod.simpleSwap;
-      it('SELL USDC -> FUSDT', async () => {
-        await testE2E(
-          tokens.USDC,
-          tokens.FUSDT,
-          holders.USDC,
-          '111000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('multiSwap', () => {
-      const contractMethod = ContractMethod.multiSwap;
-      it('SELL USDC -> fUSDT', async () => {
-        await testE2E(
-          tokens.USDC,
-          tokens.FUSDT,
-          holders.USDC,
-          '111000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('megaSwap', () => {
-      const contractMethod = ContractMethod.megaSwap;
-      it('SELL USDC -> fUSDT', async () => {
-        await testE2E(
-          tokens.USDC,
-          tokens.FUSDT,
-          holders.USDC,
-          '111000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-  });
-});
-
-describe('ZyberswapStable', () => {
-  const dexKey = 'ZyberswapStable';
-
-  describe('Arbitrum', () => {
-    const network = Network.ARBITRUM;
-    const tokens = Tokens[network];
-    const holders = Holders[network];
-    const provider = new StaticJsonRpcProvider(
-      generateConfig(network).privateHttpProvider,
-      network,
-    );
-
-    const sideToContractMethods = new Map([
-      [
-        SwapSide.SELL,
-        [
-          ContractMethod.simpleSwap,
-          ContractMethod.multiSwap,
-          ContractMethod.megaSwap,
-        ],
-      ],
-    ]);
-
-    const pairs: { name: string; sellAmount: string }[][] = [
-      [
-        { name: 'USDC', sellAmount: '111000000' },
-        { name: 'USDT', sellAmount: '111000000' },
-      ],
-      [
-        { name: 'USDC', sellAmount: '111000000' },
-        { name: 'DAI', sellAmount: '111000000000000000' },
-      ],
-      [
-        { name: 'USDT', sellAmount: '111000000' },
-        { name: 'DAI', sellAmount: '111000000000000000' },
-      ],
-    ];
-
-    sideToContractMethods.forEach((contractMethods, side) =>
-      describe(`${side}`, () => {
-        contractMethods.forEach((contractMethod: ContractMethod) => {
-          pairs.forEach(pair => {
-            describe(`${contractMethod}`, () => {
-              it(`${pair[0].name} -> ${pair[1].name}`, async () => {
-                await testE2E(
-                  tokens[pair[0].name],
-                  tokens[pair[1].name],
-                  holders[pair[0].name],
-                  pair[0].sellAmount,
-                  side,
-                  dexKey,
-                  contractMethod,
-                  network,
-                  provider,
-                );
-              });
-              it(`${pair[1].name} -> ${pair[0].name}`, async () => {
-                await testE2E(
-                  tokens[pair[1].name],
-                  tokens[pair[0].name],
-                  holders[pair[1].name],
-                  pair[1].sellAmount,
-                  side,
-                  dexKey,
-                  contractMethod,
-                  network,
-                  provider,
-                );
-              });
-            });
-          });
-        });
-      }),
-    );
-  });
-});
-
-describe('Saddle', () => {
-  const dexKey = 'Saddle';
-
-  describe('Mainnet', () => {
-    const network = Network.MAINNET;
-    const tokens = Tokens[network];
-    const holders = Holders[network];
-    const provider = new StaticJsonRpcProvider(
-      generateConfig(network).privateHttpProvider,
-      network,
-    );
-    describe('simpleSwap', () => {
-      const contractMethod = ContractMethod.simpleSwap;
-      it('SELL FEI -> newFRAX', async () => {
-        await testE2E(
-          tokens.FEI,
-          tokens.newFRAX,
-          holders.FEI,
-          '11000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-      it('SELL wBTC -> renBTC', async () => {
-        await testE2E(
-          tokens.WBTC,
-          tokens.renBTC,
-          holders.WBTC,
-          '100000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('multiSwap', () => {
-      const contractMethod = ContractMethod.multiSwap;
-      it('SELL FEI -> FRAX', async () => {
-        await testE2E(
-          tokens.FEI,
-          tokens.newFRAX,
-          holders.FEI,
-          '11000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-      it('SELL wBTC -> renBTC', async () => {
-        await testE2E(
-          tokens.WBTC,
-          tokens.renBTC,
-          holders.WBTC,
-          '100000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('megaSwap', () => {
-      const contractMethod = ContractMethod.megaSwap;
-      it('SELL FEI -> FRAX', async () => {
-        await testE2E(
-          tokens.FEI,
-          tokens.newFRAX,
-          holders.FEI,
-          '11000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-      it('SELL wBTC -> renBTC', async () => {
-        await testE2E(
-          tokens.WBTC,
-          tokens.renBTC,
-          holders.WBTC,
-          '100000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-  });
-
-  describe('Fantom', () => {
-    const network = Network.FANTOM;
-    const tokens = Tokens[network];
-    const holders = Holders[network];
-    const provider = new StaticJsonRpcProvider(
-      generateConfig(network).privateHttpProvider,
-      network,
-    );
-    describe('simpleSwap', () => {
-      const contractMethod = ContractMethod.simpleSwap;
-      it('SELL USDC -> FRAX', async () => {
-        await testE2E(
-          tokens.USDC,
-          tokens.FRAX,
-          holders.USDC,
-          '111000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('multiSwap', () => {
-      const contractMethod = ContractMethod.multiSwap;
-      it('SELL USDC -> FRAX', async () => {
-        await testE2E(
-          tokens.USDC,
-          tokens.FRAX,
-          holders.USDC,
-          '111000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('megaSwap', () => {
-      const contractMethod = ContractMethod.megaSwap;
-      it('SELL USDC -> FRAX', async () => {
-        await testE2E(
-          tokens.USDC,
-          tokens.FRAX,
-          holders.USDC,
-          '111000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-  });
-
-  describe('Arbitrum', () => {
-    const network = Network.ARBITRUM;
-    const tokens = Tokens[network];
-    const holders = Holders[network];
-    const provider = new StaticJsonRpcProvider(
-      generateConfig(network).privateHttpProvider,
-      network,
-    );
-    describe('simpleSwap', () => {
-      const contractMethod = ContractMethod.simpleSwap;
-      it('SELL USDC -> FRAX', async () => {
-        await testE2E(
-          tokens.USDC,
-          tokens.FRAX,
-          holders.USDC,
-          '111000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('multiSwap', () => {
-      const contractMethod = ContractMethod.multiSwap;
-      it('SELL USDC -> FRAX', async () => {
-        await testE2E(
-          tokens.USDC,
-          tokens.FRAX,
-          holders.USDC,
-          '111000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('megaSwap', () => {
-      const contractMethod = ContractMethod.megaSwap;
-      it('SELL USDC -> FRAX', async () => {
-        await testE2E(
-          tokens.USDC,
-          tokens.FRAX,
-          holders.USDC,
-          '111000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-  });
 });
 
 describe('Synapse', () => {
@@ -904,104 +495,6 @@ describe('Synapse', () => {
     // });
   });
 
-  describe('Fantom', () => {
-    const network = Network.FANTOM;
-    const tokens = Tokens[network];
-    const holders = Holders[network];
-    const provider = new StaticJsonRpcProvider(
-      generateConfig(network).privateHttpProvider,
-      network,
-    );
-    describe('simpleSwap', () => {
-      const contractMethod = ContractMethod.simpleSwap;
-      it('SELL USDC -> FUSDT', async () => {
-        await testE2E(
-          tokens.USDC,
-          tokens.FUSDT,
-          holders.USDC,
-          '111000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-      it('SELL nETH -> WETH', async () => {
-        await testE2E(
-          tokens.nETH,
-          tokens.WETH,
-          holders.nETH,
-          '1000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('multiSwap', () => {
-      const contractMethod = ContractMethod.multiSwap;
-
-      it('SELL USDC -> fUSDT', async () => {
-        await testE2E(
-          tokens.USDC,
-          tokens.FUSDT,
-          holders.USDC,
-          '111000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-      it('SELL nETH -> WETH', async () => {
-        await testE2E(
-          tokens.nETH,
-          tokens.WETH,
-          holders.nETH,
-          '1000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('megaSwap', () => {
-      const contractMethod = ContractMethod.megaSwap;
-      it('SELL USDC -> fUSDT', async () => {
-        await testE2E(
-          tokens.USDC,
-          tokens.FUSDT,
-          holders.USDC,
-          '111000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-      it('SELL nETH -> WETH', async () => {
-        await testE2E(
-          tokens.nETH,
-          tokens.WETH,
-          holders.nETH,
-          '1000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-  });
-
   describe('Avalanche', () => {
     const network = Network.AVALANCHE;
     const tokens = Tokens[network];