wip

Author: 0xClandestine

src/interfaces/IInstantSlasher.sol

@@ -10,9 +10,16 @@ import {ISlasher} from "./ISlasher.sol";
 /// @dev Extends base interfaces to provide access controlled slashing functionality
 interface IInstantSlasher is ISlasher {
     /// @notice Immediately executes a slashing request
-    /// @param _slashingParams Parameters defining the slashing request including operator and amount
+    /// @param params Parameters defining the slashing request including operator and amount
     /// @dev Can only be called by the authorized slasher
     function fulfillSlashingRequest(
-        IAllocationManager.SlashingParams memory _slashingParams
+        IAllocationManager.SlashingParams memory params
+    ) external;
+
+    /// @notice Immediately executes a slashing request and burns or redistributes shares
+    /// @param params Parameters defining the slashing request including operator and amount
+    /// @dev Can only be called by the authorized slasher
+    function fulfillSlashingRequestAndBurnOrRedistribute(
+        IAllocationManager.SlashingParams memory params
     ) external;
 }

src/interfaces/IVetoableSlasher.sol

@@ -83,4 +83,11 @@ interface IVetoableSlasher is
     function fulfillSlashingRequest(
         uint256 slashId
     ) external;
+
+    /// @notice Executes a slashing request after the veto period has passed and burns or redistributes shares
+    /// @param slashId The ID of the slashing request to fulfill
+    /// @dev Can only be called by the authorized slasher after the veto period
+    function fulfillSlashingRequestAndBurnOrRedistribute(
+        uint256 slashId
+    ) external;
 }

src/slashers/InstantSlasher.sol

@@ -22,9 +22,15 @@ contract InstantSlasher is IInstantSlasher, SlasherBase {
 
     /// @inheritdoc IInstantSlasher
     function fulfillSlashingRequest(
-        IAllocationManager.SlashingParams calldata _slashingParams
+        IAllocationManager.SlashingParams calldata params
     ) external virtual override(IInstantSlasher) onlySlasher {
-        _fulfillSlashingRequest(_slashingParams);
-        _updateOperatorStakeWeights(_slashingParams.operator);
+        _fulfillSlashingRequest(params);
+    }
+
+    /// @inheritdoc IInstantSlasher
+    function fulfillSlashingRequestAndBurnOrRedistribute(
+        IAllocationManager.SlashingParams calldata params
+    ) external virtual override onlySlasher {
+        _fulfillSlashingRequestAndBurnOrRedistribute(params);
     }
 }

src/slashers/VetoableSlasher.sol

@@ -60,7 +60,18 @@ contract VetoableSlasher is IVetoableSlasher, SlasherBase {
     function fulfillSlashingRequest(
         uint256 slashId
     ) external virtual override onlySlasher {
-        _fulfillSlashingRequestAndMarkAsCompleted(slashId);
+        IVetoableSlasherTypes.VetoableSlashingRequest storage request = slashingRequests[slashId];
+        _markAsCompleted(request);
+        _fulfillSlashingRequest(request.params);
+    }
+
+    /// @inheritdoc IVetoableSlasher
+    function fulfillSlashingRequestAndBurnOrRedistribute(
+        uint256 slashId
+    ) external virtual override onlySlasher {
+        IVetoableSlasherTypes.VetoableSlashingRequest storage request = slashingRequests[slashId];
+        _markAsCompleted(request);
+        _fulfillSlashingRequestAndBurnOrRedistribute(request.params);
     }
 
     /// @notice Internal function to create and store a new slashing request
@@ -104,22 +115,18 @@ contract VetoableSlasher is IVetoableSlasher, SlasherBase {
         emit SlashingRequestCancelled(slashId);
     }
 
-    /// @notice Internal function to fulfill a slashing request and mark it as completed
-    /// @param slashId The ID of the slashing request to fulfill
-    function _fulfillSlashingRequestAndMarkAsCompleted(
-        uint256 slashId
+    /// @notice Internal function to mark a slashing request as completed
+    /// @param request The request to mark as completed
+    function _markAsCompleted(
+        IVetoableSlasherTypes.VetoableSlashingRequest storage request
     ) internal virtual {
-        IVetoableSlasherTypes.VetoableSlashingRequest storage request = slashingRequests[slashId];
         require(block.number >= request.requestBlock + vetoWindowBlocks, VetoPeriodNotPassed());
         require(
             request.status == IVetoableSlasherTypes.SlashingStatus.Requested,
             SlashingRequestIsCancelled()
         );
 
         request.status = IVetoableSlasherTypes.SlashingStatus.Completed;
-
-        _fulfillSlashingRequest(request.params);
-        _updateOperatorStakeWeights(request.params.operator);
     }
 
     /// @notice Internal function to verify if an account is the veto committee

src/slashers/base/SlasherBase.sol

@@ -32,22 +32,23 @@ abstract contract SlasherBase is SlasherStorage {
     ) SlasherStorage(_allocationManager, _strategyManager, _registryCoordinator, _slasher) {}
 
     /// @notice Internal function to execute a slashing request
-    /// @param _params Parameters defining the slashing request including operator, strategies, and amounts
+    /// @param params Parameters defining the slashing request including operator, strategies, and amounts
     /// @dev Calls AllocationManager.slashOperator to perform the actual slashing
     function _fulfillSlashingRequest(
-        IAllocationManager.SlashingParams memory _params
+        IAllocationManager.SlashingParams memory params
     ) internal virtual returns (uint256 slashId) {
         (slashId,) = allocationManager.slashOperator({
             avs: slashingRegistryCoordinator.avs(),
-            params: _params
+            params: params
         });
         emit OperatorSlashed(
-            slashId,
-            _params.operator,
-            _params.operatorSetId,
-            _params.wadsToSlash,
-            _params.description
+            slashId, params.operator, params.operatorSetId, params.wadsToSlash, params.description
         );
+
+        // Update operator stake weights
+        address[] memory operators = new address[](1);
+        operators[0] = params.operator;
+        slashingRegistryCoordinator.updateOperators(operators);
     }
 
     /// @notice Internal function to optionally fulfill burn or redistribution instead of waiting for cron job
@@ -60,10 +61,10 @@ abstract contract SlasherBase is SlasherStorage {
 
     /// @notice Internal function to fulfill a slashing request and burn or redistribute shares
     function _fulfillSlashingRequestAndBurnOrRedistribute(
-        IAllocationManager.SlashingParams memory _params
+        IAllocationManager.SlashingParams memory params
     ) internal virtual returns (uint256 slashId) {
-        slashId = _fulfillSlashingRequest(_params);
-        _fulfillBurnOrRedistribution(_params.operatorSetId, slashId);
+        slashId = _fulfillSlashingRequest(params);
+        _fulfillBurnOrRedistribution(params.operatorSetId, slashId);
     }
 
     /// @notice Internal function to verify if an account is the authorized slasher
@@ -74,14 +75,4 @@ abstract contract SlasherBase is SlasherStorage {
     ) internal view virtual {
         require(account == slasher, OnlySlasher());
     }
-
-    /// @notice Internal function to update stake weights for the given operator
-    /// @param operator The operator to update
-    function _updateOperatorStakeWeights(
-        address operator
-    ) internal virtual {
-        address[] memory operators = new address[](1);
-        operators[0] = operator;
-        slashingRegistryCoordinator.updateOperators(operators);
-    }
 }