feat: Add liquidatable flag to collateral reserve in Spoke (#1042)

Author: miguelmtzinf

snapshots/Spoke.Operations.ZeroRiskPremium.json

@@ -1,10 +1,10 @@
 {
   "borrow: first": "191060",
   "borrow: second action, same reserve": "171032",
-  "liquidationCall (receiveShares): full": "299685",
-  "liquidationCall (receiveShares): partial": "299403",
-  "liquidationCall: full": "309785",
-  "liquidationCall: partial": "309503",
+  "liquidationCall (receiveShares): full": "299717",
+  "liquidationCall (receiveShares): partial": "299435",
+  "liquidationCall: full": "309817",
+  "liquidationCall: partial": "309535",
   "permitReserve + repay (multicall)": "165645",
   "permitReserve + supply (multicall)": "146478",
   "permitReserve + supply + enable collateral (multicall)": "160189",

snapshots/Spoke.Operations.json

@@ -1,10 +1,10 @@
 {
   "borrow: first": "261456",
   "borrow: second action, same reserve": "204428",
-  "liquidationCall (receiveShares): full": "333248",
-  "liquidationCall (receiveShares): partial": "332966",
-  "liquidationCall: full": "343348",
-  "liquidationCall: partial": "343066",
+  "liquidationCall (receiveShares): full": "333280",
+  "liquidationCall (receiveShares): partial": "332998",
+  "liquidationCall: full": "343380",
+  "liquidationCall: partial": "343098",
   "permitReserve + repay (multicall)": "162966",
   "permitReserve + supply (multicall)": "146478",
   "permitReserve + supply + enable collateral (multicall)": "160189",

src/spoke/Spoke.sol

@@ -154,6 +154,7 @@ abstract contract Spoke is ISpoke, Multicall, NoncesKeyed, AccessManagedUpgradea
         initPaused: config.paused,
         initFrozen: config.frozen,
         initBorrowable: config.borrowable,
+        initLiquidatable: config.liquidatable,
         initReceiveSharesEnabled: config.receiveSharesEnabled
       })
     });
@@ -179,6 +180,7 @@ abstract contract Spoke is ISpoke, Multicall, NoncesKeyed, AccessManagedUpgradea
       initPaused: config.paused,
       initFrozen: config.frozen,
       initBorrowable: config.borrowable,
+      initLiquidatable: config.liquidatable,
       initReceiveSharesEnabled: config.receiveSharesEnabled
     });
     emit UpdateReserveConfig(reserveId, config);
@@ -550,6 +552,7 @@ abstract contract Spoke is ISpoke, Multicall, NoncesKeyed, AccessManagedUpgradea
         paused: reserve.flags.paused(),
         frozen: reserve.flags.frozen(),
         borrowable: reserve.flags.borrowable(),
+        liquidatable: reserve.flags.liquidatable(),
         receiveSharesEnabled: reserve.flags.receiveSharesEnabled()
       });
   }

src/spoke/SpokeConfigurator.sol

@@ -116,6 +116,18 @@ contract SpokeConfigurator is Ownable2Step, ISpokeConfigurator {
     targetSpoke.updateReserveConfig(reserveId, reserveConfig);
   }
 
+  /// @inheritdoc ISpokeConfigurator
+  function updateLiquidatable(
+    address spoke,
+    uint256 reserveId,
+    bool liquidatable
+  ) external onlyOwner {
+    ISpoke targetSpoke = ISpoke(spoke);
+    ISpoke.ReserveConfig memory reserveConfig = targetSpoke.getReserveConfig(reserveId);
+    reserveConfig.liquidatable = liquidatable;
+    targetSpoke.updateReserveConfig(reserveId, reserveConfig);
+  }
+
   /// @inheritdoc ISpokeConfigurator
   function updateReceiveSharesEnabled(
     address spoke,

src/spoke/interfaces/ISpoke.sol

@@ -38,12 +38,14 @@ interface ISpoke is ISpokeBase, IMulticall, INoncesKeyed, IAccessManaged {
   /// @dev paused True if all actions are prevented for the reserve.
   /// @dev frozen True if new activity is prevented for the reserve.
   /// @dev borrowable True if the reserve is borrowable.
+  /// @dev liquidatable True if the reserve can be liquidated when used as collateral.
   /// @dev receiveSharesEnabled True if the liquidator can receive collateral shares during liquidation.
   struct ReserveConfig {
     uint24 collateralRisk;
     bool paused;
     bool frozen;
     bool borrowable;
+    bool liquidatable;
     bool receiveSharesEnabled;
   }
 
@@ -244,11 +246,14 @@ interface ISpoke is ISpokeBase, IMulticall, INoncesKeyed, IAccessManaged {
   /// @dev Can only occur during an attempted `supply`, `borrow`, or `setUsingAsCollateral` action.
   error ReserveFrozen();
 
+  /// @notice Thrown when the collateral reserve is not enabled to be liquidated.
+  error CollateralCannotBeLiquidated();
+
   /// @notice Thrown when an action causes a user's health factor to fall below the liquidation threshold.
   error HealthFactorBelowThreshold();
 
-  /// @notice Thrown when collateral cannot be liquidated.
-  error CollateralCannotBeLiquidated();
+  /// @notice Thrown when reserve is not enabled as collateral during liquidation.
+  error ReserveNotEnabledAsCollateral();
 
   /// @notice Thrown when a specified reserve is not supplied by the user during liquidation.
   error ReserveNotSupplied();

src/spoke/interfaces/ISpokeConfigurator.sol

@@ -91,6 +91,12 @@ interface ISpokeConfigurator {
   /// @param borrowable The new borrowable flag.
   function updateBorrowable(address spoke, uint256 reserveId, bool borrowable) external;
 
+  /// @notice Updates the liquidatable flag of a reserve.
+  /// @param spoke The address of the spoke.
+  /// @param reserveId The identifier of the reserve.
+  /// @param liquidatable The new liquidatable flag.
+  function updateLiquidatable(address spoke, uint256 reserveId, bool liquidatable) external;
+
   /// @notice Updates whether receiving shares on liquidation is enabled.
   /// @param spoke The address of the spoke.
   /// @param reserveId The identifier of the reserve.

src/spoke/libraries/LiquidationLogic.sol

@@ -359,13 +359,14 @@ library LiquidationLogic {
     );
     require(params.collateralReserveBalance > 0, ISpoke.ReserveNotSupplied());
     require(params.debtReserveBalance > 0, ISpoke.ReserveNotBorrowed());
+    require(params.collateralReserveFlags.liquidatable(), ISpoke.CollateralCannotBeLiquidated());
     require(
       params.healthFactor < HEALTH_FACTOR_LIQUIDATION_THRESHOLD,
       ISpoke.HealthFactorNotBelowThreshold()
     );
     require(
       params.collateralFactor > 0 && params.isUsingAsCollateral,
-      ISpoke.CollateralCannotBeLiquidated()
+      ISpoke.ReserveNotEnabledAsCollateral()
     );
     if (params.receiveShares) {
       require(

src/spoke/libraries/ReserveFlagsMap.sol

@@ -14,25 +14,30 @@ library ReserveFlagsMap {
   uint8 internal constant FROZEN_MASK = 0x02;
   /// @dev Mask for the `borrowable` flag.
   uint8 internal constant BORROWABLE_MASK = 0x04;
+  /// @dev Mask for the `liquidatable` flag.
+  uint8 internal constant LIQUIDATABLE_MASK = 0x08;
   /// @dev Mask for the `receiveSharesEnabled` flag.
-  uint8 internal constant RECEIVE_SHARES_ENABLED_MASK = 0x08;
+  uint8 internal constant RECEIVE_SHARES_ENABLED_MASK = 0x10;
 
   /// @notice Initializes the ReserveFlags with the given values.
   /// @param initPaused The initial `paused` flag status.
   /// @param initFrozen The initial `frozen` flag status.
   /// @param initBorrowable The initial `borrowable` flag status.
+  /// @param initLiquidatable The initial `liquidatable` flag status.
   /// @param initReceiveSharesEnabled The initial `receiveSharesEnabled` flag status.
   /// @return The initialized ReserveFlags.
   function create(
     bool initPaused,
     bool initFrozen,
     bool initBorrowable,
+    bool initLiquidatable,
     bool initReceiveSharesEnabled
   ) internal pure returns (ReserveFlags) {
     uint8 flags = 0;
     flags = _setStatus(flags, PAUSED_MASK, initPaused);
     flags = _setStatus(flags, FROZEN_MASK, initFrozen);
     flags = _setStatus(flags, BORROWABLE_MASK, initBorrowable);
+    flags = _setStatus(flags, LIQUIDATABLE_MASK, initLiquidatable);
     flags = _setStatus(flags, RECEIVE_SHARES_ENABLED_MASK, initReceiveSharesEnabled);
     return ReserveFlags.wrap(flags);
   }
@@ -61,6 +66,14 @@ library ReserveFlagsMap {
     return ReserveFlags.wrap(_setStatus(ReserveFlags.unwrap(flags), BORROWABLE_MASK, status));
   }
 
+  /// @notice Sets the new status for the `liquidatable` flag.
+  /// @param flags The current ReserveFlags.
+  /// @param status The new status for the `liquidatable` flag.
+  /// @return The updated ReserveFlags.
+  function setLiquidatable(ReserveFlags flags, bool status) internal pure returns (ReserveFlags) {
+    return ReserveFlags.wrap(_setStatus(ReserveFlags.unwrap(flags), LIQUIDATABLE_MASK, status));
+  }
+
   /// @notice Sets the new status for the `receiveSharesEnabled` flag.
   /// @param flags The current ReserveFlags.
   /// @param status The new status for the `receiveSharesEnabled` flag.
@@ -96,6 +109,13 @@ library ReserveFlagsMap {
     return (ReserveFlags.unwrap(flags) & BORROWABLE_MASK) != 0;
   }
 
+  /// @notice Returns the `liquidatable` flag status.
+  /// @param flags The current ReserveFlags.
+  /// @return True if the flag is set.
+  function liquidatable(ReserveFlags flags) internal pure returns (bool) {
+    return (ReserveFlags.unwrap(flags) & LIQUIDATABLE_MASK) != 0;
+  }
+
   /// @notice Returns the `receiveSharesEnabled` flag status.
   /// @param flags The current ReserveFlags.
   /// @return True if the flag is set.