feat: emit all user state changes on LiquidationCall event (#992)

Author: yan-man

snapshots/Spoke.Operations.ZeroRiskPremium.json

@@ -1,10 +1,10 @@
 {
   "borrow: first": "187966",
   "borrow: second action, same reserve": "167938",
-  "liquidationCall (receiveShares): full": "294802",
-  "liquidationCall (receiveShares): partial": "293124",
-  "liquidationCall: full": "302109",
-  "liquidationCall: partial": "300431",
+  "liquidationCall (receiveShares): full": "296660",
+  "liquidationCall (receiveShares): partial": "294982",
+  "liquidationCall: full": "303967",
+  "liquidationCall: partial": "302289",
   "permitReserve + repay (multicall)": "196047",
   "permitReserve + supply (multicall)": "173494",
   "permitReserve + supply + enable collateral (multicall)": "216808",

snapshots/Spoke.Operations.json

@@ -1,10 +1,10 @@
 {
   "borrow: first": "257929",
   "borrow: second action, same reserve": "200901",
-  "liquidationCall (receiveShares): full": "327985",
-  "liquidationCall (receiveShares): partial": "314827",
-  "liquidationCall: full": "335292",
-  "liquidationCall: partial": "322134",
+  "liquidationCall (receiveShares): full": "329843",
+  "liquidationCall (receiveShares): partial": "316685",
+  "liquidationCall: full": "337150",
+  "liquidationCall: partial": "323992",
   "permitReserve + repay (multicall)": "195488",
   "permitReserve + supply (multicall)": "173494",
   "permitReserve + supply + enable collateral (multicall)": "216808",

src/spoke/interfaces/ISpokeBase.sol

@@ -71,15 +71,23 @@ interface ISpokeBase {
   /// @param debtReserveId The identifier of the reserve to be repaid with the liquidation.
   /// @param user The address of the borrower getting liquidated.
   /// @param debtToLiquidate The debt amount of borrowed reserve to be liquidated.
+  /// @param drawnSharesToLiquidate The amount of drawn shares to be liquidated.
+  /// @param premiumDelta A struct representing the changes to premium debt after liquidation.
   /// @param collateralToLiquidate The total amount of collateral asset to be liquidated, inclusive of liquidation fee.
+  /// @param collateralSharesToLiquidate The total amount of collateral shares to liquidate.
+  /// @param collateralSharesToLiquidator The amount of collateral shares that the liquidator received.
   /// @param liquidator The address of the liquidator.
-  /// @param receiveShares True if the liquidator receives collateral in supplied shares rather than underlying assets.
+  /// @param receiveShares True if the liquidator received collateral in supplied shares rather than underlying assets.
   event LiquidationCall(
     uint256 indexed collateralReserveId,
     uint256 indexed debtReserveId,
     address indexed user,
     uint256 debtToLiquidate,
+    uint256 drawnSharesToLiquidate,
+    IHubBase.PremiumDelta premiumDelta,
     uint256 collateralToLiquidate,
+    uint256 collateralSharesToLiquidate,
+    uint256 collateralSharesToLiquidator,
     address liquidator,
     bool receiveShares
   );

src/spoke/libraries/LiquidationLogic.sol

@@ -116,6 +116,19 @@ library LiquidationLogic {
     bool receiveShares;
   }
 
+  struct LiquidateUserVars {
+    uint256 collateralReserveBalance;
+    uint256 collateralToLiquidate;
+    uint256 collateralToLiquidator;
+    uint256 debtToLiquidate;
+    bool isCollateralPositionEmpty;
+    uint256 collateralSharesToLiquidate;
+    uint256 collateralSharesToLiquidator;
+    bool isDebtPositionEmpty;
+    uint256 drawnSharesToLiquidate;
+    IHubBase.PremiumDelta premiumDelta;
+  }
+
   // see ISpoke.HEALTH_FACTOR_LIQUIDATION_THRESHOLD docs
   uint64 public constant HEALTH_FACTOR_LIQUIDATION_THRESHOLD = 1e18;
 
@@ -140,7 +153,9 @@ library LiquidationLogic {
     ISpoke.DynamicReserveConfig storage collateralDynConfig,
     LiquidateUserParams memory params
   ) external returns (bool) {
-    uint256 collateralReserveBalance = collateralReserve.hub.previewRemoveByShares(
+    LiquidateUserVars memory vars;
+
+    vars.collateralReserveBalance = collateralReserve.hub.previewRemoveByShares(
       collateralReserve.assetId,
       positions[params.user][params.collateralReserveId].suppliedShares
     );
@@ -158,58 +173,62 @@ library LiquidationLogic {
         healthFactor: params.healthFactor,
         collateralReserveId: params.collateralReserveId,
         collateralFactor: collateralDynConfig.collateralFactor,
-        collateralReserveBalance: collateralReserveBalance,
+        collateralReserveBalance: vars.collateralReserveBalance,
         debtReserveBalance: params.drawnDebt + params.premiumDebt,
         receiveShares: params.receiveShares
       })
     );
 
     (
-      uint256 collateralToLiquidate,
-      uint256 collateralToLiquidator,
-      uint256 debtToLiquidate
+      vars.collateralToLiquidate,
+      vars.collateralToLiquidator,
+      vars.debtToLiquidate
     ) = _calculateLiquidationAmounts(
-        CalculateLiquidationAmountsParams({
-          healthFactorForMaxBonus: liquidationConfig.healthFactorForMaxBonus,
-          liquidationBonusFactor: liquidationConfig.liquidationBonusFactor,
-          targetHealthFactor: liquidationConfig.targetHealthFactor,
-          debtReserveBalance: params.drawnDebt + params.premiumDebt,
-          collateralReserveBalance: collateralReserveBalance,
-          debtToCover: params.debtToCover,
-          totalDebtValue: params.totalDebtValue,
-          healthFactor: params.healthFactor,
-          maxLiquidationBonus: collateralDynConfig.maxLiquidationBonus,
-          collateralFactor: collateralDynConfig.collateralFactor,
-          liquidationFee: collateralDynConfig.liquidationFee,
-          debtAssetPrice: IAaveOracle(params.oracle).getReservePrice(params.debtReserveId),
-          debtAssetDecimals: debtReserve.decimals,
-          collateralAssetPrice: IAaveOracle(params.oracle).getReservePrice(
-            params.collateralReserveId
-          ),
-          collateralAssetDecimals: collateralReserve.decimals
-        })
-      );
+      CalculateLiquidationAmountsParams({
+        healthFactorForMaxBonus: liquidationConfig.healthFactorForMaxBonus,
+        liquidationBonusFactor: liquidationConfig.liquidationBonusFactor,
+        targetHealthFactor: liquidationConfig.targetHealthFactor,
+        debtReserveBalance: params.drawnDebt + params.premiumDebt,
+        collateralReserveBalance: vars.collateralReserveBalance,
+        debtToCover: params.debtToCover,
+        totalDebtValue: params.totalDebtValue,
+        healthFactor: params.healthFactor,
+        maxLiquidationBonus: collateralDynConfig.maxLiquidationBonus,
+        collateralFactor: collateralDynConfig.collateralFactor,
+        liquidationFee: collateralDynConfig.liquidationFee,
+        debtAssetPrice: IAaveOracle(params.oracle).getReservePrice(params.debtReserveId),
+        debtAssetDecimals: debtReserve.decimals,
+        collateralAssetPrice: IAaveOracle(params.oracle).getReservePrice(
+          params.collateralReserveId
+        ),
+        collateralAssetDecimals: collateralReserve.decimals
+      })
+    );
 
-    bool isCollateralPositionEmpty = _liquidateCollateral(
+    (
+      vars.collateralSharesToLiquidate,
+      vars.collateralSharesToLiquidator,
+      vars.isCollateralPositionEmpty
+    ) = _liquidateCollateral(
       collateralReserve,
       positions,
       LiquidateCollateralParams({
         collateralReserveId: params.collateralReserveId,
-        collateralToLiquidate: collateralToLiquidate,
-        collateralToLiquidator: collateralToLiquidator,
+        collateralToLiquidate: vars.collateralToLiquidate,
+        collateralToLiquidator: vars.collateralToLiquidator,
         liquidator: params.liquidator,
         user: params.user,
         receiveShares: params.receiveShares
       })
     );
 
-    bool isDebtPositionEmpty = _liquidateDebt(
+    (vars.drawnSharesToLiquidate, vars.premiumDelta, vars.isDebtPositionEmpty) = _liquidateDebt(
       debtReserve,
       positions[params.user][params.debtReserveId],
       positionStatus[params.user],
       LiquidateDebtParams({
         debtReserveId: params.debtReserveId,
-        debtToLiquidate: debtToLiquidate,
+        debtToLiquidate: vars.debtToLiquidate,
         premiumDebt: params.premiumDebt,
         accruedPremium: params.accruedPremium,
         liquidator: params.liquidator,
@@ -221,16 +240,20 @@ library LiquidationLogic {
       params.collateralReserveId,
       params.debtReserveId,
       params.user,
-      debtToLiquidate,
-      collateralToLiquidate,
+      vars.debtToLiquidate,
+      vars.drawnSharesToLiquidate,
+      vars.premiumDelta,
+      vars.collateralToLiquidate,
+      vars.collateralSharesToLiquidate,
+      vars.collateralSharesToLiquidator,
       params.liquidator,
       params.receiveShares
     );
 
     return
       _evaluateDeficit({
-        isCollateralPositionEmpty: isCollateralPositionEmpty,
-        isDebtPositionEmpty: isDebtPositionEmpty,
+        isCollateralPositionEmpty: vars.isCollateralPositionEmpty,
+        isDebtPositionEmpty: vars.isDebtPositionEmpty,
         activeCollateralCount: params.activeCollateralCount,
         borrowedCount: params.borrowedCount
       });
@@ -277,21 +300,22 @@ library LiquidationLogic {
   }
 
   /// @dev Invoked by `liquidateUser` method.
+  /// @return The total amount of collateral shares to be liquidated.
+  /// @return The amount of collateral shares that the liquidator receives.
   /// @return True if the user collateral position becomes empty after removing.
   function _liquidateCollateral(
     ISpoke.Reserve storage collateralReserve,
     mapping(address user => mapping(uint256 reserveId => ISpoke.UserPosition)) storage positions,
     LiquidateCollateralParams memory params
-  ) internal returns (bool) {
+  ) internal returns (uint256, uint256, bool) {
     ISpoke.UserPosition storage collateralPosition = positions[params.user][
       params.collateralReserveId
     ];
     IHubBase hub = collateralReserve.hub;
     uint256 assetId = collateralReserve.assetId;
 
     uint256 sharesToLiquidate = hub.previewRemoveByAssets(assetId, params.collateralToLiquidate);
-    uint120 suppliedShares = collateralPosition.suppliedShares - sharesToLiquidate.toUint120();
-    collateralPosition.suppliedShares = suppliedShares;
+    uint120 userSuppliedShares = collateralPosition.suppliedShares - sharesToLiquidate.toUint120();
 
     uint256 sharesToLiquidator;
     if (params.collateralToLiquidator > 0) {
@@ -306,52 +330,55 @@ library LiquidationLogic {
       }
     }
 
+    collateralPosition.suppliedShares = userSuppliedShares;
+
     if (sharesToLiquidate > sharesToLiquidator) {
       hub.payFeeShares(assetId, sharesToLiquidate.uncheckedSub(sharesToLiquidator));
     }
 
-    return suppliedShares == 0;
+    return (sharesToLiquidate, sharesToLiquidator, userSuppliedShares == 0);
   }
 
   /// @dev Invoked by `liquidateUser` method.
+  /// @return The amount of drawn shares to be liquidated.
+  /// @return A struct representing the changes to premium debt after liquidation.
   /// @return True if the debt position becomes zero after restoring.
   function _liquidateDebt(
     ISpoke.Reserve storage debtReserve,
     ISpoke.UserPosition storage debtPosition,
     ISpoke.PositionStatus storage positionStatus,
     LiquidateDebtParams memory params
-  ) internal returns (bool) {
-    {
-      uint256 premiumDebtToLiquidate = params.premiumDebt.min(params.debtToLiquidate);
-      uint256 drawnDebtToLiquidate = params.debtToLiquidate - premiumDebtToLiquidate;
-
-      IHubBase.PremiumDelta memory premiumDelta = IHubBase.PremiumDelta({
-        sharesDelta: -debtPosition.premiumShares.toInt256(),
-        offsetDelta: -debtPosition.premiumOffset.toInt256(),
-        realizedDelta: params.accruedPremium.toInt256() - premiumDebtToLiquidate.toInt256()
-      });
+  ) internal returns (uint256, IHubBase.PremiumDelta memory, bool) {
+    uint256 premiumDebtToLiquidate = params.premiumDebt.min(params.debtToLiquidate);
+    uint256 drawnDebtToLiquidate = params.debtToLiquidate - premiumDebtToLiquidate;
+
+    IHubBase.PremiumDelta memory premiumDelta = IHubBase.PremiumDelta({
+      sharesDelta: -debtPosition.premiumShares.toInt256(),
+      offsetDelta: -debtPosition.premiumOffset.toInt256(),
+      realizedDelta: params.accruedPremium.toInt256() - premiumDebtToLiquidate.toInt256()
+    });
 
-      debtReserve.underlying.safeTransferFrom(
-        params.liquidator,
-        address(debtReserve.hub),
-        drawnDebtToLiquidate + premiumDebtToLiquidate
-      );
-      uint256 drawnSharesLiquidated = debtReserve.hub.restore(
-        debtReserve.assetId,
-        drawnDebtToLiquidate,
-        premiumDebtToLiquidate,
-        premiumDelta
-      );
-      debtPosition.settlePremiumDebt(premiumDelta.realizedDelta);
-      debtPosition.drawnShares -= drawnSharesLiquidated.toUint120();
-    }
+    debtReserve.underlying.safeTransferFrom(
+      params.liquidator,
+      address(debtReserve.hub),
+      drawnDebtToLiquidate + premiumDebtToLiquidate
+    );
+    uint256 drawnSharesLiquidated = debtReserve.hub.restore(
+      debtReserve.assetId,
+      drawnDebtToLiquidate,
+      premiumDebtToLiquidate,
+      premiumDelta
+    );
+    debtPosition.settlePremiumDebt(premiumDelta.realizedDelta);
+    debtPosition.drawnShares -= drawnSharesLiquidated.toUint120();
 
+    bool isDebtPositionEmpty = false;
     if (debtPosition.drawnShares == 0) {
       positionStatus.setBorrowing(params.debtReserveId, false);
-      return true;
+      isDebtPositionEmpty = true;
     }
 
-    return false;
+    return (drawnSharesLiquidated, premiumDelta, isDebtPositionEmpty);
   }
 
   /// @notice Validates the liquidation call.

tests/mocks/LiquidationLogicWrapper.sol

@@ -5,7 +5,7 @@ pragma solidity ^0.8.0;
 import {SafeCast} from 'src/dependencies/openzeppelin/SafeCast.sol';
 import {SafeERC20} from 'src/dependencies/openzeppelin/SafeERC20.sol';
 import {IERC20} from 'src/dependencies/openzeppelin/IERC20.sol';
-import {IHub} from 'src/hub/interfaces/IHub.sol';
+import {IHub, IHubBase} from 'src/hub/interfaces/IHub.sol';
 import {ISpoke} from 'src/spoke/interfaces/ISpoke.sol';
 import {PositionStatusMap} from 'src/spoke/libraries/PositionStatusMap.sol';
 import {LiquidationLogic} from 'src/spoke/libraries/LiquidationLogic.sol';
@@ -214,7 +214,7 @@ contract LiquidationLogicWrapper {
 
   function liquidateCollateral(
     LiquidationLogic.LiquidateCollateralParams memory params
-  ) public returns (bool) {
+  ) public returns (uint256, uint256, bool) {
     return
       LiquidationLogic._liquidateCollateral(
         _reserves[_collateralReserveId],
@@ -223,7 +223,9 @@ contract LiquidationLogicWrapper {
       );
   }
 
-  function liquidateDebt(LiquidationLogic.LiquidateDebtParams memory params) public returns (bool) {
+  function liquidateDebt(
+    LiquidationLogic.LiquidateDebtParams memory params
+  ) public returns (uint256, IHubBase.PremiumDelta memory, bool) {
     return
       LiquidationLogic._liquidateDebt(
         _reserves[_debtReserveId],

tests/unit/Hub/Hub.Rescue.t.sol

@@ -198,6 +198,8 @@ contract HubRescueTest is HubBase {
 
     vm.prank(address(rescueSpoke));
     hub1.add(daiAssetId, liquidityFee);
+
+    assertEq(hub1.getAssetAccruedFees(daiAssetId), liquidityFee, 'accrued liquidity fee');
   }
 
   function _rescue(