@web3dotorg/evm-slc-core-contracts 0.3.2

package/governance/Governance.sol

@@ -0,0 +1,969 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+/* solhint-disable-next-line no-unused-import */
+import {IERC6372} from "@openzeppelin/contracts/interfaces/IERC6372.sol";
+/* solhint-disable-next-line no-unused-import */
+import {IGovernor} from "@openzeppelin/contracts/governance/IGovernor.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {ERC1967Utils} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol";
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import {GovernorUpgradeable} from "@openzeppelin/contracts-upgradeable/governance/GovernorUpgradeable.sol";
+
+import {Paginator} from "@solarity/solidity-lib/libs/arrays/Paginator.sol";
+
+import {Errors} from "../libs/Errors.sol";
+import {IWrappedToken} from "../interfaces/IWrappedToken.sol";
+import {ISLCCore} from "../interfaces/ISLCCore.sol";
+import {IGovernance} from "../interfaces/IGovernance.sol";
+import {IQParameters} from "../interfaces/IQParameters.sol";
+import {INeutralsRegistry} from "../interfaces/INeutralsRegistry.sol";
+import {IExecutorsRegistry} from "../interfaces/IExecutorsRegistry.sol";
+import {DAOSLC_PARAM_NAME, TREASURY_ADDRESS_PARAM_NAME} from "../utils/Globals.sol";
+
+contract Governance is IGovernance, GovernorUpgradeable, UUPSUpgradeable {
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    using SafeERC20 for IWrappedToken;
+
+    // keccak256(abi.encode(uint256(keccak256("evm-slc-core.storage.Governance")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant GOVERNANCE_STORAGE_LOCATION =
+        0xb93e2841340255f69de4f9300770e3cc1894dc081e8bf6d34a78e9ac897c7900;
+
+    bytes32 private constant GOVERNOR_STORAGE_LOCATION =
+        0x7c712897014dbe49c045ef1299aa2d5f9e67e48eea4403efa21f1e0f3ac0cb00;
+
+    string private constant VOTING_DELAY_PARAM_NAME = "slc.governance.votingDelay";
+
+    // solhint-disable-next-line gas-small-strings
+    string private constant NEUTRALS_VOTING_PERIOD_PARAM_NAME =
+        "slc.governance.neutralsVotingPeriod";
+
+    // solhint-disable-next-line gas-small-strings
+    string private constant EXECUTORS_VOTING_PERIOD_PARAM_NAME =
+        "slc.governance.executorsVotingPeriod";
+
+    // solhint-disable-next-line gas-small-strings
+    string private constant NEUTRALS_THRESHOLD_PARAM_NAME = "slc.governance.neutralsThreshold";
+
+    // solhint-disable-next-line gas-small-strings
+    string private constant EXECUTORS_THRESHOLD_PARAM_NAME = "slc.governance.executorsThreshold";
+
+    string private constant EXECUTORS_SHARE_PARAM_NAME = "slc.governance.executorsShare";
+
+    string private constant NEUTRALS_SHARE_PARAM_NAME = "slc.governance.neutralsShare";
+
+    string private constant TREASURY_SHARE_PARAM_NAME = "slc.governance.treasuryShare";
+
+    string private constant MIN_SERVICE_FEE_PARAM_NAME = "slc.governance.minServiceFee";
+
+    enum VotingPhase {
+        None,
+        Neutrals,
+        Executors,
+        Executed
+    }
+
+    struct GovernanceStorage {
+        IWrappedToken token;
+        IExecutorsRegistry executorsRegistry;
+        INeutralsRegistry neutralsRegistry;
+        IQParameters parametersRegistry;
+        mapping(address slcCore => SLCGovernanceState) slcGovernanceState;
+        mapping(uint256 proposalId => SLCProposalState) proposalState;
+    }
+
+    struct SLCGovernanceState {
+        uint256 totalRequestsCount;
+        mapping(uint256 requestNumber => ServiceRequestState) requestState;
+    }
+
+    struct ServiceRequestState {
+        address requester;
+        uint256 serviceFee;
+        uint256 neutralsNumber;
+        string additionalLink;
+        bytes data;
+        VotingPhase votingPhase;
+        bytes32 leadingOperationHash;
+        // Proposals
+        uint256 requestNonce;
+        uint256[] proposalIds;
+    }
+
+    struct SLCProposalState {
+        // Parent data
+        address slcCore;
+        uint256 requestNumber;
+        // Voting parameters
+        uint256 neutralsThreshold;
+        uint256 executorsThreshold;
+        // Service request data
+        EnumerableSet.AddressSet selectedNeutrals;
+        // Voting data
+        OperationBundle[] operationBundles;
+        mapping(bytes32 operationHash => uint256 position) operationBundlePosition;
+        mapping(bytes32 operationHash => OperationBundle) operationBundleByHash;
+        mapping(bytes32 operationHash => EnumerableSet.AddressSet) operationByNeutral;
+        mapping(address neutral => bytes32 operationHash) neutralToOperation;
+        EnumerableSet.AddressSet positiveExecutorVotes;
+        EnumerableSet.AddressSet negativeExecutorVotes;
+    }
+
+    struct SLCProposalStateView {
+        // Voting parameters
+        uint256 neutralsThreshold;
+        uint256 executorsThreshold;
+        // Service request data
+        address[] selectedNeutrals;
+        bytes32[] neutralToOperationHashes;
+        // Voting data
+        OperationBundle[] operationBundles;
+        address[] positiveExecutorVotes;
+        address[] negativeExecutorVotes;
+    }
+
+    event RejectedByExecutors(uint256 proposalId, uint256 newProposalId);
+
+    error Unreachable();
+    error AccountAlreadyVoted(address account);
+    error NeutralsThresholdTooHigh(uint256 threshold);
+    error ExecutorsThresholdTooHigh(uint256 threshold);
+    error InvalidTimepoint(uint256 timepoint);
+    error AccountNotSelected(address account);
+    error AccountNotExecutor(address account);
+    error InvalidServiceFee(uint256 serviceFee, uint256 msgValue);
+    error InvalidVotingPhaseForExecutorVote(VotingPhase votingPhase);
+    error InvalidVotingPhaseForProposeOperations(VotingPhase votingPhase);
+    error InvalidSharesTotal(uint256 totalShares);
+    error ServiceFeeTooLow(uint256 serviceFee, uint256 minServiceFee);
+    error MinServiceFeeNotSet(address parametersRegistry);
+
+    modifier onlyDAOSLC() {
+        _requireDAOSLC();
+        _;
+    }
+
+    function __Governance_init(
+        address token_,
+        address executorsRegistry_,
+        address neutralsRegistry_,
+        address parametersRegistry_
+    ) external initializer {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        $.token = IWrappedToken(token_);
+        $.executorsRegistry = IExecutorsRegistry(executorsRegistry_);
+        $.neutralsRegistry = INeutralsRegistry(neutralsRegistry_);
+        $.parametersRegistry = IQParameters(parametersRegistry_);
+
+        // Approve token usage for reward distribution
+        $.token.approve(executorsRegistry_, type(uint256).max);
+        $.token.approve(neutralsRegistry_, type(uint256).max);
+    }
+
+    function processServiceRequest(
+        address requester_,
+        uint256 serviceFee_,
+        uint256 neutralsNumber_,
+        string calldata additionalLink_,
+        bytes calldata data_
+    ) external payable override returns (bool) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        address slcCore_ = msg.sender;
+
+        uint256 minServiceFee_ = _getMinServiceFee();
+        require(serviceFee_ >= minServiceFee_, ServiceFeeTooLow(serviceFee_, minServiceFee_));
+
+        (uint256 proposalId_, uint256 requestCounter_) = _makeProposal(
+            additionalLink_,
+            requester_
+        );
+
+        ServiceRequestState storage requestState = $.slcGovernanceState[slcCore_].requestState[
+            requestCounter_
+        ];
+        requestState.requester = requester_;
+        requestState.serviceFee = serviceFee_;
+        requestState.neutralsNumber = neutralsNumber_;
+        requestState.additionalLink = additionalLink_;
+        requestState.data = data_;
+
+        address[] memory selectedNeutrals_ = $.neutralsRegistry.getNeutralsSlice(neutralsNumber_);
+        _fillProposalState(selectedNeutrals_, proposalId_);
+
+        _distributeServiceFeeRewards(proposalId_, selectedNeutrals_);
+
+        return true;
+    }
+
+    function proposeOperations(
+        uint256 proposalId_,
+        OperationBundle calldata operationBundle_
+    ) external {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        ServiceRequestState storage requestState = $
+            .slcGovernanceState[$.proposalState[proposalId_].slcCore]
+            .requestState[$.proposalState[proposalId_].requestNumber];
+
+        require(
+            requestState.votingPhase == VotingPhase.Neutrals,
+            InvalidVotingPhaseForProposeOperations(requestState.votingPhase)
+        );
+
+        require(
+            $.proposalState[proposalId_].selectedNeutrals.contains(msg.sender),
+            AccountNotSelected(msg.sender)
+        );
+
+        SLCProposalState storage proposalState = $.proposalState[proposalId_];
+
+        bytes32 operationHash_ = hashOperation(operationBundle_);
+
+        bytes32 previousOperationHash_ = proposalState.neutralToOperation[msg.sender];
+        if (previousOperationHash_ != bytes32(0)) {
+            proposalState.operationByNeutral[previousOperationHash_].remove(msg.sender);
+
+            if (proposalState.operationByNeutral[previousOperationHash_].length() == 0) {
+                _removeOperation(proposalState, previousOperationHash_);
+            }
+        }
+
+        proposalState.operationByNeutral[operationHash_].add(msg.sender);
+        proposalState.neutralToOperation[msg.sender] = operationHash_;
+
+        _addOperation(proposalState, operationBundle_, operationHash_);
+
+        proposalState.operationBundleByHash[operationHash_] = operationBundle_;
+    }
+
+    function implementation() external view returns (address) {
+        return ERC1967Utils.getImplementation();
+    }
+
+    /**
+     * @inheritdoc IERC6372
+     */
+    function clock() public view override returns (uint48) {
+        return uint48(block.timestamp);
+    }
+
+    /**
+     * @inheritdoc IERC6372
+     */
+    // solhint-disable-next-line func-name-mixedcase
+    function CLOCK_MODE() public pure override returns (string memory) {
+        return "mode=timestamp";
+    }
+
+    // TODO: fix
+    function COUNTING_MODE() public pure virtual override returns (string memory) {
+        return "support=bravo,fractional&quorum=for,abstain&params=fractional";
+    }
+
+    function getServiceRequestsBySLCCore(
+        address slcCore_,
+        uint256 offset_,
+        uint256 limit_
+    ) external view returns (ServiceRequestState[] memory) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        uint256 to_ = Paginator.getTo(
+            $.slcGovernanceState[slcCore_].totalRequestsCount,
+            offset_,
+            limit_
+        );
+
+        ServiceRequestState[] memory requests_ = new ServiceRequestState[](to_ - offset_);
+
+        for (uint256 i = offset_; i < to_; ++i) {
+            requests_[i - offset_] = $.slcGovernanceState[slcCore_].requestState[i];
+        }
+
+        return requests_;
+    }
+
+    function getProposalsByServiceRequest(
+        address slcCore_,
+        uint256 requestNumber_,
+        uint256 offset_,
+        uint256 limit_
+    ) external view returns (SLCProposalStateView[] memory, ProposalCore[] memory) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        uint256[] storage proposalIds_ = $
+            .slcGovernanceState[slcCore_]
+            .requestState[requestNumber_]
+            .proposalIds;
+
+        uint256 to_ = Paginator.getTo(proposalIds_.length, offset_, limit_);
+
+        SLCProposalStateView[] memory proposals_ = new SLCProposalStateView[](to_ - offset_);
+        ProposalCore[] memory proposalCores_ = new ProposalCore[](to_ - offset_);
+
+        for (uint256 i = offset_; i < to_; ++i) {
+            (proposals_[i - offset_], proposalCores_[i - offset_]) = getProposalData(
+                proposalIds_[i]
+            );
+        }
+
+        return (proposals_, proposalCores_);
+    }
+
+    function getProposalData(
+        uint256 proposalId
+    ) public view returns (SLCProposalStateView memory, ProposalCore memory) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+        GovernorStorage storage $governor = _getGovernorStorageData();
+
+        SLCProposalState storage proposalState = $.proposalState[proposalId];
+
+        bytes32[] memory neutralToOperationHashes_ = new bytes32[](
+            proposalState.selectedNeutrals.length()
+        );
+
+        uint256 selectedNeutralsLength_ = proposalState.selectedNeutrals.length();
+        for (uint256 i = 0; i < selectedNeutralsLength_; ++i) {
+            neutralToOperationHashes_[i] = proposalState.neutralToOperation[
+                proposalState.selectedNeutrals.at(i)
+            ];
+        }
+
+        SLCProposalStateView memory proposalData = SLCProposalStateView({
+            neutralsThreshold: proposalState.neutralsThreshold,
+            executorsThreshold: proposalState.executorsThreshold,
+            selectedNeutrals: proposalState.selectedNeutrals.values(),
+            neutralToOperationHashes: neutralToOperationHashes_,
+            operationBundles: proposalState.operationBundles,
+            positiveExecutorVotes: proposalState.positiveExecutorVotes.values(),
+            negativeExecutorVotes: proposalState.negativeExecutorVotes.values()
+        });
+
+        ProposalCore memory proposalCore = $governor._proposals[proposalId];
+
+        return (proposalData, proposalCore);
+    }
+
+    function hasVoted(uint256 proposalId, address account) external view returns (bool) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        return
+            $.proposalState[proposalId].positiveExecutorVotes.contains(account) ||
+            $.proposalState[proposalId].negativeExecutorVotes.contains(account);
+    }
+
+    function state(uint256 proposalId) public view override returns (ProposalState) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        if (
+            $.proposalState[proposalId].negativeExecutorVotes.length() >=
+            $.proposalState[proposalId].executorsThreshold
+        ) {
+            return ProposalState.Defeated;
+        }
+
+        if (_voteSucceeded(proposalId)) {
+            return ProposalState.Succeeded;
+        }
+
+        return super.state(proposalId);
+    }
+
+    function hashOperation(OperationBundle memory operation_) public pure returns (bytes32) {
+        return keccak256(abi.encode(operation_));
+    }
+
+    function getSystemToken() external view returns (address) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+        return address($.token);
+    }
+
+    function getParametersRegistry() external view returns (address) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+        return address($.parametersRegistry);
+    }
+
+    /**
+     * @inheritdoc IGovernor
+     */
+    function votingDelay() public view override returns (uint256) {
+        try _getGovernanceStorage().parametersRegistry.getUint(VOTING_DELAY_PARAM_NAME) returns (
+            uint256 votingDelay_
+        ) {
+            return votingDelay_;
+        } catch {
+            return 0;
+        }
+    }
+
+    /**
+     * @inheritdoc IGovernor
+     */
+    function votingPeriod() public view override returns (uint256) {
+        return getNeutralsVotingPeriod() + getExecutorsVotingPeriod();
+    }
+
+    /**
+     * @inheritdoc IGovernor
+     */
+    function quorum(uint256 timepoint) public view override returns (uint256) {
+        require(timepoint > 0 && timepoint <= 2, InvalidTimepoint(timepoint));
+
+        VotingPhase votingPhase = VotingPhase(timepoint);
+
+        if (votingPhase == VotingPhase.Neutrals) {
+            return getNeutralsThreshold();
+        }
+
+        return getExecutorsThreshold();
+    }
+
+    function getNeutralsVotingPeriod() public view returns (uint256) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        try $.parametersRegistry.getUint(NEUTRALS_VOTING_PERIOD_PARAM_NAME) returns (
+            uint256 neutralsVotingPeriod_
+        ) {
+            return neutralsVotingPeriod_;
+        } catch {
+            revert Errors.ParameterIsNotSet(
+                address($.parametersRegistry),
+                NEUTRALS_VOTING_PERIOD_PARAM_NAME
+            );
+        }
+    }
+
+    function getExecutorsVotingPeriod() public view returns (uint256) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        try $.parametersRegistry.getUint(EXECUTORS_VOTING_PERIOD_PARAM_NAME) returns (
+            uint256 executorsVotingPeriod_
+        ) {
+            return executorsVotingPeriod_;
+        } catch {
+            revert Errors.ParameterIsNotSet(
+                address($.parametersRegistry),
+                EXECUTORS_VOTING_PERIOD_PARAM_NAME
+            );
+        }
+    }
+
+    /**
+     * @notice Returns the threshold for the neutrals voting phase. Expected value is in range [0, 100].
+     */
+    function getNeutralsThreshold() public view returns (uint256) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        try $.parametersRegistry.getUint(NEUTRALS_THRESHOLD_PARAM_NAME) returns (
+            uint256 neutralsThreshold_
+        ) {
+            if (neutralsThreshold_ > 100) {
+                revert NeutralsThresholdTooHigh(neutralsThreshold_);
+            }
+
+            return neutralsThreshold_;
+        } catch {
+            revert Errors.ParameterIsNotSet(
+                address($.parametersRegistry),
+                NEUTRALS_THRESHOLD_PARAM_NAME
+            );
+        }
+    }
+
+    /**
+     * @notice Returns the threshold for the executors voting phase. Expected value is in range [0, 100].
+     */
+    function getExecutorsThreshold() public view returns (uint256) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        try $.parametersRegistry.getUint(EXECUTORS_THRESHOLD_PARAM_NAME) returns (
+            uint256 executorsThreshold_
+        ) {
+            if (executorsThreshold_ > 100) {
+                revert ExecutorsThresholdTooHigh(executorsThreshold_);
+            }
+
+            return executorsThreshold_;
+        } catch {
+            revert Errors.ParameterIsNotSet(
+                address($.parametersRegistry),
+                EXECUTORS_THRESHOLD_PARAM_NAME
+            );
+        }
+    }
+
+    /**
+     * @inheritdoc IERC165
+     */
+    function supportsInterface(
+        bytes4 interfaceId_
+    ) public view override(IERC165, GovernorUpgradeable) returns (bool) {
+        return
+            interfaceId_ == type(IGovernance).interfaceId || super.supportsInterface(interfaceId_);
+    }
+
+    function _distributeServiceFeeRewards(
+        uint256 proposalId_,
+        address[] memory selectedNeutrals_
+    ) internal {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        ServiceRequestState storage requestState = $
+            .slcGovernanceState[$.proposalState[proposalId_].slcCore]
+            .requestState[$.proposalState[proposalId_].requestNumber];
+
+        uint256 serviceFee_ = requestState.serviceFee;
+        if (serviceFee_ == 0 && msg.value == 0) return;
+
+        if (msg.value > 0) {
+            require(serviceFee_ == msg.value, InvalidServiceFee(serviceFee_, msg.value));
+            $.token.deposit{value: msg.value}();
+        } else {
+            $.token.safeTransferFrom(requestState.requester, address(this), serviceFee_);
+        }
+
+        uint256 executorsShare_ = _getExecutorsShare();
+        uint256 neutralsShare_ = _getNeutralsShare();
+        uint256 treasuryShare_ = _getTreasuryShare();
+
+        // Validate shares total 100%
+        uint256 totalShares_ = executorsShare_ + neutralsShare_ + treasuryShare_;
+        require(totalShares_ == 100, InvalidSharesTotal(totalShares_));
+
+        // Calculate amounts
+        uint256 executorsAmount_ = (serviceFee_ * executorsShare_) / 100;
+        uint256 neutralsAmount_ = (serviceFee_ * neutralsShare_) / 100;
+        uint256 treasuryAmount_ = (serviceFee_ * treasuryShare_) / 100;
+
+        // Distribute to executors
+        if (executorsAmount_ > 0) {
+            $.executorsRegistry.distributeRewards(executorsAmount_);
+        }
+
+        // Distribute to neutrals
+        if (neutralsAmount_ > 0) {
+            $.neutralsRegistry.distributeRewards(selectedNeutrals_, neutralsAmount_);
+        }
+
+        // Send to treasury
+        if (treasuryAmount_ > 0) {
+            address treasury_ = _getTreasuryAddress();
+            $.token.safeTransfer(treasury_, treasuryAmount_);
+        }
+    }
+
+    function _executeOperations(
+        uint256 proposalId,
+        address[] memory targets,
+        uint256[] memory /*values*/,
+        bytes[] memory /*calldatas*/,
+        bytes32 /*descriptionHash*/
+    ) internal override {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        ServiceRequestState storage requestState = $
+            .slcGovernanceState[$.proposalState[proposalId].slcCore]
+            .requestState[$.proposalState[proposalId].requestNumber];
+
+        bytes32 leadingOperationHash_ = requestState.leadingOperationHash;
+        if (leadingOperationHash_ == bytes32(0)) {
+            revert Unreachable();
+        }
+
+        OperationBundle storage leadingOperationBundle_ = $
+            .proposalState[proposalId]
+            .operationBundleByHash[leadingOperationHash_];
+
+        ISLCCore slcCore_ = ISLCCore(targets[0]);
+
+        uint256 operationsLength_ = leadingOperationBundle_.operations.length;
+        for (uint256 i = 0; i < operationsLength_; ++i) {
+            slcCore_.arbitraryExecute(
+                leadingOperationBundle_.operations[i].operation_,
+                leadingOperationBundle_.operations[i].to_,
+                leadingOperationBundle_.operations[i].data_,
+                leadingOperationBundle_.operations[i].value_
+            );
+        }
+
+        requestState.votingPhase = VotingPhase.Executed;
+    }
+
+    /**
+     * @dev Register a vote for `proposalId` by `account` with a given `support`, voting `weight` and voting `params`.
+     *
+     * Note: Support is generic and can represent various things depending on the voting system used.
+     */
+    // solhint-disable-next-line function-max-lines
+    function _countVote(
+        uint256 proposalId,
+        address account,
+        uint8 support,
+        uint256 totalWeight,
+        bytes memory
+    ) internal virtual override returns (uint256) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        ServiceRequestState storage requestState = $
+            .slcGovernanceState[$.proposalState[proposalId].slcCore]
+            .requestState[$.proposalState[proposalId].requestNumber];
+
+        require($.executorsRegistry.isExecutor(account), AccountNotExecutor(account));
+
+        if (requestState.votingPhase == VotingPhase.Neutrals && _quorumReached(proposalId)) {
+            requestState.votingPhase = VotingPhase.Executors;
+            requestState.leadingOperationHash = _findLeadingOperation(proposalId);
+        }
+
+        require(
+            requestState.votingPhase == VotingPhase.Executors,
+            InvalidVotingPhaseForExecutorVote(requestState.votingPhase)
+        );
+
+        if (
+            $.proposalState[proposalId].positiveExecutorVotes.contains(account) ||
+            $.proposalState[proposalId].negativeExecutorVotes.contains(account)
+        ) {
+            revert AccountAlreadyVoted(account);
+        }
+
+        if (support == 1) {
+            $.proposalState[proposalId].positiveExecutorVotes.add(account);
+        } else {
+            $.proposalState[proposalId].negativeExecutorVotes.add(account);
+        }
+
+        if (
+            $.proposalState[proposalId].negativeExecutorVotes.length() >=
+            $.proposalState[proposalId].executorsThreshold
+        ) {
+            (uint256 newProposalId_, ) = _makeProposal(
+                requestState.additionalLink,
+                requestState.requester
+            );
+            _fillProposalState(
+                $.proposalState[proposalId].selectedNeutrals.values(),
+                newProposalId_
+            );
+
+            emit RejectedByExecutors(proposalId, newProposalId_);
+        }
+
+        if (
+            $.proposalState[proposalId].positiveExecutorVotes.length() >=
+            $.proposalState[proposalId].executorsThreshold
+        ) {
+            _executeProposal(proposalId);
+        }
+
+        return totalWeight;
+    }
+
+    // solhint-disable-next-line no-empty-blocks
+    function _authorizeUpgrade(address) internal override onlyDAOSLC {}
+
+    /**
+     * @dev Amount of votes already cast passes the threshold limit.
+     */
+    function _quorumReached(uint256 proposalId_) internal view override returns (bool) {
+        return _findLeadingOperation(proposalId_) != bytes32(0);
+    }
+
+    /**
+     * @dev Is the proposal successful or not.
+     */
+    function _voteSucceeded(uint256 proposalId_) internal view override returns (bool) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        return
+            $.proposalState[proposalId_].positiveExecutorVotes.length() >=
+            $.proposalState[proposalId_].executorsThreshold;
+    }
+
+    /**
+     * @notice For executors and neutrals voting weight is always 1 for the time being
+     */
+    function _getVotes(address, uint256, bytes memory) internal pure override returns (uint256) {
+        return 1;
+    }
+
+    function _requireDAOSLC() internal view {
+        require(msg.sender == _getDAOSLC(), Errors.SenderExpectedToBeDAOSLC(msg.sender));
+    }
+
+    function _getDAOSLC() internal view returns (address) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        try $.parametersRegistry.getAddr(DAOSLC_PARAM_NAME) returns (address daoslc_) {
+            return daoslc_;
+        } catch {
+            revert Errors.ParameterIsNotSet(address($.parametersRegistry), DAOSLC_PARAM_NAME);
+        }
+    }
+
+    function _getExecutorsShare() internal view returns (uint256) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        try $.parametersRegistry.getUint(EXECUTORS_SHARE_PARAM_NAME) returns (
+            uint256 executorsShare_
+        ) {
+            return executorsShare_;
+        } catch {
+            revert Errors.ParameterIsNotSet(
+                address($.parametersRegistry),
+                EXECUTORS_SHARE_PARAM_NAME
+            );
+        }
+    }
+
+    function _getNeutralsShare() internal view returns (uint256) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        try $.parametersRegistry.getUint(NEUTRALS_SHARE_PARAM_NAME) returns (
+            uint256 neutralsShare_
+        ) {
+            return neutralsShare_;
+        } catch {
+            revert Errors.ParameterIsNotSet(
+                address($.parametersRegistry),
+                NEUTRALS_SHARE_PARAM_NAME
+            );
+        }
+    }
+
+    function _getTreasuryShare() internal view returns (uint256) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        try $.parametersRegistry.getUint(TREASURY_SHARE_PARAM_NAME) returns (
+            uint256 treasuryShare_
+        ) {
+            return treasuryShare_;
+        } catch {
+            revert Errors.ParameterIsNotSet(
+                address($.parametersRegistry),
+                TREASURY_SHARE_PARAM_NAME
+            );
+        }
+    }
+
+    function _getTreasuryAddress() internal view returns (address) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        try $.parametersRegistry.getAddr(TREASURY_ADDRESS_PARAM_NAME) returns (address treasury_) {
+            return treasury_;
+        } catch {
+            revert Errors.ParameterIsNotSet(
+                address($.parametersRegistry),
+                TREASURY_ADDRESS_PARAM_NAME
+            );
+        }
+    }
+
+    function _getMinServiceFee() internal view returns (uint256) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        try $.parametersRegistry.getUint(MIN_SERVICE_FEE_PARAM_NAME) returns (
+            uint256 minServiceFee_
+        ) {
+            return minServiceFee_;
+        } catch {
+            revert Errors.ParameterIsNotSet(
+                address($.parametersRegistry),
+                MIN_SERVICE_FEE_PARAM_NAME
+            );
+        }
+    }
+
+    function _makeProposal(
+        string memory additionalLink_,
+        address requester_
+    ) private returns (uint256 proposalId_, uint256 requestCounter_) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        address slcCore_ = msg.sender;
+
+        // solhint-disable-next-line gas-increment-by-one
+        requestCounter_ = $.slcGovernanceState[slcCore_].totalRequestsCount++;
+        // solhint-disable-next-line gas-increment-by-one
+        uint256 requestNonce_ = $
+            .slcGovernanceState[slcCore_]
+            .requestState[requestCounter_]
+            .requestNonce++;
+
+        address[] memory targets = new address[](1);
+        targets[0] = slcCore_;
+
+        uint256[] memory values = new uint256[](1);
+        values[0] = 0;
+
+        bytes[] memory calldatas = new bytes[](1);
+        calldatas[0] = abi.encodePacked(requestCounter_, requestNonce_);
+
+        proposalId_ = _propose(targets, values, calldatas, additionalLink_, requester_);
+
+        $.proposalState[proposalId_].slcCore = slcCore_;
+        $.proposalState[proposalId_].requestNumber = requestCounter_;
+    }
+
+    function _executeProposal(uint256 proposalId_) private {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        uint256 requestCounter_ = $.proposalState[proposalId_].requestNumber;
+        ServiceRequestState storage requestState = $
+            .slcGovernanceState[$.proposalState[proposalId_].slcCore]
+            .requestState[requestCounter_];
+
+        address[] memory targets = new address[](1);
+        targets[0] = $.proposalState[proposalId_].slcCore;
+
+        // Here we need to execute the previous proposal related to this request
+        bytes[] memory calldatas = new bytes[](1);
+        calldatas[0] = abi.encodePacked(requestCounter_, requestState.requestNonce - 1);
+
+        execute(
+            targets,
+            new uint256[](1),
+            calldatas,
+            keccak256(bytes(requestState.additionalLink))
+        );
+    }
+
+    function _fillProposalState(address[] memory selectedNeutrals_, uint256 proposalId_) private {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        ServiceRequestState storage requestState = $
+            .slcGovernanceState[$.proposalState[proposalId_].slcCore]
+            .requestState[$.proposalState[proposalId_].requestNumber];
+
+        uint256 neutralsLength_ = selectedNeutrals_.length;
+        for (uint256 i = 0; i < neutralsLength_; ++i) {
+            $.proposalState[proposalId_].selectedNeutrals.add(selectedNeutrals_[i]);
+        }
+
+        $.proposalState[proposalId_].neutralsThreshold = Math.mulDiv(
+            neutralsLength_,
+            getNeutralsThreshold(),
+            100,
+            Math.Rounding.Ceil
+        );
+
+        uint256 executorsCount_ = $.executorsRegistry.getExecutorsCount();
+        $.proposalState[proposalId_].executorsThreshold = Math.mulDiv(
+            executorsCount_,
+            getExecutorsThreshold(),
+            100,
+            Math.Rounding.Ceil
+        );
+
+        requestState.proposalIds.push(proposalId_);
+
+        requestState.votingPhase = VotingPhase.Neutrals;
+    }
+
+    function _addOperation(
+        SLCProposalState storage proposalState,
+        OperationBundle memory operationBundle_,
+        bytes32 operationHash_
+    ) private returns (bool) {
+        if (!_containsOperation(proposalState, operationHash_)) {
+            proposalState.operationBundles.push(operationBundle_);
+            // The value is stored at length-1, but we add 1 to all indexes
+            // and use 0 as a sentinel value
+            proposalState.operationBundlePosition[operationHash_] = proposalState
+                .operationBundles
+                .length;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function _removeOperation(
+        SLCProposalState storage proposalState,
+        bytes32 operationHash_
+    ) private returns (bool) {
+        // We cache the value's position to prevent multiple reads from the same storage slot
+        uint256 position_ = proposalState.operationBundlePosition[operationHash_];
+
+        if (position_ != 0) {
+            // Equivalent to contains(set, value)
+            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
+            // the array, and then remove the last element (sometimes called as 'swap and pop').
+
+            uint256 valueIndex_ = position_ - 1;
+            uint256 lastIndex_ = proposalState.operationBundles.length - 1;
+
+            if (valueIndex_ != lastIndex_) {
+                OperationBundle storage lastValue = proposalState.operationBundles[lastIndex_];
+
+                // Move the lastValue to the index where the value to delete is
+                proposalState.operationBundles[valueIndex_] = lastValue;
+                // Update the tracked position of the lastValue (that was just moved)
+                proposalState.operationBundlePosition[hashOperation(lastValue)] = position_;
+            }
+
+            // Delete the slot where the moved value was stored
+            proposalState.operationBundles.pop();
+
+            // Delete the tracked position for the deleted slot
+            delete proposalState.operationBundlePosition[operationHash_];
+
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function _containsOperation(
+        SLCProposalState storage proposalState,
+        bytes32 operationHash_
+    ) private view returns (bool) {
+        return proposalState.operationBundlePosition[operationHash_] != 0;
+    }
+
+    function _findLeadingOperation(uint256 proposalId_) private view returns (bytes32) {
+        GovernanceStorage storage $ = _getGovernanceStorage();
+
+        SLCProposalState storage proposalState = $.proposalState[proposalId_];
+
+        uint256 operationBundlesLength_ = proposalState.operationBundles.length;
+        uint256 leadingOperationApprovals_ = 0;
+        bytes32 leadingOperation_ = bytes32(0);
+
+        for (uint256 i = 0; i < operationBundlesLength_; ++i) {
+            bytes32 operationHash_ = hashOperation(proposalState.operationBundles[i]);
+            uint256 operationApprovals_ = proposalState
+                .operationByNeutral[operationHash_]
+                .length();
+
+            if (
+                operationApprovals_ >= proposalState.neutralsThreshold &&
+                operationApprovals_ > leadingOperationApprovals_
+            ) {
+                leadingOperation_ = operationHash_;
+                leadingOperationApprovals_ = operationApprovals_;
+            }
+        }
+
+        return leadingOperation_;
+    }
+
+    function _getGovernanceStorage() private pure returns (GovernanceStorage storage $) {
+        /* solhint-disable-next-line no-inline-assembly */
+        assembly ("memory-safe") {
+            $.slot := GOVERNANCE_STORAGE_LOCATION
+        }
+    }
+
+    function _getGovernorStorageData() private pure returns (GovernorStorage storage $) {
+        /* solhint-disable-next-line no-inline-assembly */
+        assembly ("memory-safe") {
+            $.slot := GOVERNOR_STORAGE_LOCATION
+        }
+    }
+}