Fixed DefaultReserveInterestRateStrategy

contracts/lendingpool/DefaultReserveInterestRateStrategy.sol

@@ -35,34 +35,34 @@ contract DefaultReserveInterestRateStrategy is IReserveInterestRateStrategy {
   LendingPoolAddressesProvider public immutable addressesProvider;
 
   //base variable borrow rate when Utilization rate = 0. Expressed in ray
-  uint256 internal immutable baseVariableBorrowRate;
+  uint256 internal immutable _baseVariableBorrowRate;
 
   //slope of the variable interest curve when utilization rate > 0 and <= OPTIMAL_UTILIZATION_RATE. Expressed in ray
-  uint256 internal immutable variableRateSlope1;
+  uint256 internal immutable _variableRateSlope1;
 
   //slope of the variable interest curve when utilization rate > OPTIMAL_UTILIZATION_RATE. Expressed in ray
-  uint256 internal immutable variableRateSlope2;
+  uint256 internal immutable _variableRateSlope2;
 
   //slope of the stable interest curve when utilization rate > 0 and <= OPTIMAL_UTILIZATION_RATE. Expressed in ray
-  uint256 internal immutable stableRateSlope1;
+  uint256 internal immutable _stableRateSlope1;
 
   //slope of the stable interest curve when utilization rate > OPTIMAL_UTILIZATION_RATE. Expressed in ray
-  uint256 internal immutable stableRateSlope2;
+  uint256 internal immutable _stableRateSlope2;
 
   constructor(
-    LendingPoolAddressesProvider _provider,
-    uint256 _baseVariableBorrowRate,
-    uint256 _variableRateSlope1,
-    uint256 _variableRateSlope2,
-    uint256 _stableRateSlope1,
-    uint256 _stableRateSlope2
+    LendingPoolAddressesProvider provider,
+    uint256 baseVariableBorrowRate,
+    uint256 variableRateSlope1,
+    uint256 variableRateSlope2,
+    uint256 stableRateSlope1,
+    uint256 stableRateSlope2
   ) public {
-    addressesProvider = _provider;
-    baseVariableBorrowRate = _baseVariableBorrowRate;
-    variableRateSlope1 = _variableRateSlope1;
-    variableRateSlope2 = _variableRateSlope2;
-    stableRateSlope1 = _stableRateSlope1;
-    stableRateSlope2 = _stableRateSlope2;
+    addressesProvider = provider;
+    _baseVariableBorrowRate = baseVariableBorrowRate;
+    _variableRateSlope1 = variableRateSlope1;
+    _variableRateSlope2 = variableRateSlope2;
+    _stableRateSlope1 = stableRateSlope1;
+    _stableRateSlope2 = stableRateSlope2;
   }
 
   /**
@@ -70,115 +70,122 @@ contract DefaultReserveInterestRateStrategy is IReserveInterestRateStrategy {
    */
 
   function getVariableRateSlope1() external view returns (uint256) {
-    return variableRateSlope1;
+    return _variableRateSlope1;
   }
 
   function getVariableRateSlope2() external view returns (uint256) {
-    return variableRateSlope2;
+    return _variableRateSlope2;
   }
 
   function getStableRateSlope1() external view returns (uint256) {
-    return stableRateSlope1;
+    return _stableRateSlope1;
   }
 
   function getStableRateSlope2() external view returns (uint256) {
-    return stableRateSlope2;
+    return _stableRateSlope2;
   }
 
   function getBaseVariableBorrowRate() external override view returns (uint256) {
-    return baseVariableBorrowRate;
+    return _baseVariableBorrowRate;
   }
 
   /**
    * @dev calculates the interest rates depending on the available liquidity and the total borrowed.
-   * @param _reserve the address of the reserve
-   * @param _availableLiquidity the liquidity available in the reserve
-   * @param _totalBorrowsStable the total borrowed from the reserve a stable rate
-   * @param _totalBorrowsVariable the total borrowed from the reserve at a variable rate
-   * @param _averageStableBorrowRate the weighted average of all the stable rate borrows
+   * @param reserve the address of the reserve
+   * @param availableLiquidity the liquidity available in the reserve
+   * @param totalBorrowsStable the total borrowed from the reserve a stable rate
+   * @param totalBorrowsVariable the total borrowed from the reserve at a variable rate
+   * @param averageStableBorrowRate the weighted average of all the stable rate borrows
    * @return currentLiquidityRate the liquidity rate
    * @return currentStableBorrowRate stable borrow rate
    * @return currentVariableBorrowRate variable borrow rate
    **/
   function calculateInterestRates(
-    address _reserve,
-    uint256 _availableLiquidity,
-    uint256 _totalBorrowsStable,
-    uint256 _totalBorrowsVariable,
-    uint256 _averageStableBorrowRate
+    address reserve,
+    uint256 availableLiquidity,
+    uint256 totalBorrowsStable,
+    uint256 totalBorrowsVariable,
+    uint256 averageStableBorrowRate
   )
     external
     override
     view
     returns (
-      uint256 currentLiquidityRate,
-      uint256 currentStableBorrowRate,
-      uint256 currentVariableBorrowRate
+      uint256,
+      uint256,
+      uint256
     )
   {
-    uint256 totalBorrows = _totalBorrowsStable.add(_totalBorrowsVariable);
+    uint256 totalBorrows = totalBorrowsStable.add(totalBorrowsVariable);
+    uint256 currentVariableBorrowRate = 0;
+    uint256 currentStableBorrowRate = 0;
+    uint256 currentLiquidityRate = 0;
 
-    uint256 utilizationRate = (totalBorrows == 0 && _availableLiquidity == 0)
+    uint256 utilizationRate = (totalBorrows == 0 && availableLiquidity == 0)
       ? 0
-      : totalBorrows.rayDiv(_availableLiquidity.add(totalBorrows));
+      : totalBorrows.rayDiv(availableLiquidity.add(totalBorrows));
 
     currentStableBorrowRate = ILendingRateOracle(addressesProvider.getLendingRateOracle())
-      .getMarketBorrowRate(_reserve);
+      .getMarketBorrowRate(reserve);
 
     if (utilizationRate > OPTIMAL_UTILIZATION_RATE) {
       uint256 excessUtilizationRateRatio = utilizationRate.sub(OPTIMAL_UTILIZATION_RATE).rayDiv(
         EXCESS_UTILIZATION_RATE
       );
 
-      currentStableBorrowRate = currentStableBorrowRate.add(stableRateSlope1).add(
-        stableRateSlope2.rayMul(excessUtilizationRateRatio)
+      currentStableBorrowRate = currentStableBorrowRate.add(_stableRateSlope1).add(
+        _stableRateSlope2.rayMul(excessUtilizationRateRatio)
       );
 
-      currentVariableBorrowRate = baseVariableBorrowRate.add(variableRateSlope1).add(
-        variableRateSlope2.rayMul(excessUtilizationRateRatio)
+      currentVariableBorrowRate = _baseVariableBorrowRate.add(_variableRateSlope1).add(
+        _variableRateSlope2.rayMul(excessUtilizationRateRatio)
       );
     } else {
       currentStableBorrowRate = currentStableBorrowRate.add(
-        stableRateSlope1.rayMul(utilizationRate.rayDiv(OPTIMAL_UTILIZATION_RATE))
+        _stableRateSlope1.rayMul(utilizationRate.rayDiv(OPTIMAL_UTILIZATION_RATE))
       );
-      currentVariableBorrowRate = baseVariableBorrowRate.add(
-        utilizationRate.rayDiv(OPTIMAL_UTILIZATION_RATE).rayMul(variableRateSlope1)
+      currentVariableBorrowRate = _baseVariableBorrowRate.add(
+        utilizationRate.rayDiv(OPTIMAL_UTILIZATION_RATE).rayMul(_variableRateSlope1)
       );
     }
 
     currentLiquidityRate = getOverallBorrowRateInternal(
-      _totalBorrowsStable,
-      _totalBorrowsVariable,
+      totalBorrowsStable,
+      totalBorrowsVariable,
       currentVariableBorrowRate,
-      _averageStableBorrowRate
+      averageStableBorrowRate
     )
       .rayMul(utilizationRate);
+
+    return (currentLiquidityRate,
+      currentStableBorrowRate,
+      currentVariableBorrowRate);
   }
 
   /**
    * @dev calculates the overall borrow rate as the weighted average between the total variable borrows and total stable borrows.
-   * @param _totalBorrowsStable the total borrowed from the reserve a stable rate
-   * @param _totalBorrowsVariable the total borrowed from the reserve at a variable rate
-   * @param _currentVariableBorrowRate the current variable borrow rate
-   * @param _currentAverageStableBorrowRate the weighted average of all the stable rate borrows
+   * @param totalBorrowsStable the total borrowed from the reserve a stable rate
+   * @param totalBorrowsVariable the total borrowed from the reserve at a variable rate
+   * @param currentVariableBorrowRate the current variable borrow rate
+   * @param currentAverageStableBorrowRate the weighted average of all the stable rate borrows
    * @return the weighted averaged borrow rate
    **/
   function getOverallBorrowRateInternal(
-    uint256 _totalBorrowsStable,
-    uint256 _totalBorrowsVariable,
-    uint256 _currentVariableBorrowRate,
-    uint256 _currentAverageStableBorrowRate
+    uint256 totalBorrowsStable,
+    uint256 totalBorrowsVariable,
+    uint256 currentVariableBorrowRate,
+    uint256 currentAverageStableBorrowRate
   ) internal pure returns (uint256) {
-    uint256 totalBorrows = _totalBorrowsStable.add(_totalBorrowsVariable);
+    uint256 totalBorrows = totalBorrowsStable.add(totalBorrowsVariable);
 
     if (totalBorrows == 0) return 0;
 
-    uint256 weightedVariableRate = _totalBorrowsVariable.wadToRay().rayMul(
-      _currentVariableBorrowRate
+    uint256 weightedVariableRate = totalBorrowsVariable.wadToRay().rayMul(
+      currentVariableBorrowRate
     );
 
-    uint256 weightedStableRate = _totalBorrowsStable.wadToRay().rayMul(
-      _currentAverageStableBorrowRate
+    uint256 weightedStableRate = totalBorrowsStable.wadToRay().rayMul(
+      currentAverageStableBorrowRate
     );
 
     uint256 overallBorrowRate = weightedVariableRate.add(weightedStableRate).rayDiv(