remove idle supply

.github/workflows/foundry.yml

@@ -63,10 +63,10 @@ jobs:
         type: ["slow", "fast"]
         include:
           - type: "slow"
-            fuzz-runs: 8192
+            fuzz-runs: 1024
             max-test-rejects: 1048576
-            invariant-runs: 64
-            invariant-depth: 1024
+            invariant-runs: 32
+            invariant-depth: 512
           - type: "fast"
             fuzz-runs: 256
             max-test-rejects: 65536

README.md

@@ -75,12 +75,15 @@ Multiple addresses can have this role.
 It can:
 
 - Set the `supplyQueue` and `withdrawQueue`, i.e. decide on the order of the markets to supply/withdraw from.
-  - Upon a deposit, the vault will supply up to the cap of each Morpho Blue market in the `supplyQueue` in the order set. The remaining funds are left as idle supply on the vault (uncapped).
+  - Upon a deposit, the vault will supply up to the cap of each Morpho Blue market in the `supplyQueue` in the order set.
   - Upon a withdrawal, the vault will first withdraw from the idle supply and then withdraw up to the liquidity of each Morpho Blue market in the `withdrawalQueue` in the order set.
   - The `supplyQueue` only contains markets which cap has previously been non-zero.
   - The `withdrawQueue` contains all markets that have a non-zero cap or a non-zero vault allocation.
 - Instantaneously reallocate funds by supplying on markets of the `withdrawQueue` and withdrawing from markets that have the same loan asset as the vault's asset.
 
+> **Warning**
+> If `supplyQueue` is empty, depositing to the vault is disabled.
+
 #### Guardian
 
 Only one address can have this role.
@@ -91,6 +94,23 @@ It can:
 - Revoke the pending guardian (which means it can revoke any attempt to change the guardian).
 - Revoke the pending cap of any market.
 
+### Idle Supply
+
+In some cases, the vault's curator or allocators may want to keep some funds "idle", to guarantee lenders that some liquidity can be withdrawn from the vault (beyond the liquidity of each of the vault's markets).
+
+To achieve this, it is advised to allocate "idle" funds to any market on Morpho Blue having:
+
+- The vault's asset as loan token.
+- No collateral token (`address(0)`).
+- An arbitrary IRM.
+- An arbitrary oracle (`address(0)`).
+- An arbitrary LLTV.
+
+Thus, these funds cannot be borrowed on Morpho Blue and are guaranteed to be liquid; though it won't generate interest.
+
+Note that to allocate funds to this idle market, it is first required to enable its cap on MetaMorpho.
+Enabling an infinite cap (`type(uint184).max`) will always allow users to deposit on the vault.
+
 ### Rewards
 
 To redistribute rewards to vault depositors, it is advised to use the [Universal Rewards Distributor (URD)](https://github.com/morpho-org/universal-rewards-distributor).
@@ -111,8 +131,7 @@ Below is a typical example of how this use case would take place:
 
   NB: Anyone can transfer rewards from the vault to the rewards distributor unless it is unset.
   Thus, this step might be already performed by some third-party.
-  Note: the amount of rewards transferred is calculated based on the balance in the reward asset of the vault.
-  In case the reward asset is the vault’s asset, the vault’s idle liquidity is automatically subtracted to prevent stealing idle liquidity.
+  Note: the amount of rewards transferred corresponds to the vault's balance of reward asset.
 
 - Compute the new root for the vault’s rewards distributor, submit it, wait for the timelock (if any), accept the root, and let vault depositors claim their rewards according to the vault manager’s rewards re-distribution strategy.
 

src/MetaMorpho.sol

@@ -95,10 +95,6 @@ contract MetaMorpho is ERC4626, ERC20Permit, Ownable2Step, Multicall, IMetaMorph
     /// without duplicate.
     Id[] public withdrawQueue;
 
-    /// @notice Stores the idle liquidity.
-    /// @dev The idle liquidity does not generate any interest.
-    uint256 public idle;
-
     /// @notice Stores the total assets managed by this vault when the fee was last accrued.
     /// @dev May be a little off `totalAssets()` after each interaction, due to some roundings.
     uint256 public lastTotalAssets;
@@ -418,7 +414,10 @@ contract MetaMorpho is ERC4626, ERC20Permit, Ownable2Step, Multicall, IMetaMorph
 
                 totalWithdrawn += withdrawnAssets;
             } else {
-                uint256 suppliedAssets = allocation.assets.zeroFloorSub(supplyAssets);
+                uint256 suppliedAssets = allocation.assets == type(uint256).max
+                    ? totalWithdrawn.zeroFloorSub(totalSupplied)
+                    : allocation.assets.zeroFloorSub(supplyAssets);
+
                 if (suppliedAssets == 0) continue;
 
                 uint256 supplyCap = config[id].cap;
@@ -436,19 +435,7 @@ contract MetaMorpho is ERC4626, ERC20Permit, Ownable2Step, Multicall, IMetaMorph
             }
         }
 
-        uint256 newIdle;
-        if (totalWithdrawn > totalSupplied) {
-            newIdle = idle + totalWithdrawn - totalSupplied;
-        } else {
-            uint256 idleSupplied = totalSupplied - totalWithdrawn;
-            if (idle < idleSupplied) revert ErrorsLib.InsufficientIdle();
-
-            newIdle = idle - idleSupplied;
-        }
-
-        idle = newIdle;
-
-        emit EventsLib.ReallocateIdle(_msgSender(), newIdle);
+        if (totalWithdrawn != totalSupplied) revert ErrorsLib.InconsistentReallocation();
     }
 
     /* REVOKE FUNCTIONS */
@@ -520,7 +507,6 @@ contract MetaMorpho is ERC4626, ERC20Permit, Ownable2Step, Multicall, IMetaMorph
         if (skimRecipient == address(0)) revert ErrorsLib.ZeroAddress();
 
         uint256 amount = IERC20(token).balanceOf(address(this));
-        if (token == asset()) amount -= idle;
 
         IERC20(token).safeTransfer(skimRecipient, amount);
 
@@ -534,6 +520,18 @@ contract MetaMorpho is ERC4626, ERC20Permit, Ownable2Step, Multicall, IMetaMorph
         return ERC4626.decimals();
     }
 
+    /// @inheritdoc IERC4626
+    function maxDeposit(address) public view override returns (uint256) {
+        return _maxDeposit();
+    }
+
+    /// @inheritdoc IERC4626
+    function maxMint(address) public view override returns (uint256) {
+        uint256 suppliable = _maxDeposit();
+
+        return _convertToShares(suppliable, Math.Rounding.Floor);
+    }
+
     /// @inheritdoc IERC4626
     /// @dev Warning: May be lower than the actual amount of assets that can be withdrawn by `owner` due to conversion
     /// roundings between shares and assets.
@@ -609,8 +607,6 @@ contract MetaMorpho is ERC4626, ERC20Permit, Ownable2Step, Multicall, IMetaMorph
         for (uint256 i; i < withdrawQueue.length; ++i) {
             assets += MORPHO.expectedSupplyAssets(_marketParams(withdrawQueue[i]), address(this));
         }
-
-        assets += idle;
     }
 
     /* ERC4626 (INTERNAL) */
@@ -635,6 +631,20 @@ contract MetaMorpho is ERC4626, ERC20Permit, Ownable2Step, Multicall, IMetaMorph
         assets -= _simulateWithdrawMorpho(assets);
     }
 
+    /// @dev Returns the maximum amount of assets that the vault can supply on Morpho.
+    function _maxDeposit() internal view returns (uint256 totalSuppliable) {
+        for (uint256 i; i < supplyQueue.length; ++i) {
+            Id id = supplyQueue[i];
+
+            uint256 supplyCap = config[id].cap;
+            if (supplyCap == 0) continue;
+
+            uint256 supplyAssets = MORPHO.expectedSupplyAssets(_marketParams(id), address(this));
+
+            totalSuppliable += supplyCap.zeroFloorSub(supplyAssets);
+        }
+    }
+
     /// @inheritdoc ERC4626
     /// @dev The accrual of performance fees is taken into account in the conversion.
     function _convertToShares(uint256 assets, Math.Rounding rounding) internal view override returns (uint256) {
@@ -689,13 +699,13 @@ contract MetaMorpho is ERC4626, ERC20Permit, Ownable2Step, Multicall, IMetaMorph
     /// @dev Depending on 4 cases, reverts when withdrawing "too much" with:
     /// 1. ERC20InsufficientAllowance when withdrawing more than `caller`'s allowance.
     /// 2. ERC20InsufficientBalance when withdrawing more than `owner`'s balance but less than vault's total assets.
-    /// 3. WithdrawMorphoFailed when withdrawing more than vault's total assets.
-    /// 4. WithdrawMorphoFailed when withdrawing more than `owner`'s balance but less than the available liquidity.
+    /// 3. NotEnoughLiquidity when withdrawing more than vault's total assets.
+    /// 4. NotEnoughLiquidity when withdrawing more than `owner`'s balance but less than the available liquidity.
     function _withdraw(address caller, address receiver, address owner, uint256 assets, uint256 shares)
         internal
         override
     {
-        if (_withdrawMorpho(assets) != 0) revert ErrorsLib.WithdrawMorphoFailed();
+        _withdrawMorpho(assets);
 
         super._withdraw(caller, receiver, owner, assets, shares);
     }
@@ -776,7 +786,7 @@ contract MetaMorpho is ERC4626, ERC20Permit, Ownable2Step, Multicall, IMetaMorph
 
     /* LIQUIDITY ALLOCATION */
 
-    /// @dev Supplies `assets` to Morpho and increase the idle liquidity if necessary.
+    /// @dev Supplies `assets` to Morpho.
     function _supplyMorpho(uint256 assets) internal {
         for (uint256 i; i < supplyQueue.length; ++i) {
             Id id = supplyQueue[i];
@@ -799,43 +809,36 @@ contract MetaMorpho is ERC4626, ERC20Permit, Ownable2Step, Multicall, IMetaMorph
             if (assets == 0) return;
         }
 
-        idle += assets;
+        if (assets != 0) revert ErrorsLib.AllCapsReached();
     }
 
-    /// @dev Withdraws `assets` from the idle liquidity and Morpho if necessary.
-    /// @return remaining The assets left to be withdrawn.
-    function _withdrawMorpho(uint256 assets) internal returns (uint256 remaining) {
-        (remaining, idle) = _withdrawIdle(assets);
-
-        if (remaining == 0) return 0;
-
+    /// @dev Withdraws `assets` from Morpho.
+    function _withdrawMorpho(uint256 assets) internal {
         for (uint256 i; i < withdrawQueue.length; ++i) {
             Id id = withdrawQueue[i];
             MarketParams memory marketParams = _marketParams(id);
             (uint256 supplyAssets,, Market memory market) = _accruedSupplyBalance(marketParams, id);
 
             uint256 toWithdraw = UtilsLib.min(
-                _withdrawable(marketParams, market.totalSupplyAssets, market.totalBorrowAssets, supplyAssets), remaining
+                _withdrawable(marketParams, market.totalSupplyAssets, market.totalBorrowAssets, supplyAssets), assets
             );
 
             if (toWithdraw > 0) {
                 // Using try/catch to skip markets that revert.
                 try MORPHO.withdraw(marketParams, toWithdraw, 0, address(this), address(this)) {
-                    remaining -= toWithdraw;
+                    assets -= toWithdraw;
                 } catch {}
             }
 
-            if (remaining == 0) return 0;
+            if (assets == 0) return;
         }
-    }
-
-    /// @dev Simulates a withdraw of `assets` from the idle liquidity and Morpho if necessary.
-    /// @return remaining The assets left to be withdrawn.
-    function _simulateWithdrawMorpho(uint256 assets) internal view returns (uint256 remaining) {
-        (remaining,) = _withdrawIdle(assets);
 
-        if (remaining == 0) return 0;
+        if (assets != 0) revert ErrorsLib.NotEnoughLiquidity();
+    }
 
+    /// @dev Simulates a withdraw of `assets` from Morpho.
+    /// @return The remaining assets to be withdrawn.
+    function _simulateWithdrawMorpho(uint256 assets) internal view returns (uint256) {
         for (uint256 i; i < withdrawQueue.length; ++i) {
             Id id = withdrawQueue[i];
             MarketParams memory marketParams = _marketParams(id);
@@ -848,25 +851,19 @@ contract MetaMorpho is ERC4626, ERC20Permit, Ownable2Step, Multicall, IMetaMorph
             // 1. oracle.price() is never called (the vault doesn't borrow)
             // 2. the amount is capped to the liquidity available on Morpho
             // 3. virtually accruing interest didn't fail
-            remaining -= UtilsLib.min(
+            assets = assets.zeroFloorSub(
                 _withdrawable(
                     marketParams,
                     totalSupplyAssets,
                     totalBorrowAssets,
                     supplyShares.toAssetsDown(totalSupplyAssets, totalSupplyShares)
-                ),
-                remaining
+                )
             );
 
-            if (remaining == 0) return 0;
+            if (assets == 0) break;
         }
-    }
 
-    /// @dev Withdraws `assets` from the idle liquidity.
-    /// @return The remaining assets to withdraw.
-    /// @return The new `idle` liquidity value.
-    function _withdrawIdle(uint256 assets) internal view returns (uint256, uint256) {
-        return (assets.zeroFloorSub(idle), idle.zeroFloorSub(assets));
+        return assets;
     }
 
     /// @dev Returns the withdrawable amount of assets from the market defined by `marketParams`, given the market's

src/interfaces/IMetaMorpho.sol

@@ -45,7 +45,6 @@ interface IMetaMorphoBase {
     function withdrawQueue(uint256) external view returns (Id);
     function withdrawQueueLength() external view returns (uint256);
 
-    function idle() external view returns (uint256);
     function lastTotalAssets() external view returns (uint256);
 
     function submitTimelock(uint256 newTimelock) external;

src/libraries/ErrorsLib.sol

@@ -57,8 +57,8 @@ library ErrorsLib {
     /// @notice Thrown when there's no pending value to set.
     error NoPendingValue();
 
-    /// @notice Thrown when the remaining asset to withdraw is not 0.
-    error WithdrawMorphoFailed();
+    /// @notice Thrown when the requested liquidity cannot be withdrawn from Morpho.
+    error NotEnoughLiquidity();
 
     /// @notice Thrown when submitting a cap for a market which does not exist.
     error MarketNotCreated();
@@ -81,6 +81,9 @@ library ErrorsLib {
     /// @notice Thrown when setting the fee to a non zero value while the fee recipient is the zero address.
     error ZeroFeeRecipient();
 
-    /// @notice Thrown when the idle liquidity is insufficient to cover supply during a reallocation of funds.
-    error InsufficientIdle();
+    /// @notice Thrown when the amount withdrawn is not excatly the amount supplied.
+    error InconsistentReallocation();
+
+    /// @notice Thrown when all caps have been reached.
+    error AllCapsReached();
 }

src/libraries/EventsLib.sol

@@ -13,7 +13,7 @@ library EventsLib {
     /// @notice Emitted when a pending `newTimelock` is submitted.
     event SubmitTimelock(uint256 newTimelock);
 
-    /// @notice Emitted `timelock` is set to `newTimelock`.
+    /// @notice Emitted when `timelock` is set to `newTimelock`.
     event SetTimelock(address indexed caller, uint256 newTimelock);
 
     /// @notice Emitted when `skimRecipient` is set to `newSkimRecipient`.
@@ -79,9 +79,6 @@ library EventsLib {
     /// @param withdrawnShares The amount of shares burned.
     event ReallocateWithdraw(address indexed caller, Id indexed id, uint256 withdrawnAssets, uint256 withdrawnShares);
 
-    /// @notice Emitted when a reallocation added or removed assets from idle.
-    event ReallocateIdle(address indexed caller, uint256 idle);
-
     /// @notice Emitted when interest are accrued.
     /// @param newTotalAssets The assets of the vault after accruing the interest but before the interaction.
     /// @param feeShares The shares minted to the fee recipient.

src/mocks/ERC20Mock.sol

@@ -6,10 +6,12 @@ import {ERC20} from "@openzeppelin/token/ERC20/ERC20.sol";
 contract ERC20Mock is ERC20 {
     constructor(string memory _name, string memory _symbol) ERC20(_name, _symbol) {}
 
+    /// @dev Required for ERC4626-compliance tests.
     function mint(address account, uint256 amount) external {
         _mint(account, amount);
     }
 
+    /// @dev Required for ERC4626-compliance tests.
     function burn(address account, uint256 amount) external {
         _burn(account, amount);
     }

test/forge/ERC4626ComplianceTest.sol

@@ -15,6 +15,7 @@ contract ERC4626ComplianceTest is IntegrationTest, ERC4626Test {
         _vaultMayBeEmpty = true;
         _unlimitedAmount = true;
 
-        _setCap(allMarkets[0], 1e28);
+        _setCap(allMarkets[0], 100e18);
+        _sortSupplyQueueIdleLast();
     }
 }