feat: slasher templates / examples

src/ServiceManagerBase.sol

@@ -14,7 +14,6 @@ import {IRegistryCoordinator} from "./interfaces/IRegistryCoordinator.sol";
 import {IStakeRegistry} from "./interfaces/IStakeRegistry.sol";
 import {BitmapUtils} from "./libraries/BitmapUtils.sol";
 import {LibMergeSort} from "./libraries/LibMergeSort.sol";
-import {console} from "forge-std/Test.sol";
 
 /**
  * @title Minimal implementation of a ServiceManager-type contract.
@@ -24,6 +23,8 @@ import {console} from "forge-std/Test.sol";
 abstract contract ServiceManagerBase is ServiceManagerBaseStorage {
     using BitmapUtils for *;
 
+    uint256 public constant SLASHER_PROPOSAL_DELAY = 7 days;
+
     /// @notice when applied to a function, only allows the RegistryCoordinator to call it
     modifier onlyRegistryCoordinator() {
         require(
@@ -177,12 +178,25 @@ abstract contract ServiceManagerBase is ServiceManagerBaseStorage {
     }
 
     /**
-     * @notice Sets the slasher address
+     * @notice Proposes a new slasher address
      * @param newSlasher The new slasher address
      * @dev only callable by the owner
      */
-    function setSlasher(address newSlasher) external onlyOwner {
-        _setSlasher(newSlasher);
+    function proposeNewSlasher(address newSlasher) external onlyOwner {
+        _proposeNewSlasher(newSlasher);
+    }
+
+    /**
+     * @notice Accepts the proposed slasher address after the delay period
+     * @dev only callable by the owner
+     */
+    function acceptProposedSlasher() external onlyOwner {
+        require(
+            block.timestamp >= slasherProposalTimestamp + SLASHER_PROPOSAL_DELAY,
+            "ServiceManager: Slasher proposal delay not met"
+        );
+        _setSlasher(proposedSlasher);
+        delete proposedSlasher;
     }
 
     /**
@@ -342,6 +356,12 @@ abstract contract ServiceManagerBase is ServiceManagerBaseStorage {
         rewardsInitiator = newRewardsInitiator;
     }
 
+    function _proposeNewSlasher(address newSlasher) internal {
+        proposedSlasher = newSlasher;
+        slasherProposalTimestamp = block.timestamp;
+        emit SlasherProposed(newSlasher, slasherProposalTimestamp);
+    }
+
     function _setSlasher(address newSlasher) internal {
         emit SlasherUpdated(slasher, newSlasher);
         slasher = newSlasher;
@@ -425,6 +445,10 @@ abstract contract ServiceManagerBase is ServiceManagerBaseStorage {
         return address(_avsDirectory);
     }
 
+    function allocationManager() external view override returns (address) {
+        return address(_allocationManager);
+    }
+
     function _checkRewardsInitiator() internal view {
         require(
             msg.sender == rewardsInitiator,

src/ServiceManagerBaseStorage.sol

@@ -40,6 +40,13 @@ abstract contract ServiceManagerBaseStorage is IServiceManager, OwnableUpgradeab
     /// @notice The address of the slasher account
     address public slasher;
 
+    /// @notice The address of the proposed slasher account
+    address public proposedSlasher;
+
+    /// @notice The timestamp when the slasher was proposed
+    uint256 public slasherProposalTimestamp;
+
+    /// @notice Boolean indicating if the migration has been finalized
     bool public migrationFinalized;
 
     /// @notice Sets the (immutable) `_avsDirectory`, `_rewardsCoordinator`, `_registryCoordinator`, `_stakeRegistry`, and `_allocationManager` addresses
@@ -58,5 +65,5 @@ abstract contract ServiceManagerBaseStorage is IServiceManager, OwnableUpgradeab
     }
 
     // storage gap for upgradeability
-    uint256[48] private __GAP;
+    uint256[46] private __GAP;
 }

src/StakeRegistry.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.12;
 
 import {IDelegationManager} from "eigenlayer-contracts/src/contracts/interfaces/IDelegationManager.sol";
 import {IAVSDirectory, OperatorSet} from "eigenlayer-contracts/src/contracts/interfaces/IAVSDirectory.sol";
+import {IAllocationManager} from "eigenlayer-contracts/src/contracts/interfaces/IAllocationManager.sol";
 import {IServiceManager} from "./interfaces/IServiceManager.sol";
 
 import {StakeRegistryStorage, IStrategy} from "./StakeRegistryStorage.sol";
@@ -229,6 +230,18 @@ contract StakeRegistry is StakeRegistryStorage {
         _setMinimumStakeForQuorum(quorumNumber, minimumStake);
     }
 
+    /**
+     * @notice Sets the stake type for the registry
+     * @param _stakeType The type of stake to track (TOTAL_DELEGATED, TOTAL_SLASHABLE, or BOTH)
+     */
+    function setStakeType(StakeType _stakeType) external onlyCoordinatorOwner {
+        _setStakeType(_stakeType);
+    }
+
+
+    function setSlashableStakeLookahead(uint32 _lookAheadPeriod) external onlyCoordinatorOwner {
+        _setLookAheadPeriod(_lookAheadPeriod);
+    }
     /** 
      * @notice Adds strategies and weights to the quorum
      * @dev Checks to make sure that the *same* strategy cannot be added multiple times (checks against both against existing and new strategies).
@@ -491,15 +504,17 @@ contract StakeRegistry is StakeRegistryStorage {
         uint256 stratsLength = strategyParamsLength(quorumNumber);
         StrategyParams memory strategyAndMultiplier;
 
-        uint256[] memory strategyShares;
-        //  = delegation.getDelegatableShares(operator, strategiesPerQuorum[quorumNumber]);
+        address[] memory operators = new address[](1);
+        operators[0] = operator;
+        uint32 beforeTimestamp = uint32(block.timestamp + slashableStakeLookAhead);
+        (uint256[][] memory strategyShares, ) = IAllocationManager(serviceManager.allocationManager()).getMinDelegatedAndSlashableOperatorShares(OperatorSet(address(serviceManager), quorumNumber), operators ,strategiesPerQuorum[quorumNumber], beforeTimestamp);
         for (uint256 i = 0; i < stratsLength; i++) {
             // accessing i^th StrategyParams struct for the quorumNumber
             strategyAndMultiplier = strategyParams[quorumNumber][i];
 
             // add the weight from the shares for this strategy to the total weight
-            if (strategyShares[i] > 0) {
-                weight += uint96(strategyShares[i] * strategyAndMultiplier.multiplier / WEIGHTING_DIVISOR);
+            if (strategyShares[i][0] > 0) {
+                weight += uint96(strategyShares[i][0] * strategyAndMultiplier.multiplier / WEIGHTING_DIVISOR);
             }
         }
 
@@ -731,6 +746,27 @@ contract StakeRegistry is StakeRegistryStorage {
         return indices;
     }
 
+    /**
+     * @notice Sets the stake type for the registry
+     * @param _stakeType The type of stake to track (TOTAL_DELEGATED, TOTAL_SLASHABLE, or BOTH)
+     */
+    function _setStakeType(StakeType _stakeType) internal {
+        StakeType oldStakeType = stakeType;
+        stakeType = _stakeType;
+        emit StakeTypeSet(oldStakeType, _stakeType);
+    }
+
+    /**
+     * @notice Sets the look ahead time for checking operator shares
+     * @param _lookAheadDays The number of days to look ahead when checking shares
+     */
+    function _setLookAheadPeriod(uint32 _lookAheadDays) internal {
+        uint32 oldLookAheadDays = slashableStakeLookAhead;
+        slashableStakeLookAhead = _lookAheadDays;
+        emit LookAheadPeriodChanged(oldLookAheadDays, _lookAheadDays);
+    }
+
+
     function _checkRegistryCoordinator() internal view {
         require(
             msg.sender == address(registryCoordinator),

src/StakeRegistryStorage.sol

@@ -52,6 +52,9 @@ abstract contract StakeRegistryStorage is IStakeRegistry {
     mapping(uint8 => StrategyParams[]) public strategyParams;
     mapping(uint8 => IStrategy[]) public strategiesPerQuorum;
 
+    StakeType public stakeType;
+
+    uint32 public slashableStakeLookAhead;
 
     constructor(
         IRegistryCoordinator _registryCoordinator, 
@@ -67,5 +70,5 @@ abstract contract StakeRegistryStorage is IStakeRegistry {
 
     // storage gap for upgradeability
     // slither-disable-next-line shadowing-state
-    uint256[45] private __GAP;
+    uint256[44] private __GAP;
 }

src/interfaces/IServiceManager.sol

@@ -5,6 +5,7 @@ import {IRewardsCoordinator} from "eigenlayer-contracts/src/contracts/interfaces
 import {IServiceManagerUI} from "./IServiceManagerUI.sol";
 import {ISignatureUtils} from "eigenlayer-contracts/src/contracts/interfaces/ISignatureUtils.sol";
 import {IAllocationManagerTypes} from "eigenlayer-contracts/src/contracts/interfaces/IAllocationManager.sol";
+import {IAllocationManager} from "eigenlayer-contracts/src/contracts/interfaces/IAllocationManager.sol";
 
 /**
  * @title Minimal interface for a ServiceManager-type contract that forms the single point for an AVS to push updates to EigenLayer
@@ -50,4 +51,5 @@ interface IServiceManager is IServiceManagerUI {
     // EVENTS
     event RewardsInitiatorUpdated(address prevRewardsInitiator, address newRewardsInitiator);
     event SlasherUpdated(address prevSlasher, address newSlasher);
+    event SlasherProposed(address newSlasher, uint256 slasherProposalTimestamp);
 }

src/interfaces/IServiceManagerUI.sol

@@ -58,4 +58,7 @@ interface IServiceManagerUI {
 
     /// @notice Returns the EigenLayer AVSDirectory contract.
     function avsDirectory() external view returns (address);
+
+    /// @notice Returns the EigenLayer AllocationManager contract.
+    function allocationManager() external view returns (address);
 }

src/interfaces/ISlasher.sol

@@ -0,0 +1,45 @@
+
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.12;
+
+import {IStrategy} from "eigenlayer-contracts/src/contracts/interfaces/IStrategy.sol";
+import {IAllocationManager} from "eigenlayer-contracts/src/contracts/interfaces/IAllocationManager.sol";
+
+interface ISlasherEvents {
+    event SlashingRequested(
+        uint256 indexed requestId,
+        address indexed operator,
+        uint32 indexed operatorSetId,
+        uint256 wadToSlash,
+        string description
+    );
+
+    event SlashingRequestCancelled(uint256 indexed requestId);
+
+    event OperatorSlashed(
+        uint256 indexed slashingRequestId,
+        address indexed operator,
+        uint32 indexed operatorSetId,
+        IStrategy[] strategies,
+        uint256 wadToSlash,
+        string description
+    );
+}
+
+interface ISlasherTypes {
+    enum SlashingStatus {
+        Null,
+        Requested,
+        Completed,
+        Cancelled
+    }
+
+    struct SlashingRequest {
+        IAllocationManager.SlashingParams params;
+        uint256 requestTimestamp;
+        SlashingStatus status;
+    }
+
+}
+
+interface ISlasher is ISlasherEvents, ISlasherTypes{}

src/interfaces/IStakeRegistry.sol

@@ -11,6 +11,12 @@ import {IRegistry} from "./IRegistry.sol";
  * @author Layr Labs, Inc.
  */
 interface IStakeRegistry is IRegistry {
+
+    enum StakeType {
+        TOTAL_DELEGATED,
+        TOTAL_SLASHABLE,
+        BOTH
+    }
 
     // DATA STRUCTURES
 
@@ -42,6 +48,13 @@ interface IStakeRegistry is IRegistry {
         uint8 quorumNumber,
         uint96 stake
     );
+
+
+    /// @notice emitted when the look ahead time for checking operator shares is updated
+    event LookAheadPeriodChanged(uint32 oldLookAheadDays, uint32 newLookAheadDays);
+
+    /// @notice emitted when the stake type is updated
+    event StakeTypeSet(StakeType previousStakeType, StakeType newStakeType);
     /// @notice emitted when the minimum stake for a quorum is updated
     event MinimumStakeForQuorumUpdated(uint8 indexed quorumNumber, uint96 minimumStake);
     /// @notice emitted when a new quorum is created

src/slashers/InstantSlasher.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.12;
+
+import {IStrategy} from "eigenlayer-contracts/src/contracts/interfaces/IStrategy.sol";
+import {IAllocationManager} from "eigenlayer-contracts/src/contracts/interfaces/IAllocationManager.sol";
+import {SlasherBase} from "./base/SlasherBase.sol";
+
+contract InstantSlasher is SlasherBase {
+
+    function initialize(address _serviceManager, address _slasher) external initializer {
+        __SlasherBase_init(_serviceManager, _slasher);
+    }
+
+    function fulfillSlashingRequest(
+        IAllocationManager.SlashingParams memory _slashingParams
+    ) external virtual onlySlasher {
+        uint256 requestId = nextRequestId++;
+        _fulfillSlashingRequest(requestId, _slashingParams);
+    }
+
+
+}