Set asset as collateral

src/MorphoInternal.sol

@@ -277,6 +277,8 @@ abstract contract MorphoInternal is MorphoStorage {
         view
         returns (uint256 borrowable, uint256 maxDebt)
     {
+        if (!_market[underlying].isCollateral) return (0, 0);
+
         (uint256 underlyingPrice, uint256 ltv, uint256 liquidationThreshold, uint256 tokenUnit) =
             _assetLiquidityData(underlying, vars);
 

src/MorphoSetters.sol

@@ -74,6 +74,26 @@ abstract contract MorphoSetters is IMorphoSetters, MorphoInternal {
         emit Events.TreasuryVaultSet(treasuryVault);
     }
 
+    /// @notice Sets the `underlying` asset as collateral or not on the pool.
+    /// @dev Note that it is possible to set an asset as collateral whose market is not created yet on the protocol.
+    function setAssetIsCollateralOnPool(address underlying, bool isCollateral) external onlyOwner {
+        if (isCollateral && !_market[underlying].isCreated()) revert Errors.MarketNotCreated();
+        if (!isCollateral && _market[underlying].isCreated()) _market[underlying].setAssetIsCollateral(isCollateral);
+
+        _POOL.setUserUseReserveAsCollateral(underlying, isCollateral);
+    }
+
+    /// @notice Sets the `underlying` asset as collateral or not on Morpho.
+    /// @dev If the asset is set as collateral, the behavior is propagated to the pool.
+    function setAssetIsCollateral(address underlying, bool isCollateral)
+        external
+        onlyOwner
+        isMarketCreated(underlying)
+    {
+        _market[underlying].setAssetIsCollateral(isCollateral);
+        if (isCollateral) _POOL.setUserUseReserveAsCollateral(underlying, isCollateral);
+    }
+
     /// @notice Sets the `underlying`'s reserve factor to `newReserveFactor` (in bps).
     function setReserveFactor(address underlying, uint16 newReserveFactor)
         external

src/PositionsManagerInternal.sol

@@ -20,6 +20,7 @@ import {LogarithmicBuckets} from "@morpho-data-structures/LogarithmicBuckets.sol
 import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
 import {DataTypes} from "@aave-v3-core/protocol/libraries/types/DataTypes.sol";
+import {UserConfiguration} from "@aave-v3-core/protocol/libraries/configuration/UserConfiguration.sol";
 import {ReserveConfiguration} from "@aave-v3-core/protocol/libraries/configuration/ReserveConfiguration.sol";
 
 import {ERC20} from "@solmate/tokens/ERC20.sol";
@@ -43,6 +44,7 @@ abstract contract PositionsManagerInternal is MatchingEngine {
     using EnumerableSet for EnumerableSet.AddressSet;
     using LogarithmicBuckets for LogarithmicBuckets.Buckets;
 
+    using UserConfiguration for DataTypes.UserConfigurationMap;
     using ReserveConfiguration for DataTypes.ReserveConfigurationMap;
 
     /// @dev Validates the manager's permission.
@@ -90,6 +92,7 @@ abstract contract PositionsManagerInternal is MatchingEngine {
     function _validateSupplyCollateral(address underlying, uint256 amount, address user) internal view {
         Types.Market storage market = _validateInput(underlying, amount, user);
         if (market.isSupplyCollateralPaused()) revert Errors.SupplyCollateralIsPaused();
+        if (!market.isCollateral) revert Errors.AssetNotUsedAsCollateral();
     }
 
     /// @dev Validates a borrow action.
@@ -168,6 +171,14 @@ abstract contract PositionsManagerInternal is MatchingEngine {
         if (!borrowMarket.isCreated() || !collateralMarket.isCreated()) revert Errors.MarketNotCreated();
         if (collateralMarket.isLiquidateCollateralPaused()) revert Errors.LiquidateCollateralIsPaused();
         if (borrowMarket.isLiquidateBorrowPaused()) revert Errors.LiquidateBorrowIsPaused();
+
+        // Revert only if the collateral is not enabled as collateral on Morpho AND on the pool.
+        // This way Morpho can disable an asset as collateral on Morpho side only and still be able to liquidate unhealthy positions using this asset as collateral.
+        // This can be helpful in case the pool sets an asset's LTV to 0.
+        if (
+            !collateralMarket.isCollateral
+                && !_POOL.getUserConfiguration(address(this)).isUsingAsCollateral(_POOL.getReserveData(underlyingCollateral).id)
+        ) revert Errors.AssetNotUsedAsCollateral();
     }
 
     /// @dev Authorizes a liquidate action.

src/interfaces/IMorpho.sol

@@ -53,6 +53,8 @@ interface IMorphoSetters {
     function setP2PIndexCursor(address underlying, uint16 p2pIndexCursor) external;
     function setReserveFactor(address underlying, uint16 newReserveFactor) external;
 
+    function setAssetIsCollateralOnPool(address underlying, bool isCollateral) external;
+    function setAssetIsCollateral(address underlying, bool isCollateral) external;
     function setIsP2PDisabled(address underlying, bool isP2PDisabled) external;
     function setIsPaused(address underlying, bool isPaused) external;
     function setIsPausedForAllMarkets(bool isPaused) external;

src/libraries/Errors.sol

@@ -33,6 +33,7 @@ library Errors {
 
     error UnauthorizedWithdraw();
     error UnauthorizedLiquidate();
+    error AssetNotUsedAsCollateral();
 
     error ExceedsMaxBasisPoints();
 

src/libraries/Events.sol

@@ -90,6 +90,8 @@ library Events {
         address indexed claimer, address indexed onBehalf, address indexed rewardToken, uint256 amountClaimed
     );
 
+    event IsCollateralSet(address indexed underlying, bool isCollateral);
+
     event IsSupplyPausedSet(address indexed underlying, bool isPaused);
 
     event IsSupplyCollateralPausedSet(address indexed underlying, bool isPaused);

src/libraries/MarketLib.sol

@@ -73,6 +73,12 @@ library MarketLib {
         return market.pauseStatuses.isP2PDisabled;
     }
 
+    function setAssetIsCollateral(Types.Market storage market, bool isCollateral) internal {
+        market.isCollateral = isCollateral;
+
+        emit Events.IsCollateralSet(market.underlying, isCollateral);
+    }
+
     function setIsSupplyPaused(Types.Market storage market, bool isPaused) internal {
         market.pauseStatuses.isSupplyPaused = isPaused;
 

src/libraries/Types.sol

@@ -67,6 +67,7 @@ library Types {
         // SLOT 6
         address underlying; // 160 bits
         PauseStatuses pauseStatuses; // 80 bits
+        bool isCollateral; // 8 bits
         // SLOT 7
         address variableDebtToken; // 160 bits
         uint32 lastUpdateTimestamp; // 32 bits

test/helpers/ForkTest.sol

@@ -123,7 +123,7 @@ contract ForkTest is BaseTest {
         weth = config.getAddress("WETH");
         wNative = config.getWrappedNative();
 
-        allUnderlyings = pool.getReservesList();
+        allUnderlyings = [dai, usdc, aave, wbtc, weth];
     }
 
     function _label() internal virtual {

test/helpers/IntegrationTest.sol

@@ -55,9 +55,7 @@ contract IntegrationTest is ForkTest {
             _createMarket(allUnderlyings[i], 0, 33_33);
         }
 
-        // Supply dust to make UserConfigurationMap.isUsingAsCollateralOne() always return true.
-        _deposit(testMarkets[weth], 1e12, address(morpho));
-        _deposit(testMarkets[dai], 1e12, address(morpho));
+        _setAllAssetsAsCollateral();
 
         _forward(1); // All markets are outdated in Morpho's storage.
 
@@ -152,6 +150,18 @@ contract IntegrationTest is ForkTest {
         morpho.createMarket(market.underlying, market.reserveFactor, market.p2pIndexCursor);
     }
 
+    function _setAllAssetsAsCollateral() internal {
+        for (uint256 i; i < allUnderlyings.length; ++i) {
+            _setAssetAsCollateral(testMarkets[allUnderlyings[i]]);
+        }
+    }
+
+    function _setAssetAsCollateral(TestMarket storage market) internal {
+        // Supply dust to make UserConfigurationMap.isUsingAsCollateralOne() return true.
+        _deposit(market, (10 ** market.decimals) / 1e6, address(morpho));
+        morpho.setAssetIsCollateral(market.underlying, true);
+    }
+
     /// @dev Returns the total supply used towards the supply cap.
     function _totalSupplyToCap(TestMarket storage market) internal view returns (uint256) {
         return (IAToken(market.aToken).scaledTotalSupply() + _accruedToTreasury(market.underlying)).rayMul(
@@ -212,11 +222,18 @@ contract IntegrationTest is ForkTest {
         internal
         bypassSupplyCap(market, amount)
     {
-        deal(market.underlying, address(this), amount);
+        deal(market.underlying, address(this), type(uint256).max);
         ERC20(market.underlying).approve(address(pool), amount);
         pool.deposit(market.underlying, amount, onBehalf, 0);
     }
 
+    /// @dev Deposits the given amount of tokens on behalf of the given address, on AaveV3.
+    function _depositSimple(address underlying, uint256 amount, address onBehalf) internal {
+        deal(underlying, address(this), amount);
+        ERC20(underlying).approve(address(pool), amount);
+        pool.deposit(underlying, amount, onBehalf, 0);
+    }
+
     /// @dev Bounds the input supply cap of AaveV3 so that it is exceeded after having deposited a given amount
     function _boundSupplyCapExceeded(TestMarket storage market, uint256 amount, uint256 supplyCap)
         internal

test/integration/TestIntegrationAssetAsCollateral.sol

@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+import {IMorpho} from "src/interfaces/IMorpho.sol";
+
+import {Errors} from "src/libraries/Errors.sol";
+import {UserConfiguration} from "@aave-v3-core/protocol/libraries/configuration/UserConfiguration.sol";
+
+import {Morpho} from "src/Morpho.sol";
+
+import "test/helpers/IntegrationTest.sol";
+
+contract TestIntegrationAssetAsCollateral is IntegrationTest {
+    using UserConfiguration for DataTypes.UserConfigurationMap;
+
+    function setUp() public override {
+        super.setUp();
+
+        // Deposit LINK dust so that setting LINK as collateral does not revert on the pool.
+        _depositSimple(link, 1e12, address(morpho));
+
+        morpho.setAssetIsCollateral(dai, false);
+        morpho.setAssetIsCollateral(usdc, false);
+        morpho.setAssetIsCollateral(aave, false);
+        morpho.setAssetIsCollateral(wbtc, false);
+        morpho.setAssetIsCollateral(weth, false);
+
+        vm.startPrank(address(morpho));
+        pool.setUserUseReserveAsCollateral(dai, false);
+        pool.setUserUseReserveAsCollateral(usdc, false);
+        pool.setUserUseReserveAsCollateral(aave, false);
+        pool.setUserUseReserveAsCollateral(wbtc, false);
+        pool.setUserUseReserveAsCollateral(weth, false);
+        pool.setUserUseReserveAsCollateral(link, false);
+        vm.stopPrank();
+    }
+
+    function testSetAssetIsCollateralShouldRevertWhenMarketNotCreated(address underlying) public {
+        vm.expectRevert(Errors.MarketNotCreated.selector);
+        morpho.setAssetIsCollateral(underlying, true);
+    }
+
+    function testSetAssetIsCollateral() public {
+        assertEq(morpho.market(dai).isCollateral, false);
+        assertEq(_isUsingAsCollateral(dai), false);
+
+        morpho.setAssetIsCollateral(dai, true);
+
+        assertEq(morpho.market(dai).isCollateral, true);
+        assertEq(_isUsingAsCollateral(dai), true);
+    }
+
+    function testSetAssetIsNotCollateral() public {
+        vm.prank(address(morpho));
+        pool.setUserUseReserveAsCollateral(dai, true);
+
+        assertEq(morpho.market(dai).isCollateral, false);
+        assertEq(_isUsingAsCollateral(dai), true);
+
+        morpho.setAssetIsCollateral(dai, false);
+
+        assertEq(morpho.market(dai).isCollateral, false);
+        assertEq(_isUsingAsCollateral(dai), true);
+    }
+
+    function testSetAssetIsCollateralOnPoolShouldRevertWhenMarketIsNotCreated() public {
+        assertEq(morpho.market(link).isCollateral, false);
+        assertEq(pool.getUserConfiguration(address(morpho)).isUsingAsCollateral(pool.getReserveData(link).id), false);
+
+        vm.expectRevert(Errors.MarketNotCreated.selector);
+        morpho.setAssetIsCollateralOnPool(link, true);
+    }
+
+    function testSetAssetIsCollateralOnPoolWhenMarketIsCreatedAndIsCollateralOnMorphoAndOnPool() public {
+        vm.prank(address(morpho));
+        pool.setUserUseReserveAsCollateral(dai, true);
+        morpho.setAssetIsCollateral(dai, true);
+
+        assertEq(morpho.market(dai).isCollateral, true);
+        assertEq(_isUsingAsCollateral(dai), true);
+
+        morpho.setAssetIsCollateralOnPool(dai, true);
+
+        assertEq(morpho.market(dai).isCollateral, true);
+        assertEq(_isUsingAsCollateral(dai), true);
+    }
+
+    function testSetAssetIsCollateralOnPoolWhenMarketIsCreatedAndIsNotCollateralOnMorphoOnly() public {
+        vm.prank(address(morpho));
+        pool.setUserUseReserveAsCollateral(dai, true);
+
+        assertEq(morpho.market(dai).isCollateral, false);
+        assertEq(_isUsingAsCollateral(dai), true);
+
+        morpho.setAssetIsCollateralOnPool(dai, true);
+
+        assertEq(morpho.market(dai).isCollateral, false);
+        assertEq(_isUsingAsCollateral(dai), true);
+    }
+
+    function testSetAssetIsCollateralOnPoolWhenMarketIsCreatedAndIsNotCollateral() public {
+        assertEq(morpho.market(dai).isCollateral, false);
+        assertEq(_isUsingAsCollateral(dai), false);
+
+        morpho.setAssetIsCollateralOnPool(dai, true);
+
+        assertEq(morpho.market(dai).isCollateral, false);
+        assertEq(_isUsingAsCollateral(dai), true);
+    }
+
+    function testSetAssetIsNotCollateralOnPoolWhenMarketIsNotCreated() public {
+        vm.prank(address(morpho));
+        pool.setUserUseReserveAsCollateral(link, true);
+
+        assertEq(morpho.market(link).isCollateral, false);
+        assertEq(pool.getUserConfiguration(address(morpho)).isUsingAsCollateral(pool.getReserveData(link).id), true);
+
+        morpho.setAssetIsCollateralOnPool(link, false);
+
+        assertEq(morpho.market(link).isCollateral, false);
+        assertEq(pool.getUserConfiguration(address(morpho)).isUsingAsCollateral(pool.getReserveData(link).id), false);
+    }
+
+    function testSetAssetIsNotCollateralOnPoolWhenMarketIsCreatedAndIsCollateralOnMorphoAndOnPool() public {
+        vm.prank(address(morpho));
+        pool.setUserUseReserveAsCollateral(dai, true);
+        morpho.setAssetIsCollateral(dai, true);
+
+        assertEq(morpho.market(dai).isCollateral, true);
+        assertEq(_isUsingAsCollateral(dai), true);
+
+        morpho.setAssetIsCollateralOnPool(dai, false);
+
+        assertEq(morpho.market(dai).isCollateral, false);
+        assertEq(_isUsingAsCollateral(dai), false);
+    }
+
+    function testSetAssetIsNotCollateralOnPoolWhenMarketIsCreatedAndIsNotCollateralOnMorphoOnly() public {
+        vm.prank(address(morpho));
+        pool.setUserUseReserveAsCollateral(dai, true);
+
+        assertEq(morpho.market(dai).isCollateral, false);
+        assertEq(_isUsingAsCollateral(dai), true);
+
+        morpho.setAssetIsCollateralOnPool(dai, false);
+
+        assertEq(morpho.market(dai).isCollateral, false);
+        assertEq(_isUsingAsCollateral(dai), false);
+    }
+
+    function _isUsingAsCollateral(address underlying) internal view returns (bool) {
+        return pool.getUserConfiguration(address(morpho)).isUsingAsCollateral(pool.getReserveData(underlying).id);
+    }
+}

test/integration/TestIntegrationLiquidate.sol

@@ -482,9 +482,10 @@ contract TestIntegrationLiquidate is IntegrationTest {
             1,
             "borrow balance"
         );
-        assertEq(
+        assertApproxEqAbs(
             morpho.collateralBalance(collateralMarket.underlying, borrower),
             formerCollateralBalance - expectedSeized,
+            1,
             "collateral balance"
         );
     }

test/integration/TestIntegrationWithdraw.sol

@@ -62,7 +62,7 @@ contract TestIntegrationWithdraw is IntegrationTest {
             assertApproxLeAbs(test.withdrawn, amount, 1, "withdrawn != amount");
             assertApproxLeAbs(p2pSupply, promoted, 2, "p2pSupply != promoted");
 
-            assertApproxLeAbs(morpho.supplyBalance(market.underlying, onBehalf), remaining, 1, "supply != remaining");
+            assertApproxLeAbs(morpho.supplyBalance(market.underlying, onBehalf), remaining, 2, "supply != remaining");
             assertEq(morpho.collateralBalance(market.underlying, onBehalf), 0, "collateral != 0");
 
             // Assert Morpho's position on pool.
@@ -145,15 +145,18 @@ contract TestIntegrationWithdraw is IntegrationTest {
             assertEq(test.scaledPoolSupply, 0, "scaledPoolSupply != 0");
             assertEq(test.scaledCollateral, 0, "scaledCollateral != 0");
             assertApproxEqAbs(test.withdrawn, test.supplied, 3, "withdrawn != supplied");
-            assertEq(
-                morpho.scaledP2PBorrowBalance(market.underlying, address(promoter1)), 0, "promoterScaledP2PBorrow != 0"
+            assertApproxEqAbs(
+                morpho.scaledP2PBorrowBalance(market.underlying, address(promoter1)),
+                0,
+                2,
+                "promoterScaledP2PBorrow != 0"
             );
 
             // Assert Morpho getters.
             assertEq(morpho.supplyBalance(market.underlying, onBehalf), 0, "supply != 0");
             assertEq(morpho.collateralBalance(market.underlying, onBehalf), 0, "collateral != 0");
-            assertApproxGeAbs(
-                morpho.borrowBalance(market.underlying, address(promoter1)), promoted, 3, "promoterBorrow != promoted"
+            assertApproxEqAbs(
+                morpho.borrowBalance(market.underlying, address(promoter1)), promoted, 2, "promoterBorrow != promoted"
             );
 
             // Assert Morpho's position on pool.
@@ -173,9 +176,9 @@ contract TestIntegrationWithdraw is IntegrationTest {
 
             // Assert Morpho's market state.
             assertEq(test.morphoMarket.deltas.supply.scaledDelta, 0, "scaledSupplyDelta != 0");
-            assertApproxEqAbs(test.morphoMarket.deltas.supply.scaledP2PTotal, 0, 1, "scaledTotalSupplyP2P != 0");
+            assertApproxEqAbs(test.morphoMarket.deltas.supply.scaledP2PTotal, 0, 2, "scaledTotalSupplyP2P != 0");
             assertEq(test.morphoMarket.deltas.borrow.scaledDelta, 0, "scaledBorrowDelta != 0");
-            assertApproxEqAbs(test.morphoMarket.deltas.borrow.scaledP2PTotal, 0, 1, "scaledTotalBorrowP2P != 0");
+            assertApproxEqAbs(test.morphoMarket.deltas.borrow.scaledP2PTotal, 0, 2, "scaledTotalBorrowP2P != 0");
             assertEq(test.morphoMarket.idleSupply, 0, "idleSupply != 0");
         }
     }