Stable rate borrowing

contracts/BaseJumpRateModelV2.sol

@@ -4,7 +4,7 @@ pragma solidity 0.8.13;
 import { IAccessControlManagerV8 } from "@venusprotocol/governance-contracts/contracts/Governance/IAccessControlManagerV8.sol";
 
 import { InterestRateModel } from "./InterestRateModel.sol";
-import { BLOCKS_PER_YEAR, EXP_SCALE, MANTISSA_ONE } from "./lib/constants.sol";
+import { BLOCKS_PER_YEAR, EXP_SCALE } from "./lib/constants.sol";
 
 /**
  * @title Logic for Compound's JumpRateModel Contract V2.
@@ -97,58 +97,6 @@ abstract contract BaseJumpRateModelV2 is InterestRateModel {
         _updateJumpRateModel(baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink_);
     }
 
-    /**
-     * @notice Calculates the current supply rate per block
-     * @param cash The amount of cash in the market
-     * @param borrows The amount of borrows in the market
-     * @param reserves The amount of reserves in the market
-     * @param reserveFactorMantissa The current reserve factor for the market
-     * @param badDebt The amount of badDebt in the market
-     * @return The supply rate percentage per block as a mantissa (scaled by EXP_SCALE)
-     */
-    function getSupplyRate(
-        uint256 cash,
-        uint256 borrows,
-        uint256 reserves,
-        uint256 reserveFactorMantissa,
-        uint256 badDebt
-    ) public view virtual override returns (uint256) {
-        uint256 oneMinusReserveFactor = MANTISSA_ONE - reserveFactorMantissa;
-        uint256 borrowRate = _getBorrowRate(cash, borrows, reserves, badDebt);
-        uint256 rateToPool = (borrowRate * oneMinusReserveFactor) / EXP_SCALE;
-        uint256 incomeToDistribute = borrows * rateToPool;
-        uint256 supply = cash + borrows + badDebt - reserves;
-        return incomeToDistribute / supply;
-    }
-
-    /**
-     * @notice Calculates the utilization rate of the market: `(borrows + badDebt) / (cash + borrows + badDebt - reserves)`
-     * @param cash The amount of cash in the market
-     * @param borrows The amount of borrows in the market
-     * @param reserves The amount of reserves in the market (currently unused)
-     * @param badDebt The amount of badDebt in the market
-     * @return The utilization rate as a mantissa between [0, MANTISSA_ONE]
-     */
-    function utilizationRate(
-        uint256 cash,
-        uint256 borrows,
-        uint256 reserves,
-        uint256 badDebt
-    ) public pure returns (uint256) {
-        // Utilization rate is 0 when there are no borrows and badDebt
-        if ((borrows + badDebt) == 0) {
-            return 0;
-        }
-
-        uint256 rate = ((borrows + badDebt) * EXP_SCALE) / (cash + borrows + badDebt - reserves);
-
-        if (rate > EXP_SCALE) {
-            rate = EXP_SCALE;
-        }
-
-        return rate;
-    }
-
     /**
      * @notice Internal function to update the parameters of the interest rate model
      * @param baseRatePerYear The approximate target base APR, as a mantissa (scaled by EXP_SCALE)
@@ -172,29 +120,19 @@ abstract contract BaseJumpRateModelV2 is InterestRateModel {
 
     /**
      * @notice Calculates the current borrow rate per block, with the error code expected by the market
-     * @param cash The amount of cash in the market
-     * @param borrows The amount of borrows in the market
-     * @param reserves The amount of reserves in the market
-     * @param badDebt The amount of badDebt in the market
-     * @return The borrow rate percentage per block as a mantissa (scaled by EXP_SCALE)
+     * @param utRate The utilization rate per total borrows and cash available
+     * @return The borrow rate percentage per block as a mantissa (scaled by BASE)
      */
-    function _getBorrowRate(
-        uint256 cash,
-        uint256 borrows,
-        uint256 reserves,
-        uint256 badDebt
-    ) internal view returns (uint256) {
-        uint256 util = utilizationRate(cash, borrows, reserves, badDebt);
-        uint256 kink_ = kink;
-
-        if (util <= kink_) {
-            return ((util * multiplierPerBlock) / EXP_SCALE) + baseRatePerBlock;
-        }
-        uint256 normalRate = ((kink_ * multiplierPerBlock) / EXP_SCALE) + baseRatePerBlock;
-        uint256 excessUtil;
-        unchecked {
-            excessUtil = util - kink_;
+    function _getBorrowRate(uint256 utRate) internal view returns (uint256) {
+        if (utRate <= kink) {
+            return ((utRate * multiplierPerBlock) / EXP_SCALE) + baseRatePerBlock;
+        } else {
+            uint256 normalRate = ((kink * multiplierPerBlock) / EXP_SCALE) + baseRatePerBlock;
+            uint256 excessUtil;
+            unchecked {
+                excessUtil = utRate - kink;
+            }
+            return ((excessUtil * jumpMultiplierPerBlock) / EXP_SCALE) + normalRate;
         }
-        return ((excessUtil * jumpMultiplierPerBlock) / EXP_SCALE) + normalRate;
     }
 }

contracts/Comptroller.sol

@@ -983,6 +983,10 @@ contract Comptroller is
         _setMaxLoopsLimit(limit);
     }
 
+    function preSwapBorrowRateModeHook(address vToken) external view override {
+        _checkActionPauseState(vToken, Action.SWAP_RATE_MODE);
+    }
+
     /**
      * @notice Determine the current account liquidity with respect to liquidation threshold requirements
      * @dev The interface of this function is intentionally kept compatible with Compound and Venus Core

contracts/ComptrollerInterface.sol

@@ -45,6 +45,8 @@ interface ComptrollerInterface {
 
     function preTransferHook(address vToken, address src, address dst, uint256 transferTokens) external;
 
+    function preSwapBorrowRateModeHook(address vToken) external;
+
     function isComptroller() external view returns (bool);
 
     /*** Liquidity/Liquidation Calculations ***/

contracts/ComptrollerStorage.sol

@@ -57,7 +57,8 @@ contract ComptrollerStorage {
         LIQUIDATE,
         TRANSFER,
         ENTER_MARKET,
-        EXIT_MARKET
+        EXIT_MARKET,
+        SWAP_RATE_MODE
     }
 
     /**

contracts/ErrorReporter.sol

@@ -33,6 +33,8 @@ contract TokenErrorReporter {
 
     error LiquidateSeizeLiquidatorIsBorrower();
 
+    error SetComptrollerOwnerCheck();
+
     error ProtocolSeizeShareTooBig();
 
     error SetReserveFactorFreshCheck();
@@ -45,4 +47,8 @@ contract TokenErrorReporter {
     error ReduceReservesCashValidation();
 
     error SetInterestRateModelFreshCheck();
+    error SetStableInterestRateModelFreshCheck();
+
+    error SwapBorrowRateModeFreshnessCheck();
+    error SetRebalanceUtilizationRateThresholdAdminCheck();
 }

contracts/InterestRate/StableRateModel.sol

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+/**
+ * @title Logic for Venus stable rate.
+ */
+contract StableRateModel {
+    uint256 private constant BASE = 1e18;
+
+    /// @notice The approximate number of blocks per year that is assumed by the interest rate model
+    uint256 public constant BLOCK_PER_YEAR = 2102400;
+
+    /// @notice The stable base interest rate which is the y-intercept when utilization rate is 0(also known by base_premium)
+    uint256 public baseRatePerBlock;
+
+    /// @notice The premium rate applicable on optimal stable loan rate(also known by stable_rate_slope)
+    uint256 public stableRatePremium;
+
+    /// @notice The factor to be applied to the stable rate premium before adding to the interest rate
+    uint256 public optimalStableLoanRatio;
+
+    /// @notice The address of the owner, i.e. the Timelock contract, which can update parameters directly
+    address public owner;
+
+    event NewStableInterestParams(uint256 baseRatePerBlock, uint256 stableRatePremium, uint256 optimalStableLoanRatio);
+
+    /**
+     * @param baseRatePerYear_ The approximate target base APR, as a mantissa (scaled by BASE)
+     * @param stableRatePremium_ The multiplierPerBlock after hitting a specified utilization point
+     * @param optimalStableLoanRatio_ Optimal stable loan rate percentage.
+     * @param owner_ Address of the owner for this model(Governance)
+     */
+    constructor(uint256 baseRatePerYear_, uint256 stableRatePremium_, uint256 optimalStableLoanRatio_, address owner_) {
+        owner = owner_;
+
+        updateStableRateModelInternal(baseRatePerYear_, stableRatePremium_, optimalStableLoanRatio_);
+    }
+
+    /**
+     * @notice Updates the parameters of the interest rate model (only callable by owner, i.e. Timelock)
+     * @param baseRatePerYear_ The approximate target base APR, as a mantissa (scaled by BASE)
+     * @param stableRatePremium_ The multiplierPerBlock after hitting a specified utilization point
+     * @param optimalStableLoanRatio_ Optimal stable loan rate percentage.
+     * @custom:events Emits NewStableInterestParams, after updating the parameters
+     * @custom:access Only governance
+     */
+    function updateStableRateModel(
+        uint256 baseRatePerYear_,
+        uint256 stableRatePremium_,
+        uint256 optimalStableLoanRatio_
+    ) external virtual {
+        require(msg.sender == owner, "StableRateModel: only owner may call this function.");
+
+        updateStableRateModelInternal(baseRatePerYear_, stableRatePremium_, optimalStableLoanRatio_);
+    }
+
+    /**
+     * @notice Calculates the current borrow rate per block, with the error code expected by the market
+     * @param stableBorrows The amount of stable borrows in the market
+     * @param totalBorrows The amount of borrows in the market
+     * @param variableBorrowRate Current variable borrow rate per block of the protocol
+     * @return The borrow rate percentage per block as a mantissa (scaled by BASE)
+     */
+    function getBorrowRate(
+        uint256 stableBorrows,
+        uint256 totalBorrows,
+        uint256 variableBorrowRate
+    ) external view returns (uint256) {
+        uint256 loanRatio = stableLoanRatio(stableBorrows, totalBorrows);
+        uint256 excessLoanRatio = calculateLoanRatioDiff(loanRatio);
+
+        return (variableBorrowRate + baseRatePerBlock + ((stableRatePremium * excessLoanRatio) / BASE));
+    }
+
+    /**
+     * @notice Indicator that this is an InterestRateModel contract (for inspection)
+     * @return Always true
+     */
+    function isStableRateModel() external pure virtual returns (bool) {
+        return true;
+    }
+
+    /**
+     * @notice Calculates the ratio of the stable borrows to total borrows
+     * @param stableBorrows The amount of stable borrows in the market
+     * @param totalBorrows The amount of total borrows in the market
+     * @return The stable loan rate as a mantissa between [0, BASE]
+     */
+    function stableLoanRatio(uint256 stableBorrows, uint256 totalBorrows) public pure returns (uint256) {
+        // Loan ratio is 0 when there are no stable borrows
+        if (totalBorrows == 0) {
+            return 0;
+        }
+
+        return (stableBorrows * BASE) / totalBorrows;
+    }
+
+    /**
+     * @notice Internal function to update the parameters of the interest rate model
+     * @param baseRatePerYear_ The approximate target base APR, as a mantissa (scaled by BASE)
+     * @param stableRatePremium_ The multiplierPerBlock after hitting a specified utilization point
+     * @param optimalStableLoanRatio_ Optimal stable loan rate percentage.
+     */
+    function updateStableRateModelInternal(
+        uint256 baseRatePerYear_,
+        uint256 stableRatePremium_,
+        uint256 optimalStableLoanRatio_
+    ) internal {
+        baseRatePerBlock = baseRatePerYear_ / BLOCK_PER_YEAR;
+        stableRatePremium = stableRatePremium_;
+        optimalStableLoanRatio = optimalStableLoanRatio_;
+
+        emit NewStableInterestParams(baseRatePerBlock, stableRatePremium, optimalStableLoanRatio);
+    }
+
+    /**
+     * @notice Calculates the difference of stableLoanRatio and the optimalStableLoanRatio
+     * @param loanRatio Stable loan ratio for stable borrows in the market
+     * @return The difference between the stableLoanRatio and optimal loan rate as a mantissa between [0, BASE]
+     */
+    function calculateLoanRatioDiff(uint256 loanRatio) internal view returns (uint256) {
+        if (loanRatio == 0 || optimalStableLoanRatio > loanRatio) {
+            return 0;
+        }
+
+        return (loanRatio - optimalStableLoanRatio);
+    }
+}

contracts/InterestRateModel.sol

@@ -8,35 +8,10 @@ pragma solidity 0.8.13;
 abstract contract InterestRateModel {
     /**
      * @notice Calculates the current borrow interest rate per block
-     * @param cash The total amount of cash the market has
-     * @param borrows The total amount of borrows the market has outstanding
-     * @param reserves The total amount of reserves the market has
-     * @param badDebt The amount of badDebt in the market
+     * @param utilizationRate The utilization rate per total borrows and cash available
      * @return The borrow rate per block (as a percentage, and scaled by 1e18)
      */
-    function getBorrowRate(
-        uint256 cash,
-        uint256 borrows,
-        uint256 reserves,
-        uint256 badDebt
-    ) external view virtual returns (uint256);
-
-    /**
-     * @notice Calculates the current supply interest rate per block
-     * @param cash The total amount of cash the market has
-     * @param borrows The total amount of borrows the market has outstanding
-     * @param reserves The total amount of reserves the market has
-     * @param reserveFactorMantissa The current reserve factor the market has
-     * @param badDebt The amount of badDebt in the market
-     * @return The supply rate per block (as a percentage, and scaled by 1e18)
-     */
-    function getSupplyRate(
-        uint256 cash,
-        uint256 borrows,
-        uint256 reserves,
-        uint256 reserveFactorMantissa,
-        uint256 badDebt
-    ) external view virtual returns (uint256);
+    function getBorrowRate(uint256 utilizationRate) external view virtual returns (uint256);
 
     /**
      * @notice Indicator that this is an InterestRateModel contract (for inspection)

contracts/JumpRateModelV2.sol

@@ -26,18 +26,10 @@ contract JumpRateModelV2 is BaseJumpRateModelV2 {
 
     /**
      * @notice Calculates the current borrow rate per block
-     * @param cash The amount of cash in the market
-     * @param borrows The amount of borrows in the market
-     * @param reserves The amount of reserves in the market
-     * @param badDebt The amount of badDebt in the market
+     * @param utilizationRate The utilization rate per total borrows and cash available
      * @return The borrow rate percentage per block as a mantissa (scaled by 1e18)
      */
-    function getBorrowRate(
-        uint256 cash,
-        uint256 borrows,
-        uint256 reserves,
-        uint256 badDebt
-    ) external view override returns (uint256) {
-        return _getBorrowRate(cash, borrows, reserves, badDebt);
+    function getBorrowRate(uint256 utilizationRate) external view override returns (uint256) {
+        return _getBorrowRate(utilizationRate);
     }
 }

contracts/Lens/PoolLens.sol

@@ -53,6 +53,7 @@ contract PoolLens is ExponentialNoError {
         uint256 exchangeRateCurrent;
         uint256 supplyRatePerBlock;
         uint256 borrowRatePerBlock;
+        uint256 stableBorrowRatePerBlock;
         uint256 reserveFactorMantissa;
         uint256 supplyCaps;
         uint256 borrowCaps;
@@ -386,6 +387,7 @@ contract PoolLens is ExponentialNoError {
                 exchangeRateCurrent: exchangeRateCurrent,
                 supplyRatePerBlock: vToken.supplyRatePerBlock(),
                 borrowRatePerBlock: vToken.borrowRatePerBlock(),
+                stableBorrowRatePerBlock: vToken.stableBorrowRatePerBlock(),
                 reserveFactorMantissa: vToken.reserveFactorMantissa(),
                 supplyCaps: comptroller.supplyCaps(address(vToken)),
                 borrowCaps: comptroller.borrowCaps(address(vToken)),