LIF naming

src/Morpho.sol

@@ -350,18 +350,20 @@ contract Morpho is IMorpho {
 
         uint256 repaidAssets;
         {
-            // The liquidation incentive factor is min(maxIncentiveFactor, 1/(1 - cursor*(1 - lltv))).
-            uint256 incentiveFactor = UtilsLib.min(
+            // The liquidation incentive factor is min(maxLiquidationIncentiveFactor, 1/(1 - cursor*(1 - lltv))).
+            uint256 liquidationIncentiveFactor = UtilsLib.min(
                 MAX_LIQUIDATION_INCENTIVE_FACTOR,
                 WAD.wDivDown(WAD - LIQUIDATION_CURSOR.wMulDown(WAD - marketParams.lltv))
             );
 
             if (seizedAssets > 0) {
-                repaidAssets = seizedAssets.mulDivUp(collateralPrice, ORACLE_PRICE_SCALE).wDivUp(incentiveFactor);
+                repaidAssets =
+                    seizedAssets.mulDivUp(collateralPrice, ORACLE_PRICE_SCALE).wDivUp(liquidationIncentiveFactor);
                 repaidShares = repaidAssets.toSharesDown(market[id].totalBorrowAssets, market[id].totalBorrowShares);
             } else {
                 repaidAssets = repaidShares.toAssetsUp(market[id].totalBorrowAssets, market[id].totalBorrowShares);
-                seizedAssets = repaidAssets.wMulDown(incentiveFactor).mulDivDown(ORACLE_PRICE_SCALE, collateralPrice);
+                seizedAssets =
+                    repaidAssets.wMulDown(liquidationIncentiveFactor).mulDivDown(ORACLE_PRICE_SCALE, collateralPrice);
             }
         }
 

test/forge/BaseTest.sol

@@ -340,7 +340,7 @@ contract BaseTest is Test {
         uint256 collateral = morpho.collateral(_id, borrower);
         uint256 collateralPrice = IOracle(_marketParams.oracle).price();
         uint256 maxRepaidAssets = morpho.expectedBorrowBalance(_marketParams, borrower);
-        uint256 maxSeizedAssets = maxRepaidAssets.wMulDown(_liquidationIncentive(_marketParams.lltv)).mulDivDown(
+        uint256 maxSeizedAssets = maxRepaidAssets.wMulDown(_liquidationIncentiveFactor(_marketParams.lltv)).mulDivDown(
             ORACLE_PRICE_SCALE, collateralPrice
         );
 
@@ -357,7 +357,7 @@ contract BaseTest is Test {
         uint256 borrowShares = morpho.borrowShares(_id, borrower);
         uint256 collateralPrice = IOracle(_marketParams.oracle).price();
         uint256 maxRepaidAssets = morpho.collateral(_id, borrower).mulDivUp(collateralPrice, ORACLE_PRICE_SCALE).wDivUp(
-            _liquidationIncentive(_marketParams.lltv)
+            _liquidationIncentiveFactor(_marketParams.lltv)
         );
         (,, uint256 totalBorrowAssets, uint256 totalBorrowShares) = morpho.expectedMarketBalances(marketParams);
         uint256 maxRepaidShares = maxRepaidAssets.toSharesDown(totalBorrowAssets, totalBorrowShares);
@@ -380,7 +380,7 @@ contract BaseTest is Test {
         return maxBorrow >= borrowed;
     }
 
-    function _liquidationIncentive(uint256 lltv) internal pure returns (uint256) {
+    function _liquidationIncentiveFactor(uint256 lltv) internal pure returns (uint256) {
         return Math.min(MAX_LIQUIDATION_INCENTIVE_FACTOR, WAD.wDivDown(WAD - LIQUIDATION_CURSOR.wMulDown(WAD - lltv)));
     }
 

test/forge/integration/LiquidateIntegrationTest.sol

@@ -83,11 +83,13 @@ contract LiquidateIntegrationTest is BaseTest {
         amountSupplied = bound(amountSupplied, amountBorrowed, amountBorrowed + MAX_TEST_AMOUNT);
         _supply(amountSupplied);
 
-        uint256 incentive = _liquidationIncentive(marketParams.lltv);
-        uint256 maxSeized = amountBorrowed.wMulDown(incentive).mulDivDown(ORACLE_PRICE_SCALE, priceCollateral);
+        uint256 liquidationIncentiveFactor = _liquidationIncentiveFactor(marketParams.lltv);
+        uint256 maxSeized =
+            amountBorrowed.wMulDown(liquidationIncentiveFactor).mulDivDown(ORACLE_PRICE_SCALE, priceCollateral);
         vm.assume(maxSeized != 0);
         amountSeized = bound(amountSeized, 1, Math.min(maxSeized, amountCollateral - 1));
-        uint256 expectedRepaid = amountSeized.mulDivUp(priceCollateral, ORACLE_PRICE_SCALE).wDivUp(incentive);
+        uint256 expectedRepaid =
+            amountSeized.mulDivUp(priceCollateral, ORACLE_PRICE_SCALE).wDivUp(liquidationIncentiveFactor);
 
         borrowableToken.setBalance(LIQUIDATOR, amountBorrowed);
         collateralToken.setBalance(BORROWER, amountCollateral);
@@ -150,12 +152,12 @@ contract LiquidateIntegrationTest is BaseTest {
 
         uint256 expectedBorrowShares = amountBorrowed.toSharesUp(0, 0);
         uint256 maxRepaidShares = amountCollateral.mulDivDown(priceCollateral, ORACLE_PRICE_SCALE).wDivDown(
-            _liquidationIncentive(marketParams.lltv)
+            _liquidationIncentiveFactor(marketParams.lltv)
         );
         vm.assume(maxRepaidShares != 0);
         sharesRepaid = bound(sharesRepaid, 1, Math.min(maxRepaidShares, expectedBorrowShares));
         uint256 expectedRepaid = sharesRepaid.toAssetsUp(amountBorrowed, expectedBorrowShares);
-        uint256 expectedSeized = expectedRepaid.wMulDown(_liquidationIncentive(marketParams.lltv)).mulDivDown(
+        uint256 expectedSeized = expectedRepaid.wMulDown(_liquidationIncentiveFactor(marketParams.lltv)).mulDivDown(
             ORACLE_PRICE_SCALE, priceCollateral
         );
 
@@ -199,7 +201,7 @@ contract LiquidateIntegrationTest is BaseTest {
     }
 
     struct LiquidateBadDebtTestParams {
-        uint256 incentive;
+        uint256 liquidationIncentiveFactor;
         uint256 expectedRepaid;
         uint256 expectedRepaidShares;
         uint256 borrowSharesBeforeLiquidation;
@@ -224,8 +226,9 @@ contract LiquidateIntegrationTest is BaseTest {
 
         vm.assume(amountCollateral > 1);
 
-        params.incentive = _liquidationIncentive(marketParams.lltv);
-        params.expectedRepaid = amountCollateral.mulDivUp(priceCollateral, ORACLE_PRICE_SCALE).wDivUp(params.incentive);
+        params.liquidationIncentiveFactor = _liquidationIncentiveFactor(marketParams.lltv);
+        params.expectedRepaid =
+            amountCollateral.mulDivUp(priceCollateral, ORACLE_PRICE_SCALE).wDivUp(params.liquidationIncentiveFactor);
 
         uint256 minBorrowed = Math.max(params.expectedRepaid, amountBorrowed);
         amountBorrowed = bound(amountBorrowed, minBorrowed, Math.max(minBorrowed, MAX_TEST_AMOUNT));

test/forge/invariant/MorphoInvariantTest.sol

@@ -167,8 +167,9 @@ contract MorphoInvariantTest is InvariantTest {
         logCall("liquidateSeizedAssets")
     {
         uint256 collateralPrice = oracle.price();
-        uint256 repaidAssets =
-            seizedAssets.mulDivUp(collateralPrice, ORACLE_PRICE_SCALE).wDivUp(_liquidationIncentive(_marketParams.lltv));
+        uint256 repaidAssets = seizedAssets.mulDivUp(collateralPrice, ORACLE_PRICE_SCALE).wDivUp(
+            _liquidationIncentiveFactor(_marketParams.lltv)
+        );
 
         borrowableToken.setBalance(msg.sender, repaidAssets);
 

test/morpho_tests.tree

@@ -218,7 +218,7 @@
                 │    └── it should compute repaidShares = assetsRepaid.toSharesDown(totalBorrow[marketParams.id], totalBorrowShares[market.id])
                 ├── when repaidShares is not zero
                 │    ├── it should compute assetsRepaid = repaidShares.toAssetsUp(totalBorrow[marketParams.id], totalBorrowShares[marketParams.id])
-                │    └── it should compute seizedAssets = assetsRepaid.wMulDown(incentiveFactor).mulDivDown(ORACLE_PRICE_SCALE, collateralPrice)
+                │    └── it should compute seizedAssets = assetsRepaid.wMulDown(liquidationIncentiveFactor).mulDivDown(ORACLE_PRICE_SCALE, collateralPrice)
                 ├── it should remove repaidShares from totalBorrowShares[marketParams.id]
                 ├── it should remove assetsRepaid from totalBorrow[marketParams.id]
                 ├── it should remove repaidShares from collateral[marketParams.id][borrower]