Merge pull request #14 from aave/feat/light-deployments

Enable light deployment of the protocol

contracts/adapters/BaseUniswapAdapter.sol

@@ -386,7 +386,6 @@ abstract contract BaseUniswapAdapter is FlashLoanReceiverBase, IBaseUniswapAdapt
     }
 
     uint256 bestAmountOut;
-
     try UNISWAP_ROUTER.getAmountsOut(finalAmountIn, simplePath) returns (
       uint256[] memory resultAmounts
     ) {

contracts/deployments/ATokensAndRatesHelper.sol

@@ -20,6 +20,20 @@ contract ATokensAndRatesHelper is Ownable {
   address private poolConfigurator;
   event deployedContracts(address aToken, address strategy);
 
+  struct InitDeploymentInput {
+    address asset;
+    uint256[6] rates;
+  }
+
+  struct ConfigureReserveInput {
+    address asset;
+    uint256 baseLTV;
+    uint256 liquidationThreshold;
+    uint256 liquidationBonus;
+    uint256 reserveFactor;
+    bool stableBorrowingEnabled;
+  }
+
   constructor(
     address payable _pool,
     address _addressesProvider,
@@ -30,90 +44,40 @@ contract ATokensAndRatesHelper is Ownable {
     poolConfigurator = _poolConfigurator;
   }
 
-  function initDeployment(
-    address[] calldata assets,
-    string[] calldata symbols,
-    uint256[6][] calldata rates,
-    address treasuryAddress,
-    address incentivesController
-  ) external onlyOwner {
-    require(assets.length == symbols.length, 't Arrays not same length');
-    require(rates.length == symbols.length, 'r Arrays not same length');
-    for (uint256 i = 0; i < assets.length; i++) {
+  function initDeployment(InitDeploymentInput[] calldata inputParams) external onlyOwner {
+    for (uint256 i = 0; i < inputParams.length; i++) {
       emit deployedContracts(
-        address(
-          new AToken(
-            LendingPool(pool),
-            assets[i],
-            treasuryAddress,
-            StringLib.concat('Aave interest bearing ', symbols[i]),
-            StringLib.concat('a', symbols[i]),
-            incentivesController
-          )
-        ),
+        address(new AToken()),
         address(
           new DefaultReserveInterestRateStrategy(
             LendingPoolAddressesProvider(addressesProvider),
-            rates[i][0],
-            rates[i][1],
-            rates[i][2],
-            rates[i][3],
-            rates[i][4],
-            rates[i][5]
+            inputParams[i].rates[0],
+            inputParams[i].rates[1],
+            inputParams[i].rates[2],
+            inputParams[i].rates[3],
+            inputParams[i].rates[4],
+            inputParams[i].rates[5]
           )
         )
       );
     }
   }
 
-  function initReserve(
-    address[] calldata stables,
-    address[] calldata variables,
-    address[] calldata aTokens,
-    address[] calldata strategies,
-    uint8[] calldata reserveDecimals
-  ) external onlyOwner {
-    require(variables.length == stables.length);
-    require(aTokens.length == stables.length);
-    require(strategies.length == stables.length);
-    require(reserveDecimals.length == stables.length);
-
-    for (uint256 i = 0; i < stables.length; i++) {
-      LendingPoolConfigurator(poolConfigurator).initReserve(
-        aTokens[i],
-        stables[i],
-        variables[i],
-        reserveDecimals[i],
-        strategies[i]
-      );
-    }
-  }
-
-  function configureReserves(
-    address[] calldata assets,
-    uint256[] calldata baseLTVs,
-    uint256[] calldata liquidationThresholds,
-    uint256[] calldata liquidationBonuses,
-    uint256[] calldata reserveFactors,
-    bool[] calldata stableBorrowingEnabled
-  ) external onlyOwner {
-    require(baseLTVs.length == assets.length);
-    require(liquidationThresholds.length == assets.length);
-    require(liquidationBonuses.length == assets.length);
-    require(stableBorrowingEnabled.length == assets.length);
-    require(reserveFactors.length == assets.length);
-
+  function configureReserves(ConfigureReserveInput[] calldata inputParams) external onlyOwner {
     LendingPoolConfigurator configurator = LendingPoolConfigurator(poolConfigurator);
-    for (uint256 i = 0; i < assets.length; i++) {
+    for (uint256 i = 0; i < inputParams.length; i++) {
       configurator.configureReserveAsCollateral(
-        assets[i],
-        baseLTVs[i],
-        liquidationThresholds[i],
-        liquidationBonuses[i]
+        inputParams[i].asset,
+        inputParams[i].baseLTV,
+        inputParams[i].liquidationThreshold,
+        inputParams[i].liquidationBonus
       );
 
-      configurator.enableBorrowingOnReserve(assets[i], stableBorrowingEnabled[i]);
-      configurator.setReserveFactor(assets[i], reserveFactors[i]);
+      configurator.enableBorrowingOnReserve(
+        inputParams[i].asset,
+        inputParams[i].stableBorrowingEnabled
+      );
+      configurator.setReserveFactor(inputParams[i].asset, inputParams[i].reserveFactor);
     }
   }
 }

contracts/deployments/StableAndVariableTokensHelper.sol

@@ -18,34 +18,11 @@ contract StableAndVariableTokensHelper is Ownable {
     addressesProvider = _addressesProvider;
   }
 
-  function initDeployment(
-    address[] calldata tokens,
-    string[] calldata symbols,
-    address incentivesController
-  ) external onlyOwner {
+  function initDeployment(address[] calldata tokens, string[] calldata symbols) external onlyOwner {
     require(tokens.length == symbols.length, 'Arrays not same length');
     require(pool != address(0), 'Pool can not be zero address');
     for (uint256 i = 0; i < tokens.length; i++) {
-      emit deployedContracts(
-        address(
-          new StableDebtToken(
-            pool,
-            tokens[i],
-            StringLib.concat('Aave stable debt bearing ', symbols[i]),
-            StringLib.concat('stableDebt', symbols[i]),
-            incentivesController
-          )
-        ),
-        address(
-          new VariableDebtToken(
-            pool,
-            tokens[i],
-            StringLib.concat('Aave variable debt bearing ', symbols[i]),
-            StringLib.concat('variableDebt', symbols[i]),
-            incentivesController
-          )
-        )
-      );
+      emit deployedContracts(address(new StableDebtToken()), address(new VariableDebtToken()));
     }
   }
 

contracts/interfaces/IAToken.sol

@@ -3,8 +3,10 @@ pragma solidity 0.6.12;
 
 import {IERC20} from '../dependencies/openzeppelin/contracts/IERC20.sol';
 import {IScaledBalanceToken} from './IScaledBalanceToken.sol';
+import {IInitializableAToken} from './IInitializableAToken.sol';
+import {IAaveIncentivesController} from './IAaveIncentivesController.sol';
 
-interface IAToken is IERC20, IScaledBalanceToken {
+interface IAToken is IERC20, IScaledBalanceToken, IInitializableAToken {
   /**
    * @dev Emitted after the mint action
    * @param from The address performing the mint
@@ -80,9 +82,21 @@ interface IAToken is IERC20, IScaledBalanceToken {
   /**
    * @dev Transfers the underlying asset to `target`. Used by the LendingPool to transfer
    * assets in borrow(), withdraw() and flashLoan()
-   * @param user The recipient of the aTokens
+   * @param user The recipient of the underlying
    * @param amount The amount getting transferred
    * @return The amount transferred
    **/
   function transferUnderlyingTo(address user, uint256 amount) external returns (uint256);
+
+  /**
+   * @dev Invoked to execute actions on the aToken side after a repayment.
+   * @param user The user executing the repayment
+   * @param amount The amount getting repaid
+   **/
+  function handleRepayment(address user, uint256 amount) external;
+
+  /**
+   * @dev Returns the address of the incentives controller contract
+   **/
+  function getIncentivesController() external view returns (IAaveIncentivesController);
 }

contracts/interfaces/IInitializableAToken.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: agpl-3.0
+pragma solidity 0.6.12;
+
+import {ILendingPool} from './ILendingPool.sol';
+import {IAaveIncentivesController} from './IAaveIncentivesController.sol';
+
+/**
+ * @title IInitializableAToken
+ * @notice Interface for the initialize function on AToken
+ * @author Aave
+ **/
+interface IInitializableAToken {
+  /**
+   * @dev Emitted when an aToken is initialized
+   * @param underlyingAsset The address of the underlying asset
+   * @param pool The address of the associated lending pool
+   * @param treasury The address of the treasury
+   * @param incentivesController The address of the incentives controller for this aToken
+   * @param aTokenDecimals the decimals of the underlying
+   * @param aTokenName the name of the aToken
+   * @param aTokenSymbol the symbol of the aToken
+   * @param params A set of encoded parameters for additional initialization
+   **/
+  event Initialized(
+    address indexed underlyingAsset,
+    address indexed pool,
+    address treasury,
+    address incentivesController,
+    uint8 aTokenDecimals,
+    string aTokenName,
+    string aTokenSymbol,
+    bytes params
+  );
+
+  /**
+   * @dev Initializes the aToken
+   * @param pool The address of the lending pool where this aToken will be used
+   * @param treasury The address of the Aave treasury, receiving the fees on this aToken
+   * @param underlyingAsset The address of the underlying asset of this aToken (E.g. WETH for aWETH)
+   * @param incentivesController The smart contract managing potential incentives distribution
+   * @param aTokenDecimals The decimals of the aToken, same as the underlying asset's
+   * @param aTokenName The name of the aToken
+   * @param aTokenSymbol The symbol of the aToken
+   */
+  function initialize(
+    ILendingPool pool,
+    address treasury,
+    address underlyingAsset,
+    IAaveIncentivesController incentivesController,
+    uint8 aTokenDecimals,
+    string calldata aTokenName,
+    string calldata aTokenSymbol,
+    bytes calldata params
+  ) external;
+}

contracts/interfaces/IInitializableDebtToken.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: agpl-3.0
+pragma solidity 0.6.12;
+
+import {ILendingPool} from './ILendingPool.sol';
+import {IAaveIncentivesController} from './IAaveIncentivesController.sol';
+
+/**
+ * @title IInitializableDebtToken
+ * @notice Interface for the initialize function common between debt tokens
+ * @author Aave
+ **/
+interface IInitializableDebtToken {
+  /**
+   * @dev Emitted when a debt token is initialized
+   * @param underlyingAsset The address of the underlying asset
+   * @param pool The address of the associated lending pool
+   * @param incentivesController The address of the incentives controller for this aToken
+   * @param debtTokenDecimals the decimals of the debt token
+   * @param debtTokenName the name of the debt token
+   * @param debtTokenSymbol the symbol of the debt token
+   * @param params A set of encoded parameters for additional initialization
+   **/
+  event Initialized(
+    address indexed underlyingAsset,
+    address indexed pool,
+    address incentivesController,
+    uint8 debtTokenDecimals,
+    string debtTokenName,
+    string debtTokenSymbol,
+    bytes params
+  );
+
+  /**
+   * @dev Initializes the debt token.
+   * @param pool The address of the lending pool where this aToken will be used
+   * @param underlyingAsset The address of the underlying asset of this aToken (E.g. WETH for aWETH)
+   * @param incentivesController The smart contract managing potential incentives distribution
+   * @param debtTokenDecimals The decimals of the debtToken, same as the underlying asset's
+   * @param debtTokenName The name of the token
+   * @param debtTokenSymbol The symbol of the token
+   */
+  function initialize(
+    ILendingPool pool,
+    address underlyingAsset,
+    IAaveIncentivesController incentivesController,
+    uint8 debtTokenDecimals,
+    string memory debtTokenName,
+    string memory debtTokenSymbol,
+    bytes calldata params
+  ) external;
+}