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

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

@@ -0,0 +1,99 @@
+import { Token } from '../../types';
+import { Network } from '../../constants';
+
+import { IdleToken } from './types';
+import { IDexHelper } from '../../dex-helper';
+import CDO_ABI from '../../abi/idle-dao/idle-cdo.json';
+import { AbiItem } from 'web3-utils';
+
+const poolsByTokenAddress: {
+  [network: number]: { [address: string]: IdleToken[] };
+} = {};
+
+const TokensByAddress: { [network: number]: { [address: string]: IdleToken } } =
+  {};
+
+export const getPoolsByTokenAddress = (
+  network: number,
+  address: string,
+): IdleToken[] => {
+  return poolsByTokenAddress[network]?.[address] || [];
+};
+
+// return null if the pair does not exists otherwise return the idleToken
+export function getIdleTokenIfIdleDaoPair(
+  network: number,
+  src: Token,
+  dst: Token,
+): IdleToken | null {
+  const srcAddr = src.address.toLowerCase();
+  const dstAddr = dst.address.toLowerCase();
+
+  if (srcAddr === dstAddr) {
+    return null;
+  }
+
+  const _src = TokensByAddress[network][srcAddr];
+  const _dst = TokensByAddress[network][dstAddr];
+
+  if (_src && _src.address.toLowerCase() == dstAddr) {
+    return _src;
+  }
+
+  if (_dst && _dst.address.toLowerCase() == srcAddr) {
+    return _dst;
+  }
+
+  return null;
+}
+
+export function getTokenFromIdleToken(idleToken: IdleToken): Token {
+  return {
+    address: idleToken.idleAddress,
+    decimals: idleToken.idleDecimals,
+    symbol: idleToken.idleSymbol,
+  };
+}
+
+export function getIdleTokenByAddress(
+  network: Network,
+  address: string,
+): IdleToken | undefined {
+  return TokensByAddress[network]?.[address];
+}
+
+export function setTokensOnNetwork(
+  network: Network,
+  tokens: IdleToken[],
+  dexHelper: IDexHelper,
+): any {
+  for (let token of tokens) {
+    token.address = token.address.toLowerCase();
+    token.idleAddress = token.idleAddress.toLowerCase();
+
+    if (TokensByAddress[network] === undefined) {
+      TokensByAddress[network] = {};
+    }
+
+    if (poolsByTokenAddress[network] === undefined) {
+      poolsByTokenAddress[network] = {};
+    }
+
+    if (poolsByTokenAddress[network][token.address] === undefined) {
+      poolsByTokenAddress[network][token.address] = [];
+    }
+
+    const tokenWithContract: IdleToken = {
+      ...token,
+      cdoContract: new dexHelper.web3Provider.eth.Contract(
+        CDO_ABI as AbiItem[],
+        token.cdoAddress,
+      ),
+    };
+    TokensByAddress[network][token.idleAddress] = tokenWithContract;
+    TokensByAddress[network][token.address] = tokenWithContract;
+    poolsByTokenAddress[network][token.address].push(token);
+  }
+
+  return TokensByAddress[network];
+}

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

@@ -0,0 +1,43 @@
+import { Address } from '@paraswap/core';
+import { Contract } from 'web3-eth-contract';
+
+export type DexParams = {
+  lendingGasCost: number;
+  factoryAddress: Address;
+};
+
+export type IdleToken = {
+  idleDecimals: number;
+  idleSymbol: string;
+  idleAddress: string;
+  cdoAddress: string;
+  cdoContract?: Contract; // used to get virtualPrice
+  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: Pick<IdleToken, 'cdoAddress' | 'tokenType'>;
+  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 } 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';
+import { TOKEN_LISTS } from './token_list';
+
+export const BNify = (s: any): BigNumber =>
+  new BigNumber(typeof s === 'object' ? s : String(s));
+
+async function _getIdleTokenSymbols(
+  idleTokens: string[],
+  erc20Interface: Interface,
+  multiWrapper: MultiWrapper,
+  blockNumber?: number,
+): 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(
+  underlyingTokens: string[],
+  erc20Interface: Interface,
+  multiWrapper: MultiWrapper,
+  blockNumber?: number,
+): 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,
+  cdoInterface: Interface,
+  erc20Interface: Interface,
+  multiWrapper: MultiWrapper,
+  token: string,
+  blockNumber?: number,
+): Promise<IdleToken[]> => {
+  const data = await getDataWithAuth(endpoints[network], token);
+
+  // Fetch tokenslist from static file
+  if (!data) {
+    return TOKEN_LISTS[network];
+  }
+
+  const deployedContract = data
+    .filter((d: any) => !!d.cdoAddress)
+    .reduce((acc: any[], d: any) => {
+      if (acc.includes(d.cdoAddress)) return acc;
+      return [...acc, 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(
+    results
+      .filter(result => !!result.tokenType)
+      .map(result => result.idleAddress),
+    erc20Interface,
+    multiWrapper,
+    blockNumber,
+  );
+
+  const idleTokenDecimals = await _getIdleTokenDecimals(
+    results.filter(result => !result.tokenType).map(result => result.address),
+    erc20Interface,
+    multiWrapper,
+    blockNumber,
+  );
+
+  const output: IdleToken[] = [];
+  for (const result of results) {
+    if (result.tokenType) {
+      const idleToken: IdleToken = {
+        blockNumber: 0,
+        idleDecimals: 18,
+        cdoAddress: result.cdoAddress,
+        idleAddress: result.idleAddress,
+        address: cdosUnderlying[result.cdoAddress],
+        idleSymbol: idleTokenSymbolsList[result.idleAddress],
+        tokenType: result.tokenType as IdleToken['tokenType'],
+        decimals: idleTokenDecimals[cdosUnderlying[result.cdoAddress]],
+      };
+      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';
@@ -130,6 +131,7 @@ const Dexes = [
   Excalibur,
   AaveV2,
   AaveV3,
+  IdleDao,
   KyberDmm,
   Weth,
   PolygonMigrator,

package/src/generic-swap-transaction-builder.ts

@@ -716,7 +716,9 @@ export class GenericSwapTransactionBuilder {
     ];
 
     approvals.forEach((alreadyApproved, index) => {
-      if (!alreadyApproved && !skipApproval) {
+      // TODO: uncomment after testing
+      // if (!alreadyApproved && !skipApproval) {
+      if (!skipApproval) {
         const [token, target] = tokenTargetMapping[index].params;
         const exchangeParamIndex = tokenTargetMapping[index].exchangeParamIndex;
         const curExchangeParam = dexExchangeParams[exchangeParamIndex];

package/src/types.ts

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

package/tests/constants-e2e.ts

@@ -19,6 +19,58 @@ export const Tokens: {
   [network: number]: { [symbol: string]: SmartTokenParams };
 } = {
   [Network.MAINNET]: {
+    AA_wstETH: {
+      decimals: 18,
+      address: '0x2688fc68c4eac90d9e5e1b94776cf14eade8d877',
+    },
+    'AA_idle_cpPOR-USDC': {
+      decimals: 18,
+      address: '0x9cacd44cfdf22731bc99facf3531c809d56bd4a2',
+    },
+    'BB_idle_cpFAS-USDT': {
+      decimals: 18,
+      address: '0x3eb6318b8d9f362a0e1d99f6032edb1c4c602500',
+    },
+    AA_steakUSDC: {
+      decimals: 18,
+      address: '0x2b0e31b8ee653d2077db86dea3acf3f34ae9d5d2',
+    },
+    BB_steakUSDC: {
+      decimals: 18,
+      address: '0x7b713b1cb6eafd4061064581579ffccf7df21545',
+    },
+    AA_Re7WETH: {
+      decimals: 18,
+      address: '0x454bb3cb427b21e1c052a080e21a57753cd6969e',
+    },
+    BB_Re7WETH: {
+      decimals: 18,
+      address: '0x20aa3cd83044d2903181f7ef5c2b498a017d1c4a',
+    },
+    BB_dUSDCV3: {
+      decimals: 18,
+      address: '0x2a84a042db06222c486bcb815e961f26599d0df6',
+    },
+    AA_sUSDe: {
+      decimals: 18,
+      address: '0xf3188697bd35df73e4293d04a07ebaaf1ffc4018',
+    },
+    BB_sUSDe: {
+      decimals: 18,
+      address: '0xb8d0be502a8f12cc5213733285b430a43d07349d',
+    },
+    AA_iETHv2: {
+      decimals: 18,
+      address: '0xdf17c739b666B259DA3416d01f0310a6e429f592',
+    },
+    BB_iETHv2: {
+      decimals: 18,
+      address: '0x990b3aF34dDB502715E1070CE6778d8eB3c8Ea82',
+    },
+    USDE: {
+      address: '0x4c9edd5852cd905f086c759e8383e09bff1e68b3',
+      decimals: 18,
+    },
     ETH: {
       address: ETHER_ADDRESS,
       decimals: 18,
@@ -1416,8 +1468,22 @@ export const Holders: {
   [network: number]: { [tokenAddress: string]: Address };
 } = {
   [Network.MAINNET]: {
-    ETH: '0x0a4c79cE84202b03e95B7a692E5D728d83C44c76',
-    USDC: '0x7713974908Be4BEd47172370115e8b1219F4A5f0',
+    // Idle tokens
+    AA_wstETH: '0xd7C1b48877A7dFA7D51cf1144c89C0A3F134F935',
+    'AA_idle_cpPOR-USDC': '0x085c8eaccA6911fE60aE3f8FbAe5F3012E3A05Ec',
+    'BB_idle_cpFAS-USDT': '0xFDAD59EF0686C3Da702b7D651a3bD35a539c8Bc4',
+    AA_steakUSDC: '0x28C1eCF5B0f16E1D85B9D2677EfB79d68167cAf2',
+    BB_steakUSDC: '0x442Aea0Fd2AFbd3391DAE768F7046f132F0a6300',
+    AA_Re7WETH: '0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb',
+    BB_Re7WETH: '0x442Aea0Fd2AFbd3391DAE768F7046f132F0a6300',
+    BB_dUSDCV3: '0xFb3bD022D5DAcF95eE28a6B07825D4Ff9C5b3814',
+    AA_sUSDe: '0xaFeb95DEF3B2A3D532D74DaBd51E62048d6c07A4',
+    BB_sUSDe: '0xaFeb95DEF3B2A3D532D74DaBd51E62048d6c07A4',
+    AA_iETHv2: '0xA118aD79E2152b9a3c7Df8B8791887762b0f1D49',
+    BB_iETHv2: '0x15079cBAa74C1df2a602fAc88Bd5b98B08FfE6A4',
+    ETH: '0x176F3DAb24a159341c0509bB36B833E7fdd0a132',
+    USDC: '0x7713974908be4bed47172370115e8b1219f4a5f0',
+    USDE: '0x8707f238936c12c309bfc2B9959C35828AcFc512',
     AMPL: '0x223592a191ECfC7FDC38a9256c3BD96E771539A9',
     WBTC: '0x6daB3bCbFb336b29d06B9C793AEF7eaA57888922',
     tBTCv2: '0x84eA3907b9206427F45c7b2614925a2B86D12611',
@@ -1426,7 +1492,7 @@ export const Holders: {
     aEthUSDC: '0x42EFD1E0DB4ADa762cc5092ECBD052dE7c6e72E2',
     MAV: '0x92582aa69BB6117903a01eDdfe6EFfDDe564A69f',
     BADGER: '0x34e2741a3f8483dbe5231f61c005110ff4b9f50a',
-    STETH: '0x50b42514389F25E1f471C8F03f6f5954df0204b0',
+    STETH: '0x6663613FbD927cE78abBF7F5Ca7e2c3FE0d96d18',
     SUSHI: '0x8a108e4761386c94b8d2f98A5fFe13E472cFE76a',
     wstETH: '0x5fEC2f34D80ED82370F733043B6A536d7e9D7f8d',
     WETH: '0x6B44ba0a126a2A1a8aa6cD1AdeeD002e141Bcd44',