@paraswap/dex-lib 3.4.1 → 3.4.2-idle

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

@@ -0,0 +1,48 @@
+import { Address } from '@paraswap/core';
+import BigNumber from 'bignumber.js';
+
+export type PoolState = {
+  tokenPrice: BigInt;
+};
+
+export type PoolsState = Record<string, PoolState>;
+
+export type DexParams = {
+  fromBlock: number;
+  lendingGasCost: number;
+  factoryAddress: Address;
+};
+
+export type IdleToken = {
+  idleSymbol: string;
+  idleAddress: string;
+  cdoAddress: string;
+  tokenType: 'AA' | 'BB';
+  blockNumber: number;
+  address: string;
+  decimals: number;
+};
+
+export type TrancheToken = {
+  idleAddress: IdleToken['idleAddress'];
+  cdoAddress: IdleToken['cdoAddress'];
+  tokenType: IdleToken['tokenType'];
+};
+
+export type IdleDaoData = {
+  idleToken: IdleToken;
+  fromIdleToken: boolean;
+};
+
+export type Deposit = [amount: string, referral?: string];
+
+export type Withdraw = [amount: string];
+
+export type Param = Deposit | Withdraw;
+
+export enum PoolFunctions {
+  withdrawAA = 'withdrawAA',
+  depositAA = 'depositAARef',
+  withdrawBB = 'withdrawBB',
+  depositBB = 'depositBBRef',
+}

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

@@ -0,0 +1,216 @@
+import { endpoints, TOKEN_LISTS } from './config';
+import { BytesLike } from 'ethers';
+import BigNumber from 'bignumber.js';
+import { Interface } from '@ethersproject/abi';
+import { stringDecode, addressDecode, uint8ToNumber } from '../../lib/decoders';
+import {
+  MultiCallParams,
+  MultiResult,
+  MultiWrapper,
+} from '../../lib/multi-wrapper';
+import { IdleToken, TrancheToken } from './types';
+import axios from 'axios';
+import { Network } from '../../constants';
+import { IDexHelper } from '../../dex-helper';
+
+export const BNify = (s: any): BigNumber =>
+  new BigNumber(typeof s === 'object' ? s : String(s));
+
+async function _getIdleTokenSymbols(
+  blockNumber: number,
+  idleTokens: string[],
+  erc20Interface: Interface,
+  multiWrapper: MultiWrapper,
+): Promise<any> {
+  let calls: MultiCallParams<any>[] = [];
+
+  for (const idleAddress of idleTokens) {
+    calls.push({
+      target: idleAddress,
+      callData: erc20Interface.encodeFunctionData('symbol', []),
+      decodeFunction: (result: MultiResult<BytesLike> | BytesLike): any => {
+        return {
+          idleAddress,
+          idleSymbol: stringDecode(result),
+        };
+      },
+    });
+  }
+  const results = await multiWrapper.aggregate<any>(calls, blockNumber);
+
+  return results.reduce((output, item) => {
+    return {
+      ...output,
+      [item.idleAddress]: item.idleSymbol,
+    };
+  }, {});
+}
+
+async function _getIdleTokenDecimals(
+  blockNumber: number,
+  underlyingTokens: string[],
+  erc20Interface: Interface,
+  multiWrapper: MultiWrapper,
+): Promise<any> {
+  let calls: MultiCallParams<any>[] = [];
+
+  for (const address of underlyingTokens) {
+    calls.push({
+      target: address,
+      callData: erc20Interface.encodeFunctionData('decimals', []),
+      decodeFunction: (result: MultiResult<BytesLike> | BytesLike): any => {
+        return {
+          address,
+          decimals: uint8ToNumber(result),
+        };
+      },
+    });
+  }
+  const results = await multiWrapper.aggregate<any>(calls, blockNumber);
+
+  return results.reduce((output, item) => {
+    return {
+      ...output,
+      [item.address]: item.decimals,
+    };
+  }, {});
+}
+
+const getDataWithAuth = async (
+  endpoint: string,
+  token: string,
+  error_callback?: Function,
+) => {
+  const config = {
+    headers: { Authorization: `Bearer ${token}` },
+  };
+
+  const data = await axios.post(endpoint, {}, config).catch(err => {
+    if (typeof error_callback === 'function') {
+      error_callback(err);
+    }
+  });
+  return data?.data;
+};
+
+export const fetchTokenList_api = async (
+  network: Network,
+  dexHelper: IDexHelper,
+  blockNumber: number,
+  cdoInterface: Interface,
+  erc20Interface: Interface,
+  multiWrapper: MultiWrapper,
+  token: string,
+): Promise<IdleToken[]> => {
+  // const AUTH_TOKEN_DECODED = atob(idleDaoAuthToken!);
+  const data = await getDataWithAuth(endpoints[network], token);
+  // console.log('api_response_data', data);
+
+  // Fetch tokenslist from static file
+  if (!data) {
+    return TOKEN_LISTS;
+  }
+
+  const deployedContract = data
+    .filter((d: any) => !!d.cdoAddress)
+    .map((d: any) => d.cdoAddress);
+
+  const calls = deployedContract.reduce(
+    (calls: MultiCallParams<any>[], cdoAddress: string) => {
+      calls.push({
+        target: cdoAddress,
+        callData: cdoInterface.encodeFunctionData('AATranche', []),
+        decodeFunction: (
+          result: MultiResult<BytesLike> | BytesLike,
+        ): TrancheToken => {
+          return {
+            cdoAddress,
+            tokenType: 'AA',
+            idleAddress: addressDecode(result),
+          };
+        },
+      });
+
+      calls.push({
+        target: cdoAddress,
+        callData: cdoInterface.encodeFunctionData('BBTranche', []),
+        decodeFunction: (
+          result: MultiResult<BytesLike> | BytesLike,
+        ): TrancheToken => {
+          return {
+            cdoAddress,
+            tokenType: 'BB',
+            idleAddress: addressDecode(result),
+          };
+        },
+      });
+
+      calls.push({
+        target: cdoAddress,
+        callData: cdoInterface.encodeFunctionData('token', []),
+        decodeFunction: (result: MultiResult<BytesLike> | BytesLike): any => {
+          return {
+            cdoAddress,
+            address: addressDecode(result),
+          };
+        },
+      });
+
+      return calls;
+    },
+    [],
+  );
+
+  const results = await multiWrapper.aggregate<Record<string, string>>(
+    calls,
+    blockNumber,
+  );
+
+  const cdosUnderlying: Record<string, string> = results.reduce(
+    (cdosUnderlying, result: any) => {
+      if (!result.address) return cdosUnderlying;
+      return {
+        ...cdosUnderlying,
+        [result.cdoAddress]: result.address,
+      };
+    },
+    {},
+  );
+
+  const idleTokenSymbolsList = await _getIdleTokenSymbols(
+    blockNumber,
+    results
+      .filter(result => !!result.tokenType)
+      .map(result => result.idleAddress),
+    erc20Interface,
+    multiWrapper,
+  );
+
+  const idleTokenDecimals = await _getIdleTokenDecimals(
+    blockNumber,
+    results.filter(result => !result.tokenType).map(result => result.address),
+    erc20Interface,
+    multiWrapper,
+  );
+
+  // console.log('idleTokenDecimals', idleTokenDecimals)
+  // console.log('cdosUnderlying', cdosUnderlying)
+
+  const output: IdleToken[] = [];
+  for (const result of results) {
+    if (result.tokenType) {
+      const idleToken: IdleToken = {
+        decimals: 18,
+        blockNumber: 0,
+        cdoAddress: result.cdoAddress,
+        idleAddress: result.idleAddress,
+        address: cdosUnderlying[result.cdoAddress],
+        idleSymbol: idleTokenSymbolsList[result.idleAddress],
+        tokenType: result.tokenType as IdleToken['tokenType'],
+      };
+      output.push(idleToken);
+    }
+  }
+
+  return output;
+};

package/src/dex/index.ts

@@ -25,6 +25,7 @@ import { Onebit } from './onebit/onebit';
 import { Compound } from './compound/compound';
 import { AaveV2 } from './aave-v2/aave-v2';
 import { AaveV3 } from './aave-v3/aave-v3';
+import { IdleDao } from './idle-dao/idle-dao';
 import { OneInchLp } from './OneInchLp';
 import { DodoV1 } from './dodo-v1/dodo-v1';
 import { DodoV2 } from './dodo-v2';
@@ -126,6 +127,7 @@ const Dexes = [
   Excalibur,
   AaveV2,
   AaveV3,
+  IdleDao,
   KyberDmm,
   Weth,
   PolygonMigrator,

package/src/dex/swaap-v2/config.ts

@@ -7,6 +7,9 @@ export const SwaapV2Config: DexConfigMap<DexParams> = {
     [Network.MAINNET]: {},
     [Network.POLYGON]: {},
     [Network.ARBITRUM]: {},
+    [Network.BASE]: {},
+    [Network.BSC]: {},
+    [Network.OPTIMISM]: {},
   },
 };
 
@@ -23,4 +26,16 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'ArbitrumAdapter02', index: 6 }],
     [SwapSide.BUY]: [{ name: 'ArbitrumBuyAdapter', index: 8 }],
   },
+  [Network.BASE]: {
+    [SwapSide.SELL]: [{ name: 'BaseAdapter02', index: 1 }],
+    [SwapSide.BUY]: [{ name: 'BaseBuyAdapter', index: 8 }],
+  },
+  [Network.BSC]: {
+    [SwapSide.SELL]: [{ name: 'BscAdapter02', index: 11 }],
+    [SwapSide.BUY]: [{ name: 'BscBuyAdapter', index: 9 }],
+  },
+  [Network.OPTIMISM]: {
+    [SwapSide.SELL]: [{ name: 'OptimismAdapter02', index: 2 }],
+    [SwapSide.BUY]: [{ name: 'OptimismBuyAdapter', index: 7 }],
+  },
 };

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

@@ -60,18 +60,6 @@ describe('SwaapV2 E2E', () => {
           buyAmount: '100000000',
         },
       ],
-      [
-        {
-          name: 'USDT',
-          sellAmount: '45410357',
-          buyAmount: '100000000',
-        },
-        {
-          name: 'USDC',
-          sellAmount: '100000000',
-          buyAmount: '100000000',
-        },
-      ],
     ];
 
     sideToContractMethods.forEach((contractMethods, side) =>
@@ -138,7 +126,7 @@ describe('SwaapV2 E2E', () => {
     const pairs: { name: string; sellAmount: string; buyAmount: string }[][] = [
       [
         {
-          name: 'USDC',
+          name: 'USDCe',
           sellAmount: '45410357',
           buyAmount: '1000000000000000000',
         },
@@ -155,7 +143,7 @@ describe('SwaapV2 E2E', () => {
           buyAmount: '100000000',
         },
         {
-          name: 'USDC',
+          name: 'USDCe',
           sellAmount: '100000000',
           buyAmount: '150000000000000000000',
         },
@@ -167,7 +155,7 @@ describe('SwaapV2 E2E', () => {
           buyAmount: '100000000',
         },
         {
-          name: 'USDC',
+          name: 'USDCe',
           sellAmount: '100000000',
           buyAmount: '150000000000000000000',
         },
@@ -243,9 +231,237 @@ describe('SwaapV2 E2E', () => {
           buyAmount: '1000000000000000000',
         },
         {
-          name: 'DAI',
+          name: 'USDC',
+          sellAmount: '1000000',
+          buyAmount: '1000000',
+        },
+      ],
+    ];
+
+    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],
+                  side === SwapSide.SELL
+                    ? pair[0].sellAmount
+                    : pair[0].buyAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  sleepMs,
+                );
+              });
+              it(`${pair[1].name} -> ${pair[0].name}`, async () => {
+                await testE2E(
+                  tokens[pair[1].name],
+                  tokens[pair[0].name],
+                  holders[pair[1].name],
+                  side === SwapSide.SELL
+                    ? pair[1].sellAmount
+                    : pair[1].buyAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  sleepMs,
+                );
+              });
+            });
+          });
+        });
+      }),
+    );
+  });
+
+  describe.only('Base', () => {
+    const network = Network.BASE;
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+
+    const pairs: { name: string; sellAmount: string; buyAmount: string }[][] = [
+      [
+        {
+          name: 'AERO',
+          sellAmount: '100000000000000000000',
+          buyAmount: '100000000',
+        },
+        {
+          name: 'USDC',
+          sellAmount: '100000000',
+          buyAmount: '100000000000000000000',
+        },
+      ],
+    ];
+
+    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],
+                  side === SwapSide.SELL
+                    ? pair[0].sellAmount
+                    : pair[0].buyAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  sleepMs,
+                );
+              });
+              it(`${pair[1].name} -> ${pair[0].name}`, async () => {
+                await testE2E(
+                  tokens[pair[1].name],
+                  tokens[pair[0].name],
+                  holders[pair[1].name],
+                  side === SwapSide.SELL
+                    ? pair[1].sellAmount
+                    : pair[1].buyAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  sleepMs,
+                );
+              });
+            });
+          });
+        });
+      }),
+    );
+  });
+
+  describe.only('BSC', () => {
+    const network = Network.BSC;
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+
+    const pairs: { name: string; sellAmount: string; buyAmount: string }[][] = [
+      [
+        {
+          name: 'WBNB',
           sellAmount: '1000000000000000000',
-          buyAmount: '10000000000000000',
+          buyAmount: '100000000000000000000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '100000000000000000000',
+          buyAmount: '1000000000000000000',
+        },
+      ],
+    ];
+
+    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],
+                  side === SwapSide.SELL
+                    ? pair[0].sellAmount
+                    : pair[0].buyAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  sleepMs,
+                );
+              });
+              it(`${pair[1].name} -> ${pair[0].name}`, async () => {
+                await testE2E(
+                  tokens[pair[1].name],
+                  tokens[pair[0].name],
+                  holders[pair[1].name],
+                  side === SwapSide.SELL
+                    ? pair[1].sellAmount
+                    : pair[1].buyAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  sleepMs,
+                );
+              });
+            });
+          });
+        });
+      }),
+    );
+  });
+
+  describe.only('Optimism', () => {
+    const network = Network.OPTIMISM;
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+
+    const pairs: { name: string; sellAmount: string; buyAmount: string }[][] = [
+      [
+        {
+          name: 'WETH',
+          sellAmount: '1000000000000000000',
+          buyAmount: '100000000',
+        },
+        {
+          name: 'USDC',
+          sellAmount: '45410357',
+          buyAmount: '1000000000000000000',
         },
       ],
     ];

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

@@ -72,7 +72,7 @@ describe('Swaap V2', function () {
     const tokens = Tokens[network];
 
     const srcTokenSymbol = 'WETH';
-    const destTokenSymbol = 'USDC';
+    const destTokenSymbol = 'USDCe';
 
     const amountsForSell = [
       0n,

package/src/types.ts

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