feat: release escrow by strategy (#1412)

**Motivation:**

We want to ensure:
1. We don't need a max strategy in operatorSet count 
2. Blacklisted ERC-20 tokens do not block the escrow release of _other_
tokens

**Modifications:**

1. Added a `releaseEscrowByStrategy` functionality, which takes in an
strategy & releases that specific strategy
2. Added helper methods that both `releaseEscrow` and
`releaseEscrowByStrategy` use
3. Cleaned up some latent DM POC changes

**Result:**

Handling all edge cases :)

---------

Co-authored-by: clandestine.eth <[email protected]>

Author: ypatil12

src/contracts/core/DelegationManager.sol

@@ -207,7 +207,7 @@ contract DelegationManager is
 
     /// @inheritdoc IDelegationManager
     function completeQueuedWithdrawal(
-        Withdrawal memory withdrawal,
+        Withdrawal calldata withdrawal,
         IERC20[] calldata tokens,
         bool receiveAsTokens
     ) external onlyWhenNotPaused(PAUSED_EXIT_WITHDRAWAL_QUEUE) nonReentrant {

src/contracts/core/SlashEscrowFactory.sol

@@ -89,25 +89,57 @@ contract SlashEscrowFactory is Initializable, SlashEscrowFactoryStorage, Ownable
     ) external onlyWhenNotPaused(PAUSED_RELEASE_ESCROW) {
         address redistributionRecipient = allocationManager.getRedistributionRecipient(operatorSet);
 
-        // If the redistribution recipient is not the default burn address...
-        if (redistributionRecipient != DEFAULT_BURN_ADDRESS) {
-            require(msg.sender == redistributionRecipient, OnlyRedistributionRecipient());
-        }
-
-        // Assert that the slash ID is not paused
-        require(!isEscrowPaused(operatorSet, slashId), IPausable.CurrentlyPaused());
-
-        // Assert that the escrow delay has elapsed
-        require(block.number >= getEscrowCompleteBlock(operatorSet, slashId), EscrowDelayNotElapsed());
+        _checkReleaseSlashEscrow(operatorSet, slashId, redistributionRecipient);
 
         // Calling `clearBurnOrRedistributableShares` will transfer the underlying tokens to the `SlashEscrow`.
         // NOTE: While `clearBurnOrRedistributableShares` may have already been called, we call it again to ensure that the
         // underlying tokens are actually in escrow before processing and removing storage (which would otherwise prevent
         // the tokens from being released).
         strategyManager.clearBurnOrRedistributableShares(operatorSet, slashId);
 
-        // Release the slashEscrow. The `SlashEscrow` is deployed in `initiateSlashEscrow`.
-        _processSlashEscrow(operatorSet, slashId, getSlashEscrow(operatorSet, slashId), redistributionRecipient);
+        // Process the slash escrow for each strategy.
+        address[] memory strategies = _pendingStrategiesForSlashId[operatorSet.key()][slashId].values();
+        for (uint256 i = 0; i < strategies.length; ++i) {
+            _processSlashEscrowByStrategy({
+                operatorSet: operatorSet,
+                slashId: slashId,
+                slashEscrow: getSlashEscrow(operatorSet, slashId),
+                redistributionRecipient: redistributionRecipient,
+                strategy: IStrategy(strategies[i])
+            });
+        }
+
+        // Update the slash escrow storage.
+        _updateSlashEscrowStorage(operatorSet, slashId);
+    }
+
+    /// @inheritdoc ISlashEscrowFactory
+    function releaseSlashEscrowByStrategy(
+        OperatorSet calldata operatorSet,
+        uint256 slashId,
+        IStrategy strategy
+    ) external virtual onlyWhenNotPaused(PAUSED_RELEASE_ESCROW) {
+        address redistributionRecipient = allocationManager.getRedistributionRecipient(operatorSet);
+
+        _checkReleaseSlashEscrow(operatorSet, slashId, redistributionRecipient);
+
+        // Calling `clearBurnOrRedistributableSharesByStrategy` will transfer the underlying tokens to the `SlashEscrow`.
+        // NOTE: While the strategy may have already been cleared, we call it again to ensure that the
+        // underlying tokens are actually in escrow before processing and removing storage (which would otherwise prevent
+        // the tokens from being released).
+        strategyManager.clearBurnOrRedistributableSharesByStrategy(operatorSet, slashId, strategy);
+
+        // Release the slashEscrow.
+        _processSlashEscrowByStrategy({
+            operatorSet: operatorSet,
+            slashId: slashId,
+            slashEscrow: getSlashEscrow(operatorSet, slashId),
+            redistributionRecipient: redistributionRecipient,
+            strategy: strategy
+        });
+
+        // Update the slash escrow storage.
+        _updateSlashEscrowStorage(operatorSet, slashId);
     }
 
     /**
@@ -155,48 +187,68 @@ contract SlashEscrowFactory is Initializable, SlashEscrowFactoryStorage, Ownable
      *
      */
 
-    /// @notice Processes the slash escrow.
-    function _processSlashEscrow(
+    /// @notice Checks that the slash escrow can be released.
+    function _checkReleaseSlashEscrow(
         OperatorSet calldata operatorSet,
         uint256 slashId,
-        ISlashEscrow slashEscrow,
         address redistributionRecipient
+    ) internal view {
+        // If the redistribution recipient is not the default burn address...
+        if (redistributionRecipient != DEFAULT_BURN_ADDRESS) {
+            require(msg.sender == redistributionRecipient, OnlyRedistributionRecipient());
+        }
+
+        // Assert that the slash ID is not paused
+        require(!isEscrowPaused(operatorSet, slashId), IPausable.CurrentlyPaused());
+
+        // Assert that the escrow delay has elapsed
+        require(block.number >= getEscrowCompleteBlock(operatorSet, slashId), EscrowDelayNotElapsed());
+    }
+
+    /// @notice Processes the slash escrow for a single strategy.
+    function _processSlashEscrowByStrategy(
+        OperatorSet calldata operatorSet,
+        uint256 slashId,
+        ISlashEscrow slashEscrow,
+        address redistributionRecipient,
+        IStrategy strategy
     ) internal {
-        // Create storage pointers for readability.
-        EnumerableSet.Bytes32Set storage pendingOperatorSets = _pendingOperatorSets;
-        EnumerableSet.UintSet storage pendingSlashIds = _pendingSlashIds[operatorSet.key()];
+        // Create storage pointer for readability.
         EnumerableSet.AddressSet storage pendingStrategiesForSlashId =
             _pendingStrategiesForSlashId[operatorSet.key()][slashId];
 
-        // Iterate over the escrow array in reverse order and pop the processed entries from storage.
-        uint256 totalPendingForSlashId = pendingStrategiesForSlashId.length();
-        for (uint256 i = totalPendingForSlashId; i > 0; --i) {
-            address strategy = pendingStrategiesForSlashId.at(i - 1);
-
-            // Burn or redistribute the underlying tokens for the strategy.
-            slashEscrow.releaseTokens(
-                ISlashEscrowFactory(address(this)),
-                slashEscrowImplementation,
-                operatorSet,
-                slashId,
-                redistributionRecipient,
-                IStrategy(strategy)
-            );
-
-            // Remove the strategy and underlying amount from the pending burn or redistributions map.
-            pendingStrategiesForSlashId.remove(strategy);
-            emit EscrowComplete(operatorSet, slashId, IStrategy(strategy), redistributionRecipient);
-        }
+        // Burn or redistribute the underlying tokens for the strategy.
+        slashEscrow.releaseTokens({
+            slashEscrowFactory: ISlashEscrowFactory(address(this)),
+            slashEscrowImplementation: slashEscrowImplementation,
+            operatorSet: operatorSet,
+            slashId: slashId,
+            recipient: redistributionRecipient,
+            strategy: strategy
+        });
+
+        // Remove the strategy and underlying amount from the pending strategies escrow map.
+        pendingStrategiesForSlashId.remove(address(strategy));
+        emit EscrowComplete(operatorSet, slashId, strategy, redistributionRecipient);
+    }
+
+    function _updateSlashEscrowStorage(OperatorSet calldata operatorSet, uint256 slashId) internal {
+        // Create storage pointers for readability.
+        EnumerableSet.Bytes32Set storage pendingOperatorSets = _pendingOperatorSets;
+        EnumerableSet.UintSet storage pendingSlashIds = _pendingSlashIds[operatorSet.key()];
+        uint256 totalPendingForSlashId = _pendingStrategiesForSlashId[operatorSet.key()][slashId].length();
 
-        // Remove the slash ID from the pending slash IDs set.
-        pendingSlashIds.remove(slashId);
+        // If there are no more strategies to process, remove the slash ID from the pending slash IDs set.
+        if (totalPendingForSlashId == 0) {
+            pendingSlashIds.remove(slashId);
 
-        // Delete the start block for the slash ID.
-        delete _slashIdToStartBlock[operatorSet.key()][slashId];
+            // Delete the start block for the slash ID.
+            delete _slashIdToStartBlock[operatorSet.key()][slashId];
 
-        // Remove the operator set from the pending operator sets set if there are no more pending slash IDs.
-        if (pendingSlashIds.length() == 0) {
-            pendingOperatorSets.remove(operatorSet.key());
+            // If there are no more slash IDs for the operator set, remove the operator set from the pending operator sets set.
+            if (pendingSlashIds.length() == 0) {
+                pendingOperatorSets.remove(operatorSet.key());
+            }
         }
     }
 

src/contracts/core/SlashEscrowFactoryStorage.sol

@@ -16,7 +16,7 @@ abstract contract SlashEscrowFactoryStorage is ISlashEscrowFactory {
 
     /// @notice The pause status for the `releaseSlashEscrow` function.
     /// @dev Allows all escrow outflows to be temporarily halted.
-    uint8 public constant PAUSED_RELEASE_ESCROW = 0;
+    uint8 internal constant PAUSED_RELEASE_ESCROW = 0;
 
     // Immutable Storage
 

src/contracts/core/StrategyManager.sol

@@ -174,11 +174,11 @@ contract StrategyManager is
         OperatorSet calldata operatorSet,
         uint256 slashId
     ) external nonReentrant {
-        // Iterate over burnable shares backwards. Iterating with an increasing index can cause
-        // elements to be missed as the item to remove is swapped and popped with the last element.
+        // Get the strategies to clear.
         address[] memory strategies = _burnOrRedistributableShares[operatorSet.key()][slashId].keys();
         uint256 length = strategies.length;
 
+        // Note: We don't need to iterate backwards since we're indexing into the `EnumerableMap` directly.
         for (uint256 i = 0; i < length; ++i) {
             clearBurnOrRedistributableSharesByStrategy(operatorSet, slashId, IStrategy(strategies[i]));
         }
@@ -194,7 +194,6 @@ contract StrategyManager is
             _burnOrRedistributableShares[operatorSet.key()][slashId];
 
         (, uint256 sharesToRemove) = burnOrRedistributableShares.tryGet(address(strategy));
-
         burnOrRedistributableShares.remove(address(strategy));
 
         if (sharesToRemove != 0) {

src/contracts/interfaces/IDelegationManager.sol

@@ -174,9 +174,6 @@ interface IDelegationManagerEvents is IDelegationManagerTypes {
 
     /// @notice Emitted whenever an operator's shares are slashed for a given strategy
     event OperatorSharesSlashed(address indexed operator, IStrategy strategy, uint256 totalSlashedShares);
-
-    /// @notice Emitted when a redistribution is queued
-    event RedistributionQueued(bytes32 withdrawalRoot, Withdrawal withdrawal);
 }
 
 /**

src/contracts/interfaces/ISlashEscrowFactory.sol

@@ -57,7 +57,7 @@ interface ISlashEscrowFactory is ISlashEscrowFactoryErrors, ISlashEscrowFactoryE
     function initiateSlashEscrow(OperatorSet calldata operatorSet, uint256 slashId, IStrategy strategy) external;
 
     /**
-     * @notice Releases an escrow.
+     * @notice Releases an escrow for all strategies in a slash.
      * @param operatorSet The operator set whose escrow is being released.
      * @param slashId The slash ID of the escrow that is being released.
      * @dev The caller must be the redistribution recipient, unless the redistribution recipient
@@ -66,6 +66,21 @@ interface ISlashEscrowFactory is ISlashEscrowFactoryErrors, ISlashEscrowFactoryE
      */
     function releaseSlashEscrow(OperatorSet calldata operatorSet, uint256 slashId) external;
 
+    /**
+     * @notice Releases an escrow for a single strategy in a slash.
+     * @param operatorSet The operator set whose escrow is being released.
+     * @param slashId The slash ID of the escrow that is being released.
+     * @param strategy The strategy whose escrow is being released.
+     * @dev The caller must be the redistribution recipient, unless the redistribution recipient
+     * is the default burn address in which case anyone can call.
+     * @dev The slash escrow is released once the delay for ALL strategies has elapsed.
+     */
+    function releaseSlashEscrowByStrategy(
+        OperatorSet calldata operatorSet,
+        uint256 slashId,
+        IStrategy strategy
+    ) external;
+
     /**
      * @notice Pauses a escrow.
      * @param operatorSet The operator set whose escrow is being paused.

src/test/mocks/StrategyManagerMock.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.27;
 import "forge-std/Test.sol";
 
 import "../../contracts/interfaces/IDelegationManager.sol";
+import "../../contracts/interfaces/IStrategy.sol";
 
 contract StrategyManagerMock is Test {
     IDelegationManager public delegation;
@@ -109,7 +110,12 @@ contract StrategyManagerMock is Test {
         return (existingShares, addedShares);
     }
 
-    function clearBurnOrRedistributableShares(IStrategy strategy, uint sharesToBurn) external {}
+    function clearBurnOrRedistributableShares(OperatorSet calldata operatorSet, uint slashId) external {}
+
+    function clearBurnOrRedistributableSharesByStrategy(OperatorSet calldata operatorSet, uint slashId, IStrategy strategy)
+        external
+        returns (uint)
+    {}
 
     function getBurnOrRedistributableCount(OperatorSet calldata operatorSet, uint slashId) external view returns (uint) {
         return _burnOrRedistributableCount;