@paraswap/dex-lib 3.4.0 → 3.4.1

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

@@ -1597,181 +1597,6 @@ describe('UniswapV2 E2E Mainnet', () => {
     });
   });
 
-  describe('SakeSwap', () => {
-    const dexKey = 'SakeSwap';
-
-    describe('Simpleswap', () => {
-      // http://localhost:3333/v2/prices/?from=0xdac17f958d2ee523a2206206994597c13d831ec7&to=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&amount=200000000&includeDEXS=SakeSwap&side=SELL&network=1
-      it('TOKEN -> ETH', async () => {
-        await testE2E(
-          tokens.USDT,
-          tokens.ETH,
-          holders.USDT,
-          '200000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-      it('ETH -> TOKEN', async () => {
-        // http://localhost:3333/v2/prices/?from=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&to=0xdac17f958d2ee523a2206206994597c13d831ec7&amount=1000000000000000000&includeDEXS=SakeSwap&side=SELL&network=1
-        await testE2E(
-          tokens.ETH,
-          tokens.USDT,
-          holders.ETH,
-          '500000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-      it('TOKEN -> TOKEN', async () => {
-        // http://localhost:3333/v2/prices/?from=0x2260fac5e5542a773aa44fbcfedf7c193bc2c599&to=0xdac17f958d2ee523a2206206994597c13d831ec7&amount=1000000&includeDEXS=SakeSwap&side=SELL&network=1
-        await testE2E(
-          tokens.WBTC,
-          tokens.USDT,
-          holders.WBTC,
-          '50000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('SimpleBuy', () => {
-      // http://localhost:3333/v2/prices/?from=0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48&to=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&amount=2000000000&includeDEXS=SakeSwap&side=BUY&network=1
-      it('TOKEN -> ETH', async () => {
-        await testE2E(
-          tokens.LINK,
-          tokens.ETH,
-          holders.LINK,
-          '2000000000',
-          SwapSide.BUY,
-          dexKey,
-          ContractMethod.simpleBuy,
-          network,
-          provider,
-        );
-      });
-      it('ETH -> TOKEN', async () => {
-        // http://localhost:3333/v2/prices/?from=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&to=0xdac17f958d2ee523a2206206994597c13d831ec7&amount=1000000&includeDEXS=SakeSwap&side=BUY&network=1
-        await testE2E(
-          tokens.ETH,
-          tokens.USDT,
-          holders.ETH,
-          '1000000',
-          SwapSide.BUY,
-          dexKey,
-          ContractMethod.simpleBuy,
-          network,
-          provider,
-        );
-      });
-      it('TOKEN -> TOKEN', async () => {
-        // http://localhost:3333/v2/prices/?from=0x2260fac5e5542a773aa44fbcfedf7c193bc2c599&to=0xdac17f958d2ee523a2206206994597c13d831ec7&amount=100000&includeDEXS=SakeSwap&side=BUY&network=1
-        await testE2E(
-          tokens.WBTC,
-          tokens.USDT,
-          holders.WBTC,
-          '100000',
-          SwapSide.BUY,
-          dexKey,
-          ContractMethod.simpleBuy,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('Multiswap', () => {
-      it('TOKEN -> ETH', async () => {
-        await testE2E(
-          tokens.USDT,
-          tokens.ETH,
-          holders.USDT,
-          '200000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-      it('ETH -> TOKEN', async () => {
-        await testE2E(
-          tokens.ETH,
-          tokens.USDT,
-          holders.ETH,
-          '500000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-      it('TOKEN -> TOKEN', async () => {
-        await testE2E(
-          tokens.WBTC,
-          tokens.USDT,
-          holders.WBTC,
-          '1000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('MegaPath', () => {
-      it('TOKEN -> ETH', async () => {
-        await testE2E(
-          tokens.USDT,
-          tokens.ETH,
-          holders.USDT,
-          '200000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.megaSwap,
-          network,
-          provider,
-        );
-      });
-      it('ETH -> TOKEN', async () => {
-        await testE2E(
-          tokens.ETH,
-          tokens.USDT,
-          holders.ETH,
-          '500000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.megaSwap,
-          network,
-          provider,
-        );
-      });
-      it('TOKEN -> TOKEN', async () => {
-        await testE2E(
-          tokens.WBTC,
-          tokens.USDT,
-          holders.WBTC,
-          '1000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.megaSwap,
-          network,
-          provider,
-        );
-      });
-    });
-  });
-
   describe('PancakeSwapV2', () => {
     const dexKey = 'PancakeSwapV2';
 

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

@@ -793,419 +793,6 @@ describe('UniswapV2 E2E Polygon', () => {
     });
   });
 
-  describe('JetSwap', () => {
-    const dexKey = 'JetSwap';
-
-    describe('Simpleswap', () => {
-      it('USDC -> MATIC', async () => {
-        await testE2E(
-          tokens.USDC,
-          tokens.MATIC,
-          holders.USDC,
-          '10000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-      it('USDT -> USDC', async () => {
-        await testE2E(
-          tokens.USDT,
-          tokens.USDC,
-          holders.USDT,
-          '1000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-      it('MATIC -> USDC', async () => {
-        await testE2E(
-          tokens.MATIC,
-          tokens.USDC,
-          holders.MATIC,
-          '100000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('SimpleBuy', () => {
-      it('USDC -> MATIC', async () => {
-        await testE2E(
-          tokens.USDC,
-          tokens.MATIC,
-          holders.USDC,
-          '100000000000000000000',
-          SwapSide.BUY,
-          dexKey,
-          ContractMethod.simpleBuy,
-          network,
-          provider,
-        );
-      });
-      it('USDT -> USDC', async () => {
-        await testE2E(
-          tokens.USDT,
-          tokens.USDC,
-          holders.USDT,
-          '1000000000',
-          SwapSide.BUY,
-          dexKey,
-          ContractMethod.simpleBuy,
-          network,
-          provider,
-        );
-      });
-      it('MATIC -> USDC', async () => {
-        await testE2E(
-          tokens.MATIC,
-          tokens.USDC,
-          holders.MATIC,
-          '10000000',
-          SwapSide.BUY,
-          dexKey,
-          ContractMethod.simpleBuy,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('MultiSwap', () => {
-      it('USDC -> MATIC', async () => {
-        await testE2E(
-          tokens.USDC,
-          tokens.MATIC,
-          holders.USDC,
-          '1000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-      it('USDT -> USDC', async () => {
-        await testE2E(
-          tokens.USDT,
-          tokens.USDC,
-          holders.USDT,
-          '1000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-      it('MATIC -> USDC', async () => {
-        await testE2E(
-          tokens.MATIC,
-          tokens.USDC,
-          holders.MATIC,
-          '100000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('MegaSwap', () => {
-      it('USDT -> USDC', async () => {
-        await testE2E(
-          tokens.USDT,
-          tokens.USDC,
-          holders.USDT,
-          '1000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.megaSwap,
-          network,
-          provider,
-        );
-      });
-    });
-  });
-
-  describe('Polycat', () => {
-    const dexKey = 'Polycat';
-
-    describe('simpleSwap', () => {
-      it('MATIC -> TOKEN', async () => {
-        await testE2E(
-          tokens.MATIC,
-          tokens.WETH,
-          holders.MATIC,
-          '100000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('Token -> MATIC', async () => {
-        await testE2E(
-          tokens.WETH,
-          tokens.MATIC,
-          holders.WETH,
-          '1000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('Token -> Token', async () => {
-        await testE2E(
-          tokens.USDT,
-          tokens.DAI,
-          holders.USDT,
-          '1000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('multiSwap', () => {
-      it('MATIC -> TOKEN', async () => {
-        await testE2E(
-          tokens.MATIC,
-          tokens.WETH,
-          holders.MATIC,
-          '100000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('Token -> MATIC', async () => {
-        await testE2E(
-          tokens.WETH,
-          tokens.MATIC,
-          holders.WETH,
-          '1000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('Token -> Token', async () => {
-        await testE2E(
-          tokens.USDT,
-          tokens.DAI,
-          holders.USDT,
-          '1000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-    });
-    describe('megaSwap', () => {
-      it('MATIC -> TOKEN', async () => {
-        await testE2E(
-          tokens.MATIC,
-          tokens.WETH,
-          holders.MATIC,
-          '100000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.megaSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('Token -> MATIC', async () => {
-        await testE2E(
-          tokens.WETH,
-          tokens.MATIC,
-          holders.WETH,
-          '1000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.megaSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('Token -> Token', async () => {
-        await testE2E(
-          tokens.USDT,
-          tokens.DAI,
-          holders.USDT,
-          '1000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.megaSwap,
-          network,
-          provider,
-        );
-      });
-    });
-  });
-
-  describe('RadioShack', () => {
-    const dexKey = 'RadioShack';
-
-    describe('simpleSwap', () => {
-      it('MATIC -> TOKEN', async () => {
-        await testE2E(
-          tokens.MATIC,
-          tokens.RADIO,
-          holders.MATIC,
-          '100000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('Token -> MATIC', async () => {
-        await testE2E(
-          tokens.RADIO,
-          tokens.MATIC,
-          holders.RADIO,
-          '1000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('Token -> Token', async () => {
-        await testE2E(
-          tokens.RADIO,
-          tokens.DAI,
-          holders.RADIO,
-          '1000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.simpleSwap,
-          network,
-          provider,
-        );
-      });
-    });
-
-    describe('multiSwap', () => {
-      it('MATIC -> TOKEN', async () => {
-        await testE2E(
-          tokens.MATIC,
-          tokens.RADIO,
-          holders.MATIC,
-          '100000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('Token -> MATIC', async () => {
-        await testE2E(
-          tokens.RADIO,
-          tokens.MATIC,
-          holders.RADIO,
-          '1000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('Token -> Token', async () => {
-        await testE2E(
-          tokens.RADIO,
-          tokens.DAI,
-          holders.RADIO,
-          '1000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.multiSwap,
-          network,
-          provider,
-        );
-      });
-    });
-
-    describe('megaSwap', () => {
-      it('MATIC -> TOKEN', async () => {
-        await testE2E(
-          tokens.MATIC,
-          tokens.RADIO,
-          holders.MATIC,
-          '100000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.megaSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('Token -> MATIC', async () => {
-        await testE2E(
-          tokens.RADIO,
-          tokens.MATIC,
-          holders.RADIO,
-          '1000000000000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.megaSwap,
-          network,
-          provider,
-        );
-      });
-
-      it('Token -> Token', async () => {
-        await testE2E(
-          tokens.RADIO,
-          tokens.DAI,
-          holders.RADIO,
-          '1000000000',
-          SwapSide.SELL,
-          dexKey,
-          ContractMethod.megaSwap,
-          network,
-          provider,
-        );
-      });
-    });
-  });
-
   describe(`Swapsicle`, () => {
     const dexKey = 'Swapsicle';
 

package/src/dex/weth/config.ts

@@ -10,9 +10,6 @@ export const WethConfig: DexConfigMap<DexParams> = {
     [Network.MAINNET]: {
       poolGasCost: WethGasCost,
     },
-    [Network.ROPSTEN]: {
-      poolGasCost: WethGasCost,
-    },
     [Network.RINKEBY]: {
       poolGasCost: WethGasCost,
     },

package/src/dex/wsteth/wsteth.ts

@@ -266,10 +266,7 @@ export class WstETH extends SimpleExchange implements IDex<WstETHData> {
       targetExchange: this.config.wstETHAddress,
       returnAmountPos:
         side === SwapSide.SELL
-          ? extractReturnAmountPosition(
-              WstETH.wstETHIface,
-              swapFunction,
-            )
+          ? extractReturnAmountPosition(WstETH.wstETHIface, swapFunction)
           : undefined,
     };
   }

package/src/types.ts

@@ -303,7 +303,6 @@ export type Config = {
   uniswapV3EventLoggingSampleRate?: number;
   swaapV2AuthToken?: string;
   dexalotAuthToken?: string;
-  smardexSubgraphAuthToken?: string;
   forceRpcFallbackDexs: string[];
 };
 

package/tests/constants-e2e.ts

@@ -412,21 +412,6 @@ export const Tokens: {
       decimals: 18,
     },
   },
-  [Network.ROPSTEN]: {
-    DAI: {
-      address: '0xaD6D458402F60fD3Bd25163575031ACDce07538D',
-      decimals: 18,
-    },
-    WETH: {
-      address: '0xc778417E063141139Fce010982780140Aa0cD5Ab',
-      decimals: 18,
-    },
-    ETH: { address: ETHER_ADDRESS, decimals: 18 },
-    USDC: {
-      address: '0x2ecf57cfaf2faedf1575d2372398ee34c428d6c3',
-      decimals: 6,
-    },
-  },
   [Network.POLYGON]: {
     jGBP: {
       address: '0x767058f11800fba6a682e73a6e79ec5eb74fac8c',
@@ -1381,12 +1366,6 @@ export const Holders: {
     eETH: '0x0f1DfeF1a40557d279d0de6E49aB306891A638b8',
     weETH: '0xfB4cB868727D9622258bf2B26A8CFc95f6742669',
   },
-  [Network.ROPSTEN]: {
-    ETH: '0x43262A12d8610AA70C15DbaeAC321d51613c9071',
-    DAI: '0xbe13517a2b520b2449068D2ec45280992B04047B',
-    WETH: '0xdA87Da8C599E8A8993f3CBCD0aA5A1316A559A6D',
-    USDC: '0xb2dafb6fc7f66526e72027ade0f044beda0ba11e',
-  },
   [Network.POLYGON]: {
     jGBP: '0x02aa0B826c7BA6386DdBE04C0a8715A1c0A16B24',
     MATIC: '0xfCbB9e5BB354B6F9fd40362Cee043F510dd3028D',

package/tests/generate-new-limit-order.ts

@@ -7,7 +7,7 @@ import { Network, NULL_ADDRESS } from '../src/constants';
 import { ParaSwapLimitOrdersConfig } from '../src/dex/paraswap-limit-orders/config';
 import { generateConfig } from '../src/config';
 
-const network = Network.ROPSTEN;
+const network = Network.MAINNET;
 const provider = ethers.getDefaultProvider(
   generateConfig(network).privateHttpProvider,
 );

package/.idea/aws.xml

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="accountSettings">
-    <option name="activeProfile" value="profile:default" />
-    <option name="activeRegion" value="us-east-1" />
-    <option name="recentlyUsedProfiles">
-      <list>
-        <option value="profile:default" />
-      </list>
-    </option>
-    <option name="recentlyUsedRegions">
-      <list>
-        <option value="us-east-1" />
-      </list>
-    </option>
-  </component>
-</project>