{
    "Function": "slitherConstructorConstantVariables",
    "File": "contracts/governance/GovernorAlpha.sol",
    "Parent Contracts": [],
    "High-Level Calls": [],
    "Internal Calls": [
        "keccak256(bytes)",
        "keccak256(bytes)"
    ],
    "Library Calls": [],
    "Low-Level Calls": [],
    "Code": "contract GovernorAlpha {\n    // The name of this contract\n    string public constant NAME = \"Vader Governor Alpha\";\n\n    // The maximum number of actions that can be included in a proposal\n    uint256 public constant PROPOSAL_MAX_OPERATIONS = 10;\n\n    // The delay before voting on a proposal may take place, once proposed\n    uint256 public constant VOTING_DELAY = 1;\n\n    // The duration of voting on a proposal, in blocks\n    uint256 public immutable VOTING_PERIOD;\n\n    // The address of the Vader Protocol Timelock\n    ITimelock public timelock;\n\n    // The address of the Governor Guardian\n    address public guardian;\n\n    // The total number of proposals\n    uint256 public proposalCount;\n\n    // address of xVader token\n    IXVader public immutable xVader;\n\n    // address of fee receiver\n    address public feeReceiver;\n\n    // amount of fee deducted when proposing proposal\n    uint256 public feeAmount;\n\n    // address of council that is allowed to veto on proposals\n    address public council;\n\n    /**\n     * @dev {Proposal} struct contains parameters for a single proposal.\n     * id: Unique id for looking up a proposal.\n     * canceled: Flag marking whether the proposal has been canceled.\n     * executed: Flag marking whether the proposal has been executed.\n     * proposer: Creator of the proposal\n     * eta: The timestamp that the proposal will be available for execution, set once the vote succeeds\n     * targets: the ordered list of target addresses for calls to be made\n     * values: The ordered list of values (i.e. msg.value) to be passed to the calls to be made\n     * signatures: The ordered list of function signatures to be called\n     * calldatas: The ordered list of calldata to be passed to each call\n     * startBlock: startBlock: The block at which voting begins: holders must delegate their votes prior to this block\n     * endBlock: The block at which voting ends: votes must be cast prior to this block\n     * forVotes: Current number of votes in favor of this proposal\n     * againstVotes: Current number of votes in opposition to this proposal\n     * vetoStatus: Veto status if the proposal has been vetoed by council in favor or against\n     // C4-Audit Fix for Issue # 141\n     * receipts: Receipts of ballots for the entire set of voters\n     */\n    struct Proposal {\n        uint256 id;\n        bool canceled;\n        bool executed;\n        address proposer;\n        uint256 eta;\n        address[] targets;\n        uint256[] values;\n        string[] signatures;\n        bytes[] calldatas;\n        uint256 startBlock;\n        uint256 endBlock;\n        uint224 forVotes;\n        uint224 againstVotes;\n        VetoStatus vetoStatus;\n        mapping(address => Receipt) receipts;\n    }\n\n    /**\n     * @dev {Receipt} struct contains parameters for a voter against a particular proposal\n     * and is a ballot receipt record for a voter.\n     *\n     * hasVoted: Whether or not a vote has been casted\n     * support: Whether or not the voter supports the proposal\n     * votes: The number of votes the voter had, which were cast\n     */\n    struct Receipt {\n        bool hasVoted;\n        bool support;\n        uint224 votes;\n    }\n\n    /**\n     * @dev {VetoStatus} contains parameters representing if a proposal has been vetoed by council\n     *\n     * hasBeenVetoed: Whether proposal has been vetoed or not\n     // C4-Audit Fix for Issue # 142\n     * support: Whether veto is in favor of or against proposal\n     */\n    struct VetoStatus {\n        bool hasBeenVetoed;\n        bool support;\n    }\n\n    // Possible states that a proposal may be in\n    enum ProposalState {\n        Pending,\n        Active,\n        Canceled,\n        Defeated,\n        Succeeded,\n        Queued,\n        Expired,\n        Executed\n    }\n\n    // The official record of all proposals ever proposed\n    mapping(uint256 => Proposal) public proposals;\n\n    // The latest proposal for each proposer\n    mapping(address => uint256) public latestProposalIds;\n\n    // The EIP-712 typehash for the contract's domain\n    bytes32 public constant DOMAIN_TYPEHASH =\n        keccak256(\n            \"EIP712Domain(string name,uint256 chainId,address verifyingContract)\"\n        );\n\n    // The EIP-712 typehash for the ballot struct used by the contract\n    bytes32 public constant BALLOT_TYPEHASH =\n        keccak256(\"Ballot(uint256 proposalId,bool support)\");\n\n    // An event emitted when a new proposal is created\n    event ProposalCreated(\n        uint256 id,\n        address proposer,\n        address[] targets,\n        uint256[] values,\n        string[] signatures,\n        bytes[] calldatas,\n        uint256 startBlock,\n        uint256 endBlock,\n        string description\n    );\n\n    // An event emitted when a vote has been cast on a proposal\n    event VoteCast(\n        address voter,\n        uint256 proposalId,\n        bool support,\n        uint256 votes\n    );\n\n    // An event emitted when a proposal has been canceled\n    event ProposalCanceled(uint256 id);\n\n    // An event emitted when a proposal has been queued in the Timelock\n    event ProposalQueued(uint256 id, uint256 eta);\n\n    // An event emitted when a proposal has been executed in the Timelock\n    event ProposalExecuted(uint256 id);\n\n    // An event emitted when fee receiver is changed\n    event FeeReceiverChanged(address oldFeeReceiver, address newFeeReceiver);\n\n    // An event emitted when fee amount is changed\n    event FeeAmountChanged(uint256 oldFeeAmount, uint256 newFeeAmount);\n\n    // An event emitted when a proposal has been vetoed by the council\n    event ProposalVetoed(uint256 proposalId, bool support);\n\n    // An event emitted when council is changed\n    event CouncilChanged(address oldCouncil, address newCouncil);\n\n    /* ========== CONSTRUCTOR ========== */\n\n    /**\n     * @dev Initializes the contract's state setting xVader, fee receiver,\n     * council and guardian addresses along with the fee amount.\n     *\n     * It performs sanity checks for the address type parameters against zero\n     * address values.\n     */\n    constructor(\n        address guardian_,\n        address xVader_,\n        address feeReceiver_,\n        uint256 feeAmount_,\n        address council_,\n        uint256 votingPeriod_\n    ) {\n        require(\n            xVader_ != address(0),\n            \"GovernorAlpha::constructor: xVader address is zero\"\n        );\n\n        require(\n            guardian_ != address(0) &&\n                feeReceiver_ != address(0) &&\n                council_ != address(0),\n            \"GovernorAlpha::constructor: guardian, feeReceiver or council cannot be zero\"\n        );\n\n        guardian = guardian_;\n        xVader = IXVader(xVader_);\n        feeReceiver = feeReceiver_;\n        feeAmount = feeAmount_;\n        council = council_;\n\n        VOTING_PERIOD = votingPeriod_ == 0\n            ? 17280 // ~3 days in blocks (assuming 15s blocks)\n            : votingPeriod_;\n\n        emit FeeReceiverChanged(address(0), feeReceiver_);\n        emit FeeAmountChanged(0, feeAmount_);\n    }\n\n    /* ========== VIEWS ========== */\n\n    // The number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed\n    function quorumVotes(uint256 blockNumber) public view returns (uint256) {\n        return (xVader.getPastTotalSupply(blockNumber) * 4) / 100; // 4% of xVader's supply at the time of proposal creation.\n    }\n\n    /**\n     * @dev Returns the actions contained in a proposal with id {proposalId}.\n     */\n    function getActions(uint256 proposalId)\n        public\n        view\n        returns (\n            address[] memory targets,\n            uint256[] memory values,\n            string[] memory signatures,\n            bytes[] memory calldatas\n        )\n    {\n        Proposal storage p = proposals[proposalId];\n        return (p.targets, p.values, p.signatures, p.calldatas);\n    }\n\n    /**\n     * @dev Returns receipt of the {voter} against the proposal with id {proposalId}.\n     */\n    function getReceipt(uint256 proposalId, address voter)\n        public\n        view\n        returns (Receipt memory)\n    {\n        return proposals[proposalId].receipts[voter];\n    }\n\n    /**\n     * @dev Returns the current state of the proposal with id {proposalId}.\n     *\n     * Requirements:\n     * - The {proposalId} should be greater than 0\n     * - The {proposalId} should be less than or equal to {proposalCount}\n     */\n    function state(uint256 proposalId) public view returns (ProposalState) {\n        require(\n            proposalCount >= proposalId && proposalId > 0,\n            \"GovernorAlpha::state: invalid proposal id\"\n        );\n\n        Proposal storage proposal = proposals[proposalId];\n        if (proposal.canceled) return ProposalState.Canceled;\n\n        if (proposal.vetoStatus.hasBeenVetoed) {\n            // proposal has been vetoed\n            uint256 _eta = proposal.eta;\n\n            // proposal has been vetoed in favor, so considered succeeded\n            if (proposal.vetoStatus.support && _eta == 0)\n                return ProposalState.Succeeded;\n\n            // proposal has been vetoed against, so considered defeated\n            if (_eta == 0) return ProposalState.Defeated;\n        } else {\n            // proposal has not been vetoed, normal flow ensues\n            if (block.number <= proposal.startBlock)\n                return ProposalState.Pending;\n\n            if (block.number <= proposal.endBlock) return ProposalState.Active;\n\n            if (\n                proposal.forVotes <= proposal.againstVotes ||\n                proposal.forVotes < quorumVotes(proposal.startBlock)\n            ) return ProposalState.Defeated;\n\n            if (proposal.eta == 0) return ProposalState.Succeeded;\n        }\n\n        if (proposal.executed) return ProposalState.Executed;\n\n        // C4-Audit Fix for Issue # 177\n        unchecked {\n            if (block.timestamp >= proposal.eta + timelock.GRACE_PERIOD())\n                return ProposalState.Expired;\n        }\n\n        return ProposalState.Queued;\n    }\n\n    /* ========== MUTATIVE FUNCTIONS ========== */\n\n    /**\n     * @dev Sets timelock state variable. Contracts {GovernorAlpha} and\n     * {Timelock} have circular dependencies upon each other and constructors\n     * cannot be used to set them, hence this function is introduced to set\n     * {Timelock} in {GovernorAlpha} after it has been deployed.\n     *\n     * Requirements:\n     * - only guardian can call this function\n     */\n    function setTimelock(address _timelock) external onlyGuardian {\n        require(\n            _timelock != address(0),\n            \"GovernorAlpha::initTimelock: _timelock cannot be zero address\"\n        );\n        timelock = ITimelock(_timelock);\n    }\n\n    /**\n     * @dev Allows any to make a proposal by depositing {feeAmount} xVader.\n     * It accepts targets along with the values, signature and calldatas\n     * for the actions to perform if the proposal succeeds.\n     *\n     * Requirements:\n     * - targets, values, signatures and calldatas arrays' lengths must be greater\n     // C4-Audit Fix for Issue # 141\n     *   than zero, less than or equal to {proposalMaxOperations} and are the same lengths.\n     * - the caller must approve {feeAmount} xVader to this contract prior to call.\n     * - the caller must not have an active/pending proposal.\n     */\n    function propose(\n        address[] memory targets,\n        uint256[] memory values,\n        string[] memory signatures,\n        bytes[] memory calldatas,\n        string memory description\n    ) public returns (uint256 proposalId) {\n        require(\n            targets.length == values.length &&\n                targets.length == signatures.length &&\n                targets.length == calldatas.length,\n            \"GovernorAlpha::propose: proposal function information arity mismatch\"\n        );\n        require(\n            targets.length != 0,\n            \"GovernorAlpha::propose: must provide actions\"\n        );\n        require(\n            targets.length <= PROPOSAL_MAX_OPERATIONS,\n            \"GovernorAlpha::propose: too many actions\"\n        );\n\n        xVader.transferFrom(msg.sender, feeReceiver, feeAmount);\n\n        uint256 latestProposalId = latestProposalIds[msg.sender];\n        if (latestProposalId != 0) {\n            ProposalState proposersLatestProposalState = state(\n                latestProposalId\n            );\n            require(\n                proposersLatestProposalState != ProposalState.Active,\n                \"GovernorAlpha::propose: one live proposal per proposer, found an already active proposal\"\n            );\n            require(\n                proposersLatestProposalState != ProposalState.Pending,\n                \"GovernorAlpha::propose: one live proposal per proposer, found an already pending proposal\"\n            );\n        }\n\n        // C4-Audit Fix for Issue # 177\n        uint256 startBlock;\n        uint256 endBlock;\n        unchecked {\n            startBlock = block.number + VOTING_DELAY;\n            endBlock = startBlock + VOTING_PERIOD;\n        }\n\n        proposalId = ++proposalCount;\n        Proposal storage newProposal = proposals[proposalId];\n        newProposal.id = proposalId;\n        newProposal.proposer = msg.sender;\n        newProposal.targets = targets;\n        newProposal.values = values;\n        newProposal.signatures = signatures;\n        newProposal.calldatas = calldatas;\n        newProposal.startBlock = startBlock;\n        newProposal.endBlock = endBlock;\n\n        latestProposalIds[msg.sender] = proposalId;\n\n        emit ProposalCreated(\n            proposalId,\n            msg.sender,\n            targets,\n            values,\n            signatures,\n            calldatas,\n            startBlock,\n            endBlock,\n            description\n        );\n    }\n\n    /**\n     * @dev Queues a proposal by setting the hashes of its actions in {Timelock} contract.\n     * It also determines 'eta' for the proposal by adding timestamp to {delay} in {Timelock}\n     * and sets it against the proposal in question.\n     *\n     * Requirements:\n     * - the proposal in question must have succeeded either through majority for-votes\n     *   or has been vetoed in its favour.\n     */\n    function queue(uint256 proposalId) public {\n        require(\n            state(proposalId) == ProposalState.Succeeded,\n            \"GovernorAlpha::queue: proposal can only be queued if it is succeeded\"\n        );\n        Proposal storage proposal = proposals[proposalId];\n        // C4-Audit Fix for Issue # 177\n        uint256 eta;\n        unchecked{\n            eta = block.timestamp + timelock.delay();\n        }\n\n        uint256 length = proposal.targets.length;\n        // C4-Audit Fix for Issue # 81\n        for (uint256 i = 0; i < length; ++i) {\n            _queueOrRevert(\n                proposal.targets[i],\n                proposal.values[i],\n                proposal.signatures[i],\n                proposal.calldatas[i],\n                eta\n            );\n        }\n        proposal.eta = eta;\n        emit ProposalQueued(proposalId, eta);\n    }\n\n    /**\n     * @dev Executes a proposal after it has been queued and cool-off time has elapsed.\n     * It sets the {executed} status of the proposal to 'true'.\n     *\n     * Requirements:\n     // C4-Audit Fix for Issue # 142\n     * - the proposal in question must have been queued and cool-off time has elapsed\n     * - none of the actions of the proposal revert upon execution\n     */\n    function execute(uint256 proposalId) public payable {\n        require(\n            state(proposalId) == ProposalState.Queued,\n            \"GovernorAlpha::execute: proposal can only be executed if it is queued\"\n        );\n        Proposal storage proposal = proposals[proposalId];\n        proposal.executed = true;\n        uint256 length = proposal.targets.length;\n        // C4-Audit Fix for Issue # 81\n        for (uint256 i = 0; i < length; ++i) {\n            timelock.executeTransaction{value: proposal.values[i]}(\n                proposal.targets[i],\n                proposal.values[i],\n                proposal.signatures[i],\n                proposal.calldatas[i],\n                proposal.eta\n            );\n        }\n        emit ProposalExecuted(proposalId);\n    }\n\n    /**\n     * @dev Casts vote by {msg.sender}.\n     * It calls the internal function `_castVote` to perform vote casting.\n     */\n    function castVote(uint256 proposalId, bool support) public {\n        return _castVote(msg.sender, proposalId, support);\n    }\n\n    /**\n     * @dev Called by a relayer to cast vote by a message signer.\n     *\n     * Requirements:\n     * - {signatory} retrieved must not be a zero address\n     */\n    function castVoteBySig(\n        uint256 proposalId,\n        bool support,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public {\n        bytes32 domainSeparator = keccak256(\n            abi.encode(\n                DOMAIN_TYPEHASH,\n                keccak256(bytes(NAME)),\n                getChainId(),\n                address(this)\n            )\n        );\n\n        bytes32 structHash = keccak256(\n            abi.encode(BALLOT_TYPEHASH, proposalId, support)\n        );\n\n        bytes32 digest = keccak256(\n            abi.encodePacked(\"\\x19\\x01\", domainSeparator, structHash)\n        );\n\n        address signatory = ecrecover(digest, v, r, s);\n\n        require(\n            signatory != address(0),\n            \"GovernorAlpha::castVoteBySig: invalid signature\"\n        );\n\n        return _castVote(signatory, proposalId, support);\n    }\n\n    /* ========== RESTRICTED FUNCTIONS ========== */\n\n    /**\n     * @dev Changes the {feeReceiver}.\n     *\n     * Requirements:\n     * - only guardian can call\n     */\n    function changeFeeReceiver(address feeReceiver_) external onlyGuardian {\n        emit FeeReceiverChanged(feeReceiver, feeReceiver_);\n        feeReceiver = feeReceiver_;\n    }\n\n    /**\n     * @dev Changes the {feeAmount}.\n     *\n     * Requirements:\n     * - only guardian can call\n     */\n    function changeFeeAmount(uint256 feeAmount_) external onlyGuardian {\n        emit FeeAmountChanged(feeAmount, feeAmount_);\n        feeAmount = feeAmount_;\n    }\n\n    // C4-Audit Fix for Issue # 142\n    /**\n     * @dev Allows vetoing of a proposal in favor or against it.\n     * It also queues a proposal if it has been vetoed in favor of it and.\n     * sets the veto status of the proposal.\n     *\n     * Requirements:\n     * - can only be called by {council}\n     * - proposal being vetoed must be active or pending\n     * - none of the actions in proposal being vetoed point to the contract\n     *   itself. This to restrict council from vetoing a proposal intended\n     *   to change council.\n     */\n    function veto(uint256 proposalId, bool support) external onlyCouncil {\n        ProposalState _state = state(proposalId);\n        require(\n            _state == ProposalState.Active || _state == ProposalState.Pending,\n            \"GovernorAlpha::veto: Proposal can only be vetoed when active\"\n        );\n\n        Proposal storage proposal = proposals[proposalId];\n        address[] memory _targets = proposal.targets;\n        // C4-Audit Fix for Issue # 81\n        for (uint256 i = 0; i < _targets.length; ++i) {\n            if (_targets[i] == address(this)) {\n                // C4-Audit Fix for Issue # 167\n                bytes memory callData = proposal.calldatas[i];\n                bytes4 sig;\n                assembly {\n                    sig := mload(add(callData, 0x20))\n                }\n                require(\n                    sig != this.changeCouncil.selector,\n                    \"GovernorAlpha::veto: council cannot veto a council changing proposal\"\n                );\n            }\n        }\n\n        VetoStatus storage _vetoStatus = proposal.vetoStatus;\n        _vetoStatus.hasBeenVetoed = true;\n        _vetoStatus.support = support;\n\n        if (support) {\n            queue(proposalId);\n        }\n\n        emit ProposalVetoed(proposalId, support);\n    }\n\n    /**\n     * @dev Changes the {council}.\n     *\n     * Requirements:\n     // C4-Audit Fix for Issue # 142\n     * - can only be called by {Timelock} contract through a non-vetoable proposal\n     */\n    function changeCouncil(address council_) external onlyTimelock {\n        emit CouncilChanged(council, council_);\n        council = council_;\n    }\n\n    /**\n     * @dev Cancels the proposal with id {proposalId}.\n     * It also sets the {canceled} property of {Proposal} to `true` and\n     * removes the proposal's corresponding actions from {Timelock} contract.\n     *\n     * Requirements:\n     * - proposal must not be already executed\n     */\n    function cancel(uint256 proposalId) public onlyGuardian {\n        ProposalState _state = state(proposalId);\n        require(\n            _state != ProposalState.Executed,\n            \"GovernorAlpha::cancel: cannot cancel executed proposal\"\n        );\n\n        Proposal storage proposal = proposals[proposalId];\n        proposal.canceled = true;\n        uint256 length = proposal.targets.length;\n        // C4-Audit Fix for Issue # 81\n        for (uint256 i = 0; i < length; ++i) {\n            timelock.cancelTransaction(\n                proposal.targets[i],\n                proposal.values[i],\n                proposal.signatures[i],\n                proposal.calldatas[i],\n                proposal.eta\n            );\n        }\n\n        emit ProposalCanceled(proposalId);\n    }\n\n    /**\n     * @dev Calls {acceptAdmin} on {Timelock} contract and makes the current contract\n     * the admin of {Timelock} contract.\n     *\n     * Requirements:\n     * - only guardian can call it\n     * - current contract must be the `pendingAdmin` in {Timelock} contract\n     */\n    function __acceptAdmin() public onlyGuardian {\n        timelock.acceptAdmin();\n    }\n\n    /**\n     * @dev Gives up the guardian role associated with the contract.\n     *\n     * Requirements:\n     * - only callable by guardian\n     */\n    function __abdicate() public onlyGuardian {\n        guardian = address(0);\n    }\n\n    /**\n     * @dev Queues the transaction to set `pendingAdmin` in {Timelock}.\n     *\n     * Requirements:\n     * - only callable by guardian\n     */\n    function __queueSetTimelockPendingAdmin(\n        address newPendingAdmin,\n        uint256 eta\n    ) public onlyGuardian {\n        timelock.queueTransaction(\n            address(timelock),\n            0,\n            \"setPendingAdmin(address)\",\n            abi.encode(newPendingAdmin),\n            eta\n        );\n    }\n\n    /**\n     * @dev Executes the transaction to set `pendingAdmin` in {Timelock}.\n     *\n     * Requirements:\n     * - only callable by guardian\n     */\n    function __executeSetTimelockPendingAdmin(\n        address newPendingAdmin,\n        uint256 eta\n    ) public onlyGuardian {\n        timelock.executeTransaction(\n            address(timelock),\n            0,\n            \"setPendingAdmin(address)\",\n            abi.encode(newPendingAdmin),\n            eta\n        );\n    }\n\n    /* ========== INTERNAL FUNCTIONS ========== */\n\n    /**\n     * @dev Queues a transaction in {Timelock}.\n     *\n     * Requirements:\n     * - transaction is not already queued in {Timelock}\n     */\n    function _queueOrRevert(\n        address target,\n        uint256 value,\n        string memory signature,\n        bytes memory data,\n        uint256 eta\n    ) internal {\n        require(\n            !timelock.queuedTransactions(\n                keccak256(abi.encode(target, value, signature, data, eta))\n            ),\n            \"GovernorAlpha::_queueOrRevert: proposal action already queued at eta\"\n        );\n        timelock.queueTransaction(target, value, signature, data, eta);\n    }\n\n    /**\n     * @dev Casts vote against proposal with id {proposalId}.\n     * It gets the voting weight of voter from {xVader} token contract corresponding to\n     * the blocknumber when proposal started and adds those votes to either\n     * {forVotes} or {againstVotes} property of {Proposal} depending upon if\n     * the voter is voting in favor of or against the proposal.\n     *\n     * Requirements:\n     * - proposal being voted must be active\n     * - voter has not already voted against the proposal\n     */\n    function _castVote(\n        address voter,\n        uint256 proposalId,\n        bool support\n    ) internal {\n        require(\n            state(proposalId) == ProposalState.Active,\n            \"GovernorAlpha::_castVote: voting is closed\"\n        );\n\n        Proposal storage proposal = proposals[proposalId];\n        Receipt storage receipt = proposal.receipts[voter];\n\n        require(\n            !receipt.hasVoted,\n            \"GovernorAlpha::_castVote: voter already voted\"\n        );\n\n        // optimistically casting to uint224 as xVader contract performs the checks for\n        // votes to not overflow uint224.\n        uint224 votes = uint224(\n            xVader.getPastVotes(voter, proposal.startBlock)\n        );\n\n        // C4-Audit Fix for Issue # 177\n        unchecked {\n            if (support) {\n                proposal.forVotes = proposal.forVotes + votes;\n            } else {\n                proposal.againstVotes = proposal.againstVotes + votes;\n            }\n        }\n\n        receipt.hasVoted = true;\n        receipt.support = support;\n        receipt.votes = votes;\n\n        emit VoteCast(voter, proposalId, support, votes);\n    }\n\n    // gets the chainid from current network\n    function getChainId() internal view returns (uint256 chainId) {\n        assembly {\n            chainId := chainid()\n        }\n    }\n\n    /* ========== PRIVATE FUNCTIONS ========== */\n    // C4-Audit Fix for Issue # 142\n    // ensures only {guardian} is able to call a particular function.\n    function _onlyGuardian() private view {\n        require(\n            msg.sender == guardian,\n            \"GovernorAlpha::_onlyGuardian: only guardian can call\"\n        );\n    }\n\n    // C4-Audit Fix for Issue # 142\n    // ensures only {timelock} is able to call a particular function.\n    function _onlyTimelock() private view {\n        require(\n            msg.sender == address(timelock),\n            \"GovernorAlpha::_onlyTimelock: only timelock can call\"\n        );\n    }\n\n    // C4-Audit Fix for Issue # 142\n    // ensures only {council} is able to call a particular function.\n    function _onlyCouncil() private view {\n        require(\n            msg.sender == council,\n            \"GovernorAlpha::_onlyCouncil: only council can call\"\n        );\n    }\n\n    /* ========== MODIFIERS ========== */\n\n    /**\n     * @dev Throws if invoked by anyone else other than the {guardian}\n     */\n    modifier onlyGuardian() {\n        _onlyGuardian();\n        _;\n    }\n\n    /**\n     * @dev Throws if invoked by anyone else other than the {timelock}\n     */\n    modifier onlyTimelock() {\n        _onlyTimelock();\n        _;\n    }\n\n    /**\n     * @dev Throws if invoked by anyone else other than the {council}\n     */\n    modifier onlyCouncil() {\n        _onlyCouncil();\n        _;\n    }\n}"
}