aave-protocol-v2/helpers/contracts-helpers.ts

import {Contract, Signer, utils, ethers} from 'ethers';

import {getDb, BRE} from './misc-utils';
import {
  tEthereumAddress,
  eContractid,
  tStringTokenSmallUnits,
  eEthereumNetwork,
  AavePools,
  iParamsPerNetwork,
  iParamsPerPool,
  TokenContractId,
  iMultiPoolsAssets,
  IReserveParams,
} from './types';
import {LendingPoolAddressesProvider} from '../types/LendingPoolAddressesProvider';
import {MintableErc20} from '../types/MintableErc20';
import {LendingPoolAddressesProviderRegistry} from '../types/LendingPoolAddressesProviderRegistry';
import {LendingPoolConfigurator} from '../types/LendingPoolConfigurator';
import {readArtifact} from '@nomiclabs/buidler/plugins';
import {Artifact} from '@nomiclabs/buidler/types';
import {LendingPool} from '../types/LendingPool';
import {PriceOracle} from '../types/PriceOracle';
import {MockAggregator} from '../types/MockAggregator';
import {LendingRateOracle} from '../types/LendingRateOracle';
import {DefaultReserveInterestRateStrategy} from '../types/DefaultReserveInterestRateStrategy';
import {LendingPoolLiquidationManager} from '../types/LendingPoolLiquidationManager';
import {InitializableAdminUpgradeabilityProxy} from '../types/InitializableAdminUpgradeabilityProxy';
import {MockFlashLoanReceiver} from '../types/MockFlashLoanReceiver';
import {WalletBalanceProvider} from '../types/WalletBalanceProvider';
import {AToken} from '../types/AToken';
import {AaveProtocolTestHelpers} from '../types/AaveProtocolTestHelpers';
import BigNumber from 'bignumber.js';
import {Ierc20Detailed} from '../types/Ierc20Detailed';
import {StableDebtToken} from '../types/StableDebtToken';
import {VariableDebtToken} from '../types/VariableDebtToken';
import {MockContract} from 'ethereum-waffle';
import {getReservesConfigByPool} from './constants';
import {verifyContract} from './etherscan-verification';
import {FeeProvider} from '../types/FeeProvider';
import {TokenDistributor} from '../types/TokenDistributor';

export type MockTokenMap = {[symbol: string]: MintableErc20};

export const registerContractInJsonDb = async (contractId: string, contractInstance: Contract) => {
  const currentNetwork = BRE.network.name;
  if (currentNetwork !== 'buidlerevm' && currentNetwork !== 'soliditycoverage') {
    console.log(`*** ${contractId} ***\n`);
    console.log(`Network: ${currentNetwork}`);
    console.log(`tx: ${contractInstance.deployTransaction.hash}`);
    console.log(`contract address: ${contractInstance.address}`);
    console.log(`deployer address: ${contractInstance.deployTransaction.from}`);
    console.log(`gas price: ${contractInstance.deployTransaction.gasPrice}`);
    console.log(`gas used: ${contractInstance.deployTransaction.gasLimit}`);
    console.log(`\n******`);
    console.log();
  }

  await getDb()
    .set(`${contractId}.${currentNetwork}`, {
      address: contractInstance.address,
      deployer: contractInstance.deployTransaction.from,
    })
    .write();
};

export const insertContractAddressInDb = async (id: eContractid, address: tEthereumAddress) =>
  await getDb()
    .set(`${id}.${BRE.network.name}`, {
      address,
    })
    .write();

export const getEthersSigners = async (): Promise<Signer[]> =>
  await Promise.all(await BRE.ethers.getSigners());

export const getEthersSignersAddresses = async (): Promise<tEthereumAddress[]> =>
  await Promise.all((await BRE.ethers.getSigners()).map((signer) => signer.getAddress()));

export const getCurrentBlock = async () => {
  return BRE.ethers.provider.getBlockNumber();
};

export const decodeAbiNumber = (data: string): number =>
  parseInt(utils.defaultAbiCoder.decode(['uint256'], data).toString());

export const deployContract = async <ContractType extends Contract>(
  contractName: string,
  args: any[]
): Promise<ContractType> => {
  const contract = (await (await BRE.ethers.getContractFactory(contractName)).deploy(
    ...args
  )) as ContractType;

  await registerContractInJsonDb(<eContractid>contractName, contract);
  return contract;
};

export const getContract = async <ContractType extends Contract>(
  contractName: string,
  address: string
): Promise<ContractType> => (await BRE.ethers.getContractAt(contractName, address)) as ContractType;

export const deployLendingPoolAddressesProvider = async (verify?: boolean) => {
  const instance = await deployContract<LendingPoolAddressesProvider>(
    eContractid.LendingPoolAddressesProvider,
    []
  );
  if (verify) {
    await verifyContract(eContractid.LendingPoolAddressesProvider, instance.address, []);
  }
  return instance;
};

export const deployLendingPoolAddressesProviderRegistry = async (verify?: boolean) => {
  const instance = await deployContract<LendingPoolAddressesProviderRegistry>(
    eContractid.LendingPoolAddressesProviderRegistry,
    []
  );
  if (verify) {
    await verifyContract(eContractid.LendingPoolAddressesProviderRegistry, instance.address, []);
  }
  return instance;
};

export const deployFeeProvider = async (verify?: boolean) => {
  const instance = await deployContract<FeeProvider>(eContractid.FeeProvider, []);

  if (verify) {
    await verifyContract(eContractid.FeeProvider, instance.address, []);
  }
  return instance;
};

export const deployLendingPoolConfigurator = async (verify?: boolean) => {
  const instance = await deployContract<LendingPoolConfigurator>(
    eContractid.LendingPoolConfigurator,
    []
  );
  if (verify) {
    await verifyContract(eContractid.LendingPoolConfigurator, instance.address, []);
  }
  return instance;
};

const deployLibrary = async (libraryId: eContractid) => {
  const factory = await BRE.ethers.getContractFactory(libraryId);
  const library = await factory.deploy();
  await library.deployed();

  return library;
};

export const linkLibrariesToArtifact = async (artifact: Artifact) => {
  const reserveLogic = await deployLibrary(eContractid.ReserveLogic);

  const genericLogicArtifact = await readArtifact(
    BRE.config.paths.artifacts,
    eContractid.GenericLogic
  );

  const linkedGenericLogicByteCode = linkBytecode(genericLogicArtifact, {
    [eContractid.ReserveLogic]: reserveLogic.address,
  });

  const genericLogicFactory = await BRE.ethers.getContractFactory(
    genericLogicArtifact.abi,
    linkedGenericLogicByteCode
  );

  const genericLogic = await (await genericLogicFactory.deploy()).deployed();

  const validationLogicArtifact = await readArtifact(
    BRE.config.paths.artifacts,
    eContractid.ValidationLogic
  );

  const linkedValidationLogicByteCode = linkBytecode(validationLogicArtifact, {
    [eContractid.ReserveLogic]: reserveLogic.address,
    [eContractid.GenericLogic]: genericLogic.address,
  });

  const validationLogicFactory = await BRE.ethers.getContractFactory(
    validationLogicArtifact.abi,
    linkedValidationLogicByteCode
  );

  const validationLogic = await (await validationLogicFactory.deploy()).deployed();

  const linkedBytecode = linkBytecode(artifact, {
    [eContractid.ReserveLogic]: reserveLogic.address,
    [eContractid.GenericLogic]: genericLogic.address,
    [eContractid.ValidationLogic]: validationLogic.address,
  });
  const factory = await BRE.ethers.getContractFactory(artifact.abi, linkedBytecode);

  return factory;
};

export const deployLendingPool = async (verify?: boolean) => {
  const lendingPoolArtifact = await readArtifact(
    BRE.config.paths.artifacts,
    eContractid.LendingPool
  );
  const factory = await linkLibrariesToArtifact(lendingPoolArtifact);
  const lendingPool = await factory.deploy();
  const instance = (await lendingPool.deployed()) as LendingPool;
  if (verify) {
    await verifyContract(eContractid.LendingPool, instance.address, []);
  }
  return instance;
};

export const deployPriceOracle = async (verify?: boolean) => {
  const instance = await deployContract<PriceOracle>(eContractid.PriceOracle, []);
  if (verify) {
    await verifyContract(eContractid.PriceOracle, instance.address, []);
  }
  return instance;
};

export const deployMockAggregator = async (price: tStringTokenSmallUnits, verify?: boolean) => {
  const args = [price];
  const instance = await deployContract<MockAggregator>(eContractid.MockAggregator, args);
  if (verify) {
    await verifyContract(eContractid.MockAggregator, instance.address, args);
  }
  return instance;
};

export const deployChainlinkProxyPriceProvider = async (
  [assetsAddresses, sourcesAddresses, fallbackOracleAddress]: [
    tEthereumAddress[],
    tEthereumAddress[],
    tEthereumAddress
  ],
  verify?: boolean
) => {
  const args = [assetsAddresses, sourcesAddresses, fallbackOracleAddress];
  const instance = await deployContract<MockAggregator>(
    eContractid.ChainlinkProxyPriceProvider,
    args
  );
  if (verify) {
    await verifyContract(eContractid.MockAggregator, instance.address, args);
  }
  return instance;
};

export const getChainlingProxyPriceProvider = async (address?: tEthereumAddress) =>
  await getContract<MockAggregator>(
    eContractid.ChainlinkProxyPriceProvider,
    address ||
      (await getDb().get(`${eContractid.ChainlinkProxyPriceProvider}.${BRE.network.name}`).value())
        .address
  );

export const deployLendingRateOracle = async (verify?: boolean) => {
  const instance = await deployContract<LendingRateOracle>(eContractid.LendingRateOracle, []);
  if (verify) {
    await verifyContract(eContractid.LendingRateOracle, instance.address, []);
  }
  return instance;
};

export const deployLendingPoolLiquidationManager = async (verify?: boolean) => {
  const liquidationManagerArtifact = await readArtifact(
    BRE.config.paths.artifacts,
    eContractid.LendingPoolLiquidationManager
  );

  const factory = await linkLibrariesToArtifact(liquidationManagerArtifact);

  const liquidationManager = await factory.deploy();
  return (await liquidationManager.deployed()) as LendingPoolLiquidationManager;
};

export const deployTokenDistributor = async (verify?: boolean) => {
  const instance = await deployContract<TokenDistributor>(eContractid.TokenDistributor, []);
  if (verify) {
    await verifyContract(eContractid.TokenDistributor, instance.address, []);
  }
  return instance;
};

export const deployInitializableAdminUpgradeabilityProxy = async (verify?: boolean) => {
  const instance = await deployContract<InitializableAdminUpgradeabilityProxy>(
    eContractid.InitializableAdminUpgradeabilityProxy,
    []
  );
  if (verify) {
    await verifyContract(eContractid.InitializableAdminUpgradeabilityProxy, instance.address, []);
  }
  return instance;
};

export const deployMockFlashLoanReceiver = async (
  addressesProvider: tEthereumAddress,
  verify?: boolean
) => {
  const args = [addressesProvider];
  const instance = await deployContract<MockFlashLoanReceiver>(
    eContractid.MockFlashLoanReceiver,
    args
  );
  if (verify) {
    await verifyContract(eContractid.MockFlashLoanReceiver, instance.address, args);
  }
  return instance;
};

export const deployWalletBalancerProvider = async (
  addressesProvider: tEthereumAddress,
  verify?: boolean
) => {
  const args = [addressesProvider];
  const instance = await deployContract<WalletBalanceProvider>(
    eContractid.WalletBalanceProvider,
    args
  );
  if (verify) {
    await verifyContract(eContractid.WalletBalanceProvider, instance.address, args);
  }
  return instance;
};

export const deployAaveProtocolTestHelpers = async (
  addressesProvider: tEthereumAddress,
  verify?: boolean
) => {
  const args = [addressesProvider];
  const instance = await deployContract<AaveProtocolTestHelpers>(
    eContractid.AaveProtocolTestHelpers,
    args
  );

  if (verify) {
    await verifyContract(eContractid.AaveProtocolTestHelpers, instance.address, args);
  }
  return instance;
};

export const deployMintableErc20 = async ([name, symbol, decimals]: [string, string, number]) =>
  await deployContract<MintableErc20>(eContractid.MintableErc20, [name, symbol, decimals]);

export const deployDefaultReserveInterestRateStrategy = async ([
  addressesProvider,
  baseVariableBorrowRate,
  variableSlope1,
  variableSlope2,
  stableSlope1,
  stableSlope2,
]: [tEthereumAddress, string, string, string, string, string]) =>
  await deployContract<DefaultReserveInterestRateStrategy>(
    eContractid.DefaultReserveInterestRateStrategy,
    [
      addressesProvider,
      baseVariableBorrowRate,
      variableSlope1,
      variableSlope2,
      stableSlope1,
      stableSlope2,
    ]
  );

export const deployStableDebtToken = async ([name, symbol, underlyingAsset, poolAddress]: [
  string,
  string,
  tEthereumAddress,
  tEthereumAddress
]) => {
  const token = await deployContract<StableDebtToken>(eContractid.StableDebtToken, [
    poolAddress,
    underlyingAsset,
    name,
    symbol,
  ]);

  return token;
};

export const deployVariableDebtToken = async ([name, symbol, underlyingAsset, poolAddress]: [
  string,
  string,
  tEthereumAddress,
  tEthereumAddress
]) => {
  const token = await deployContract<VariableDebtToken>(eContractid.VariableDebtToken, [
    poolAddress,
    underlyingAsset,
    name,
    symbol,
  ]);

  return token;
};

export const deployGenericAToken = async ([poolAddress, underlyingAssetAddress, name, symbol]: [
  tEthereumAddress,
  tEthereumAddress,
  string,
  string
]) => {
  const token = await deployContract<AToken>(eContractid.AToken, [
    poolAddress,
    underlyingAssetAddress,
    name,
    symbol,
  ]);

  return token;
};

export const getLendingPoolAddressesProvider = async (address?: tEthereumAddress) => {
  return await getContract<LendingPoolAddressesProvider>(
    eContractid.LendingPoolAddressesProvider,
    address ||
      (await getDb().get(`${eContractid.LendingPoolAddressesProvider}.${BRE.network.name}`).value())
        .address
  );
};

export const getLendingPoolConfiguratorProxy = async (address?: tEthereumAddress) => {
  return await getContract<LendingPoolConfigurator>(
    eContractid.LendingPoolConfigurator,
    address ||
      (await getDb().get(`${eContractid.LendingPoolConfigurator}.${BRE.network.name}`).value())
        .address
  );
};

export const getLendingPool = async (address?: tEthereumAddress) => {
  const lendingPoolArtifact = await readArtifact(
    BRE.config.paths.artifacts,
    eContractid.LendingPool
  );

  const factory = await linkLibrariesToArtifact(lendingPoolArtifact);

  return <LendingPool>(
    await factory.attach(
      address ||
        (await getDb().get(`${eContractid.LendingPool}.${BRE.network.name}`).value()).address
    )
  );
};

export const getPriceOracle = async (address?: tEthereumAddress) => {
  return await getContract<PriceOracle>(
    eContractid.PriceOracle,
    address || (await getDb().get(`${eContractid.PriceOracle}.${BRE.network.name}`).value()).address
  );
};

export const getAToken = async (address?: tEthereumAddress) => {
  return await getContract<AToken>(
    eContractid.AToken,
    address || (await getDb().get(`${eContractid.AToken}.${BRE.network.name}`).value()).address
  );
};

export const getMintableErc20 = async (address: tEthereumAddress) => {
  return await getContract<MintableErc20>(
    eContractid.MintableErc20,
    address ||
      (await getDb().get(`${eContractid.MintableErc20}.${BRE.network.name}`).value()).address
  );
};

export const getIErc20Detailed = async (address: tEthereumAddress) => {
  return await getContract<Ierc20Detailed>(
    eContractid.IERC20Detailed,
    address ||
      (await getDb().get(`${eContractid.IERC20Detailed}.${BRE.network.name}`).value()).address
  );
};

export const getAaveProtocolTestHelpers = async (address?: tEthereumAddress) => {
  return await getContract<AaveProtocolTestHelpers>(
    eContractid.AaveProtocolTestHelpers,
    address ||
      (await getDb().get(`${eContractid.AaveProtocolTestHelpers}.${BRE.network.name}`).value())
        .address
  );
};

export const getFeeProvider = async (address?: tEthereumAddress) =>
  await getContract<FeeProvider>(
    eContractid.FeeProvider,
    address || (await getDb().get(`${eContractid.FeeProvider}.${BRE.network.name}`).value()).address
  );

export const getInterestRateStrategy = async (address?: tEthereumAddress) => {
  return await getContract<DefaultReserveInterestRateStrategy>(
    eContractid.DefaultReserveInterestRateStrategy,
    address ||
      (
        await getDb()
          .get(`${eContractid.DefaultReserveInterestRateStrategy}.${BRE.network.name}`)
          .value()
      ).address
  );
};

export const getMockFlashLoanReceiver = async (address?: tEthereumAddress) => {
  return await getContract<MockFlashLoanReceiver>(
    eContractid.MockFlashLoanReceiver,
    address ||
      (await getDb().get(`${eContractid.MockFlashLoanReceiver}.${BRE.network.name}`).value())
        .address
  );
};

export const getLendingRateOracle = async (address?: tEthereumAddress) => {
  return await getContract<LendingRateOracle>(
    eContractid.LendingRateOracle,
    address ||
      (await getDb().get(`${eContractid.LendingRateOracle}.${BRE.network.name}`).value()).address
  );
};

const linkBytecode = (artifact: Artifact, libraries: any) => {
  let bytecode = artifact.bytecode;

  for (const [fileName, fileReferences] of Object.entries(artifact.linkReferences)) {
    for (const [libName, fixups] of Object.entries(fileReferences)) {
      const addr = libraries[libName];

      if (addr === undefined) {
        continue;
      }

      for (const fixup of fixups) {
        bytecode =
          bytecode.substr(0, 2 + fixup.start * 2) +
          addr.substr(2) +
          bytecode.substr(2 + (fixup.start + fixup.length) * 2);
      }
    }
  }

  return bytecode;
};

export const getParamPerNetwork = <T>(
  {kovan, ropsten, main}: iParamsPerNetwork<T>,
  network: eEthereumNetwork
) => {
  switch (network) {
    case eEthereumNetwork.kovan:
      return kovan;
    case eEthereumNetwork.ropsten:
      return ropsten;
    case eEthereumNetwork.main:
      return main;
    default:
      return main;
  }
};

export const getParamPerPool = <T>({proto, secondary}: iParamsPerPool<T>, pool: AavePools) => {
  switch (pool) {
    case AavePools.proto:
      return proto;
    case AavePools.secondary:
      return secondary;
    default:
      return proto;
  }
};

export const convertToCurrencyDecimals = async (tokenAddress: tEthereumAddress, amount: string) => {
  const token = await getIErc20Detailed(tokenAddress);
  let decimals = (await token.decimals()).toString();

  return ethers.utils.parseUnits(amount, decimals);
};

export const convertToCurrencyUnits = async (tokenAddress: string, amount: string) => {
  const token = await getIErc20Detailed(tokenAddress);
  let decimals = new BigNumber(await token.decimals());
  const currencyUnit = new BigNumber(10).pow(decimals);
  const amountInCurrencyUnits = new BigNumber(amount).div(currencyUnit);
  return amountInCurrencyUnits.toFixed();
};

export const deployAllMockTokens = async (verify?: boolean) => {
  const tokens: {[symbol: string]: MockContract | MintableErc20} = {};

  const protoConfigData = getReservesConfigByPool(AavePools.proto);
  const secondaryConfigData = getReservesConfigByPool(AavePools.secondary);

  for (const tokenSymbol of Object.keys(TokenContractId)) {
    let decimals = 18;

    let configData = (<any>protoConfigData)[tokenSymbol];

    if (!configData) {
      configData = (<any>secondaryConfigData)[tokenSymbol];
    }

    if (!configData) {
      decimals = 18;
    }

    tokens[tokenSymbol] = await deployMintableErc20([
      tokenSymbol,
      tokenSymbol,
      configData ? configData.reserveDecimals : 18,
    ]);
    await registerContractInJsonDb(tokenSymbol.toUpperCase(), tokens[tokenSymbol]);

    if (verify) {
      await verifyContract(eContractid.MintableErc20, tokens[tokenSymbol].address, []);
    }
  }
  return tokens;
};

export const getMockedTokens = async () => {
  const db = getDb();
  const tokens: MockTokenMap = await Object.keys(TokenContractId).reduce<Promise<MockTokenMap>>(
    async (acc, tokenSymbol) => {
      const accumulator = await acc;
      const address = db.get(`${tokenSymbol.toUpperCase()}.${BRE.network.name}`).value().address;
      accumulator[tokenSymbol] = await getContract<MintableErc20>(
        eContractid.MintableErc20,
        address
      );
      return Promise.resolve(acc);
    },
    Promise.resolve({})
  );
  return tokens;
};

export const getPairsTokenAggregator = (
  allAssetsAddresses: {
    [tokenSymbol: string]: tEthereumAddress;
  },
  aggregatorsAddresses: {[tokenSymbol: string]: tEthereumAddress}
): [string[], string[]] => {
  const {ETH, ...assetsAddressesWithoutEth} = allAssetsAddresses;

  const pairs = Object.entries(assetsAddressesWithoutEth).map(([tokenSymbol, tokenAddress]) => {
    if (tokenSymbol !== 'ETH') {
      const aggregatorAddressIndex = Object.keys(aggregatorsAddresses).findIndex(
        (value) => value === tokenSymbol
      );
      const [, aggregatorAddress] = (Object.entries(aggregatorsAddresses) as [
        string,
        tEthereumAddress
      ][])[aggregatorAddressIndex];
      return [tokenAddress, aggregatorAddress];
    }
  });

  const mappedPairs = pairs.map(([asset]) => asset);
  const mappedAggregators = pairs.map(([, source]) => source);

  return [mappedPairs, mappedAggregators];
};

export const initReserves = async (
  reservesParams: iMultiPoolsAssets<IReserveParams>,
  tokenAddresses: {[symbol: string]: tEthereumAddress},
  lendingPoolAddressesProvider: LendingPoolAddressesProvider,
  lendingPool: LendingPool,
  lendingPoolConfigurator: LendingPoolConfigurator,
  aavePool: AavePools
) => {
  if (aavePool !== AavePools.proto && aavePool !== AavePools.secondary) {
    console.log(`Invalid Aave pool ${aavePool}`);
    process.exit(1);
  }

  for (let [assetSymbol, {reserveDecimals}] of Object.entries(reservesParams) as [
    string,
    IReserveParams
  ][]) {
    const assetAddressIndex = Object.keys(tokenAddresses).findIndex(
      (value) => value === assetSymbol
    );
    const [, tokenAddress] = (Object.entries(tokenAddresses) as [string, string][])[
      assetAddressIndex
    ];

    const {isActive: reserveInitialized} = await lendingPool.getReserveConfigurationData(
      tokenAddress
    );

    if (reserveInitialized) {
      console.log(`Reserve ${assetSymbol} is already active, skipping configuration`);
      continue;
    }

    try {
      const reserveParamIndex = Object.keys(reservesParams).findIndex(
        (value) => value === assetSymbol
      );
      const [
        ,
        {
          baseVariableBorrowRate,
          variableRateSlope1,
          variableRateSlope2,
          stableRateSlope1,
          stableRateSlope2,
        },
      ] = (Object.entries(reservesParams) as [string, IReserveParams][])[reserveParamIndex];
      const rateStrategyContract = await deployDefaultReserveInterestRateStrategy([
        lendingPoolAddressesProvider.address,
        baseVariableBorrowRate,
        variableRateSlope1,
        variableRateSlope2,
        stableRateSlope1,
        stableRateSlope2,
      ]);

      const stableDebtToken = await deployStableDebtToken([
        `Aave stable debt bearing ${assetSymbol === 'WETH' ? 'ETH' : assetSymbol}`,
        `stableDebt${assetSymbol === 'WETH' ? 'ETH' : assetSymbol}`,
        tokenAddress,
        lendingPool.address,
      ]);

      const variableDebtToken = await deployVariableDebtToken([
        `Aave variable debt bearing ${assetSymbol === 'WETH' ? 'ETH' : assetSymbol}`,
        `variableDebt${assetSymbol === 'WETH' ? 'ETH' : assetSymbol}`,
        tokenAddress,
        lendingPool.address,
      ]);

      const aToken = await deployGenericAToken([
        lendingPool.address,
        tokenAddress,
        `Aave interest bearing ${assetSymbol === 'WETH' ? 'ETH' : assetSymbol}`,
        `a${assetSymbol === 'WETH' ? 'ETH' : assetSymbol}`,
      ]);

      if (process.env.POOL === AavePools.secondary) {
        if (assetSymbol.search('UNI') === -1) {
          assetSymbol = `Uni${assetSymbol}`;
        } else {
          assetSymbol = assetSymbol.replace(/_/g, '').replace('UNI', 'Uni');
        }
      }

      await lendingPoolConfigurator.initReserve(
        tokenAddress,
        aToken.address,
        stableDebtToken.address,
        variableDebtToken.address,
        reserveDecimals,
        rateStrategyContract.address
      );
    } catch (e) {
      console.log(`Reserve initialization for ${assetSymbol} failed with error ${e}. Skipped.`);
    }
  }
};