@paraswap/dex-lib 3.7.7-skip-approval → 3.7.7-skip-approval.2

package/src/config.ts

@@ -31,6 +31,7 @@ type BaseConfig = {
   rpcPollingBlocksBackToTriggerUpdate: number;
   hashFlowAuthToken?: string;
   hashFlowDisabledMMs: string[];
+  idleDaoAuthToken?: string;
   swaapV2AuthToken?: string;
   dexalotAuthToken?: string;
   forceRpcFallbackDexs: string[];
@@ -72,6 +73,7 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     rpcPollingBlocksBackToTriggerUpdate: 0,
     swaapV2AuthToken: process.env.API_KEY_SWAAP_V2_AUTH_TOKEN || '',
     hashFlowAuthToken: process.env.API_KEY_HASHFLOW_AUTH_TOKEN || '',
+    idleDaoAuthToken: process.env.API_KEY_IDLEDAO_AUTH_TOKEN || '',
     hashFlowDisabledMMs:
       process.env[`HASHFLOW_DISABLED_MMS_1`]?.split(',') || [],
     uniswapV3EventLoggingSampleRate: 0,
@@ -455,6 +457,7 @@ export function generateConfig(network: number): Config {
     rpcPollingBlocksBackToTriggerUpdate:
       baseConfig.rpcPollingBlocksBackToTriggerUpdate,
     hashFlowAuthToken: baseConfig.hashFlowAuthToken,
+    idleDaoAuthToken: baseConfig.idleDaoAuthToken,
     swaapV2AuthToken: baseConfig.swaapV2AuthToken,
     dexalotAuthToken: baseConfig.dexalotAuthToken,
     hashFlowDisabledMMs: baseConfig.hashFlowDisabledMMs,

package/src/dex/aave-v3-stata/aave-v3-stata.ts

@@ -427,6 +427,7 @@ export class AaveV3Stata
       exchangeData: swapData,
       targetExchange: exchange,
       returnAmountPos,
+      skipApproval: srcType === TokenType.STATA_TOKEN,
     };
   }
 

package/src/dex/idle-dao/config.ts

@@ -0,0 +1,26 @@
+import { DexParams, IdleToken } from './types';
+import { DexConfigMap, AdapterMappings } from '../../types';
+import { Network, SwapSide } from '../../constants';
+
+export const Config: DexConfigMap<DexParams> = {
+  IdleDao: {
+    [Network.MAINNET]: {
+      lendingGasCost: 328 * 1000,
+      factoryAddress: '0x3c9916bb9498f637e2fa86c2028e26275dc9a631',
+    },
+  },
+};
+
+export const Adapters: Record<number, AdapterMappings> = {
+  [Network.MAINNET]: {
+    [SwapSide.SELL]: [{ name: '', index: 0 }],
+    [SwapSide.BUY]: [{ name: '', index: 0 }],
+  },
+};
+
+export const endpoints: Record<number, string> = {
+  [Network.MAINNET]: 'https://api.idle.finance/pools',
+  [Network.POLYGON]: 'https://api-polygon.idle.finance/pools',
+  [Network.OPTIMISM]: 'https://api-optimism.idle.finance/pools',
+  [Network.ZKEVM]: 'https://api-zkevm.idle.finance/pools',
+};

package/src/dex/idle-dao/idle-dao-e2e.test.ts

@@ -0,0 +1,112 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import { Tokens, Holders } from '../../../tests/constants-e2e';
+import { Network, ContractMethod, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+
+  const sideToContractMethods = new Map([
+    [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
+  ]);
+
+  describe(`${network}`, () => {
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            it(`${tokenASymbol} -> ${tokenBSymbol} - ${tokenAAmount}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${tokenBSymbol} -> ${tokenASymbol} - ${tokenBAmount}`, async () => {
+              await testE2E(
+                tokens[tokenBSymbol],
+                tokens[tokenASymbol],
+                holders[tokenBSymbol],
+                side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
+describe('IdleDao E2E', () => {
+  const dexKey = 'IdleDao';
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+    const tests = [
+      {
+        tokenASymbol: 'STETH',
+        tokenBSymbol: 'AA_wstETH',
+        tokenAAmount: '1000000000000000000',
+        tokenBAmount: '1000000000000000000',
+      },
+      {
+        tokenASymbol: 'USDC',
+        tokenBSymbol: 'AA_idle_cpPOR-USDC',
+        tokenAAmount: '1000000',
+        tokenBAmount: '1000000000000000000',
+      },
+      {
+        tokenASymbol: 'USDT',
+        tokenBSymbol: 'BB_idle_cpFAS-USDT',
+        tokenAAmount: '1000000',
+        tokenBAmount: '1000000000000000000',
+      },
+      {
+        tokenASymbol: 'WETH',
+        tokenBSymbol: 'BB_Re7WETH',
+        tokenAAmount: '100000000000000',
+        tokenBAmount: '100000000000000',
+      },
+    ];
+
+    tests.forEach(testData => {
+      testForNetwork(
+        network,
+        dexKey,
+        testData.tokenASymbol,
+        testData.tokenBSymbol,
+        testData.tokenAAmount,
+        testData.tokenBAmount,
+      );
+    });
+  });
+});

package/src/dex/idle-dao/idle-dao-integration.test.ts

@@ -0,0 +1,155 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { IdleDao } from './idle-dao';
+import { checkPoolPrices, checkPoolsLiquidity } from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+
+async function testForIntegration(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+) {
+  const TokenA = Tokens[network][tokenASymbol];
+  const TokenB = Tokens[network][tokenBSymbol];
+  const tokenAAmounts = [
+    0n,
+    BigInt(tokenAAmount),
+    BigInt(tokenAAmount) * BigInt(2),
+  ];
+  const tokenBAmounts = [
+    0n,
+    BigInt(tokenBAmount),
+    BigInt(tokenBAmount) * BigInt(2),
+  ];
+
+  describe('IdleDao', function () {
+    it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+      const dexHelper = new DummyDexHelper(network);
+      const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      const idleDao = new IdleDao(network, dexKey, dexHelper);
+
+      await idleDao.initializePricing(blocknumber);
+
+      const pools = await idleDao.getPoolIdentifiers(TokenA, TokenB);
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await idleDao.getPricesVolume(
+        TokenA,
+        TokenB,
+        tokenAAmounts,
+        SwapSide.SELL,
+        blocknumber,
+        pools,
+      );
+
+      expect(poolPrices).not.toBeNull();
+      checkPoolPrices(poolPrices!, tokenAAmounts, SwapSide.SELL, dexKey);
+    });
+
+    it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+      const dexHelper = new DummyDexHelper(network);
+      const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      const idleDao = new IdleDao(network, dexKey, dexHelper);
+
+      await idleDao.initializePricing(blocknumber);
+
+      const pools = await idleDao.getPoolIdentifiers(TokenA, TokenB);
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await idleDao.getPricesVolume(
+        TokenA,
+        TokenB,
+        tokenBAmounts,
+        SwapSide.BUY,
+        blocknumber,
+        pools,
+      );
+
+      expect(poolPrices).not.toBeNull();
+      checkPoolPrices(poolPrices!, tokenBAmounts, SwapSide.BUY, dexKey);
+    });
+
+    it('getTopPoolsForToken', async function () {
+      const dexHelper = new DummyDexHelper(network);
+      const idleDao = new IdleDao(network, dexKey, dexHelper);
+
+      const poolLiquidity = await idleDao.getTopPoolsForToken(
+        TokenA.address,
+        10,
+      );
+
+      checkPoolsLiquidity(poolLiquidity, TokenA.address, dexKey);
+    });
+  });
+}
+
+describe('IdleDao Integration tests', () => {
+  const dexKey = 'IdleDao';
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+    const tests = [
+      {
+        tokenASymbol: 'STETH',
+        tokenBSymbol: 'AA_wstETH',
+        tokenAAmount: '1000000000000000000',
+        tokenBAmount: '1000000000000000000',
+      },
+      {
+        tokenASymbol: 'USDC',
+        tokenBSymbol: 'AA_idle_cpPOR-USDC',
+        tokenAAmount: '1000000',
+        tokenBAmount: '1000000000000000000',
+      },
+      {
+        tokenASymbol: 'USDT',
+        tokenBSymbol: 'BB_idle_cpFAS-USDT',
+        tokenAAmount: '1000000',
+        tokenBAmount: '1000000000000000000',
+      },
+      {
+        tokenASymbol: 'WETH',
+        tokenBSymbol: 'BB_Re7WETH',
+        tokenAAmount: '100000000000000',
+        tokenBAmount: '100000000000000',
+      },
+      {
+        tokenASymbol: 'WETH',
+        tokenBSymbol: 'AA_Re7WETH',
+        tokenAAmount: '1000000000000000',
+        tokenBAmount: '1000000000000000',
+      },
+      {
+        tokenASymbol: 'STETH',
+        tokenBSymbol: 'AA_iETHv2',
+        tokenAAmount: '1000000000000000',
+        tokenBAmount: '1000000000000000',
+      },
+      {
+        tokenASymbol: 'STETH',
+        tokenBSymbol: 'BB_iETHv2',
+        tokenAAmount: '1000000000000000',
+        tokenBAmount: '1000000000000000',
+      },
+    ];
+
+    tests.forEach(testData => {
+      testForIntegration(
+        network,
+        dexKey,
+        testData.tokenASymbol,
+        testData.tokenBSymbol,
+        testData.tokenAAmount,
+        testData.tokenBAmount,
+      );
+    });
+  });
+});