@paraswap/dex-lib 3.4.0 → 3.4.1

package/src/dex/aave-v1/aave-v1-e2e.test.ts

@@ -1,105 +0,0 @@
-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 { aaveV1GetToken } from './tokens';
-import { generateConfig } from '../../config';
-
-jest.setTimeout(1000 * 60 * 3);
-
-describe('AaveV1 E2E', () => {
-  describe('AaveV1 MAINNET', () => {
-    const dexKey = 'AaveV1';
-    const network = Network.MAINNET;
-    const holders = Holders[network];
-    const provider = new StaticJsonRpcProvider(
-      generateConfig(network).privateHttpProvider,
-      network,
-    );
-    // TODO: Modify the USDTSymbol, aUSDTSymbol, aETHAmount;
-
-    const aETHSymbol: string = 'aETH';
-    const aUSDTSymbol: string = 'aUSDT';
-    const USDTSymbol: string = 'USDT';
-
-    const aUSDTAmount: string = '20000000';
-    const USDTAmount: string = '20000000';
-    const aETHAmount: string = '100000000000000000';
-    const ethAmount = '100000000000000000';
-
-    const ETH = Tokens[network]['ETH'];
-    const aETH = aaveV1GetToken(network, aETHSymbol);
-    const aUSDT = aaveV1GetToken(network, aUSDTSymbol);
-
-    expect(aETH).not.toBe(null);
-    expect(aUSDT).not.toBe(null);
-    const USDT = Tokens[network][USDTSymbol];
-
-    const contractMethods: { [side in SwapSide]: ContractMethod[] } = {
-      [SwapSide.SELL]: [ContractMethod.swapExactAmountIn],
-      [SwapSide.BUY]: [],
-    };
-
-    [SwapSide.SELL, SwapSide.BUY].forEach((side: SwapSide) =>
-      contractMethods[side].forEach((contractMethod: ContractMethod) => {
-        describe(`${contractMethod}`, () => {
-          it('ETH -> aETH', async () => {
-            await testE2E(
-              ETH,
-              aETH!,
-              holders['ETH'],
-              side === SwapSide.SELL ? ethAmount : aETHAmount,
-              side,
-              dexKey,
-              contractMethod,
-              network,
-              provider,
-            );
-          });
-          it('aETH -> ETH', async () => {
-            await testE2E(
-              aETH!,
-              ETH,
-              holders[aETHSymbol],
-              side === SwapSide.SELL ? aETHAmount : ethAmount,
-              side,
-              dexKey,
-              contractMethod,
-              network,
-              provider,
-            );
-          });
-          it('USDT -> aUSDT', async () => {
-            await testE2E(
-              USDT,
-              aUSDT!,
-              holders[USDTSymbol],
-              side === SwapSide.SELL ? USDTAmount : aUSDTAmount,
-              side,
-              dexKey,
-              contractMethod,
-              network,
-              provider,
-            );
-          });
-          it('aUSDT -> USDT', async () => {
-            await testE2E(
-              aUSDT!,
-              USDT,
-              holders[aUSDTSymbol],
-              side === SwapSide.SELL ? aUSDTAmount : USDTAmount,
-              side,
-              dexKey,
-              contractMethod,
-              network,
-              provider,
-            );
-          });
-        });
-      }),
-    );
-  });
-});

package/src/dex/aave-v1/aave-v1-integration.test.ts

@@ -1,100 +0,0 @@
-import dotenv from 'dotenv';
-dotenv.config();
-
-import { DummyDexHelper } from '../../dex-helper/index';
-import { Network, SwapSide } from '../../constants';
-import { AaveV1 } from './aave-v1';
-import {
-  checkPoolsLiquidity,
-  checkConstantPoolPrices,
-} from '../../../tests/utils';
-import { Tokens } from '../../../tests/constants-e2e';
-import { aaveV1GetToken } from './tokens';
-import { BI_POWS } from '../../bigint-constants';
-
-describe('AaveV1', function () {
-  describe('AaveV1 MAINNET', () => {
-    const network = Network.MAINNET;
-    const USDTSymbol = 'USDT';
-    const USDT = Tokens[network][USDTSymbol];
-
-    const aUSDTSymbol = 'aUSDT';
-    const aUSDT = aaveV1GetToken(network, aUSDTSymbol);
-    if (!aUSDT) {
-      expect(aUSDT).not.toBe(null);
-      return;
-    }
-
-    const amounts = [0n, BI_POWS[18], 2000000000000000000n];
-
-    const dexKey = 'AaveV1';
-    it('getPoolIdentifiers and getPricesVolume SELL', async function () {
-      const dexHelper = new DummyDexHelper(network);
-      const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
-      const aaveV1 = new AaveV1(network, dexKey, dexHelper);
-
-      const pools = await aaveV1.getPoolIdentifiers(
-        USDT,
-        aUSDT,
-        SwapSide.SELL,
-        blocknumber,
-      );
-      console.log(`${USDTSymbol} <> ${aUSDTSymbol} Pool Identifiers: `, pools);
-
-      expect(pools.length).toBeGreaterThan(0);
-
-      const poolPrices = await aaveV1.getPricesVolume(
-        USDT,
-        aUSDT,
-        amounts,
-        SwapSide.SELL,
-        blocknumber,
-        pools,
-      );
-
-      console.log('${USDTSymbol} <> ${aUSDTSymbol} Pool Prices: ', poolPrices);
-
-      expect(poolPrices).not.toBeNull();
-      checkConstantPoolPrices(poolPrices!, amounts, dexKey);
-    });
-
-    it('getPoolIdentifiers and getPricesVolume BUY', async function () {
-      const dexHelper = new DummyDexHelper(network);
-      const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
-      const aaveV1 = new AaveV1(network, dexKey, dexHelper);
-
-      const pools = await aaveV1.getPoolIdentifiers(
-        USDT,
-        aUSDT,
-        SwapSide.BUY,
-        blocknumber,
-      );
-      console.log(`${USDTSymbol} <> ${aUSDTSymbol} Pool Identifiers: `, pools);
-
-      expect(pools.length).toBeGreaterThan(0);
-
-      const poolPrices = await aaveV1.getPricesVolume(
-        USDT,
-        aUSDT,
-        amounts,
-        SwapSide.BUY,
-        blocknumber,
-        pools,
-      );
-      console.log('${USDTSymbol} <> ${aUSDTSymbol} Pool Prices: ', poolPrices);
-
-      expect(poolPrices).not.toBeNull();
-      checkConstantPoolPrices(poolPrices!, amounts, dexKey);
-    });
-
-    it('getTopPoolsForToken', async function () {
-      const dexHelper = new DummyDexHelper(network);
-      const aaveV1 = new AaveV1(network, dexKey, dexHelper);
-
-      const poolLiquidity = await aaveV1.getTopPoolsForToken(USDT.address, 10);
-      console.log(`${USDTSymbol} Top Pools:`, poolLiquidity);
-
-      checkPoolsLiquidity(poolLiquidity, USDT.address, dexKey);
-    });
-  });
-});

package/src/dex/aave-v1/aave-v1.ts

@@ -1,261 +0,0 @@
-import { Interface, JsonFragment } from '@ethersproject/abi';
-import {
-  Token,
-  Address,
-  ExchangePrices,
-  PoolPrices,
-  AdapterExchangeParam,
-  SimpleExchangeParam,
-  PoolLiquidity,
-  Logger,
-  NumberAsString,
-  DexExchangeParam,
-} from '../../types';
-import { SwapSide, Network } from '../../constants';
-import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
-import { getBigIntPow, getDexKeysWithNetwork } from '../../utils';
-import { IDex } from '../../dex/idex';
-import { IDexHelper } from '../../dex-helper/idex-helper';
-import { AaveV1Data, AaveV1Param } from './types';
-import { SimpleExchange } from '../simple-exchange';
-import { AaveV1Config, Adapters } from './config';
-import AAVE_LENDING_POOL_ABI_V1 from '../../abi/AaveV1_lending_pool.json';
-import ERC20 from '../../abi/erc20.json';
-import { isAAVEPair } from './tokens';
-
-const AaveGasCost = 400 * 1000;
-
-enum AaveV1Functions {
-  deposit = 'deposit',
-  redeem = 'redeem',
-}
-
-const AAVE_LENDING_POOL = '0x398eC7346DcD622eDc5ae82352F02bE94C62d119';
-const AAVE_PROXY = '0x3dfd23a6c5e8bbcfc9581d2e864a68feb6a076d3';
-const REF_CODE = 1;
-
-export class AaveV1
-  extends SimpleExchange
-  implements IDex<AaveV1Data, AaveV1Param>
-{
-  readonly hasConstantPriceLargeAmounts = true;
-  readonly isFeeOnTransferSupported = false;
-
-  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
-    getDexKeysWithNetwork(AaveV1Config);
-
-  logger: Logger;
-  aavePool: Interface;
-  aContract: Interface;
-
-  constructor(
-    protected network: Network,
-    dexKey: string,
-    protected dexHelper: IDexHelper, // TODO: add any additional optional params to support other fork DEXes
-  ) {
-    super(dexHelper, dexKey);
-    this.logger = dexHelper.getLogger(dexKey);
-    this.aavePool = new Interface(AAVE_LENDING_POOL_ABI_V1 as JsonFragment[]);
-    this.aContract = new Interface(ERC20 as JsonFragment[]);
-  }
-
-  async initializePricing(blockNumber: number) {}
-
-  // Returns the list of contract adapters (name and index)
-  // for a buy/sell. Return null if there are no adapters.
-  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
-    return Adapters[this.network][side];
-  }
-
-  // Returns list of pool identifiers that can be used
-  // for a given swap. poolIdentifiers must be unique
-  // across DEXes. It is recommended to use
-  // ${dexKey}_${poolAddress} as a poolIdentifier
-  async getPoolIdentifiers(
-    srcToken: Token,
-    destToken: Token,
-    side: SwapSide,
-    blockNumber: number,
-  ): Promise<string[]> {
-    const aToken = isAAVEPair(this.network, srcToken, destToken);
-    if (aToken === null) {
-      return [];
-    }
-    return [`${this.dexKey}_${aToken.address}`];
-  }
-
-  // Returns pool prices for amounts.
-  // If limitPools is defined only pools in limitPools
-  // should be used. If limitPools is undefined then
-  // any pools can be used.
-  async getPricesVolume(
-    srcToken: Token,
-    destToken: Token,
-    amounts: bigint[],
-    side: SwapSide,
-    blockNumber: number,
-    limitPools?: string[],
-  ): Promise<null | ExchangePrices<AaveV1Data>> {
-    const aToken = isAAVEPair(this.network, srcToken, destToken);
-    if (!aToken) {
-      return null;
-    }
-    const fromAToken = aToken == srcToken;
-    return [
-      {
-        prices: amounts,
-        unit: getBigIntPow(
-          (side === SwapSide.SELL ? destToken : srcToken).decimals,
-        ),
-        gasCost: AaveGasCost,
-        exchange: this.dexKey,
-        data: {
-          fromAToken,
-          isV2: false,
-        },
-        poolAddresses: [fromAToken ? srcToken.address : destToken.address],
-      },
-    ];
-  }
-
-  // Returns estimated gas cost of calldata for this DEX in multiSwap
-  getCalldataGasCost(poolPrices: PoolPrices<AaveV1Data>): number | number[] {
-    return (
-      CALLDATA_GAS_COST.DEX_OVERHEAD +
-      CALLDATA_GAS_COST.LENGTH_SMALL +
-      CALLDATA_GAS_COST.ADDRESS
-    );
-  }
-
-  // Encode params required by the exchange adapter
-  // Used for multiSwap, buy & megaSwap
-  getAdapterParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
-    data: AaveV1Data,
-    side: SwapSide,
-  ): AdapterExchangeParam {
-    const aToken = data.fromAToken ? srcToken : destToken; // Warning
-    const payload = this.abiCoder.encodeParameter(
-      {
-        ParentStruct: {
-          aToken: 'address',
-        },
-      },
-      { aToken },
-    );
-
-    return {
-      targetExchange: AAVE_LENDING_POOL,
-      payload,
-      networkFee: '0',
-    };
-  }
-
-  // Encode call data used by simpleSwap like routers
-  // Used for simpleSwap & simpleBuy
-  // Hint: this.buildSimpleParamWithoutWETHConversion
-  // could be useful
-  async getSimpleParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
-    data: AaveV1Data,
-    side: SwapSide,
-  ): Promise<SimpleExchangeParam> {
-    const amount = side === SwapSide.SELL ? srcAmount : destAmount;
-    const [Interface, swapFunction, swapFunctionParams, swapCallee, spender] =
-      ((): [Interface, AaveV1Functions, AaveV1Param, Address, Address?] => {
-        if (data.fromAToken) {
-          return [this.aContract, AaveV1Functions.redeem, [amount], srcToken];
-        }
-
-        return [
-          this.aavePool,
-          AaveV1Functions.deposit,
-          [srcToken, amount, REF_CODE],
-          AAVE_LENDING_POOL,
-          AAVE_PROXY, // warning
-        ];
-      })();
-
-    const swapData = Interface.encodeFunctionData(
-      swapFunction,
-      swapFunctionParams,
-    );
-
-    return this.buildSimpleParamWithoutWETHConversion(
-      srcToken,
-      amount,
-      destToken,
-      destAmount,
-      swapData,
-      swapCallee,
-      spender,
-    );
-  }
-
-  // DEAD
-  getDexParam(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    recipient: Address,
-    data: AaveV1Data,
-    side: SwapSide,
-  ): DexExchangeParam {
-    const amount = side === SwapSide.SELL ? srcAmount : destAmount;
-    const [Interface, swapFunction, swapFunctionParams, swapCallee] = ((): [
-      Interface,
-      AaveV1Functions,
-      AaveV1Param,
-      Address,
-    ] => {
-      if (data.fromAToken) {
-        return [this.aContract, AaveV1Functions.redeem, [amount], srcToken];
-      }
-
-      return [
-        this.aavePool,
-        AaveV1Functions.deposit,
-        [srcToken, amount, REF_CODE],
-        AAVE_LENDING_POOL,
-      ];
-    })();
-
-    const exchangeData = Interface.encodeFunctionData(
-      swapFunction,
-      swapFunctionParams,
-    );
-
-    return {
-      needWrapNative: this.needWrapNative,
-      dexFuncHasRecipient: false,
-      exchangeData,
-      targetExchange: swapCallee,
-      returnAmountPos: undefined,
-    };
-  }
-
-  // This is called once before getTopPoolsForToken is
-  // called for multiple tokens. This can be helpful to
-  // update common state required for calculating
-  // getTopPoolsForToken. It is optional for a DEX
-  // to implement this
-  updatePoolState(): Promise<void> {
-    return Promise.resolve();
-  }
-
-  // Returns list of top pools based on liquidity. Max
-  // limit number pools should be returned.
-  async getTopPoolsForToken(
-    tokenAddress: Address,
-    limit: number,
-  ): Promise<PoolLiquidity[]> {
-    return [];
-  }
-}

package/src/dex/aave-v1/config.ts

@@ -1,22 +0,0 @@
-import { DexParams } from './types';
-import { DexConfigMap } from '../../types';
-import { Network, SwapSide } from '../../constants';
-
-export const AaveV1Config: DexConfigMap<DexParams> = {
-  AaveV1: {
-    [Network.MAINNET]: {},
-  },
-};
-
-export const Adapters: {
-  [chainId: number]: { [side: string]: { name: string; index: number }[] };
-} = {
-  [Network.MAINNET]: {
-    [SwapSide.SELL]: [
-      {
-        name: 'Adapter03',
-        index: 5,
-      },
-    ],
-  },
-};

package/src/dex/aave-v1/tokens-mainnet.json

@@ -1,134 +0,0 @@
-[
-  {
-    "aSymbol": "aETH",
-    "aAddress": "0x3a3a65aab0dd2a17e3f1947ba16138cd37d08c04",
-    "address": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
-    "decimals": 18
-  },
-  {
-    "aSymbol": "aDAI",
-    "aAddress": "0xfc1e690f61efd961294b3e1ce3313fbd8aa4f85d",
-    "address": "0x6b175474e89094c44da98b954eedeac495271d0f",
-    "decimals": 18
-  },
-  {
-    "aSymbol": "aUSDC",
-    "aAddress": "0x9ba00d6856a4edf4665bca2c2309936572473b7e",
-    "address": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
-    "decimals": 6
-  },
-  {
-    "aSymbol": "aSUSD",
-    "aAddress": "0x625ae63000f46200499120b906716420bd059240",
-    "address": "0x57ab1e02fee23774580c119740129eac7081e9d3",
-    "decimals": 18
-  },
-  {
-    "aSymbol": "aTUSD",
-    "aAddress": "0x4da9b813057d04baef4e5800e36083717b4a0341",
-    "address": "0x8dd5fbce2f6a956c3022ba3663759011dd51e73e",
-    "decimals": 18
-  },
-  {
-    "aSymbol": "aUSDT",
-    "aAddress": "0x71fc860f7d3a592a4a98740e39db31d25db65ae8",
-    "address": "0xdac17f958d2ee523a2206206994597c13d831ec7",
-    "decimals": 6
-  },
-  {
-    "aSymbol": "aBUSD",
-    "aAddress": "0x6ee0f7bb50a54ab5253da0667b0dc2ee526c30a8",
-    "address": "0x4fabb145d64652a948d72533023f6e7a623c7c53",
-    "decimals": 18
-  },
-  {
-    "aSymbol": "aBAT",
-    "aAddress": "0xe1ba0fb44ccb0d11b80f92f4f8ed94ca3ff51d00",
-    "address": "0x0d8775f648430679a709e98d2b0cb6250d2887ef",
-    "decimals": 18
-  },
-  {
-    "aSymbol": "aENJ",
-    "aAddress": "0x712db54daa836b53ef1ecbb9c6ba3b9efb073f40",
-    "address": "0xf629cbd94d3791c9250152bd8dfbdf380e2a3b9c",
-    "decimals": 18
-  },
-  {
-    "aSymbol": "aKNC",
-    "aAddress": "0x9d91be44c06d373a8a226e1f3b146956083803eb",
-    "address": "0xdd974d5c2e2928dea5f71b9825b8b646686bd200",
-    "decimals": 18
-  },
-  {
-    "aSymbol": "aAAVE",
-    "aAddress": "0xba3d9687cf50fe253cd2e1cfeede1d6787344ed5",
-    "address": "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9",
-    "decimals": 18
-  },
-  {
-    "aSymbol": "aLINK",
-    "aAddress": "0xa64bd6c70cb9051f6a9ba1f163fdc07e0dfb5f84",
-    "address": "0x514910771af9ca656af840dff83e8264ecf986ca",
-    "decimals": 18
-  },
-  {
-    "aSymbol": "aMANA",
-    "aAddress": "0x6fce4a401b6b80ace52baaefe4421bd188e76f6f",
-    "address": "0x0f5d2fb29fb7d3cfee444a200298f468908cc942",
-    "decimals": 18
-  },
-  {
-    "aSymbol": "aMKR",
-    "aAddress": "0x7deb5e830be29f91e298ba5ff1356bb7f8146998",
-    "address": "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2",
-    "decimals": 18
-  },
-  {
-    "aSymbol": "aREN",
-    "aAddress": "0x69948cc03f478b95283f7dbf1ce764d0fc7ec54c",
-    "address": "0x408e41876cccdc0f92210600ef50372656052a38",
-    "decimals": 18
-  },
-  {
-    "aSymbol": "aREP",
-    "aAddress": "0x71010a9d003445ac60c4e6a7017c1e89a477b438",
-    "address": "0xe94327d07fc17907b4db788e5adf2ed424addff6",
-    "decimals": 18
-  },
-  {
-    "aSymbol": "aSNX",
-    "aAddress": "0x328c4c80bc7aca0834db37e6600a6c49e12da4de",
-    "address": "0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f",
-    "decimals": 18
-  },
-  {
-    "aSymbol": "aUNI",
-    "aAddress": "0xb124541127a0a657f056d9dd06188c4f1b0e5aab",
-    "address": "0x1f9840a85d5af5bf1d1762f925bdaddc4201f984",
-    "decimals": 18
-  },
-  {
-    "aSymbol": "aWBTC",
-    "aAddress": "0xfc4b8ed459e00e5400be803a9bb3954234fd50e3",
-    "address": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599",
-    "decimals": 8
-  },
-  {
-    "aSymbol": "aYFI",
-    "aAddress": "0x12e51e77daaa58aa0e9247db7510ea4b46f9bead",
-    "address": "0x0bc529c00c6401aef6d220be8c6ea1667f6ad93e",
-    "decimals": 18
-  },
-  {
-    "aSymbol": "aZRX",
-    "aAddress": "0x6fb0855c404e09c47c3fbca25f08d4e41f9f062f",
-    "address": "0xe41d2489571d322189246dafa5ebde1f4699f498",
-    "decimals": 18
-  },
-  {
-    "aSymbol": "aLEND",
-    "aAddress": "0x7d2d3688df45ce7c552e19c27e007673da9204b8",
-    "address": "0x80fb784b7ed66730e8b1dbd9820afd29931aab03",
-    "decimals": 18
-  }
-]

package/src/dex/aave-v1/tokens.ts

@@ -1,58 +0,0 @@
-import { aToken, Token } from '../../types';
-import { Network } from '../../constants';
-
-import tokensMainnet from './tokens-mainnet.json';
-
-const Tokens: { [network: number]: { [symbol: string]: aToken } } = {};
-const TokensByAddress: { [network: number]: { [address: string]: aToken } } =
-  {};
-
-const tokensByNetwork: { [network: number]: any } = {
-  [Network.MAINNET]: tokensMainnet,
-};
-
-for (const [key, tokens] of Object.entries(tokensByNetwork)) {
-  const network = +key;
-  Tokens[network] = {};
-  TokensByAddress[network] = {};
-  for (const token of tokens) {
-    Tokens[network][token.aSymbol] = token;
-    TokensByAddress[network][token.aAddress.toLowerCase()] = token;
-  }
-}
-
-// return null if pair does not exists otherwise return the aToken
-export function isAAVEPair(
-  network: number,
-  src: Token,
-  dst: Token,
-): Token | null {
-  const srcAddr = src.address.toLowerCase();
-  const dstAddr = dst.address.toLowerCase();
-
-  const _src = TokensByAddress[network][srcAddr];
-  const _dst = TokensByAddress[network][dstAddr];
-
-  if (_src && _src.address == dstAddr) {
-    return src;
-  }
-
-  if (_dst && _dst.address == srcAddr) {
-    return dst;
-  }
-
-  return null;
-}
-
-export function aaveV1GetToken(network: number, symbol: string): Token | null {
-  const aToken = Tokens[network][symbol];
-  if (!aToken) {
-    return null;
-  }
-
-  return {
-    address: aToken.aAddress,
-    decimals: aToken.decimals,
-    symbol: aToken.aSymbol,
-  };
-}

package/src/dex/aave-v1/types.ts

@@ -1,24 +0,0 @@
-import { Address } from '../../types';
-
-export type AaveV1Data = {
-  fromAToken: boolean;
-  isV2: boolean;
-  // TODO: AaveV1Data is the dex data that is
-  // returned by the API that can be used for
-  // tx building. The data structure should be minimal.
-  // Complete me!
-};
-
-export type DexParams = {
-  // TODO: DexParams is set of parameters the can
-  // be used to initiate a DEX fork.
-  // Complete me!
-};
-
-export type AaveV1RedeemParams = [
-  _reserve: string,
-  _amount: string,
-  _referralCode: number,
-];
-export type AaveV1DepositParams = [token: string];
-export type AaveV1Param = AaveV1RedeemParams | AaveV1DepositParams;