Recover increase delta and fix safe sub

contracts/aave-v2/ExitPositionsManager.sol

@@ -67,6 +67,11 @@ contract ExitPositionsManager is IExitPositionsManager, PositionsManagerUtils {
         uint256 _amountSeized
     );
 
+    /// @notice Emitted when the peer-to-peer deltas are increased by the governance.
+    /// @param _poolToken The address of the market on which the deltas were increased.
+    /// @param _amount The amount that has been added to the deltas (in underlying).
+    event P2PDeltasIncreased(address indexed _poolToken, uint256 _amount);
+
     /// ERRORS ///
 
     /// @notice Thrown when user is not a member of the market.
@@ -250,6 +255,47 @@ contract ExitPositionsManager is IExitPositionsManager, PositionsManagerUtils {
         );
     }
 
+    /// @notice Implements increaseP2PDeltas logic.
+    /// @dev The current Morpho supply on the pool might not be enough to borrow `_amount` before resupplying it.
+    /// In this case, consider calling this function multiple times.
+    /// @param _poolToken The address of the market on which to increase deltas.
+    /// @param _amount The maximum amount to add to the deltas (in underlying).
+    function increaseP2PDeltasLogic(address _poolToken, uint256 _amount)
+        external
+        isMarketCreated(_poolToken)
+    {
+        _updateIndexes(_poolToken);
+
+        Types.Delta storage deltas = deltas[_poolToken];
+        Types.PoolIndexes memory poolIndexes = poolIndexes[_poolToken];
+
+        _amount = Math.min(
+            _amount,
+            Math.min(
+                deltas.p2pSupplyAmount.rayMul(p2pSupplyIndex[_poolToken]).zeroFloorSub(
+                    deltas.p2pSupplyDelta.rayMul(poolIndexes.poolSupplyIndex)
+                ),
+                deltas.p2pBorrowAmount.rayMul(p2pBorrowIndex[_poolToken]).zeroFloorSub(
+                    deltas.p2pBorrowDelta.rayMul(poolIndexes.poolBorrowIndex)
+                )
+            )
+        );
+
+        deltas.p2pSupplyDelta += _amount.rayDiv(poolIndexes.poolSupplyIndex);
+        deltas.p2pSupplyDelta = deltas.p2pSupplyDelta;
+        deltas.p2pBorrowDelta += _amount.rayDiv(poolIndexes.poolBorrowIndex);
+        deltas.p2pBorrowDelta = deltas.p2pBorrowDelta;
+        emit P2PSupplyDeltaUpdated(_poolToken, deltas.p2pSupplyDelta);
+        emit P2PBorrowDeltaUpdated(_poolToken, deltas.p2pBorrowDelta);
+
+        ERC20 underlyingToken = ERC20(market[_poolToken].underlyingToken);
+
+        _borrowFromPool(underlyingToken, _amount);
+        _supplyToPool(underlyingToken, _amount);
+
+        emit P2PDeltasIncreased(_poolToken, _amount);
+    }
+
     /// INTERNAL ///
 
     /// @dev Implements withdraw logic without security checks.
@@ -498,8 +544,9 @@ contract ExitPositionsManager is IExitPositionsManager, PositionsManagerUtils {
             // No need to subtract p2pBorrowDelta as it is zero.
             vars.feeToRepay = Math.zeroFloorSub(
                 delta.p2pBorrowAmount.rayMul(vars.p2pBorrowIndex),
-                (delta.p2pSupplyAmount.rayMul(vars.p2pSupplyIndex) -
-                    delta.p2pSupplyDelta.rayMul(vars.poolSupplyIndex))
+                delta.p2pSupplyAmount.rayMul(vars.p2pSupplyIndex).zeroFloorSub(
+                    delta.p2pSupplyDelta.rayMul(vars.poolSupplyIndex)
+                )
             );
 
             if (vars.feeToRepay > 0) {

contracts/aave-v2/MorphoGovernance.sol

@@ -13,6 +13,7 @@ abstract contract MorphoGovernance is MorphoUtils {
     using ReserveConfiguration for DataTypes.ReserveConfigurationMap;
     using PercentageMath for uint256;
     using SafeTransferLib for ERC20;
+    using DelegateCall for address;
     using WadRayMath for uint256;
 
     /// EVENTS ///
@@ -327,6 +328,21 @@ abstract contract MorphoGovernance is MorphoUtils {
         pool.setUserUseReserveAsCollateral(market[_poolToken].underlyingToken, _newStatus);
     }
 
+    /// @notice Increases peer-to-peer deltas, to put some liquidity back on the pool.
+    /// @dev The current Morpho supply on the pool might not be enough to borrow `_amount` before resuppling it.
+    /// In this case, consider calling multiple times this function.
+    /// @param _poolToken The address of the market on which to increase deltas.
+    /// @param _amount The maximum amount to add to the deltas (in underlying).
+    function increaseP2PDeltas(address _poolToken, uint256 _amount) external onlyOwner {
+        address(exitPositionsManager).functionDelegateCall(
+            abi.encodeWithSelector(
+                IExitPositionsManager.increaseP2PDeltasLogic.selector,
+                _poolToken,
+                _amount
+            )
+        );
+    }
+
     /// @notice Transfers the protocol reserve fee to the DAO.
     /// @param _poolTokens The addresses of the pool token addresses on which to claim the reserve fee.
     /// @param _amounts The list of amounts of underlying tokens to claim on each market.

contracts/aave-v2/interfaces/IExitPositionsManager.sol

@@ -24,4 +24,6 @@ interface IExitPositionsManager {
         address _borrower,
         uint256 _amount
     ) external;
+
+    function increaseP2PDeltasLogic(address _poolToken, uint256 _amount) external;
 }

contracts/aave-v2/interfaces/aave/IVariableDebtToken.sol

@@ -69,4 +69,10 @@ interface IVariableDebtToken is IScaledBalanceToken {
         uint256 amount,
         uint256 index
     ) external;
+
+    /**
+     * @dev Returns the debt balance of the user
+     * @return The debt balance of the user.
+     **/
+    function balanceOf(address user) external view returns (uint256);
 }

contracts/aave-v3/ExitPositionsManager.sol

@@ -288,35 +288,35 @@ contract ExitPositionsManager is IExitPositionsManager, PositionsManagerUtils {
     /// @notice Implements increaseP2PDeltas logic.
     /// @dev The current Morpho supply on the pool might not be enough to borrow `_amount` before resupplying it.
     /// In this case, consider calling this function multiple times.
-    /// @param _poolToken The address of the market on which to create deltas.
-    /// @param _amount The amount to add to the deltas (in underlying).
-    function increaseP2PDeltasLogic(address _poolToken, uint256 _amount) external {
+    /// @param _poolToken The address of the market on which to increase deltas.
+    /// @param _amount The maximum amount to add to the deltas (in underlying).
+    function increaseP2PDeltasLogic(address _poolToken, uint256 _amount)
+        external
+        isMarketCreated(_poolToken)
+    {
         _updateIndexes(_poolToken);
 
         Types.Delta storage deltas = deltas[_poolToken];
-        Types.Delta memory deltasMem = deltas;
         Types.PoolIndexes memory poolIndexes = poolIndexes[_poolToken];
-        uint256 p2pSupplyIndex = p2pSupplyIndex[_poolToken];
-        uint256 p2pBorrowIndex = p2pBorrowIndex[_poolToken];
 
         _amount = Math.min(
             _amount,
             Math.min(
-                deltasMem.p2pSupplyAmount.rayMul(p2pSupplyIndex).zeroFloorSub(
-                    deltasMem.p2pSupplyDelta.rayMul(poolIndexes.poolSupplyIndex)
+                deltas.p2pSupplyAmount.rayMul(p2pSupplyIndex[_poolToken]).zeroFloorSub(
+                    deltas.p2pSupplyDelta.rayMul(poolIndexes.poolSupplyIndex)
                 ),
-                deltasMem.p2pBorrowAmount.rayMul(p2pBorrowIndex).zeroFloorSub(
-                    deltasMem.p2pBorrowDelta.rayMul(poolIndexes.poolBorrowIndex)
+                deltas.p2pBorrowAmount.rayMul(p2pBorrowIndex[_poolToken]).zeroFloorSub(
+                    deltas.p2pBorrowDelta.rayMul(poolIndexes.poolBorrowIndex)
                 )
             )
         );
 
-        deltasMem.p2pSupplyDelta += _amount.rayDiv(poolIndexes.poolSupplyIndex);
-        deltas.p2pSupplyDelta = deltasMem.p2pSupplyDelta;
-        deltasMem.p2pBorrowDelta += _amount.rayDiv(poolIndexes.poolBorrowIndex);
-        deltas.p2pBorrowDelta = deltasMem.p2pBorrowDelta;
-        emit P2PSupplyDeltaUpdated(_poolToken, deltasMem.p2pSupplyDelta);
-        emit P2PBorrowDeltaUpdated(_poolToken, deltasMem.p2pBorrowDelta);
+        deltas.p2pSupplyDelta += _amount.rayDiv(poolIndexes.poolSupplyIndex);
+        deltas.p2pSupplyDelta = deltas.p2pSupplyDelta;
+        deltas.p2pBorrowDelta += _amount.rayDiv(poolIndexes.poolBorrowIndex);
+        deltas.p2pBorrowDelta = deltas.p2pBorrowDelta;
+        emit P2PSupplyDeltaUpdated(_poolToken, deltas.p2pSupplyDelta);
+        emit P2PBorrowDeltaUpdated(_poolToken, deltas.p2pBorrowDelta);
 
         ERC20 underlyingToken = ERC20(market[_poolToken].underlyingToken);
         _borrowFromPool(underlyingToken, _amount);

contracts/aave-v3/MorphoGovernance.sol

@@ -413,16 +413,12 @@ abstract contract MorphoGovernance is MorphoUtils {
         emit DeprecatedStatusSet(_poolToken, _isDeprecated);
     }
 
-    /// @notice Creates peer-to-peer deltas, to put some liquidity back on the pool.
+    /// @notice Increases peer-to-peer deltas, to put some liquidity back on the pool.
     /// @dev The current Morpho supply on the pool might not be enough to borrow `_amount` before resuppling it.
     /// In this case, consider calling multiple times this function.
-    /// @param _poolToken The address of the market on which to create deltas.
-    /// @param _amount The amount to add to the deltas (in underlying).
-    function increaseP2PDeltas(address _poolToken, uint256 _amount)
-        external
-        onlyOwner
-        isMarketCreated(_poolToken)
-    {
+    /// @param _poolToken The address of the market on which to increase deltas.
+    /// @param _amount The maximum amount to add to the deltas (in underlying).
+    function increaseP2PDeltas(address _poolToken, uint256 _amount) external onlyOwner {
         address(exitPositionsManager).functionDelegateCall(
             abi.encodeWithSelector(
                 IExitPositionsManager.increaseP2PDeltasLogic.selector,

contracts/compound/MorphoGovernance.sol

@@ -9,6 +9,7 @@ import "./MorphoUtils.sol";
 /// @notice Governance functions for Morpho.
 abstract contract MorphoGovernance is MorphoUtils {
     using SafeTransferLib for ERC20;
+    using DelegateCall for address;
 
     /// EVENTS ///
 
@@ -274,6 +275,21 @@ abstract contract MorphoGovernance is MorphoUtils {
         emit ClaimRewardsPauseStatusSet(_newStatus);
     }
 
+    /// @notice Increases peer-to-peer deltas, to put some liquidity back on the pool.
+    /// @dev The current Morpho supply on the pool might not be enough to borrow `_amount` before resuppling it.
+    /// In this case, consider calling multiple times this function.
+    /// @param _poolToken The address of the market on which to increase deltas.
+    /// @param _amount The maximum amount to add to the deltas (in underlying).
+    function increaseP2PDeltas(address _poolToken, uint256 _amount) external onlyOwner {
+        address(positionsManager).functionDelegateCall(
+            abi.encodeWithSelector(
+                IPositionsManager.increaseP2PDeltasLogic.selector,
+                _poolToken,
+                _amount
+            )
+        );
+    }
+
     /// @notice Transfers the protocol reserve fee to the DAO.
     /// @param _poolTokens The addresses of the pool token addresses on which to claim the reserve fee.
     /// @param _amounts The list of amounts of underlying tokens to claim on each market.

contracts/compound/PositionsManager.sol

@@ -95,6 +95,11 @@ contract PositionsManager is IPositionsManager, MatchingEngine {
         uint256 _amountSeized
     );
 
+    /// @notice Emitted when the peer-to-peer deltas are increased by the governance.
+    /// @param _poolToken The address of the market on which the deltas were increased.
+    /// @param _amount The amount that has been added to the deltas (in underlying).
+    event P2PDeltasIncreased(address indexed _poolToken, uint256 _amount);
+
     /// @notice Emitted when the borrow peer-to-peer delta is updated.
     /// @param _poolToken The address of the market.
     /// @param _p2pBorrowDelta The borrow peer-to-peer delta after update.
@@ -493,6 +498,46 @@ contract PositionsManager is IPositionsManager, MatchingEngine {
         );
     }
 
+    /// @notice Implements increaseP2PDeltas logic.
+    /// @dev The current Morpho supply on the pool might not be enough to borrow `_amount` before resupplying it.
+    /// In this case, consider calling this function multiple times.
+    /// @param _poolToken The address of the market on which to increase deltas.
+    /// @param _amount The maximum amount to add to the deltas (in underlying).
+    function increaseP2PDeltasLogic(address _poolToken, uint256 _amount)
+        external
+        isMarketCreated(_poolToken)
+    {
+        _updateP2PIndexes(_poolToken);
+
+        Types.Delta storage deltas = deltas[_poolToken];
+        Types.LastPoolIndexes memory lastPoolIndexes = lastPoolIndexes[_poolToken];
+
+        uint256 poolSupplyIndex = ICToken(_poolToken).exchangeRateStored();
+        _amount = Math.min(
+            _amount,
+            Math.min(
+                deltas.p2pSupplyAmount.mul(p2pSupplyIndex[_poolToken]).safeSub(
+                    deltas.p2pSupplyDelta.mul(poolSupplyIndex)
+                ),
+                deltas.p2pBorrowAmount.mul(p2pBorrowIndex[_poolToken]).safeSub(
+                    deltas.p2pBorrowDelta.mul(lastPoolIndexes.lastBorrowPoolIndex)
+                )
+            )
+        );
+
+        deltas.p2pSupplyDelta += _amount.div(poolSupplyIndex);
+        deltas.p2pSupplyDelta = deltas.p2pSupplyDelta;
+        deltas.p2pBorrowDelta += _amount.div(lastPoolIndexes.lastBorrowPoolIndex);
+        deltas.p2pBorrowDelta = deltas.p2pBorrowDelta;
+        emit P2PSupplyDeltaUpdated(_poolToken, deltas.p2pSupplyDelta);
+        emit P2PBorrowDeltaUpdated(_poolToken, deltas.p2pBorrowDelta);
+
+        _borrowFromPool(_poolToken, _amount);
+        _supplyToPool(_poolToken, _getUnderlying(_poolToken), _amount);
+
+        emit P2PDeltasIncreased(_poolToken, _amount);
+    }
+
     /// INTERNAL ///
 
     /// @dev Implements withdraw logic without security checks.
@@ -754,8 +799,9 @@ contract PositionsManager is IPositionsManager, MatchingEngine {
             // No need to subtract p2pBorrowDelta as it is zero.
             vars.feeToRepay = CompoundMath.safeSub(
                 delta.p2pBorrowAmount.mul(vars.p2pBorrowIndex),
-                (delta.p2pSupplyAmount.mul(vars.p2pSupplyIndex) -
-                    delta.p2pSupplyDelta.mul(ICToken(_poolToken).exchangeRateStored()))
+                delta.p2pSupplyAmount.mul(vars.p2pSupplyIndex).safeSub(
+                    delta.p2pSupplyDelta.mul(ICToken(_poolToken).exchangeRateStored())
+                )
             );
 
             if (vars.feeToRepay > 0) {

contracts/compound/interfaces/IPositionsManager.sol

@@ -38,4 +38,6 @@ interface IPositionsManager {
         address _borrower,
         uint256 _amount
     ) external;
+
+    function increaseP2PDeltasLogic(address _poolToken, uint256 _amount) external;
 }