@paraswap/dex-lib 4.1.7 → 4.1.8

package/src/dex/curve-v2/curve-v2-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('CurveV2 Gas Estimation', () => {
+  const dexKey = 'CurveV2';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountInOnCurveV2', () => {
+    const USDC = Tokens[network]['USDC'];
+    const USDT = Tokens[network]['USDT'];
+    const amount = 1000000n; // 1 usdc
+
+    it('exchange_underlying', async () => {
+      await testGasEstimation(
+        network,
+        USDC,
+        USDT,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountInOnCurveV2,
+      );
+    });
+  });
+});

package/src/dex/fluid-dex/fluid-dex-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('FluidDex Gas Estimation', () => {
+  const dexKey = 'FluidDex';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const USDC = Tokens[network]['USDC'];
+    const USDT = Tokens[network]['USDT'];
+    const amount = 10000n;
+
+    it('swapIn', async () => {
+      await testGasEstimation(
+        network,
+        USDC,
+        USDT,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/fx-protocol-rusd/fx-protocol-rusd-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('FxProtocolRusd Gas Estimation', () => {
+  const dexKey = 'FxProtocolRusd';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const weETH = Tokens[network]['weETH'];
+    const rUSD = Tokens[network]['rUSD'];
+    const amount = 1000000000000000000n;
+
+    it('mint', async () => {
+      await testGasEstimation(
+        network,
+        weETH,
+        rUSD,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/hashflow/hashflow-gas-estimation.test.ts

@@ -0,0 +1,30 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('Hashflow Gas Estimation', () => {
+  const dexKey = 'Hashflow';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const USDT = Tokens[network]['USDT'];
+    const USDC = Tokens[network]['USDC'];
+    const amount = 100000000n;
+
+    // todo: fix tx build
+    it('tradeRFQT', async () => {
+      await testGasEstimation(
+        network,
+        USDT,
+        USDC,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/idle-dao/idle-dao--gas-estimation.test.ts

@@ -0,0 +1,30 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('IdleDao Gas Estimation', () => {
+  const dexKey = 'IdleDao';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const STETH = Tokens[network]['STETH'];
+    const AA_wstETH = Tokens[network]['AA_wstETH'];
+    const amount = 1000000000000000000n;
+
+    // todo: uncomment? (the dex doesn't seem to be working)
+    // it('deposit', async () => {
+    //   await testGasEstimation(
+    //     network,
+    //     STETH,
+    //     AA_wstETH,
+    //     amount,
+    //     SwapSide.SELL,
+    //     dexKey,
+    //     ContractMethodV6.swapExactAmountIn,
+    //   );
+    // });
+  });
+});

package/src/dex/lido/lido-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('Lido Gas Estimation', () => {
+  const dexKey = 'Lido';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const STETH = Tokens[network]['STETH'];
+    const ETH = Tokens[network]['ETH'];
+    const amount = 100000000000000000000n;
+
+    it('submit', async () => {
+      await testGasEstimation(
+        network,
+        ETH,
+        STETH,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/lite-psm/lite-psm-gas-estimation.test.ts

@@ -0,0 +1,34 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+dotenv.config();
+
+describe('LitePsm Gas Estimation', () => {
+  const dexKey = 'LitePsm';
+  const network = Network.MAINNET;
+  const srcToken = Tokens[network]['USDC'];
+  const destToken = Tokens[network]['DAI'];
+  const methods: ContractMethodV6[] = [
+    ContractMethodV6.swapExactAmountInOutOnMakerPSM,
+    ContractMethodV6.swapExactAmountIn,
+  ];
+  const amount = 10000000n;
+
+  methods.forEach(async method => {
+    it(method, async () => {
+      await testGasEstimation(
+        network,
+        srcToken,
+        destToken,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        method,
+      );
+    });
+  });
+});

package/src/dex/maker-psm/maker-psm-gas-estimation.test.ts

@@ -0,0 +1,34 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+dotenv.config();
+
+describe('MakerPsm Gas Estimation', () => {
+  const dexKey = 'MakerPsm';
+  const network = Network.MAINNET;
+  const srcToken = Tokens[network]['USDC'];
+  const destToken = Tokens[network]['DAI'];
+  const methods: ContractMethodV6[] = [
+    ContractMethodV6.swapExactAmountInOutOnMakerPSM,
+    ContractMethodV6.swapExactAmountIn,
+  ];
+  const amount = 10000000n;
+
+  methods.forEach(async method => {
+    it(method, async () => {
+      await testGasEstimation(
+        network,
+        srcToken,
+        destToken,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        method,
+      );
+    });
+  });
+});

package/src/dex/maverick-v1/maverick-v1-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('MaverickV1 Gas Estimation', () => {
+  const dexKey = 'MaverickV1';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const USDT = Tokens[network]['USDT'];
+    const USDC = Tokens[network]['USDC'];
+    const amount = 1000000n;
+
+    it('exactInputSingle', async () => {
+      await testGasEstimation(
+        network,
+        USDT,
+        USDC,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/maverick-v2/maverick-v2-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('MaverickV2 Gas Estimation', () => {
+  const dexKey = 'MaverickV2';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const USDT = Tokens[network]['USDT'];
+    const USDC = Tokens[network]['USDC'];
+    const amount = 100000000n;
+
+    it('swap', async () => {
+      await testGasEstimation(
+        network,
+        USDT,
+        USDC,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/pancakeswap-v3/pancakeswap-v3-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('PancakeswapV3 Gas Estimation', () => {
+  const dexKey = 'PancakeswapV3';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const USDT = Tokens[network]['USDT'];
+    const USDC = Tokens[network]['USDC'];
+    const amount = 100000000n;
+
+    it('exactInput', async () => {
+      await testGasEstimation(
+        network,
+        USDT,
+        USDC,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/polygon-migrator/polygon-migrator-gas-estimation.test.ts

@@ -0,0 +1,41 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('PolygonMigrator Gas Estimation', () => {
+  const dexKey = 'PolygonMigrator';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const POL = Tokens[network]['POL'];
+    const MATIC = Tokens[network]['MATIC'];
+    const amount = 10000000000000000000n;
+
+    it('unmigrate', async () => {
+      await testGasEstimation(
+        network,
+        POL,
+        MATIC,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+
+    it('migrate', async () => {
+      await testGasEstimation(
+        network,
+        MATIC,
+        POL,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/sky-converter/sky-converter-gas-estimation.test.ts

@@ -0,0 +1,78 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('SkyConverter Gas Estimation', () => {
+  const network = Network.MAINNET;
+
+  describe('DaiUsds', () => {
+    const dexKey = 'DaiUsds';
+
+    describe('swapExactAmountIn', () => {
+      const DAI = Tokens[network]['DAI'];
+      const USDS = Tokens[network]['USDS'];
+      const amount = 10000000000000000000n;
+
+      it('daiToUsds', async () => {
+        await testGasEstimation(
+          network,
+          DAI,
+          USDS,
+          amount,
+          SwapSide.SELL,
+          dexKey,
+          ContractMethodV6.swapExactAmountIn,
+        );
+      });
+
+      it('usdsToDai', async () => {
+        await testGasEstimation(
+          network,
+          USDS,
+          DAI,
+          amount,
+          SwapSide.SELL,
+          dexKey,
+          ContractMethodV6.swapExactAmountIn,
+        );
+      });
+    });
+  });
+
+  describe('MkrSky', () => {
+    const dexKey = 'MkrSky';
+
+    describe('swapExactAmountIn', () => {
+      const MKR = Tokens[network]['MKR'];
+      const SKY = Tokens[network]['SKY'];
+      const amount = 10000000000000000000n;
+
+      it('mkrToSky', async () => {
+        await testGasEstimation(
+          network,
+          MKR,
+          SKY,
+          amount,
+          SwapSide.SELL,
+          dexKey,
+          ContractMethodV6.swapExactAmountIn,
+        );
+      });
+
+      it('skyToMkr', async () => {
+        await testGasEstimation(
+          network,
+          SKY,
+          MKR,
+          amount,
+          SwapSide.SELL,
+          dexKey,
+          ContractMethodV6.swapExactAmountIn,
+        );
+      });
+    });
+  });
+});

package/src/dex/solidly/solidly-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('Solidly Gas Estimation', () => {
+  const dexKey = 'SolidlyV2';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const USDT = Tokens[network]['USDT'];
+    const USDC = Tokens[network]['USDC'];
+    const amount = 100000000n;
+
+    it('swap', async () => {
+      await testGasEstimation(
+        network,
+        USDT,
+        USDC,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/solidly-v3/solidly-v3-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('SolidlyV3 Gas Estimation', () => {
+  const dexKey = 'SolidlyV3';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const USDT = Tokens[network]['USDT'];
+    const USDC = Tokens[network]['USDC'];
+    const amount = 100000000n;
+
+    it('swap', async () => {
+      await testGasEstimation(
+        network,
+        USDT,
+        USDC,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/spark/spark-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('Spark Gas Estimation', () => {
+  const dexKey = 'Spark';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const DAI = Tokens[network]['DAI'];
+    const sDAI = Tokens[network]['sDAI'];
+    const amount = 1000000000000000000n;
+
+    it('deposit', async () => {
+      await testGasEstimation(
+        network,
+        DAI,
+        sDAI,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/stader/stader-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('Stader Gas Estimation', () => {
+  const dexKey = 'Stader';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const ETH = Tokens[network]['ETH'];
+    const ETHx = Tokens[network]['ETHx'];
+    const amount = 1000000000000000000n;
+
+    it('deposit', async () => {
+      await testGasEstimation(
+        network,
+        ETH,
+        ETHx,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/stkgho/stkgho-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('StkGHO Gas Estimation', () => {
+  const dexKey = 'StkGHO';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const GHO = Tokens[network]['GHO'];
+    const stkGHO = Tokens[network]['stkGHO'];
+    const amount = 1000000000000000000n;
+
+    it('stake', async () => {
+      await testGasEstimation(
+        network,
+        GHO,
+        stkGHO,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/swaap-v2/swaap-v2-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('SwaapV2 Gas Estimation', () => {
+  const dexKey = 'SwaapV2';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const USDC = Tokens[network]['USDC'];
+    const WETH = Tokens[network]['WETH'];
+    const amount = 45410357n;
+
+    it('swap', async () => {
+      await testGasEstimation(
+        network,
+        USDC,
+        WETH,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/swell/swell-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('Swell Gas Estimation', () => {
+  const dexKey = 'Swell';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const ETH = Tokens[network]['ETH'];
+    const SWETH = Tokens[network]['SWETH'];
+    const amount = 45410357n;
+
+    it('deposit', async () => {
+      await testGasEstimation(
+        network,
+        ETH,
+        SWETH,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});