Reallocate by withdrawals + sink

src/PublicAllocator.sol

@@ -6,15 +6,23 @@ import {
 } from "../lib/metamorpho/src/interfaces/IMetaMorpho.sol";
 
 import {MarketParamsLib} from "../lib/metamorpho/lib/morpho-blue/src/libraries/MarketParamsLib.sol";
-
 import {MorphoBalancesLib} from "../lib/metamorpho/lib/morpho-blue/src/libraries/periphery/MorphoBalancesLib.sol";
 
 import {Market} from "../lib/metamorpho/lib/morpho-blue/src/interfaces/IMorpho.sol";
-import {UtilsLib} from "./libraries/UtilsLib.sol";
+
+import {UtilsLib} from "../lib/metamorpho/lib/morpho-blue/src/libraries/UtilsLib.sol";
 
 import {ErrorsLib} from "./libraries/ErrorsLib.sol";
 import {EventsLib} from "./libraries/EventsLib.sol";
-import {FlowCap, FlowConfig, SupplyConfig, IPublicAllocatorStaticTyping, IPublicAllocatorBase} from "./interfaces/IPublicAllocator.sol";
+import {
+    FlowCap,
+    FlowConfig,
+    SupplyConfig,
+    Withdrawal,
+    MAX_SETTABLE_FLOW_CAP,
+    IPublicAllocatorStaticTyping,
+    IPublicAllocatorBase
+} from "./interfaces/IPublicAllocator.sol";
 
 /// @title MetaMorpho
 /// @author Morpho Labs
@@ -24,7 +32,6 @@ contract PublicAllocator is IPublicAllocatorStaticTyping {
     using MorphoBalancesLib for IMorpho;
     using MarketParamsLib for MarketParams;
     using UtilsLib for uint256;
-    using UtilsLib for uint128;
 
     /// CONSTANTS ///
 
@@ -72,36 +79,53 @@ contract PublicAllocator is IPublicAllocatorStaticTyping {
     /// PUBLIC ///
 
     /// @inheritdoc IPublicAllocatorBase
-    function reallocate(MarketAllocation[] calldata allocations) external payable {
+    function withdrawTo(Withdrawal[] calldata withdrawals, MarketParams calldata depositMarketParams)
+        external
+        payable
+    {
         if (msg.value != fee) revert ErrorsLib.IncorrectFee();
 
-        uint256[] memory assets = new uint256[](allocations.length);
-        for (uint256 i = 0; i < allocations.length; i++) {
-            // Do not compute interest twice for every market
-            MORPHO.accrueInterest(allocations[i].marketParams);
-            assets[i] = MORPHO.expectedSupplyAssets(allocations[i].marketParams, address(VAULT));
+        MarketAllocation[] memory allocations = new MarketAllocation[](withdrawals.length + 1);
+        Id depositMarketId = depositMarketParams.id();
+        uint128 totalWithdrawn;
+
+        for (uint256 i = 0; i < withdrawals.length; i++) {
+            Id id = withdrawals[i].marketParams.id();
+
+            // Revert if the market is elsewhere in the list, or is the deposit market.
+            for (uint256 j = i + 1; j < withdrawals.length; j++) {
+                if (Id.unwrap(id) == Id.unwrap(withdrawals[j].marketParams.id())) {
+                    revert ErrorsLib.InconsistentWithdrawTo();
+                }
+            }
+            if (Id.unwrap(id) == Id.unwrap(depositMarketId)) revert ErrorsLib.InconsistentWithdrawTo();
+
+            uint128 withdrawnAssets = withdrawals[i].amount;
+            totalWithdrawn += withdrawnAssets;
+
+            MORPHO.accrueInterest(withdrawals[i].marketParams);
+            uint256 assets = MORPHO.expectedSupplyAssets(withdrawals[i].marketParams, address(VAULT));
+
+            allocations[i].marketParams = withdrawals[i].marketParams;
+            allocations[i].assets = assets - withdrawnAssets;
+            flowCap[id].maxIn += withdrawnAssets;
+            flowCap[id].maxOut -= withdrawnAssets;
+
+            emit EventsLib.PublicWithdrawal(id, withdrawnAssets);
         }
 
+        allocations[withdrawals.length].marketParams = depositMarketParams;
+        allocations[withdrawals.length].assets = type(uint256).max;
+        flowCap[depositMarketId].maxIn -= totalWithdrawn;
+        flowCap[depositMarketId].maxOut += totalWithdrawn;
+
         VAULT.reallocate(allocations);
 
-        MarketParams memory marketParams;
-        for (uint256 i = 0; i < allocations.length; i++) {
-            marketParams = allocations[i].marketParams;
-            Id id = marketParams.id();
-            uint256 newAssets = MORPHO.expectedSupplyAssets(marketParams, address(VAULT));
-            if (newAssets >= assets[i]) {
-                if (newAssets > supplyCap[id]) revert ErrorsLib.PublicAllocatorSupplyCapExceeded(id);
-                uint128 inflow = (newAssets - assets[i]).toUint128();
-                flowCap[id].maxIn -= inflow;
-                flowCap[id].maxOut = (flowCap[id].maxOut).saturatingAdd(inflow);
-            } else {
-                uint128 outflow = (assets[i] - newAssets).toUint128();
-                flowCap[id].maxIn = (flowCap[id].maxIn).saturatingAdd(outflow);
-                flowCap[id].maxOut -= outflow;
-            }
+        if (MORPHO.expectedSupplyAssets(depositMarketParams, address(VAULT)) > supplyCap[depositMarketId]) {
+            revert ErrorsLib.PublicAllocatorSupplyCapExceeded(depositMarketId);
         }
 
-        emit EventsLib.PublicReallocate(msg.sender);
+        emit EventsLib.PublicReallocateTo(msg.sender, depositMarketId, totalWithdrawn);
     }
 
     /// OWNER ONLY ///
@@ -123,6 +147,9 @@ contract PublicAllocator is IPublicAllocatorStaticTyping {
     /// @inheritdoc IPublicAllocatorBase
     function setFlowCaps(FlowConfig[] calldata flowCaps) external onlyOwner {
         for (uint256 i = 0; i < flowCaps.length; i++) {
+            if (flowCaps[i].cap.maxIn > MAX_SETTABLE_FLOW_CAP || flowCaps[i].cap.maxOut > MAX_SETTABLE_FLOW_CAP) {
+                revert ErrorsLib.MaxSettableFlowCapExceeded();
+            }
             flowCap[flowCaps[i].id] = flowCaps[i].cap;
         }
 

src/interfaces/IPublicAllocator.sol

@@ -1,7 +1,17 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 pragma solidity ^0.8.21;
 
-import {IMetaMorpho, IMorpho, MarketAllocation, Id} from "../../lib/metamorpho/src/interfaces/IMetaMorpho.sol";
+import {
+    IMetaMorpho,
+    IMorpho,
+    MarketAllocation,
+    Id,
+    MarketParams
+} from "../../lib/metamorpho/src/interfaces/IMetaMorpho.sol";
+
+/// @dev Equal to type(uint128).max/2, so flow caps can always be stored on 128 bits
+/// @dev The actual max possible flow cap is type(uint128).max-1.
+uint128 constant MAX_SETTABLE_FLOW_CAP = 170141183460469231731687303715884105727;
 
 struct FlowCap {
     /// @notice The maximum allowed inflow in a market
@@ -20,6 +30,13 @@ struct SupplyConfig {
     uint256 cap;
 }
 
+struct Withdrawal {
+    /// @notice The market from which to withdraw.
+    MarketParams marketParams;
+    /// @notice The amount to withdraw.
+    uint128 amount;
+}
+
 /// @dev This interface is used for factorizing IPublicAllocatorStaticTyping and IPublicAllocator.
 /// @dev Consider using the IPublicAllocator interface instead of this one.
 interface IPublicAllocatorBase {
@@ -31,18 +48,22 @@ interface IPublicAllocatorBase {
 
     /// @notice The address of the Morpho contract.
     function MORPHO() external view returns (IMorpho);
-    
+
     /// @notice The current fee.
     function fee() external view returns (uint256);
 
     /// @notice Given a market, the cap a supply through public allocation cannot exceed.
     /// @notice A withdraw through public allocation can start and end above the cap.
     function supplyCap(Id) external view returns (uint256);
 
-    /// @notice Calls the vault's `reallocate` function.
-    /// @notice See MetaMorpho's `reallocate` function documentation.
+    /// @notice Reallocate from a list of markets to one market.
+    /// @param withdrawals The markets to withdraw from,and the amounts to withdraw.
+    /// @param depositMarketParams The market receiving total withdrawn to.
+    /// @dev Will call MetaMorpho's `reallocate`.
     /// @dev Checks that the public allocator constraints are respected.
-    function reallocate(MarketAllocation[] calldata allocations) external payable;
+    function withdrawTo(Withdrawal[] calldata withdrawals, MarketParams calldata depositMarketParams)
+        external
+        payable;
 
     /// @notice Set the current fee.
     function setFee(uint256 _fee) external;
@@ -51,6 +72,7 @@ interface IPublicAllocatorBase {
     function transferFee(address payable feeRecipient) external;
 
     /// @notice Sets the maximum inflow and outflow through public allocation for some markets.
+    /// @dev Max allowed inflow/outflow is MAX_SETTABLE_FLOW_CAP.
     /// @dev Doesn't revert if it doesn't change the storage at all.
     function setFlowCaps(FlowConfig[] calldata _flowCaps) external;
 

src/libraries/ErrorsLib.sol

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 pragma solidity ^0.8.0;
 
-import {Id} from "../../lib/metamorpho/src/interfaces/IMetaMorpho.sol";
+import {Id, MarketParams} from "../../lib/metamorpho/src/interfaces/IMetaMorpho.sol";
+import {Withdrawal} from "../interfaces/IPublicAllocator.sol";
 
 /// @title ErrorsLib
 /// @author Morpho Labs
@@ -38,6 +39,12 @@ library ErrorsLib {
     /// @notice Thrown when the value is already set.
     error AlreadySet();
 
+    /// @notice Thrown when there are duplicates with nonzero assets in `withdrawTo` arguments.
+    error InconsistentWithdrawTo();
+
+    /// @notice Thrown when attempting to set max inflow/outflow above the MAX_SETTABLE_FLOW_CAP.
+    error MaxSettableFlowCapExceeded();
+
     /// @notice Thrown when the PublicAllocatorFactory is called with a vault not made by the MetaMorphoFactory.
     error NotMetaMorpho();
 }

src/libraries/EventsLib.sol

@@ -1,17 +1,20 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 pragma solidity ^0.8.0;
 
-import {FlowConfig, SupplyConfig} from "../interfaces/IPublicAllocator.sol";
+import {FlowConfig, SupplyConfig, Id} from "../interfaces/IPublicAllocator.sol";
 
 /// @title EventsLib
 /// @author Morpho Labs
 /// @custom:contact security@morpho.org
 /// @notice Library exposing events.
 library EventsLib {
-    /// @notice Emitted when the public reallocation is triggered.
-    event PublicReallocate(address sender);
+    /// @notice Emitted during a public reallocation for each withdrawn-from market.
+    event PublicWithdrawal(Id id, uint256 withdrawnAssets);
 
-    /// @notice Emitted when the owner changes the `fee`.
+    /// @notice Emitted at the end of a public reallocation.
+    event PublicReallocateTo(address sender, Id depositMarketId, uint256 depositedAssets);
+
+    /// @notice Emitted when the owner changes the `fee`
     event SetFee(uint256 fee);
 
     /// @notice Emitted when the owner transfers the fee.