refactor: further refactored the cache layer and replaced reads/calls

contracts/protocol/lendingpool/LendingPool.sol

@@ -288,28 +288,44 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
     reserve.updateState(cachedData);
 
     if (interestRateMode == DataTypes.InterestRateMode.STABLE) {
-      IStableDebtToken(reserve.stableDebtTokenAddress).burn(msg.sender, stableDebt);
+      IStableDebtToken(cachedData.stableDebtTokenAddress).burn(msg.sender, stableDebt);
-      IVariableDebtToken(reserve.variableDebtTokenAddress).mint(
+
+      cachedData.newPrincipalStableDebt = cachedData.newTotalStableDebt = cachedData
+        .oldTotalStableDebt
+        .sub(stableDebt);
+
+      IVariableDebtToken(cachedData.variableDebtTokenAddress).mint(
         msg.sender,
         msg.sender,
         stableDebt,
-        reserve.variableBorrowIndex
+        cachedData.newVariableBorrowIndex
+      );
+      cachedData.newScaledVariableDebt = cachedData.oldScaledVariableDebt.add(
+        stableDebt.rayDiv(cachedData.newVariableBorrowIndex)
       );
     } else {
-      IVariableDebtToken(reserve.variableDebtTokenAddress).burn(
+      IVariableDebtToken(cachedData.variableDebtTokenAddress).burn(
         msg.sender,
         variableDebt,
-        reserve.variableBorrowIndex
+        cachedData.newVariableBorrowIndex
       );
-      IStableDebtToken(reserve.stableDebtTokenAddress).mint(
+      cachedData.newScaledVariableDebt = cachedData.oldScaledVariableDebt.sub(
+        variableDebt.rayDiv(cachedData.newVariableBorrowIndex)
+      );
+
+      IStableDebtToken(cachedData.stableDebtTokenAddress).mint(
         msg.sender,
         msg.sender,
         variableDebt,
         reserve.currentStableBorrowRate
       );
+
+      cachedData.newPrincipalStableDebt = cachedData.newTotalStableDebt = cachedData
+        .oldTotalStableDebt
+        .add(stableDebt);
     }
 
-    reserve.updateInterestRates(asset, reserve.aTokenAddress, 0, 0);
+    reserve.updateInterestRates(cachedData, asset, 0, 0);
 
     emit Swap(asset, msg.sender, rateMode);
   }
@@ -327,10 +343,8 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
     DataTypes.ReserveData storage reserve = _reserves[asset];
     CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve);
 
-    IERC20 stableDebtToken = IERC20(reserve.stableDebtTokenAddress);
+    IERC20 stableDebtToken = IERC20(cachedData.stableDebtTokenAddress);
-    IERC20 variableDebtToken = IERC20(reserve.variableDebtTokenAddress);
+    IERC20 variableDebtToken = IERC20(cachedData.variableDebtTokenAddress);
-    address aTokenAddress = reserve.aTokenAddress;
-
     uint256 stableDebt = IERC20(stableDebtToken).balanceOf(user);
 
     ValidationLogic.validateRebalanceStableBorrowRate(
@@ -338,7 +352,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
       asset,
       stableDebtToken,
       variableDebtToken,
-      aTokenAddress
+      cachedData.aTokenAddress
     );
 
     reserve.updateState(cachedData);
@@ -351,7 +365,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
       reserve.currentStableBorrowRate
     );
 
-    reserve.updateInterestRates(asset, aTokenAddress, 0, 0);
+    reserve.updateInterestRates(cachedData, asset, 0, 0);
 
     emit RebalanceStableBorrowRate(asset, user);
   }
@@ -475,7 +489,6 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
 
     ValidationLogic.validateFlashloan(assets, amounts, _reserves);
 
-
     vars.receiver = IFlashLoanReceiver(receiverAddress);
 
     for (vars.i = 0; vars.i < assets.length; vars.i++) {
@@ -508,8 +521,8 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
           vars.currentPremium
         );
         reserve.updateInterestRates(
+          cachedData,
           vars.currentAsset,
-          vars.currentATokenAddress,
           vars.currentAmountPlusPremium,
           0
         );
@@ -553,11 +566,11 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
   function mintToTreasury(address[] calldata reserves) public {
     for (uint256 i = 0; i < reserves.length; i++) {
       address reserveAddress = reserves[i];
-      
+
       DataTypes.ReserveData storage reserve = _reserves[reserveAddress];
 
       // this cover both inactive reserves and invalid reserves since the flag will be 0 for both
-      if(!reserve.configuration.getActive()){
+      if (!reserve.configuration.getActive()) {
         continue;
       }
 
@@ -874,48 +887,49 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
     DataTypes.UserConfigurationMap storage userConfig = _usersConfig[vars.onBehalfOf];
     CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve);
 
-    address oracle = _addressesProvider.getPriceOracle();
+    reserve.updateState(cachedData);
-
-    uint256 amountInETH =
-      IPriceOracleGetter(oracle).getAssetPrice(vars.asset).mul(vars.amount).div(
-        10**reserve.configuration.getDecimals()
-      );
 
     ValidationLogic.validateBorrow(
+      cachedData,
       vars.asset,
-      reserve,
       vars.onBehalfOf,
       vars.amount,
-      amountInETH,
       vars.interestRateMode,
       _maxStableRateBorrowSizePercent,
       _reserves,
       userConfig,
       _reservesList,
       _reservesCount,
-      oracle
+      _addressesProvider.getPriceOracle()
     );
 
-    reserve.updateState(cachedData);
-
     uint256 currentStableRate = 0;
 
     bool isFirstBorrowing = false;
     if (DataTypes.InterestRateMode(vars.interestRateMode) == DataTypes.InterestRateMode.STABLE) {
       currentStableRate = reserve.currentStableBorrowRate;
 
-      isFirstBorrowing = IStableDebtToken(reserve.stableDebtTokenAddress).mint(
+      isFirstBorrowing = IStableDebtToken(cachedData.stableDebtTokenAddress).mint(
         vars.user,
         vars.onBehalfOf,
         vars.amount,
         currentStableRate
       );
+
+      cachedData.newPrincipalStableDebt = cachedData.newTotalStableDebt = cachedData
+        .oldTotalStableDebt
+        .add(vars.amount);
+      
     } else {
-      isFirstBorrowing = IVariableDebtToken(reserve.variableDebtTokenAddress).mint(
+      isFirstBorrowing = IVariableDebtToken(cachedData.variableDebtTokenAddress).mint(
         vars.user,
         vars.onBehalfOf,
         vars.amount,
-        reserve.variableBorrowIndex
+        cachedData.newVariableBorrowIndex
+      );
+
+      cachedData.newScaledVariableDebt = cachedData.newScaledVariableDebt.add(
+        vars.amount.rayDiv(cachedData.newVariableBorrowIndex)
       );
     }
 
@@ -924,14 +938,14 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
     }
 
     reserve.updateInterestRates(
+      cachedData,
       vars.asset,
-      vars.aTokenAddress,
       0,
       vars.releaseUnderlying ? vars.amount : 0
     );
 
     if (vars.releaseUnderlying) {
-      IAToken(vars.aTokenAddress).transferUnderlyingTo(vars.user, vars.amount);
+      IAToken(cachedData.aTokenAddress).transferUnderlyingTo(vars.user, vars.amount);
     }
 
     emit Borrow(
@@ -956,14 +970,16 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
     DataTypes.ReserveData storage reserve = _reserves[asset];
     CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve);
 
-    ValidationLogic.validateDeposit(reserve, amount);
-
     reserve.updateState(cachedData);
-    reserve.updateInterestRates(asset, cachedData.aTokenAddress, amount, 0);
+
+    ValidationLogic.validateDeposit(reserve, cachedData, amount);
+
+    reserve.updateInterestRates(cachedData, asset, amount, 0);
 
     IERC20(asset).safeTransferFrom(msg.sender, cachedData.aTokenAddress, amount);
 
-    bool isFirstDeposit = IAToken(cachedData.aTokenAddress).mint(onBehalfOf, amount, cachedData.newLiquidityIndex);
+    bool isFirstDeposit =
+      IAToken(cachedData.aTokenAddress).mint(onBehalfOf, amount, cachedData.newLiquidityIndex);
 
     if (isFirstDeposit) {
       _usersConfig[onBehalfOf].setUsingAsCollateral(reserve.id, true);
@@ -982,11 +998,12 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
     DataTypes.UserConfigurationMap storage userConfig = _usersConfig[msg.sender];
     CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve);
 
-    address aToken = reserve.aTokenAddress;
-
     reserve.updateState(cachedData);
 
-    uint256 userBalance = IAToken(aToken).scaledBalanceOf(msg.sender).rayMul(cachedData.newLiquidityIndex);
+    uint256 userBalance =
+      IAToken(cachedData.aTokenAddress).scaledBalanceOf(msg.sender).rayMul(
+        cachedData.newLiquidityIndex
+      );
 
     uint256 amountToWithdraw = amount;
 
@@ -996,9 +1013,14 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
 
     ValidationLogic.validateWithdraw(reserve, amountToWithdraw, userBalance);
 
-    reserve.updateInterestRates(asset, aToken, 0, amountToWithdraw);
+    reserve.updateInterestRates(cachedData, asset, 0, amountToWithdraw);
 
-    IAToken(aToken).burn(msg.sender, to, amountToWithdraw, cachedData.newLiquidityIndex);
+    IAToken(cachedData.aTokenAddress).burn(
+      msg.sender,
+      to,
+      amountToWithdraw,
+      cachedData.newLiquidityIndex
+    );
 
     if (userConfig.isUsingAsCollateral(reserve.id)) {
       if (userConfig.isBorrowingAny()) {
@@ -1055,25 +1077,30 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage
     reserve.updateState(cachedData);
 
     if (interestRateMode == DataTypes.InterestRateMode.STABLE) {
-      IStableDebtToken(reserve.stableDebtTokenAddress).burn(onBehalfOf, paybackAmount);
+      IStableDebtToken(cachedData.stableDebtTokenAddress).burn(onBehalfOf, paybackAmount);
+      cachedData.newPrincipalStableDebt = cachedData.newTotalStableDebt = cachedData
+        .oldTotalStableDebt
+        .sub(paybackAmount);
     } else {
-      IVariableDebtToken(reserve.variableDebtTokenAddress).burn(
+      IVariableDebtToken(cachedData.variableDebtTokenAddress).burn(
         onBehalfOf,
         paybackAmount,
-        reserve.variableBorrowIndex
+        cachedData.newVariableBorrowIndex
+      );
+      cachedData.newScaledVariableDebt = cachedData.oldScaledVariableDebt.sub(
+        paybackAmount.rayDiv(cachedData.newVariableBorrowIndex)
       );
     }
 
-    address aToken = reserve.aTokenAddress;
+    reserve.updateInterestRates(cachedData, asset, paybackAmount, 0);
-    reserve.updateInterestRates(asset, aToken, paybackAmount, 0);
 
     if (stableDebt.add(variableDebt).sub(paybackAmount) == 0) {
       _usersConfig[onBehalfOf].setBorrowing(reserve.id, false);
     }
 
-    IERC20(asset).safeTransferFrom(msg.sender, aToken, paybackAmount);
+    IERC20(asset).safeTransferFrom(msg.sender, cachedData.aTokenAddress, paybackAmount);
 
-    IAToken(aToken).handleRepayment(msg.sender, paybackAmount);
+    IAToken(cachedData.aTokenAddress).handleRepayment(msg.sender, paybackAmount);
 
     emit Repay(asset, onBehalfOf, msg.sender, paybackAmount);
 

contracts/protocol/lendingpool/LendingPoolCollateralManager.sol

@@ -169,26 +169,37 @@ contract LendingPoolCollateralManager is
       IVariableDebtToken(debtReserve.variableDebtTokenAddress).burn(
         user,
         vars.actualDebtToLiquidate,
-        debtReserve.variableBorrowIndex
+        debtReserveCachedData.newVariableBorrowIndex
+      );
+      debtReserveCachedData.newScaledVariableDebt = debtReserveCachedData.oldScaledVariableDebt.sub(
+        vars.actualDebtToLiquidate.rayDiv(debtReserveCachedData.newVariableBorrowIndex)
       );
     } else {
       // If the user doesn't have variable debt, no need to try to burn variable debt tokens
       if (vars.userVariableDebt > 0) {
-        IVariableDebtToken(debtReserve.variableDebtTokenAddress).burn(
+        IVariableDebtToken(debtReserveCachedData.variableDebtTokenAddress).burn(
           user,
           vars.userVariableDebt,
-          debtReserve.variableBorrowIndex
+          debtReserveCachedData.newVariableBorrowIndex
         );
+        debtReserveCachedData.newScaledVariableDebt = debtReserveCachedData
+          .oldScaledVariableDebt
+          .sub(vars.userVariableDebt.rayDiv(debtReserveCachedData.newVariableBorrowIndex));
       }
-      IStableDebtToken(debtReserve.stableDebtTokenAddress).burn(
+      IStableDebtToken(debtReserveCachedData.stableDebtTokenAddress).burn(
         user,
         vars.actualDebtToLiquidate.sub(vars.userVariableDebt)
       );
+
+      debtReserveCachedData.newPrincipalStableDebt = debtReserveCachedData
+        .newTotalStableDebt = debtReserveCachedData.oldTotalStableDebt.sub(
+        vars.actualDebtToLiquidate.sub(vars.userVariableDebt)
+      );
     }
 
     debtReserve.updateInterestRates(
+      debtReserveCachedData,
       debtAsset,
-      debtReserve.aTokenAddress,
       vars.actualDebtToLiquidate,
       0
     );
@@ -203,12 +214,13 @@ contract LendingPoolCollateralManager is
         emit ReserveUsedAsCollateralEnabled(collateralAsset, msg.sender);
       }
     } else {
-      CachingHelper.CachedData memory collateralReserveCachedData = CachingHelper.fetchData(collateralReserve);
+      CachingHelper.CachedData memory collateralReserveCachedData =
+        CachingHelper.fetchData(collateralReserve);
 
       collateralReserve.updateState(collateralReserveCachedData);
       collateralReserve.updateInterestRates(
+        collateralReserveCachedData,
         collateralAsset,
-        address(vars.collateralAtoken),
         0,
         vars.maxCollateralToLiquidate
       );

contracts/protocol/libraries/configuration/ReserveConfiguration.sol

@@ -65,6 +65,16 @@ library ReserveConfiguration {
     return self.data & ~LTV_MASK;
   }
 
+    /**
+   * @dev Gets the Loan to Value of the reserve
+   * @param self The reserve configuration
+   * @return The loan to value
+   **/
+  function getLtvMemory(DataTypes.ReserveConfigurationMap memory self) internal view returns (uint256) {
+    return self.data & ~LTV_MASK;
+  }
+
+
   /**
    * @dev Sets the liquidation threshold of the reserve
    * @param self The reserve configuration
@@ -150,6 +160,20 @@ library ReserveConfiguration {
     return (self.data & ~DECIMALS_MASK) >> RESERVE_DECIMALS_START_BIT_POSITION;
   }
 
+
+  /**
+   * @dev Gets the decimals of the underlying asset of the reserve
+   * @param self The reserve configuration
+   * @return The decimals of the asset
+   **/
+  function getDecimalsMemory(DataTypes.ReserveConfigurationMap memory self)
+    internal
+    view
+    returns (uint256)
+  {
+    return (self.data & ~DECIMALS_MASK) >> RESERVE_DECIMALS_START_BIT_POSITION;
+  }
+
   /**
    * @dev Sets the active state of the reserve
    * @param self The reserve configuration
@@ -293,6 +317,19 @@ library ReserveConfiguration {
     return (self.data & ~RESERVE_FACTOR_MASK) >> RESERVE_FACTOR_START_BIT_POSITION;
   }
 
+  /**
+   * @dev Gets the reserve factor of the reserve
+   * @param self The reserve configuration
+   * @return The reserve factor
+   **/
+  function getReserveFactorMemory(DataTypes.ReserveConfigurationMap memory self)
+    internal
+    view
+    returns (uint256)
+  {
+    return (self.data & ~RESERVE_FACTOR_MASK) >> RESERVE_FACTOR_START_BIT_POSITION;
+  }
+
   /**
    * @dev Sets the borrow cap of the reserve
    * @param self The reserve configuration

contracts/protocol/libraries/helpers/CachingHelper.sol

@@ -4,13 +4,14 @@ pragma experimental ABIEncoderV2;
 
 import {DataTypes} from '../types/DataTypes.sol';
 import {IVariableDebtToken} from '../../../interfaces/IVariableDebtToken.sol';
+import {IStableDebtToken} from '../../../interfaces/IStableDebtToken.sol';
 
 library CachingHelper {
   struct CachedData {
     uint256 oldScaledVariableDebt;
     uint256 oldTotalVariableDebt;
-    uint256 newSscaledVariableDebt;
+    uint256 newScaledVariableDebt;
-    uint256 newTtotalVariableDebt;
+    uint256 newTotalVariableDebt;
     uint256 oldPrincipalStableDebt;
     uint256 oldAvgStableBorrowRate;
     uint256 oldTotalStableDebt;
@@ -28,6 +29,7 @@ library CachingHelper {
     address stableDebtTokenAddress;
     address variableDebtTokenAddress;
     uint40 reserveLastUpdateTimestamp;
+    uint40 stableDebtLastUpdateTimestamp;
   }
 
   function fetchData(DataTypes.ReserveData storage reserveData)
@@ -51,9 +53,23 @@ library CachingHelper {
 
     cachedData.reserveLastUpdateTimestamp = reserveData.lastUpdateTimestamp;
 
-    cachedData.oldScaledVariableDebt = IVariableDebtToken(cachedData.variableDebtTokenAddress)
+    cachedData.oldScaledVariableDebt = cachedData.newScaledVariableDebt = IVariableDebtToken(
+      cachedData
+        .variableDebtTokenAddress
+    )
       .scaledTotalSupply();
-    
+
+    (
+      cachedData.oldPrincipalStableDebt,
+      cachedData.oldTotalStableDebt,
+      cachedData.oldAvgStableBorrowRate,
+      cachedData.stableDebtLastUpdateTimestamp
+    ) = IStableDebtToken(cachedData.stableDebtTokenAddress).getSupplyData();
+
+    cachedData.newPrincipalStableDebt = cachedData.oldPrincipalStableDebt;
+    cachedData.newTotalStableDebt = cachedData.oldTotalStableDebt;
+    cachedData.newAvgStableBorrowRate = cachedData.oldAvgStableBorrowRate;
+
     return cachedData;
   }
 }

contracts/protocol/libraries/logic/ReserveLogic.sol

@@ -108,23 +108,13 @@ library ReserveLogic {
    * @dev Updates the liquidity cumulative index and the variable borrow index.
    * @param reserve the reserve object
    **/
-  function updateState(DataTypes.ReserveData storage reserve, CachingHelper.CachedData memory cachedData) internal {
+  function updateState(
+    DataTypes.ReserveData storage reserve,
+    CachingHelper.CachedData memory cachedData
+  ) internal {
+    _updateIndexes(reserve, cachedData);
 
-      _updateIndexes(
+    _accrueToTreasury(reserve, cachedData);
-        reserve,
-        cachedData
-      );
-
-    
-
-    _accrueToTreasury(
-      reserve,
-      cachedData.oldScaledVariableDebt,
-      cachedData.oldVariableBorrowIndex,
-      cachedData.newLiquidityIndex,
-      cachedData.newVariableBorrowIndex,
-      cachedData.reserveLastUpdateTimestamp
-    );
   }
 
   /**
@@ -191,22 +181,21 @@ library ReserveLogic {
    **/
   function updateInterestRates(
     DataTypes.ReserveData storage reserve,
+    CachingHelper.CachedData memory cachedData,
     address reserveAddress,
-    address aTokenAddress,
     uint256 liquidityAdded,
     uint256 liquidityTaken
   ) internal {
     UpdateInterestRatesLocalVars memory vars;
 
-    vars.stableDebtTokenAddress = reserve.stableDebtTokenAddress;
+    if (cachedData.oldTotalStableDebt != cachedData.newTotalStableDebt) {
+      cachedData.newAvgStableBorrowRate = IStableDebtToken(cachedData.stableDebtTokenAddress)
+        .getAverageStableRate();
+    }
 
-    (vars.totalStableDebt, vars.avgStableRate) = IStableDebtToken(vars.stableDebtTokenAddress)
+    cachedData.newTotalVariableDebt = cachedData.newScaledVariableDebt.rayMul(
-      .getTotalSupplyAndAvgRate();
+      cachedData.newVariableBorrowIndex
-
+    );
-
-    vars.totalVariableDebt = IVariableDebtToken(reserve.variableDebtTokenAddress)
-      .scaledTotalSupply()
-      .rayMul(reserve.variableBorrowIndex);
 
     (
       vars.newLiquidityRate,
@@ -214,13 +203,13 @@ library ReserveLogic {
       vars.newVariableRate
     ) = IReserveInterestRateStrategy(reserve.interestRateStrategyAddress).calculateInterestRates(
       reserveAddress,
-      aTokenAddress,
+      cachedData.aTokenAddress,
       liquidityAdded,
       liquidityTaken,
-      vars.totalStableDebt,
+      cachedData.newTotalStableDebt,
-      vars.totalVariableDebt,
+      cachedData.newTotalVariableDebt,
-      vars.avgStableRate,
+      cachedData.newAvgStableBorrowRate,
-      reserve.configuration.getReserveFactor()
+      cachedData.reserveConfiguration.getReserveFactorMemory()
     );
     require(vars.newLiquidityRate <= type(uint128).max, Errors.RL_LIQUIDITY_RATE_OVERFLOW);
     require(vars.newStableRate <= type(uint128).max, Errors.RL_STABLE_BORROW_RATE_OVERFLOW);
@@ -235,8 +224,8 @@ library ReserveLogic {
       vars.newLiquidityRate,
       vars.newStableRate,
       vars.newVariableRate,
-      reserve.liquidityIndex,
+      cachedData.newLiquidityIndex,
-      reserve.variableBorrowIndex
+      cachedData.newVariableBorrowIndex
     );
   }
 
@@ -258,46 +247,35 @@ library ReserveLogic {
    * @dev Mints part of the repaid interest to the reserve treasury as a function of the reserveFactor for the
    * specific asset.
    * @param reserve The reserve reserve to be updated
-   * @param scaledVariableDebt The current scaled total variable debt
+   * @param cachedData The caching layer for the reserve data
-   * @param previousVariableBorrowIndex The variable borrow index before the last accumulation of the interest
-   * @param newLiquidityIndex The new liquidity index
-   * @param newVariableBorrowIndex The variable borrow index after the last accumulation of the interest
    **/
   function _accrueToTreasury(
     DataTypes.ReserveData storage reserve,
-    uint256 scaledVariableDebt,
+    CachingHelper.CachedData memory cachedData
-    uint256 previousVariableBorrowIndex,
-    uint256 newLiquidityIndex,
-    uint256 newVariableBorrowIndex,
-    uint40 timestamp
   ) internal {
     MintToTreasuryLocalVars memory vars;
 
-    vars.reserveFactor = reserve.configuration.getReserveFactor();
+    vars.reserveFactor = cachedData.reserveConfiguration.getReserveFactorMemory();
 
     if (vars.reserveFactor == 0) {
       return;
     }
 
-    //fetching the principal, total stable debt and the avg stable rate
-    (
-      vars.principalStableDebt,
-      vars.currentStableDebt,
-      vars.avgStableRate,
-      vars.stableSupplyUpdatedTimestamp
-    ) = IStableDebtToken(reserve.stableDebtTokenAddress).getSupplyData();
-
     //calculate the last principal variable debt
-    vars.previousVariableDebt = scaledVariableDebt.rayMul(previousVariableBorrowIndex);
+    vars.previousVariableDebt = cachedData.oldScaledVariableDebt.rayMul(
+      cachedData.oldVariableBorrowIndex
+    );
 
     //calculate the new total supply after accumulation of the index
-    vars.currentVariableDebt = scaledVariableDebt.rayMul(newVariableBorrowIndex);
+    vars.currentVariableDebt = cachedData.oldScaledVariableDebt.rayMul(
+      cachedData.newVariableBorrowIndex
+    );
 
     //calculate the stable debt until the last timestamp update
     vars.cumulatedStableInterest = MathUtils.calculateCompoundedInterest(
       vars.avgStableRate,
       vars.stableSupplyUpdatedTimestamp,
-      timestamp
+      cachedData.reserveLastUpdateTimestamp
     );
 
     vars.previousStableDebt = vars.principalStableDebt.rayMul(vars.cumulatedStableInterest);
@@ -312,7 +290,9 @@ library ReserveLogic {
     vars.amountToMint = vars.totalDebtAccrued.percentMul(vars.reserveFactor);
 
     if (vars.amountToMint != 0) {
-      reserve.accruedToTreasury = reserve.accruedToTreasury.add(vars.amountToMint.rayDiv(newLiquidityIndex));
+      reserve.accruedToTreasury = reserve.accruedToTreasury.add(
+        vars.amountToMint.rayDiv(cachedData.newLiquidityIndex)
+      );
     }
   }
 
@@ -325,16 +305,23 @@ library ReserveLogic {
     DataTypes.ReserveData storage reserve,
     CachingHelper.CachedData memory cachedData
   ) internal {
-
     cachedData.newLiquidityIndex = cachedData.oldLiquidityIndex;
     cachedData.newVariableBorrowIndex = cachedData.oldVariableBorrowIndex;
 
     //only cumulating if there is any income being produced
     if (cachedData.oldLiquidityRate > 0) {
       uint256 cumulatedLiquidityInterest =
-        MathUtils.calculateLinearInterest(cachedData.oldLiquidityRate, cachedData.reserveLastUpdateTimestamp);
+        MathUtils.calculateLinearInterest(
-       cachedData.newLiquidityIndex = cumulatedLiquidityInterest.rayMul(cachedData.oldLiquidityIndex);
+          cachedData.oldLiquidityRate,
-      require( cachedData.newLiquidityIndex <= type(uint128).max, Errors.RL_LIQUIDITY_INDEX_OVERFLOW);
+          cachedData.reserveLastUpdateTimestamp
+        );
+      cachedData.newLiquidityIndex = cumulatedLiquidityInterest.rayMul(
+        cachedData.oldLiquidityIndex
+      );
+      require(
+        cachedData.newLiquidityIndex <= type(uint128).max,
+        Errors.RL_LIQUIDITY_INDEX_OVERFLOW
+      );
 
       reserve.liquidityIndex = uint128(cachedData.newLiquidityIndex);
 
@@ -342,8 +329,13 @@ library ReserveLogic {
       //that there is actual variable debt before accumulating
       if (cachedData.oldScaledVariableDebt != 0) {
         uint256 cumulatedVariableBorrowInterest =
-          MathUtils.calculateCompoundedInterest(cachedData.oldVariableBorrowRate, cachedData.reserveLastUpdateTimestamp);
+          MathUtils.calculateCompoundedInterest(
-        cachedData.newVariableBorrowIndex = cumulatedVariableBorrowInterest.rayMul(cachedData.oldVariableBorrowIndex);
+            cachedData.oldVariableBorrowRate,
+            cachedData.reserveLastUpdateTimestamp
+          );
+        cachedData.newVariableBorrowIndex = cumulatedVariableBorrowInterest.rayMul(
+          cachedData.oldVariableBorrowIndex
+        );
         require(
           cachedData.newVariableBorrowIndex <= type(uint128).max,
           Errors.RL_VARIABLE_BORROW_INDEX_OVERFLOW

contracts/protocol/libraries/logic/ValidationLogic.sol

@@ -12,11 +12,14 @@ import {SafeERC20} from '../../../dependencies/openzeppelin/contracts/SafeERC20.
 import {ReserveConfiguration} from '../configuration/ReserveConfiguration.sol';
 import {UserConfiguration} from '../configuration/UserConfiguration.sol';
 import {Errors} from '../helpers/Errors.sol';
+import {CachingHelper} from '../helpers/CachingHelper.sol';
 import {Helpers} from '../helpers/Helpers.sol';
 import {IReserveInterestRateStrategy} from '../../../interfaces/IReserveInterestRateStrategy.sol';
 import {IVariableDebtToken} from '../../../interfaces/IVariableDebtToken.sol';
 import {IStableDebtToken} from '../../../interfaces/IStableDebtToken.sol';
+import {IAToken} from '../../../interfaces/IAToken.sol';
 import {DataTypes} from '../types/DataTypes.sol';
+import {IPriceOracleGetter} from '../../../interfaces/IPriceOracleGetter.sol';
 
 /**
  * @title ReserveLogic library
@@ -40,11 +43,15 @@ library ValidationLogic {
    * @param reserve The reserve object on which the user is depositing
    * @param amount The amount to be deposited
    */
-  function validateDeposit(DataTypes.ReserveData storage reserve, uint256 amount) internal view {
+  function validateDeposit(
-    DataTypes.ReserveConfigurationMap memory reserveConfiguration = reserve.configuration;
+    DataTypes.ReserveData storage reserve,
-    (bool isActive, bool isFrozen, , , bool isPaused) = reserveConfiguration.getFlagsMemory();
+    CachingHelper.CachedData memory cachedData,
-    (, , , uint256 reserveDecimals, ) = reserveConfiguration.getParamsMemory();
+    uint256 amount
-    uint256 supplyCap = reserveConfiguration.getSupplyCapMemory();
+  ) internal view {
+    (bool isActive, bool isFrozen, , , bool isPaused) =
+      cachedData.reserveConfiguration.getFlagsMemory();
+    (, , , uint256 reserveDecimals, ) = cachedData.reserveConfiguration.getParamsMemory();
+    uint256 supplyCap = cachedData.reserveConfiguration.getSupplyCapMemory();
 
     require(amount != 0, Errors.VL_INVALID_AMOUNT);
     require(isActive, Errors.VL_NO_ACTIVE_RESERVE);
@@ -52,7 +59,11 @@ library ValidationLogic {
     require(!isFrozen, Errors.VL_RESERVE_FROZEN);
     require(
       supplyCap == 0 ||
-        IERC20(reserve.aTokenAddress).totalSupply().add(amount).div(10**reserveDecimals) <
+        IAToken(cachedData.aTokenAddress)
+          .scaledTotalSupply()
+          .rayMul(cachedData.newLiquidityIndex)
+          .add(amount)
+          .div(10**reserveDecimals) <
         supplyCap,
       Errors.VL_SUPPLY_CAP_EXCEEDED
     );
@@ -85,10 +96,11 @@ library ValidationLogic {
     uint256 userBorrowBalanceETH;
     uint256 availableLiquidity;
     uint256 healthFactor;
-    uint256 totalSupplyStableDebt;
+    uint256 totalDebt;
     uint256 totalSupplyVariableDebt;
     uint256 reserveDecimals;
     uint256 borrowCap;
+    uint256 amountInETH;
     bool isActive;
     bool isFrozen;
     bool isPaused;
@@ -99,10 +111,8 @@ library ValidationLogic {
   /**
    * @dev Validates a borrow action
    * @param asset The address of the asset to borrow
-   * @param reserve The reserve state from which the user is borrowing
    * @param userAddress The address of the user
    * @param amount The amount to be borrowed
-   * @param amountInETH The amount to be borrowed, in ETH
    * @param interestRateMode The interest rate mode at which the user is borrowing
    * @param maxStableLoanPercent The max amount of the liquidity that can be borrowed at stable rate, in percentage
    * @param reservesData The state of all the reserves
@@ -112,11 +122,10 @@ library ValidationLogic {
    */
 
   function validateBorrow(
+    CachingHelper.CachedData memory cachedData,
     address asset,
-    DataTypes.ReserveData storage reserve,
     address userAddress,
     uint256 amount,
-    uint256 amountInETH,
     uint256 interestRateMode,
     uint256 maxStableLoanPercent,
     mapping(address => DataTypes.ReserveData) storage reservesData,
@@ -127,8 +136,7 @@ library ValidationLogic {
   ) external view {
     ValidateBorrowLocalVars memory vars;
 
-    DataTypes.ReserveConfigurationMap memory reserveConfiguration = reserve.configuration;
+    (, , , vars.reserveDecimals, ) = cachedData.reserveConfiguration.getParamsMemory();
-    (, , , vars.reserveDecimals, ) = reserveConfiguration.getParamsMemory();
 
     (
       vars.isActive,
@@ -136,7 +144,7 @@ library ValidationLogic {
       vars.borrowingEnabled,
       vars.stableRateBorrowingEnabled,
       vars.isPaused
-    ) = reserveConfiguration.getFlagsMemory();
+    ) = cachedData.reserveConfiguration.getFlagsMemory();
 
     require(vars.isActive, Errors.VL_NO_ACTIVE_RESERVE);
     require(!vars.isPaused, Errors.VL_RESERVE_PAUSED);
@@ -152,18 +160,23 @@ library ValidationLogic {
       Errors.VL_INVALID_INTEREST_RATE_MODE_SELECTED
     );
 
-    vars.totalSupplyStableDebt = IERC20(reserve.stableDebtTokenAddress).totalSupply();
+    vars.borrowCap = cachedData.reserveConfiguration.getBorrowCapMemory();
-    vars.borrowCap = reserveConfiguration.getBorrowCapMemory();
-    vars.totalSupplyVariableDebt = IERC20(reserve.variableDebtTokenAddress).totalSupply();
 
-    require(
+    if (vars.borrowCap > 0) {
-      vars.borrowCap == 0 ||
+      {
-        vars.totalSupplyStableDebt.add(vars.totalSupplyVariableDebt).add(amount).div(
+        vars.totalSupplyVariableDebt = cachedData.oldScaledVariableDebt.rayMul(
-          10**vars.reserveDecimals
+          cachedData.newVariableBorrowIndex
-        ) <
+        );
-        vars.borrowCap,
+
-      Errors.VL_BORROW_CAP_EXCEEDED
+        vars.totalDebt = cachedData.oldTotalStableDebt.add(vars.totalSupplyVariableDebt).add(
-    );
+          amount
+        );
+        require(
+          vars.totalDebt.div(10**vars.reserveDecimals) < vars.borrowCap,
+          Errors.VL_BORROW_CAP_EXCEEDED
+        );
+      }
+    }
 
     (
       vars.userCollateralBalanceETH,
@@ -187,8 +200,11 @@ library ValidationLogic {
       Errors.VL_HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD
     );
 
+    vars.amountInETH = IPriceOracleGetter(oracle).getAssetPrice(asset);
+    vars.amountInETH = vars.amountInETH.mul(amount).div(10**vars.reserveDecimals);
+
     //add the current already borrowed amount to the amount requested to calculate the total collateral needed.
-    vars.amountOfCollateralNeededETH = vars.userBorrowBalanceETH.add(amountInETH).percentDiv(
+    vars.amountOfCollateralNeededETH = vars.userBorrowBalanceETH.add(vars.amountInETH).percentDiv(
       vars.currentLtv
     ); //LTV is calculated in percentage
 
@@ -211,13 +227,13 @@ library ValidationLogic {
       require(vars.stableRateBorrowingEnabled, Errors.VL_STABLE_BORROWING_NOT_ENABLED);
 
       require(
-        !userConfig.isUsingAsCollateral(reserve.id) ||
+        !userConfig.isUsingAsCollateral(reservesData[asset].id) ||
-          reserve.configuration.getLtv() == 0 ||
+          cachedData.reserveConfiguration.getLtvMemory() == 0 ||
-          amount > IERC20(reserve.aTokenAddress).balanceOf(userAddress),
+          amount > IERC20(cachedData.aTokenAddress).balanceOf(userAddress),
         Errors.VL_COLLATERAL_SAME_AS_BORROWING_CURRENCY
       );
 
-      vars.availableLiquidity = IERC20(asset).balanceOf(reserve.aTokenAddress);
+      vars.availableLiquidity = IERC20(asset).balanceOf(cachedData.aTokenAddress);
 
       //calculate the max available loan size in stable rate mode as a percentage of the
       //available liquidity