feat: make update user rp reserveId agnostic (#404)

* feat: make update user rp reserveId agnostic

* fix: rm hf check on updateUserRiskPremium

* feat: use custom multicall

* fix: natspec

* fix: correct revert cond

* test: begin user rp tests

* chore: comment

* feat: emit reserve config on addReserve, fix test name

Author: DhairyaSethi

snapshots/Spoke.Getters.json

@@ -1,7 +1,7 @@
 {
-  "getUserAccountData: supplies: 0, borrows: 0": "23895",
-  "getUserAccountData: supplies: 1, borrows: 0": "73141",
-  "getUserAccountData: supplies: 2, borrows: 0": "117432",
-  "getUserAccountData: supplies: 2, borrows: 1": "146405",
-  "getUserAccountData: supplies: 2, borrows: 2": "173848"
+  "getUserAccountData: supplies: 0, borrows: 0": "23917",
+  "getUserAccountData: supplies: 1, borrows: 0": "73163",
+  "getUserAccountData: supplies: 2, borrows: 0": "117454",
+  "getUserAccountData: supplies: 2, borrows: 1": "146427",
+  "getUserAccountData: supplies: 2, borrows: 2": "173870"
 }

snapshots/Spoke.Operations.json

@@ -1,15 +1,15 @@
 {
-  "borrow": "481621",
-  "repay: full": "221810",
-  "repay: partial": "290017",
+  "borrow": "481646",
+  "repay: full": "221830",
+  "repay: partial": "290042",
   "supply: 0 debt, collateralDisabled": "171802",
   "supply: 0 debt, collateralEnabled": "171778",
   "supply: 1 debt": "171826",
   "supply: 2 debt": "171837",
   "supply: 3 debt": "171790",
-  "updateUserRiskPremium": "186410",
-  "updateUserRiskPremium: 2 debts": "227359",
+  "updateUserRiskPremium": "172555",
+  "updateUserRiskPremium: 2 debts": "213546",
   "usingAsCollateral": "50661",
-  "withdraw: full": "218158",
-  "withdraw: partial": "229109"
+  "withdraw: full": "218183",
+  "withdraw: partial": "229134"
 }

src/contracts/Spoke.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import {Multicall} from 'src/dependencies/openzeppelin/Multicall.sol';
+import {Multicall} from 'src/misc/Multicall.sol';
 
 // libraries
 import {WadRayMath} from 'src/libraries/math/WadRayMath.sol';
@@ -88,6 +88,7 @@ contract Spoke is ISpoke, Multicall {
     });
 
     emit ReserveAdded(reserveId, assetId);
+    emit ReserveConfigUpdated(reserveId, config);
 
     return reserveId;
   }
@@ -311,6 +312,7 @@ contract Spoke is ISpoke, Multicall {
     emit Repay(reserveId, msg.sender, restoredShares);
   }
 
+  /// @inheritdoc ISpoke
   function setUsingAsCollateral(uint256 reserveId, bool usingAsCollateral) external {
     DataTypes.Reserve storage reserve = _reserves[reserveId];
     DataTypes.UserPosition storage userPosition = _userPositions[msg.sender][reserveId];
@@ -323,58 +325,13 @@ contract Spoke is ISpoke, Multicall {
     emit UsingAsCollateral(reserveId, msg.sender, usingAsCollateral);
   }
 
-  /// @dev Must be called on a reserve user is already borrowing
-  /// @dev If not called by position owner or DAO, reverts if user risk premium increases
-  function updateUserRiskPremium(uint256 reserveId, address user) external {
-    DataTypes.Reserve storage reserve = _reserves[reserveId];
-    DataTypes.UserPosition storage userPosition = _userPositions[user][reserveId];
-    require(_isBorrowing(userPosition), UserNotBorrowingReserve(reserveId));
-    uint256 assetId = reserve.assetId;
-
-    uint256 userPremiumDrawnShares = userPosition.premiumDrawnShares;
-    uint256 userPremiumOffset = userPosition.premiumOffset;
-    uint256 accruedPremium = HUB.convertToDrawnAssets(assetId, userPremiumDrawnShares) -
-      userPremiumOffset; // assets(premiumShares) - offset should never be < 0
-    userPosition.premiumDrawnShares = 0;
-    userPosition.premiumOffset = 0;
-    userPosition.realizedPremium += accruedPremium;
-
-    _refreshPremiumDebt(
-      reserve,
-      user,
-      assetId,
-      -int256(userPremiumDrawnShares),
-      -int256(userPremiumOffset),
-      int256(accruedPremium)
-    );
-
-    uint256 newUserRiskPremium = _validateUserPosition(user); // validates HF
-
-    uint256 newUserPremiumDrawnShares = userPosition.premiumDrawnShares = userPosition
-      .baseDrawnShares
-      .percentMul(newUserRiskPremium);
-    // TODO: With access control, also allow DAO to update user risk premium in case of increase
-    // Check new premium drawn shares as proxy for user risk premium
-    require(
-      msg.sender == user || newUserPremiumDrawnShares < userPremiumDrawnShares,
-      NoUserRiskPremiumDecrease()
-    );
-    userPremiumOffset = userPosition.premiumOffset = HUB.previewOffset(
-      assetId,
-      userPosition.premiumDrawnShares
-    );
-
-    _refreshPremiumDebt(
-      reserve,
-      user,
-      assetId,
-      int256(newUserPremiumDrawnShares),
-      int256(userPremiumOffset),
-      0
-    );
-    _notifyRiskPremiumUpdate(assetId, user, newUserRiskPremium);
-
-    emit UserRiskPremiumUpdate(user, newUserRiskPremium);
+  /// @inheritdoc ISpoke
+  function updateUserRiskPremium(address user) external {
+    (uint256 userRiskPremium, , , , ) = _calculateUserAccountData(user);
+    bool premiumIncrease = _notifyRiskPremiumUpdate(type(uint256).max, user, userRiskPremium);
+    // todo allow authorized caller to increase as well
+    require(msg.sender == user || !premiumIncrease, Unauthorized());
+    emit UserRiskPremiumUpdate(user, userRiskPremium);
   }
 
   function getUsingAsCollateral(uint256 reserveId, address user) external view returns (bool) {
@@ -441,6 +398,7 @@ contract Spoke is ISpoke, Multicall {
     (, , uint256 healthFactor, , ) = _calculateUserAccountData(user);
     return healthFactor;
   }
+
   function getReservePrice(uint256 reserveId) public view returns (uint256) {
     return oracle.getAssetPrice(_reserves[reserveId].assetId);
   }
@@ -841,7 +799,8 @@ contract Spoke is ISpoke, Multicall {
     uint256 assetIdToAvoid,
     address userAddress,
     uint256 newUserRiskPremium
-  ) internal {
+  ) internal returns (bool) {
+    bool premiumIncrease;
     uint256 reserveCount_ = reserveCount;
     uint256 reserveId;
     while (reserveId < reserveCount_) {
@@ -861,11 +820,17 @@ contract Spoke is ISpoke, Multicall {
         userPosition.premiumOffset = HUB.previewOffset(assetId, userPosition.premiumDrawnShares);
         userPosition.realizedPremium += accruedUserPremium;
 
+        int256 premiumDrawnSharesDelta = _signedDiff(
+          userPosition.premiumDrawnShares,
+          oldUserPremiumDrawnShares
+        );
+        if (!premiumIncrease) premiumIncrease = premiumDrawnSharesDelta > 0;
+
         _refreshPremiumDebt(
           reserve,
           userAddress,
           assetId,
-          _signedDiff(userPosition.premiumDrawnShares, oldUserPremiumDrawnShares),
+          premiumDrawnSharesDelta,
           _signedDiff(userPosition.premiumOffset, oldUserPremiumOffset),
           int256(accruedUserPremium)
         );
@@ -874,6 +839,7 @@ contract Spoke is ISpoke, Multicall {
         ++reserveId;
       }
     }
+    return premiumIncrease;
   }
 
   function _validateUserPosition(address userAddress) internal view returns (uint256) {
@@ -903,7 +869,7 @@ contract Spoke is ISpoke, Multicall {
     return int256(a) - int256(b); // todo use safeCast when amounts packed to uint112/uint128
   }
 
-  function _validateLiquidationConfig(DataTypes.LiquidationConfig calldata config) internal view {
+  function _validateLiquidationConfig(DataTypes.LiquidationConfig calldata config) internal pure {
     _validateCloseFactor(config.closeFactor);
     // if liquidationBonusFactor == 0, then variable liquidation bonus will not be applied
     require(
@@ -917,7 +883,7 @@ contract Spoke is ISpoke, Multicall {
     );
   }
 
-  function _validateCloseFactor(uint256 closeFactor) internal view {
+  function _validateCloseFactor(uint256 closeFactor) internal pure {
     require(closeFactor >= HEALTH_FACTOR_LIQUIDATION_THRESHOLD, InvalidCloseFactor());
   }
 }

src/dependencies/openzeppelin/Multicall.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IMulticall {
+  /**
+   * @notice Call multiple functions in the current contract and return the data from all of them if they all succeed.
+   * @param data The encoded function data for each of the calls to make to this contract.
+   * @return results The results from each of the calls passed in via data.
+   */
+  function multicall(bytes[] calldata data) external returns (bytes[] memory results);
+}

src/interfaces/IMulticall.sol

@@ -1,14 +1,15 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
+import {IMulticall} from 'src/interfaces/IMulticall.sol';
 import {DataTypes} from 'src/libraries/types/DataTypes.sol';
 
 /**
  * @title ISpoke
  * @author Aave Labs
  * @notice Basic interface for Spoke
  */
-interface ISpoke {
+interface ISpoke is IMulticall {
   event ReserveAdded(uint256 indexed reserveId, uint256 indexed assetId);
   event ReserveConfigUpdated(uint256 indexed reserveId, DataTypes.ReserveConfig config);
   event LiquidityPremiumUpdated(uint256 indexed reserveId, uint256 liquidityPremium);
@@ -59,13 +60,15 @@ interface ISpoke {
   error InvalidHubAddress();
   error InvalidHealthFactorBonusThreshold();
   error InvalidLiquidationBonusFactor();
-  error NoUserRiskPremiumDecrease();
+  error Unauthorized();
 
   function addReserve(
     uint256 assetId,
     DataTypes.ReserveConfig memory params
   ) external returns (uint256);
+
   function updateReserveConfig(uint256 reserveId, DataTypes.ReserveConfig calldata params) external;
+
   function updateLiquidationConfig(DataTypes.LiquidationConfig calldata config) external;
 
   /**
@@ -100,19 +103,41 @@ interface ISpoke {
    */
   function repay(uint256 reserveId, uint256 amount) external;
 
+  /**
+   * @notice Allows suppliers to enable/disable a specific supplied reserve as collateral.
+   * @param reserveId The reserveId of the underlying asset as registered on the spoke.
+   * @param usingAsCollateral True if the user wants to use the supply as collateral, false otherwise.
+   */
   function setUsingAsCollateral(uint256 reserveId, bool usingAsCollateral) external;
-  function updateUserRiskPremium(uint256 reserveId, address user) external;
+
+  /**
+   * @notice Allows updating the risk premium on user position.
+   * @dev If the risk premium has increased, the caller must be authorized or the owner of the position,
+   * reverts with `Unauthorized` otherwise.
+   * @param user The address of the user.
+   */
+  function updateUserRiskPremium(address user) external;
 
   function getCollateralFactor(uint256 reserveId) external view returns (uint256);
+
   function getHealthFactor(address user) external view returns (uint256);
+
   function getLiquidityPremium(uint256 reserveId) external view returns (uint256);
+
   function getReserve(uint256 reserveId) external view returns (DataTypes.Reserve memory);
+
   function getReserveDebt(uint256 reserveId) external view returns (uint256, uint256);
+
   function getReservePrice(uint256 reserveId) external view returns (uint256);
+
   function getReserveRiskPremium(uint256 reserveId) external view returns (uint256);
+
   function getReserveSuppliedAmount(uint256 reserveId) external view returns (uint256);
+
   function getReserveSuppliedShares(uint256 reserveId) external view returns (uint256);
+
   function getReserveTotalDebt(uint256 reserveId) external view returns (uint256);
+
   function getUserAccountData(
     address user
   )
@@ -125,22 +150,34 @@ interface ISpoke {
       uint256 totalCollateralInBaseCurrency,
       uint256 totalDebtInBaseCurrency
     );
+
   function getUserDebt(uint256 reserveId, address user) external view returns (uint256, uint256);
+
   function getUserPosition(
     uint256 reserveId,
     address user
   ) external view returns (DataTypes.UserPosition memory);
+
   function getUserRiskPremium(address user) external view returns (uint256);
+
   function getUserSuppliedAmount(uint256 reserveId, address user) external view returns (uint256);
+
   function getUserSuppliedShares(uint256 reserveId, address user) external view returns (uint256);
+
   function getUserTotalDebt(uint256 reserveId, address user) external view returns (uint256);
+
   function getUsingAsCollateral(uint256 reserveId, address user) external view returns (bool);
+
   function reserveCount() external view returns (uint256);
+
   function reservesList(uint256) external view returns (uint256);
+
   function HEALTH_FACTOR_LIQUIDATION_THRESHOLD() external view returns (uint256);
+
   function getVariableLiquidationBonus(
     uint256 reserveId,
     uint256 healthFactor
   ) external view returns (uint256);
+
   function getLiquidationConfig() external view returns (DataTypes.LiquidationConfig memory);
 }

src/interfaces/ISpoke.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IMulticall} from 'src/interfaces/IMulticall.sol';
+
+/**
+ * @title Multicall
+ * @author Aave Labs, inspired by the OpenZeppelin Multicall contract
+ * @notice This contract allows for batching multiple calls into a single call.
+ */
+abstract contract Multicall is IMulticall {
+  /// @inheritdoc IMulticall
+  function multicall(bytes[] calldata data) external returns (bytes[] memory) {
+    bytes[] memory results = new bytes[](data.length);
+    for (uint256 i; i < data.length; ++i) {
+      (bool ok, bytes memory res) = address(this).delegatecall(data[i]);
+
+      assembly ('memory-safe') {
+        if iszero(ok) {
+          revert(add(res, 32), mload(res)) // bubble up first revert
+        }
+      }
+
+      results[i] = res;
+    }
+  }
+}

src/misc/Multicall.sol

@@ -717,6 +717,11 @@ abstract contract Base is Test {
     return price.percentMul(percent);
   }
 
+  function setNewPrice(uint256 assetId, uint256 percent) public {
+    uint256 newPrice = calcNewPrice(oracle.getAssetPrice(assetId), percent);
+    oracle.setAssetPrice(assetId, newPrice);
+  }
+
   /// @dev Helper function to calculate asset amount corresponding to single drawn share
   function minimumAssetsPerDrawnShare(uint256 assetId) internal view returns (uint256) {
     return hub.convertToDrawnAssets(assetId, 1);