@web3dotorg/evm-slc-core-contracts 0.3.2

package/governance/ExecutorsRegistry.sol

@@ -0,0 +1,710 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {ERC1967Utils} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+
+import {Paginator} from "@solarity/solidity-lib/libs/arrays/Paginator.sol";
+import {PriorityQueue} from "@solarity/solidity-lib/libs/data-structures/PriorityQueue.sol";
+import {AValueDistributor} from "@solarity/solidity-lib/finance/staking/AValueDistributor.sol";
+
+import {Errors} from "../libs/Errors.sol";
+
+import {DAOSLC_PARAM_NAME} from "../utils/Globals.sol";
+
+import {IGovernance} from "../interfaces/IGovernance.sol";
+import {IQParameters} from "../interfaces/IQParameters.sol";
+import {IExecutorsRegistry} from "../interfaces/IExecutorsRegistry.sol";
+
+/**
+ * @title ExecutorsRegistry
+ */
+contract ExecutorsRegistry is IExecutorsRegistry, ERC165, UUPSUpgradeable, AValueDistributor {
+    using SafeERC20 for IERC20;
+    using PriorityQueue for PriorityQueue.AddressQueue;
+
+    // keccak256(abi.encode(uint256(keccak256("evm-slc-core.storage.ExecutorsRegistry")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant EXECUTORS_REGISTRY_STORAGE_LOCATION =
+        0x84b429261479e61afa83fbf020317b3fd4401958ce5dd91d22b08cd00ea3ae00;
+
+    string private constant MAX_ACTIVE_EXECUTORS_PARAM_NAME = "slc.executors.maxActiveExecutors";
+    string private constant MINIMUM_STAKE_PARAM_NAME = "slc.executors.minimumStake";
+    string private constant WITHDRAWAL_PERIOD_PARAM_NAME = "slc.executors.withdrawalPeriod";
+    string private constant SLASHING_RECIPIENT_PARAM_NAME = "slc.executors.slashingRecipient";
+
+    struct ExecutorInfo {
+        uint256 stake;
+        bool isApproved;
+        bool isActive;
+        bool isStandby;
+    }
+
+    struct WithdrawalAnnouncement {
+        uint256 amount;
+        uint256 announcedAt;
+        uint256 availableAt;
+    }
+
+    struct ExecutorsRegistryStorage {
+        IGovernance governance;
+        IERC20 stakeToken;
+        IQParameters parametersRegistry;
+        uint256 rewardsToDistribute;
+        uint256 maxActiveExecutors;
+        PriorityQueue.AddressQueue activeExecutors;
+        PriorityQueue.AddressQueue standbyExecutors;
+        mapping(address executor => ExecutorInfo info) executors;
+        mapping(address executor => WithdrawalAnnouncement) withdrawalAnnouncements;
+    }
+
+    modifier onlyDAOSLC() {
+        _requireDAOSLC();
+        _;
+    }
+
+    modifier onlyGovernance() {
+        _requireGovernance();
+        _;
+    }
+
+    modifier syncedMaxActiveExecutors() {
+        _requiredSyncedMaxActiveExecutors();
+        _;
+    }
+
+    function __ExecutorsRegistry_init(
+        address governance_,
+        address[] calldata initialExecutors_
+    ) external initializer {
+        __UUPSUpgradeable_init();
+
+        if (governance_ == address(0)) revert Errors.InvalidGovernance();
+
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+        $.governance = IGovernance(governance_);
+
+        address stakeToken_ = $.governance.getSystemToken();
+        address parametersRegistry_ = $.governance.getParametersRegistry();
+
+        if (stakeToken_ == address(0)) revert Errors.InvalidERC20Token();
+        if (parametersRegistry_ == address(0)) revert Errors.InvalidParametersRegistry();
+
+        $.stakeToken = IERC20(stakeToken_);
+        $.parametersRegistry = IQParameters(parametersRegistry_);
+        $.maxActiveExecutors = _getMaxActiveExecutors();
+
+        for (uint256 i = 0; i < initialExecutors_.length; ++i) {
+            address executor_ = initialExecutors_[i];
+            if (executor_ == address(0)) revert InvalidInitialExecutor(executor_);
+
+            $.executors[executor_].isApproved = true;
+
+            _addToActiveQueue(executor_);
+        }
+    }
+
+    /**
+     * @notice Stake tokens to become an executor
+     * @param amount_ Amount of tokens to stake
+     */
+    function stake(uint256 amount_) external syncedMaxActiveExecutors {
+        if (amount_ == 0) revert Errors.InvalidStakeAmount(amount_);
+
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+        ExecutorInfo storage executorInfo = $.executors[msg.sender];
+
+        executorInfo.stake += amount_;
+
+        _manipulateExecutorState(msg.sender);
+
+        $.stakeToken.safeTransferFrom(msg.sender, address(this), amount_);
+
+        emit ExecutorStaked(msg.sender, amount_, executorInfo.stake);
+    }
+
+    /**
+     * @notice Announce withdrawal intention
+     * @param amount_ Amount of tokens to withdraw
+     * @dev The withdrawal period should be longer than the typical DAO slashing proposal
+     *      execution time to ensure that executors cannot front-run slashing by announcing
+     *      withdrawal. Note that announced withdrawals can still be slashed during the
+     *      withdrawal period, as the slashing function accounts for withdrawal announcements.
+     */
+    function announceWithdrawal(uint256 amount_) public syncedMaxActiveExecutors {
+        if (amount_ == 0) revert Errors.InvalidStakeAmount(amount_);
+
+        address executor_ = msg.sender;
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+        ExecutorInfo storage executorInfo = $.executors[executor_];
+        WithdrawalAnnouncement storage announcement = $.withdrawalAnnouncements[executor_];
+
+        if (executorInfo.stake == 0) revert ExecutorHasNoStake(executor_);
+        if (amount_ > executorInfo.stake)
+            revert Errors.InsufficientStakeAmount(executor_, amount_, executorInfo.stake);
+        if (announcement.announcedAt != 0) revert WithdrawalAlreadyAnnounced(executor_);
+
+        uint256 withdrawalPeriod_ = _getWithdrawalPeriod();
+        uint256 availableAt_ = block.timestamp + withdrawalPeriod_;
+
+        announcement.amount = amount_;
+        announcement.announcedAt = block.timestamp;
+        announcement.availableAt = availableAt_;
+
+        executorInfo.stake -= amount_;
+
+        _manipulateExecutorState(executor_);
+
+        emit WithdrawalAnnounced(executor_, amount_, availableAt_);
+    }
+
+    /**
+     * @notice Complete withdrawal after announcement period
+     */
+    function completeWithdrawal() external {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+        ExecutorInfo storage executorInfo = $.executors[msg.sender];
+        WithdrawalAnnouncement storage announcement = $.withdrawalAnnouncements[msg.sender];
+
+        if (announcement.announcedAt == 0) revert NoWithdrawalAnnouncement(msg.sender);
+
+        if (block.timestamp < announcement.availableAt) {
+            revert WithdrawalNotReady(msg.sender, announcement.availableAt);
+        }
+
+        uint256 amount_ = announcement.amount;
+
+        delete $.withdrawalAnnouncements[msg.sender];
+
+        $.stakeToken.safeTransfer(msg.sender, amount_);
+
+        emit ExecutorUnstaked(msg.sender, amount_, executorInfo.stake);
+    }
+
+    /**
+     * @notice Cancel withdrawal announcement
+     */
+    function cancelWithdrawal() public syncedMaxActiveExecutors {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+        ExecutorInfo storage executorInfo = $.executors[msg.sender];
+        WithdrawalAnnouncement storage announcement = $.withdrawalAnnouncements[msg.sender];
+
+        if (announcement.announcedAt == 0) revert NoWithdrawalAnnouncement(msg.sender);
+
+        uint256 amount_ = announcement.amount;
+
+        executorInfo.stake += amount_;
+
+        delete $.withdrawalAnnouncements[msg.sender];
+
+        _manipulateExecutorState(msg.sender);
+
+        emit WithdrawalCancelled(msg.sender, amount_);
+    }
+
+    /**
+     * @notice Update withdrawal announcement amount
+     * @param newAmount_ New withdrawal amount
+     */
+    function updateWithdrawalAnnouncement(uint256 newAmount_) external {
+        cancelWithdrawal();
+        announceWithdrawal(newAmount_);
+    }
+
+    /**
+     * @notice Approve an executor (only DAOSLC)
+     * @param executor_ Address of the executor to approve
+     */
+    function approveExecutor(address executor_) external onlyDAOSLC syncedMaxActiveExecutors {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+        ExecutorInfo storage executorInfo = $.executors[executor_];
+
+        if (executorInfo.isApproved) revert ExecutorAlreadyApproved(executor_);
+
+        executorInfo.isApproved = true;
+
+        _manipulateExecutorState(executor_);
+
+        emit ExecutorApproved(executor_);
+    }
+
+    /**
+     * @notice Disapprove an executor (only DAOSLC)
+     * @param executor_ Address of the executor to disapprove
+     */
+    function disapproveExecutor(address executor_) external onlyDAOSLC syncedMaxActiveExecutors {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+        ExecutorInfo storage executorInfo = $.executors[executor_];
+
+        if (!executorInfo.isApproved) revert ExecutorNotApproved(executor_);
+
+        executorInfo.isApproved = false;
+
+        _removeFromActiveQueue(executor_);
+        _removeFromStandby(executor_);
+        _tryActivateFromStandby();
+
+        emit ExecutorDisapproved(executor_);
+    }
+
+    /**
+     * @notice Slash an executor's stake (only DAOSLC)
+     * @param executor_ Address of the executor to slash
+     * @param amount_ Amount to slash from the executor's stake
+     * @dev This function accounts for withdrawal announcements to prevent front-running.
+     *      If an executor has announced withdrawal, the total slashable amount includes
+     *      both their current stake and the withdrawal announcement amount.
+     */
+    function slashExecutor(
+        address executor_,
+        uint256 amount_
+    ) external onlyDAOSLC syncedMaxActiveExecutors {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+        ExecutorInfo storage executorInfo = $.executors[executor_];
+        WithdrawalAnnouncement storage announcement = $.withdrawalAnnouncements[executor_];
+
+        uint256 totalSlashableAmount_ = executorInfo.stake;
+        if (announcement.announcedAt != 0) {
+            totalSlashableAmount_ += announcement.amount;
+        }
+
+        if (totalSlashableAmount_ == 0) revert ExecutorHasNoStake(executor_);
+        if (amount_ > totalSlashableAmount_)
+            revert Errors.InsufficientStakeAmount(executor_, amount_, executorInfo.stake);
+
+        address slashingRecipient_ = _getSlashingRecipient();
+
+        if (amount_ > executorInfo.stake && announcement.announcedAt != 0) {
+            executorInfo.stake += announcement.amount;
+            delete $.withdrawalAnnouncements[executor_];
+        }
+
+        executorInfo.stake -= amount_;
+
+        _manipulateExecutorState(executor_);
+
+        $.stakeToken.safeTransfer(slashingRecipient_, amount_);
+
+        emit ExecutorSlashed(executor_, amount_, slashingRecipient_);
+    }
+
+    /**
+     * @notice Distribute rewards to active executors (only Governance)
+     * @param amount_ Total amount to distribute
+     */
+    function distributeRewards(uint256 amount_) external onlyGovernance {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+
+        $.stakeToken.safeTransferFrom(msg.sender, address(this), amount_);
+
+        $.rewardsToDistribute = amount_;
+
+        _update(address(0));
+
+        $.rewardsToDistribute = 0;
+
+        emit RewardsDistributed(amount_);
+    }
+
+    /**
+     * @notice Claim rewards for the caller
+     */
+    function claimRewards() external {
+        uint256 rewards_ = _distributeAllValue(msg.sender);
+
+        _getExecutorsRegistryStorage().stakeToken.safeTransfer(msg.sender, rewards_);
+
+        emit RewardsClaimed(msg.sender, rewards_);
+    }
+
+    /**
+     * @notice Synchronize local maxActiveExecutors parameter with the one in the registry
+     */
+    function boundActiveExecutors() external {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+        uint256 remoteMaxActiveExecutors_ = _getMaxActiveExecutors();
+        if ($.maxActiveExecutors == remoteMaxActiveExecutors_) {
+            revert Errors.ParameterIsAlreadySynced(MAX_ACTIVE_EXECUTORS_PARAM_NAME);
+        }
+
+        $.maxActiveExecutors = remoteMaxActiveExecutors_;
+
+        _handleMaxActiveExecutorsResize();
+    }
+
+    function tryBecomeActive() external syncedMaxActiveExecutors {
+        _tryActivateExecutor(msg.sender);
+    }
+
+    /**
+     * @inheritdoc IExecutorsRegistry
+     */
+    function getExecutorsCount() external view override returns (uint256) {
+        return _getExecutorsRegistryStorage().activeExecutors.length();
+    }
+
+    /**
+     * @inheritdoc IExecutorsRegistry
+     */
+    function isExecutor(address candidate_) public view override returns (bool) {
+        return _getExecutorsRegistryStorage().executors[candidate_].isActive;
+    }
+
+    /**
+     * @notice Get executor information
+     * @param executor_ Address of the executor
+     * @return ExecutorInfo struct with all executor data
+     */
+    function getExecutorInfo(address executor_) external view returns (ExecutorInfo memory) {
+        return _getExecutorsRegistryStorage().executors[executor_];
+    }
+
+    /**
+     * @notice Get active executors list with pagination
+     * @param offset_ Starting index
+     * @param limit_ Maximum number of executors to return
+     * @return Array of active executor addresses
+     */
+    function getActiveExecutors(
+        uint256 offset_,
+        uint256 limit_
+    ) external view returns (address[] memory) {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+
+        uint256 to_ = Paginator.getTo($.activeExecutors.length(), offset_, limit_);
+
+        address[] memory result = new address[](to_ - offset_);
+
+        for (uint256 i = offset_; i < to_; ++i) {
+            result[i - offset_] = address(uint160(uint256(($.activeExecutors._queue._values[i]))));
+        }
+
+        return result;
+    }
+
+    /**
+     * @notice Get standby executors list with pagination
+     * @param offset_ Starting index
+     * @param limit_ Maximum number of executors to return
+     * @return Array of standby executor addresses
+     */
+    function getStandbyExecutors(
+        uint256 offset_,
+        uint256 limit_
+    ) external view returns (address[] memory) {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+
+        uint256 to_ = Paginator.getTo($.standbyExecutors.length(), offset_, limit_);
+
+        address[] memory result = new address[](to_ - offset_);
+
+        for (uint256 i = offset_; i < to_; ++i) {
+            result[i - offset_] = address(
+                uint160(uint256(($.standbyExecutors._queue._values[i])))
+            );
+        }
+
+        return result;
+    }
+
+    /**
+     * @notice Get withdrawal announcement information for an executor
+     * @param executor_ Address of the executor
+     * @return Withdrawal announcement struct
+     */
+    function getWithdrawalAnnouncement(
+        address executor_
+    ) external view returns (WithdrawalAnnouncement memory) {
+        return _getExecutorsRegistryStorage().withdrawalAnnouncements[executor_];
+    }
+
+    /**
+     * @notice Check if withdrawal is ready to be completed
+     * @param executor_ Address of the executor
+     * @return True if withdrawal can be completed
+     */
+    function isWithdrawalReady(address executor_) external view returns (bool) {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+        WithdrawalAnnouncement storage announcement = $.withdrawalAnnouncements[executor_];
+
+        if (announcement.announcedAt == 0) return false;
+
+        return block.timestamp >= announcement.availableAt;
+    }
+
+    function hasShares(address executor_) public view returns (bool) {
+        return userDistribution(executor_).shares == 1;
+    }
+
+    function supportsInterface(
+        bytes4 interfaceId_
+    ) public view override(ERC165, IERC165) returns (bool) {
+        return
+            interfaceId_ == type(IExecutorsRegistry).interfaceId ||
+            super.supportsInterface(interfaceId_);
+    }
+
+    function implementation() external view returns (address) {
+        return ERC1967Utils.getImplementation();
+    }
+
+    function _getValueToDistribute(uint256, uint256) internal view override returns (uint256) {
+        return _getExecutorsRegistryStorage().rewardsToDistribute;
+    }
+
+    function _tryActivateExecutor(address executor_) internal {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+        ExecutorInfo storage executorInfo = $.executors[executor_];
+
+        if (!executorInfo.isApproved) return;
+        if (executorInfo.stake < _getMinimumStake()) return;
+
+        if ($.activeExecutors.length() < $.maxActiveExecutors) {
+            _activateExecutor(executor_);
+        } else {
+            address lowestExecutor_ = $.activeExecutors.topValue();
+            uint256 lowestStake_ = $.executors[lowestExecutor_].stake;
+
+            if (executorInfo.stake > lowestStake_) {
+                _removeFromActiveQueue(lowestExecutor_);
+                _addToStandby(lowestExecutor_);
+
+                _activateExecutor(executor_);
+            } else {
+                _addToStandby(executor_);
+            }
+        }
+    }
+
+    // We need our topValue to be the one with the lowest stake
+    function _addToActiveQueue(address executor_) internal {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+        ExecutorInfo storage executorInfo = $.executors[executor_];
+
+        $.activeExecutors.add(executor_, type(uint256).max - executorInfo.stake);
+
+        executorInfo.isActive = true;
+
+        _updateExecutorShares(executor_);
+    }
+
+    function _addToStandby(address executor_) internal {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+        ExecutorInfo storage executorInfo = $.executors[executor_];
+
+        if (executorInfo.stake < _getMinimumStake()) return;
+
+        if (executorInfo.isStandby) {
+            _removeFromStandby(executor_);
+        }
+
+        $.standbyExecutors.add(executor_, executorInfo.stake);
+
+        executorInfo.isStandby = true;
+
+        emit ExecutorMovedToStandby(executor_);
+    }
+
+    function _removeFromStandby(address executor_) internal {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+
+        $.standbyExecutors.remove(executor_);
+
+        $.executors[executor_].isStandby = false;
+    }
+
+    function _removeFromActiveQueue(address executor_) internal {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+
+        $.activeExecutors.remove(executor_);
+
+        $.executors[executor_].isActive = false;
+
+        _updateExecutorShares(executor_);
+    }
+
+    function _tryActivateFromStandby() internal {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+
+        if ($.standbyExecutors.length() == 0) return;
+
+        // Get highest staked standby executor (top of max priority queue)
+        // Guaranteed to be non-zero address since we check for length above
+        _tryActivateExecutor($.standbyExecutors.topValue());
+    }
+
+    function _activateExecutor(address executor_) internal {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+
+        _removeFromStandby(executor_);
+        _addToActiveQueue(executor_);
+
+        emit ExecutorActivated(executor_, $.executors[executor_].stake);
+    }
+
+    /**
+     * @notice Handle changing of maxActiveExecutors parameter in Registry.
+     * In case of maxActiveExecutor increasing, do nothing, but if it is decreased,
+     * and size of the list of active executors is greater than
+     * the maxActiveExecutors parameter, then the list will be reduced.
+     * Executors, which was removed from active queue, are moved to standby list.
+     */
+    function _handleMaxActiveExecutorsResize() internal {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+        uint256 maxActiveExecutors_ = $.maxActiveExecutors;
+        uint256 activeExecutorsLength_ = $.activeExecutors.length();
+
+        if (maxActiveExecutors_ >= activeExecutorsLength_) return;
+
+        // SAFE: Previously checked, that activeExecutorsLength_ > maxActiveExecutors_
+        uint256 delta_ = activeExecutorsLength_ - maxActiveExecutors_;
+
+        while (delta_ > 0) {
+            address lowestExecutor_ = $.activeExecutors.topValue();
+
+            _removeFromActiveQueue(lowestExecutor_);
+            _addToStandby(lowestExecutor_);
+
+            --delta_;
+        }
+    }
+
+    // solhint-disable-next-line no-empty-blocks
+    function _authorizeUpgrade(address newImplementation_) internal override onlyDAOSLC {}
+
+    function _getMinimumStake() internal view returns (uint256) {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+
+        try $.parametersRegistry.getUint(MINIMUM_STAKE_PARAM_NAME) returns (
+            uint256 minimumStake_
+        ) {
+            return minimumStake_;
+        } catch {
+            revert Errors.ParameterIsNotSet(
+                address($.parametersRegistry),
+                MINIMUM_STAKE_PARAM_NAME
+            );
+        }
+    }
+
+    function _getMaxActiveExecutors() internal view returns (uint256) {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+
+        try $.parametersRegistry.getUint(MAX_ACTIVE_EXECUTORS_PARAM_NAME) returns (
+            uint256 maxActiveExecutors_
+        ) {
+            return maxActiveExecutors_;
+        } catch {
+            revert Errors.ParameterIsNotSet(
+                address($.parametersRegistry),
+                MAX_ACTIVE_EXECUTORS_PARAM_NAME
+            );
+        }
+    }
+
+    function _getDAOSLC() internal view returns (address) {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+
+        try $.parametersRegistry.getAddr(DAOSLC_PARAM_NAME) returns (address daoslc_) {
+            return daoslc_;
+        } catch {
+            revert Errors.ParameterIsNotSet(address($.parametersRegistry), DAOSLC_PARAM_NAME);
+        }
+    }
+
+    function _getWithdrawalPeriod() internal view returns (uint256) {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+
+        try $.parametersRegistry.getUint(WITHDRAWAL_PERIOD_PARAM_NAME) returns (
+            uint256 withdrawalPeriod_
+        ) {
+            return withdrawalPeriod_;
+        } catch {
+            revert Errors.ParameterIsNotSet(
+                address($.parametersRegistry),
+                WITHDRAWAL_PERIOD_PARAM_NAME
+            );
+        }
+    }
+
+    function _getSlashingRecipient() internal view returns (address) {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+
+        try $.parametersRegistry.getAddr(SLASHING_RECIPIENT_PARAM_NAME) returns (
+            address slashingRecipient_
+        ) {
+            return slashingRecipient_;
+        } catch {
+            revert Errors.ParameterIsNotSet(
+                address($.parametersRegistry),
+                SLASHING_RECIPIENT_PARAM_NAME
+            );
+        }
+    }
+
+    /**
+     * @notice Update executor shares based on eligibility (approved + above minimum stake)
+     * @dev Executors get equal shares (1 share each) if eligible, regardless of stake amount
+     * @param executor_ Address of the executor
+     */
+    function _updateExecutorShares(address executor_) private {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+        ExecutorInfo storage executorInfo = $.executors[executor_];
+
+        bool currentlyHasShares = hasShares(executor_);
+        bool isEligible = executorInfo.isApproved && isExecutor(executor_);
+
+        if (isEligible && !currentlyHasShares) {
+            _addShares(executor_, 1);
+        } else if (!isEligible && currentlyHasShares) {
+            _removeShares(executor_, 1);
+        }
+    }
+
+    function _requireGovernance() private view {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+        if (msg.sender != address($.governance)) {
+            revert Errors.SenderExpectedToBeGovernance(msg.sender);
+        }
+    }
+
+    function _manipulateExecutorState(address executor_) private {
+        if (isExecutor(executor_)) {
+            _removeFromActiveQueue(executor_);
+        } else {
+            _removeFromStandby(executor_);
+        }
+
+        _addToStandby(executor_);
+        _tryActivateFromStandby();
+
+        _updateExecutorShares(executor_);
+    }
+
+    function _requireDAOSLC() private view {
+        if (msg.sender != _getDAOSLC()) {
+            revert Errors.SenderExpectedToBeDAOSLC(msg.sender);
+        }
+    }
+
+    function _requiredSyncedMaxActiveExecutors() private view {
+        ExecutorsRegistryStorage storage $ = _getExecutorsRegistryStorage();
+        if ($.maxActiveExecutors != _getMaxActiveExecutors()) {
+            revert Errors.ParameterIsNotSynced(MAX_ACTIVE_EXECUTORS_PARAM_NAME);
+        }
+    }
+
+    function _getExecutorsRegistryStorage()
+        private
+        pure
+        returns (ExecutorsRegistryStorage storage $)
+    {
+        // solhint-disable-next-line no-inline-assembly
+        assembly ("memory-safe") {
+            $.slot := EXECUTORS_REGISTRY_STORAGE_LOCATION
+        }
+    }
+}