Merge pull request #595 from aave/feat/594-minify-pool

Reducing pool size

Author: The-3D

contracts/interfaces/IPool.sol

@@ -699,7 +699,7 @@ interface IPool {
    * @notice Returns the maximum number of reserves supported to be listed in this Pool
    * @return The maximum number of reserves supported
    */
-  function MAX_NUMBER_RESERVES() external view returns (uint256);
+  function MAX_NUMBER_RESERVES() external view returns (uint16);
 
   /**
    * @notice Mints the assets accrued through the reserve factor to the treasury in the form of aTokens

contracts/mocks/helpers/MockPool.sol

@@ -42,7 +42,7 @@ contract MockPoolInherited is Pool {
     _maxNumberOfReserves = newMaxNumberOfReserves;
   }
 
-  function MAX_NUMBER_RESERVES() public view override returns (uint256) {
+  function MAX_NUMBER_RESERVES() public view override returns (uint16) {
     return _maxNumberOfReserves;
   }
 

contracts/protocol/libraries/logic/PoolLogic.sol

@@ -0,0 +1,144 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.10;
+
+import {GPv2SafeERC20} from '../../../dependencies/gnosis/contracts/GPv2SafeERC20.sol';
+import {Address} from '../../../dependencies/openzeppelin/contracts/Address.sol';
+import {IERC20} from '../../../dependencies/openzeppelin/contracts/IERC20.sol';
+import {IAToken} from '../../../interfaces/IAToken.sol';
+import {ReserveConfiguration} from '../configuration/ReserveConfiguration.sol';
+import {Errors} from '../helpers/Errors.sol';
+import {WadRayMath} from '../math/WadRayMath.sol';
+import {DataTypes} from '../types/DataTypes.sol';
+import {ReserveLogic} from './ReserveLogic.sol';
+import {ValidationLogic} from './ValidationLogic.sol';
+
+/**
+ * @title PoolLogic library
+ * @author Aave
+ * @notice Implements the logic for Pool specific functions
+ */
+library PoolLogic {
+  using GPv2SafeERC20 for IERC20;
+  using WadRayMath for uint256;
+  using ReserveLogic for DataTypes.ReserveData;
+  using ReserveConfiguration for DataTypes.ReserveConfigurationMap;
+
+  // See `IPool` for descriptions
+  event MintedToTreasury(address indexed reserve, uint256 amountMinted);
+  event IsolationModeTotalDebtUpdated(address indexed asset, uint256 totalDebt);
+
+  /**
+   * @notice Initialize an asset reserve and add the reserve to the list of reserves
+   * @param reservesData The state of all the reserves
+   * @param reserves The addresses of all the active reserves
+   * @param params Additional parameters needed for initiation
+   * @return true if appended, false if inserted at existing empty spot
+   **/
+  function executeInitReserve(
+    mapping(address => DataTypes.ReserveData) storage reservesData,
+    mapping(uint256 => address) storage reserves,
+    DataTypes.InitReserveParams memory params
+  ) external returns (bool) {
+    require(Address.isContract(params.asset), Errors.NOT_CONTRACT);
+    reservesData[params.asset].init(
+      params.aTokenAddress,
+      params.stableDebtAddress,
+      params.variableDebtAddress,
+      params.interestRateStrategyAddress
+    );
+
+    bool reserveAlreadyAdded = reservesData[params.asset].id != 0 || reserves[0] == params.asset;
+    require(!reserveAlreadyAdded, Errors.RESERVE_ALREADY_ADDED);
+
+    for (uint16 i = 0; i < params.reservesCount; i++) {
+      if (reserves[i] == address(0)) {
+        reservesData[params.asset].id = i;
+        reserves[i] = params.asset;
+        return false;
+      }
+    }
+
+    require(params.reservesCount < params.maxNumberReserves, Errors.NO_MORE_RESERVES_ALLOWED);
+    reservesData[params.asset].id = params.reservesCount;
+    reserves[params.reservesCount] = params.asset;
+    return true;
+  }
+
+  /**
+   * @notice Rescue and transfer tokens locked in this contract
+   * @param token The address of the token
+   * @param to The address of the recipient
+   * @param amount The amount of token to transfer
+   */
+  function executeRescueTokens(
+    address token,
+    address to,
+    uint256 amount
+  ) external {
+    IERC20(token).safeTransfer(to, amount);
+  }
+
+  /**
+   * @notice Mints the assets accrued through the reserve factor to the treasury in the form of aTokens
+   * @param reservesData The state of all the reserves
+   * @param assets The list of reserves for which the minting needs to be executed
+   **/
+  function executeMintToTreasury(
+    mapping(address => DataTypes.ReserveData) storage reservesData,
+    address[] calldata assets
+  ) external {
+    for (uint256 i = 0; i < assets.length; i++) {
+      address assetAddress = assets[i];
+
+      DataTypes.ReserveData storage reserve = reservesData[assetAddress];
+
+      // this cover both inactive reserves and invalid reserves since the flag will be 0 for both
+      if (!reserve.configuration.getActive()) {
+        continue;
+      }
+
+      uint256 accruedToTreasury = reserve.accruedToTreasury;
+
+      if (accruedToTreasury != 0) {
+        reserve.accruedToTreasury = 0;
+        uint256 normalizedIncome = reserve.getNormalizedIncome();
+        uint256 amountToMint = accruedToTreasury.rayMul(normalizedIncome);
+        IAToken(reserve.aTokenAddress).mintToTreasury(amountToMint, normalizedIncome);
+
+        emit MintedToTreasury(assetAddress, amountToMint);
+      }
+    }
+  }
+
+  /**
+   * @notice Resets the isolation mode total debt of the given asset to zero
+   * @dev It requires the given asset has zero debt ceiling
+   * @param reservesData The state of all the reserves
+   * @param asset The address of the underlying asset to reset the isolationModeTotalDebt
+   */
+  function executeResetIsolationModeTotalDebt(
+    mapping(address => DataTypes.ReserveData) storage reservesData,
+    address asset
+  ) external {
+    require(reservesData[asset].configuration.getDebtCeiling() == 0, Errors.DEBT_CEILING_NOT_ZERO);
+    reservesData[asset].isolationModeTotalDebt = 0;
+    emit IsolationModeTotalDebtUpdated(asset, 0);
+  }
+
+  /**
+   * @notice Drop a reserve
+   * @param reservesData The state of all the reserves
+   * @param reserves The addresses of all the active reserves
+   * @param asset The address of the underlying asset of the reserve
+   **/
+  function executeDropReserve(
+    mapping(address => DataTypes.ReserveData) storage reservesData,
+    mapping(uint256 => address) storage reserves,
+    address asset
+  ) external {
+    DataTypes.ReserveData storage reserve = reservesData[asset];
+    ValidationLogic.validateDropReserve(reserves, reserve, asset);
+    reserves[reservesData[asset].id] = address(0);
+    delete reservesData[asset];
+  }
+}

contracts/protocol/libraries/types/DataTypes.sol

@@ -255,4 +255,14 @@ library DataTypes {
     address reserve;
     address aToken;
   }
+
+  struct InitReserveParams {
+    address asset;
+    address aTokenAddress;
+    address stableDebtAddress;
+    address variableDebtAddress;
+    address interestRateStrategyAddress;
+    uint16 reservesCount;
+    uint16 maxNumberReserves;
+  }
 }

contracts/protocol/pool/Pool.sol

@@ -1,26 +1,21 @@
 // SPDX-License-Identifier: BUSL-1.1
 pragma solidity 0.8.10;
 
-import {IERC20} from '../../dependencies/openzeppelin/contracts/IERC20.sol';
-import {GPv2SafeERC20} from '../../dependencies/gnosis/contracts/GPv2SafeERC20.sol';
-import {Address} from '../../dependencies/openzeppelin/contracts/Address.sol';
 import {VersionedInitializable} from '../libraries/aave-upgradeability/VersionedInitializable.sol';
 import {Errors} from '../libraries/helpers/Errors.sol';
-import {WadRayMath} from '../libraries/math/WadRayMath.sol';
+import {ReserveConfiguration} from '../libraries/configuration/ReserveConfiguration.sol';
+import {PoolLogic} from '../libraries/logic/PoolLogic.sol';
 import {ReserveLogic} from '../libraries/logic/ReserveLogic.sol';
 import {GenericLogic} from '../libraries/logic/GenericLogic.sol';
-import {ValidationLogic} from '../libraries/logic/ValidationLogic.sol';
 import {EModeLogic} from '../libraries/logic/EModeLogic.sol';
 import {SupplyLogic} from '../libraries/logic/SupplyLogic.sol';
 import {FlashLoanLogic} from '../libraries/logic/FlashLoanLogic.sol';
 import {BorrowLogic} from '../libraries/logic/BorrowLogic.sol';
 import {LiquidationLogic} from '../libraries/logic/LiquidationLogic.sol';
-import {ReserveConfiguration} from '../libraries/configuration/ReserveConfiguration.sol';
 import {DataTypes} from '../libraries/types/DataTypes.sol';
 import {BridgeLogic} from '../libraries/logic/BridgeLogic.sol';
 import {IERC20WithPermit} from '../../interfaces/IERC20WithPermit.sol';
 import {IPoolAddressesProvider} from '../../interfaces/IPoolAddressesProvider.sol';
-import {IAToken} from '../../interfaces/IAToken.sol';
 import {IPool} from '../../interfaces/IPool.sol';
 import {IACLManager} from '../../interfaces/IACLManager.sol';
 import {PoolStorage} from './PoolStorage.sol';
@@ -43,10 +38,7 @@ import {PoolStorage} from './PoolStorage.sol';
  *   PoolAddressesProvider
  **/
 contract Pool is VersionedInitializable, IPool, PoolStorage {
-  using WadRayMath for uint256;
-  using GPv2SafeERC20 for IERC20;
   using ReserveLogic for DataTypes.ReserveData;
-  using ReserveConfiguration for DataTypes.ReserveConfigurationMap;
 
   uint256 public constant POOL_REVISION = 0x1;
   IPoolAddressesProvider public immutable ADDRESSES_PROVIDER;
@@ -449,27 +441,7 @@ contract Pool is VersionedInitializable, IPool, PoolStorage {
 
   /// @inheritdoc IPool
   function mintToTreasury(address[] calldata assets) external override {
-    for (uint256 i = 0; i < assets.length; i++) {
-      address assetAddress = assets[i];
-
-      DataTypes.ReserveData storage reserve = _reserves[assetAddress];
-
-      // this cover both inactive reserves and invalid reserves since the flag will be 0 for both
-      if (!reserve.configuration.getActive()) {
-        continue;
-      }
-
-      uint256 accruedToTreasury = reserve.accruedToTreasury;
-
-      if (accruedToTreasury != 0) {
-        reserve.accruedToTreasury = 0;
-        uint256 normalizedIncome = reserve.getNormalizedIncome();
-        uint256 amountToMint = accruedToTreasury.rayMul(normalizedIncome);
-        IAToken(reserve.aTokenAddress).mintToTreasury(amountToMint, normalizedIncome);
-
-        emit MintedToTreasury(assetAddress, amountToMint);
-      }
-    }
+    PoolLogic.executeMintToTreasury(_reserves, assets);
   }
 
   /// @inheritdoc IPool
@@ -566,23 +538,23 @@ contract Pool is VersionedInitializable, IPool, PoolStorage {
 
   /// @inheritdoc IPool
   function getReservesList() external view override returns (address[] memory) {
-    uint256 reserveListCount = _reservesCount;
+    uint256 reservesListCount = _reservesCount;
     uint256 droppedReservesCount = 0;
-    address[] memory reserves = new address[](reserveListCount);
+    address[] memory reservesList = new address[](reservesListCount);
 
-    for (uint256 i = 0; i < reserveListCount; i++) {
+    for (uint256 i = 0; i < reservesListCount; i++) {
       if (_reservesList[i] != address(0)) {
-        reserves[i - droppedReservesCount] = _reservesList[i];
+        reservesList[i - droppedReservesCount] = _reservesList[i];
       } else {
         droppedReservesCount++;
       }
     }
 
     // Reduces the length of the reserves array by `droppedReservesCount`
     assembly {
-      mstore(reserves, sub(reserveListCount, droppedReservesCount))
+      mstore(reservesList, sub(reservesListCount, droppedReservesCount))
     }
-    return reserves;
+    return reservesList;
   }
 
   /// @inheritdoc IPool
@@ -606,7 +578,7 @@ contract Pool is VersionedInitializable, IPool, PoolStorage {
   }
 
   /// @inheritdoc IPool
-  function MAX_NUMBER_RESERVES() public view virtual override returns (uint256) {
+  function MAX_NUMBER_RESERVES() public view virtual override returns (uint16) {
     return ReserveConfiguration.MAX_RESERVES_COUNT;
   }
 
@@ -647,22 +619,28 @@ contract Pool is VersionedInitializable, IPool, PoolStorage {
     address variableDebtAddress,
     address interestRateStrategyAddress
   ) external override onlyPoolConfigurator {
-    require(Address.isContract(asset), Errors.NOT_CONTRACT);
-    _reserves[asset].init(
-      aTokenAddress,
-      stableDebtAddress,
-      variableDebtAddress,
-      interestRateStrategyAddress
-    );
-    _addReserveToList(asset);
+    if (
+      PoolLogic.executeInitReserve(
+        _reserves,
+        _reservesList,
+        DataTypes.InitReserveParams({
+          asset: asset,
+          aTokenAddress: aTokenAddress,
+          stableDebtAddress: stableDebtAddress,
+          variableDebtAddress: variableDebtAddress,
+          interestRateStrategyAddress: interestRateStrategyAddress,
+          reservesCount: _reservesCount,
+          maxNumberReserves: MAX_NUMBER_RESERVES()
+        })
+      )
+    ) {
+      _reservesCount++;
+    }
   }
 
   /// @inheritdoc IPool
   function dropReserve(address asset) external virtual override onlyPoolConfigurator {
-    DataTypes.ReserveData storage reserve = _reserves[asset];
-    ValidationLogic.validateDropReserve(_reservesList, reserve, asset);
-    _reservesList[_reserves[asset].id] = address(0);
-    delete _reserves[asset];
+    PoolLogic.executeDropReserve(_reserves, _reservesList, asset);
   }
 
   /// @inheritdoc IPool
@@ -745,9 +723,7 @@ contract Pool is VersionedInitializable, IPool, PoolStorage {
 
   /// @inheritdoc IPool
   function resetIsolationModeTotalDebt(address asset) external override onlyPoolConfigurator {
-    require(_reserves[asset].configuration.getDebtCeiling() == 0, Errors.DEBT_CEILING_NOT_ZERO);
-    _reserves[asset].isolationModeTotalDebt = 0;
-    emit IsolationModeTotalDebtUpdated(asset, 0);
+    PoolLogic.executeResetIsolationModeTotalDebt(_reserves, asset);
   }
 
   /// @inheritdoc IPool
@@ -756,31 +732,7 @@ contract Pool is VersionedInitializable, IPool, PoolStorage {
     address to,
     uint256 amount
   ) external override onlyPoolAdmin {
-    IERC20(token).safeTransfer(to, amount);
-  }
-
-  /**
-   * @notice Add an asset to the reserve list
-   * @param asset The address of the underlying asset
-   */
-  function _addReserveToList(address asset) internal {
-    bool reserveAlreadyAdded = _reserves[asset].id != 0 || _reservesList[0] == asset;
-    require(!reserveAlreadyAdded, Errors.RESERVE_ALREADY_ADDED);
-
-    uint16 reservesCount = _reservesCount;
-
-    for (uint16 i = 0; i < reservesCount; i++) {
-      if (_reservesList[i] == address(0)) {
-        _reserves[asset].id = i;
-        _reservesList[i] = asset;
-        return;
-      }
-    }
-    require(reservesCount < MAX_NUMBER_RESERVES(), Errors.NO_MORE_RESERVES_ALLOWED);
-    _reserves[asset].id = reservesCount;
-    _reservesList[reservesCount] = asset;
-    // no need to check for overflow - the require above must ensure that max number of reserves < type(uint16).max
-    _reservesCount = reservesCount + 1;
+    PoolLogic.executeRescueTokens(token, to, amount);
   }
 
   /// @inheritdoc IPool