chore: bring back non-arrayified slashOperatorShares (#1400)

ypatil12 · ypatil12 · commit 359c496ef5aa · 2025-05-24T14:51:27.000-04:00
**Motivation:**

We want to minimize the diff between slashing and redistribution. Bring
back the single call from ALM to DM for slashes.

**Modifications:**

Bring back single call from ALM to DM for slash, instead of aggregating
all mags.

**Result:**

Smaller Diff
diff --git a/src/contracts/core/AllocationManager.sol b/src/contracts/core/AllocationManager.sol
@@ -63,18 +63,11 @@ contract AllocationManager is
     function slashOperator(
         address avs,
         SlashingParams calldata params
-    )
-        external
-        onlyWhenNotPaused(PAUSED_OPERATOR_SLASHING)
-        checkCanCall(avs)
-        returns (uint256 slashId, uint256[] memory shares)
-    {
+    ) external onlyWhenNotPaused(PAUSED_OPERATOR_SLASHING) checkCanCall(avs) returns (uint256, uint256[] memory) {
         // Check that the operator set exists and the operator is registered to it
         OperatorSet memory operatorSet = OperatorSet(avs, params.operatorSetId);
-
         require(params.strategies.length == params.wadsToSlash.length, InputArrayLengthMismatch());
         require(_operatorSets[operatorSet.avs].contains(operatorSet.id), InvalidOperatorSet());
-
         require(isOperatorSlashable(params.operator, operatorSet), OperatorNotSlashable());
 
         return _slashOperator(params, operatorSet);
@@ -327,13 +320,11 @@ contract AllocationManager is
         OperatorSet memory operatorSet
     ) internal returns (uint256 slashId, uint256[] memory shares) {
         uint256[] memory wadSlashed = new uint256[](params.strategies.length);
+        shares = new uint256[](params.strategies.length);
 
         // Increment the slash count for the operator set.
         slashId = ++_slashCount[operatorSet.key()];
 
-        uint64[] memory prevMaxMagnitudes = new uint64[](params.strategies.length);
-        uint64[] memory newMaxMagnitudes = new uint64[](params.strategies.length);
-
         // For each strategy in the operator set, slash any existing allocation
         for (uint256 i = 0; i < params.strategies.length; i++) {
             // Check that `strategies` is in ascending order.
@@ -390,26 +381,24 @@ contract AllocationManager is
             // 5. Update state
             _updateAllocationInfo(params.operator, operatorSet.key(), params.strategies[i], info, allocation);
 
+            // Emit an event for the updated allocation
             emit AllocationUpdated(
                 params.operator, operatorSet, params.strategies[i], allocation.currentMagnitude, uint32(block.number)
             );
 
             _updateMaxMagnitude(params.operator, params.strategies[i], info.maxMagnitude);
 
-            prevMaxMagnitudes[i] = prevMaxMagnitude;
-            newMaxMagnitudes[i] = info.maxMagnitude;
+            // 6. Slash operators shares in the DelegationManager
+            shares[i] = delegation.slashOperatorShares({
+                operator: params.operator,
+                operatorSet: operatorSet,
+                slashId: slashId,
+                strategy: params.strategies[i],
+                prevMaxMagnitude: prevMaxMagnitude,
+                newMaxMagnitude: info.maxMagnitude
+            });
         }
 
-        // 6. Slash operators shares in the DelegationManager
-        shares = delegation.slashOperatorShares({
-            operator: params.operator,
-            operatorSet: operatorSet,
-            slashId: slashId,
-            strategies: params.strategies,
-            prevMaxMagnitudes: prevMaxMagnitudes,
-            newMaxMagnitudes: newMaxMagnitudes
-        });
-
         emit OperatorSlashed(params.operator, operatorSet, params.strategies, wadSlashed, params.description);
     }
 
diff --git a/src/contracts/core/DelegationManager.sol b/src/contracts/core/DelegationManager.sol
@@ -285,16 +285,40 @@ contract DelegationManager is
         address operator,
         OperatorSet calldata operatorSet,
         uint256 slashId,
-        IStrategy[] calldata strategies,
-        uint64[] calldata prevMaxMagnitudes,
-        uint64[] calldata newMaxMagnitudes
-    ) external onlyAllocationManager nonReentrant returns (uint256[] memory totalDepositSharesToBurn) {
-        totalDepositSharesToBurn = new uint256[](strategies.length);
-        for (uint256 i = 0; i < strategies.length; i++) {
-            totalDepositSharesToBurn[i] = _slashOperatorShares(
-                operator, operatorSet, slashId, strategies[i], prevMaxMagnitudes[i], newMaxMagnitudes[i]
-            );
-        }
+        IStrategy strategy,
+        uint64 prevMaxMagnitude,
+        uint64 newMaxMagnitude
+    ) external onlyAllocationManager nonReentrant returns (uint256 totalDepositSharesToBurn) {
+        uint256 operatorSharesSlashed = SlashingLib.calcSlashedAmount({
+            operatorShares: operatorShares[operator][strategy],
+            prevMaxMagnitude: prevMaxMagnitude,
+            newMaxMagnitude: newMaxMagnitude
+        });
+
+        uint256 scaledSharesSlashedFromQueue = _getSlashableSharesInQueue({
+            operator: operator,
+            strategy: strategy,
+            prevMaxMagnitude: prevMaxMagnitude,
+            newMaxMagnitude: newMaxMagnitude
+        });
+
+        // Calculate the total deposit shares to burn - slashed operator shares plus still-slashable
+        // shares sitting in the withdrawal queue.
+        totalDepositSharesToBurn = operatorSharesSlashed + scaledSharesSlashedFromQueue;
+
+        // Remove shares from operator
+        _decreaseDelegation({
+            operator: operator,
+            staker: address(0), // we treat this as a decrease for the 0-staker (only used for events)
+            strategy: strategy,
+            sharesToDecrease: operatorSharesSlashed
+        });
+
+        // Emit event for operator shares being slashed
+        emit OperatorSharesSlashed(operator, strategy, totalDepositSharesToBurn);
+
+        _getShareManager(strategy).increaseBurnableShares(operatorSet, slashId, strategy, totalDepositSharesToBurn);
+
         return totalDepositSharesToBurn;
     }
 
@@ -667,54 +691,8 @@ contract DelegationManager is
         emit OperatorSharesDecreased(operator, staker, strategy, sharesToDecrease);
     }
 
-    /// @dev Slashes operator shares and queues a redistribution for the slashable shares in the queue.
-    /// See `slashOperatorShares` for more details.
-    function _slashOperatorShares(
-        address operator,
-        OperatorSet memory operatorSet,
-        uint256 slashId,
-        IStrategy strategy,
-        uint64 prevMaxMagnitude,
-        uint64 newMaxMagnitude
-    ) internal returns (uint256 totalDepositSharesToBurn) {
-        // Avoid emitting events if nothing has changed for sanitization.
-        if (prevMaxMagnitude == newMaxMagnitude) return 0;
-
-        uint256 operatorSharesSlashed = SlashingLib.calcSlashedAmount({
-            operatorShares: operatorShares[operator][strategy],
-            prevMaxMagnitude: prevMaxMagnitude,
-            newMaxMagnitude: newMaxMagnitude
-        });
-
-        uint256 scaledSharesSlashedFromQueue = _getSlashableSharesInQueue({
-            operator: operator,
-            strategy: strategy,
-            prevMaxMagnitude: prevMaxMagnitude,
-            newMaxMagnitude: newMaxMagnitude
-        });
-
-        // Calculate the total deposit shares to burn - slashed operator shares plus still-slashable
-        // shares sitting in the withdrawal queue.
-        totalDepositSharesToBurn = operatorSharesSlashed + scaledSharesSlashedFromQueue;
-
-        // Remove shares from operator
-        _decreaseDelegation({
-            operator: operator,
-            staker: address(0), // we treat this as a decrease for the 0-staker (only used for events)
-            strategy: strategy,
-            sharesToDecrease: operatorSharesSlashed
-        });
-
-        // Emit event for operator shares being slashed
-        emit OperatorSharesSlashed(operator, strategy, totalDepositSharesToBurn);
-
-        _getShareManager(strategy).increaseBurnableShares(operatorSet, slashId, strategy, totalDepositSharesToBurn);
-
-        return totalDepositSharesToBurn;
-    }
-
     /// @dev If `operator` has configured a `delegationApprover`, check that `signature` and `salt`
-    /// are a valid approval for `staker` delegating to `operator`.
+    /// are a valid appfroval for `staker` delegating to `operator`.
     function _checkApproverSignature(
         address staker,
         address operator,
diff --git a/src/contracts/interfaces/IDelegationManager.sol b/src/contracts/interfaces/IDelegationManager.sol
@@ -362,9 +362,9 @@ interface IDelegationManager is ISignatureUtilsMixin, IDelegationManagerErrors,
      * @param operator The operator to decrease shares for.
      * @param operatorSet The operator set to decrease shares for.
      * @param slashId The slash id to decrease shares for.
-     * @param strategies The strategies to decrease shares for.
-     * @param prevMaxMagnitudes The previous maxMagnitudes of the operator.
-     * @param newMaxMagnitudes The new maxMagnitudes of the operator.
+     * @param strategy The strategy to decrease shares for.
+     * @param prevMaxMagnitude The previous maxMagnitude of the operator.
+     * @param newMaxMagnitude The new maxMagnitude of the operator.
      * @dev Callable only by the AllocationManager.
      * @dev Note: Assumes `prevMaxMagnitude <= newMaxMagnitude`. This invariant is maintained in
      * the AllocationManager.
@@ -374,10 +374,10 @@ interface IDelegationManager is ISignatureUtilsMixin, IDelegationManagerErrors,
         address operator,
         OperatorSet calldata operatorSet,
         uint256 slashId,
-        IStrategy[] calldata strategies,
-        uint64[] calldata prevMaxMagnitudes,
-        uint64[] calldata newMaxMagnitudes
-    ) external returns (uint256[] memory totalDepositSharesToBurn);
+        IStrategy strategy,
+        uint64 prevMaxMagnitude,
+        uint64 newMaxMagnitude
+    ) external returns (uint256 totalDepositSharesToBurn);
 
     /**
      *
diff --git a/src/test/mocks/DelegationManagerMock.sol b/src/test/mocks/DelegationManagerMock.sol
@@ -36,8 +36,6 @@ contract DelegationManagerMock is Test {
         uint[] memory amountSlashed = new uint[](strategies.length);
 
         for (uint i = 0; i < strategies.length; i++) {
-            if (prevMaxMagnitudes[i] == newMaxMagnitudes[i]) continue;
-
             amountSlashed[i] = SlashingLib.calcSlashedAmount({
                 operatorShares: operatorShares[operator][strategies[i]],
                 prevMaxMagnitude: prevMaxMagnitudes[i],
diff --git a/src/test/unit/DelegationUnit.t.sol b/src/test/unit/DelegationUnit.t.sol
