Governance

Name of the governor instance (used in building the ERC712 domain separator).

Version of the governor instance (used in building the ERC712 domain separator). Default: "1"

A description of the possible support values for castVote and the way these votes are counted, meant to be consumed by UIs to show correct vote options and interpret the results. The string is a URL-encoded sequence of key-value pairs that each describe one aspect, for example support=bravo&quorum=for,abstain.

There are 2 standard keys: support and quorum.

If a counting module makes use of encoded params, it should include this under a params key with a unique name that describes the behavior. For example:

Hashing function used to (re)build the proposal id from the proposal details..

Current state of a proposal, following Compound’s convention

The number of votes required in order for a voter to become a proposer.

Timepoint used to retrieve user’s votes and quorum. If using block number (as per Compound’s Comp), the snapshot is performed at the end of this block. Hence, voting for this proposal starts at the beginning of the following block.

Timepoint at which votes close. If using block number, votes close at the end of this block, so it is possible to cast a vote during this block.

The account that created a proposal.

The time when a queued proposal becomes executable ("ETA"). Unlike proposalSnapshot and proposalDeadline, this doesn’t use the governor clock, and instead relies on the executor’s clock which may be different. In most cases this will be a timestamp.

Whether a proposal needs to be queued before execution.

Delay, between the proposal is created and the vote starts. The unit this duration is expressed in depends on the clock (see EIP-6372) this contract uses.

This can be increased to leave time for users to buy voting power, or delegate it, before the voting of a proposal starts.

Delay between the vote start and vote end. The unit this duration is expressed in depends on the clock (see EIP-6372) this contract uses.

Minimum number of cast voted required for a proposal to be successful.

Voting power of an account at a specific timepoint.

Note: this can be implemented in a number of ways, for example by reading the delegated balance from one (or multiple), ERC20Votes tokens.

Voting power of an account at a specific timepoint given additional encoded parameters.

Returns whether account has cast a vote on proposalId.

Create a new proposal. Vote start after a delay specified by IGovernor.votingDelay and lasts for a duration specified by IGovernor.votingPeriod.

Emits a ProposalCreated event.

Queue a proposal. Some governors require this step to be performed before execution can happen. If queuing is not necessary, this function may revert. Queuing a proposal requires the quorum to be reached, the vote to be successful, and the deadline to be reached.

Emits a ProposalQueued event.

Execute a successful proposal. This requires the quorum to be reached, the vote to be successful, and the deadline to be reached. Depending on the governor it might also be required that the proposal was queued and that some delay passed.

Emits a ProposalExecuted event.

Cancel a proposal. A proposal is cancellable by the proposer, but only while it is Pending state, i.e. before the vote starts.

Emits a ProposalCanceled event.

Cast a vote

Emits a VoteCast event.

Cast a vote with a reason

Emits a VoteCast event.

Cast a vote with a reason and additional encoded parameters

Emits a VoteCast or VoteCastWithParams event depending on the length of params.

Cast a vote using the voter’s signature, including ERC-1271 signature support.

Emits a VoteCast event.

Cast a vote with a reason and additional encoded parameters using the voter’s signature, including ERC-1271 signature support.

Emits a VoteCast or VoteCastWithParams event depending on the length of params.

Emitted when a proposal is created.

Emitted when a proposal is queued.

Emitted when a proposal is executed.

Emitted when a proposal is canceled.

Emitted when a vote is cast without params.

Note: support values should be seen as buckets. Their interpretation depends on the voting module used.

Emitted when a vote is cast with params.

Note: support values should be seen as buckets. Their interpretation depends on the voting module used. params are additional encoded parameters. Their interpepretation also depends on the voting module used.

Empty proposal or a mismatch between the parameters length for a proposal call.

The vote was already cast.

Token deposits are disabled in this contract.

The account is not a proposer.

The account is not the governance executor.

The proposalId doesn’t exist.

The current state of a proposal is not the required for performing an operation. The expectedStates is a bitmap with the bits enabled for each ProposalState enum position counting from right to left.

See Governor._encodeStateBitmap.

The voting period set is not a valid period.

The proposer does not have the required votes to create a proposal.

The proposer is not allowed to create a proposal.

The vote type used is not valid for the corresponding counting module.

Queue operation is not implemented for this governor. Execute should be called directly.

The proposal hasn’t been queued yet.

The proposal has already been queued.

The provided signature is not valid for the expected voter. If the voter is a contract, the signature is not valid using IERC1271.isValidSignature.

Restricts a function so it can only be executed through governance proposals. For example, governance parameter setters in GovernorSettings are protected using this modifier.

The governance executing address may be different from the Governor’s own address, for example it could be a timelock. This can be customized by modules by overriding _executor. The executor is only able to invoke these functions during the execution of the governor’s execute function, and not under any other circumstances. Thus, for example, additional timelock proposers are not able to change governance parameters without going through the governance protocol (since v4.6).

Sets the value for name and version

Function to receive ETH that will be handled by the governor (disabled if executor is a third party contract)

See IERC165.supportsInterface.

See IGovernor.name.

See IGovernor.version.

See IGovernor.hashProposal.

The proposal id is produced by hashing the ABI encoded targets array, the values array, the calldatas array and the descriptionHash (bytes32 which itself is the keccak256 hash of the description string). This proposal id can be produced from the proposal data which is part of the ProposalCreated event. It can even be computed in advance, before the proposal is submitted.

Note that the chainId and the governor address are not part of the proposal id computation. Consequently, the same proposal (with same operation and same description) will have the same id if submitted on multiple governors across multiple networks. This also means that in order to execute the same operation twice (on the same governor) the proposer will have to change the description in order to avoid proposal id conflicts.

See IGovernor.state.

See IGovernor.proposalThreshold.

See IGovernor.proposalSnapshot.

See IGovernor.proposalDeadline.

See IGovernor.proposalProposer.

See IGovernor.proposalEta.

See IGovernor.proposalNeedsQueuing.

Reverts if the msg.sender is not the executor. In case the executor is not this contract itself, the function reverts if msg.data is not whitelisted as a result of an execute operation. See onlyGovernance.

Amount of votes already cast passes the threshold limit.

Is the proposal successful or not.

Get the voting weight of account at a specific timepoint, for a vote as described by params.

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.

Default additional encoded parameters used by castVote methods that don’t include them

Note: Should be overridden by specific implementations to use an appropriate value, the meaning of the additional params, in the context of that implementation

See IGovernor.propose. This function has opt-in frontrunning protection, described in _isValidDescriptionForProposer.

Internal propose mechanism. Can be overridden to add more logic on proposal creation.

Emits a IGovernor.ProposalCreated event.

See IGovernor.queue.

Internal queuing mechanism. Can be overridden (without a super call) to modify the way queuing is performed (for example adding a vault/timelock).

This is empty by default, and must be overridden to implement queuing.

This function returns a timestamp that describes the expected ETA for execution. If the returned value is 0 (which is the default value), the core will consider queueing did not succeed, and the public queue function will revert.

See IGovernor.execute.

Internal execution mechanism. Can be overridden (without a super call) to modify the way execution is performed (for example adding a vault/timelock).

See IGovernor.cancel.

Internal cancel mechanism with minimal restrictions. A proposal can be cancelled in any state other than Canceled, Expired, or Executed. Once cancelled a proposal can’t be re-submitted.

Emits a IGovernor.ProposalCanceled event.

See IGovernor.getVotes.

See IGovernor.getVotesWithParams.

See IGovernor.castVote.

See IGovernor.castVoteWithReason.

See IGovernor.castVoteWithReasonAndParams.

See IGovernor.castVoteBySig.

See IGovernor.castVoteWithReasonAndParamsBySig.

Internal vote casting mechanism: Check that the vote is pending, that it has not been cast yet, retrieve voting weight using IGovernor.getVotes and call the _countVote internal function. Uses the _defaultParams().

Emits a IGovernor.VoteCast event.

Internal vote casting mechanism: Check that the vote is pending, that it has not been cast yet, retrieve voting weight using IGovernor.getVotes and call the _countVote internal function.

Emits a IGovernor.VoteCast event.

Relays a transaction or function call to an arbitrary target. In cases where the governance executor is some contract other than the governor itself, like when using a timelock, this function can be invoked in a governance proposal to recover tokens or Ether that was sent to the governor contract by mistake. Note that if the executor is simply the governor itself, use of relay is redundant.

Address through which the governor executes action. Will be overloaded by module that execute actions through another contract such as a timelock.

See IERC721Receiver.onERC721Received. Receiving tokens is disabled if the governance executor is other than the governor itself (eg. when using with a timelock).

See IERC1155Receiver.onERC1155Received. Receiving tokens is disabled if the governance executor is other than the governor itself (eg. when using with a timelock).

See IERC1155Receiver.onERC1155BatchReceived. Receiving tokens is disabled if the governance executor is other than the governor itself (eg. when using with a timelock).

Encodes a ProposalState into a bytes32 representation where each bit enabled corresponds to the underlying position in the ProposalState enum. For example:

0x000…​10000 ^{^^}------ …​ ^----- Succeeded ^---- Defeated ^--- Canceled ^-- Active ^- Pending

Clock used for flagging checkpoints. Can be overridden to implement timestamp based checkpoints (and voting).

Description of the clock

Delay, between the proposal is created and the vote starts. The unit this duration is expressed in depends on the clock (see EIP-6372) this contract uses.

This can be increased to leave time for users to buy voting power, or delegate it, before the voting of a proposal starts.

Delay between the vote start and vote end. The unit this duration is expressed in depends on the clock (see EIP-6372) this contract uses.

Minimum number of cast voted required for a proposal to be successful.

See IGovernor.COUNTING_MODE.

See IGovernor.hasVoted.

Accessor to the internal vote counts.

See Governor._quorumReached.

See Governor._voteSucceeded. In this module, the forVotes must be strictly over the againstVotes.

See Governor._countVote. In this module, the support follows the VoteType enum (from Governor Bravo).

The token that voting power is sourced from.

Clock (as specified in EIP-6372) is set to match the token’s clock. Fallback to block numbers if the token does not implement EIP-6372.

Machine-readable description of the clock as specified in EIP-6372.

Initialize quorum as a fraction of the token’s total supply.

The fraction is specified as numerator / denominator. By default the denominator is 100, so quorum is specified as a percent: a numerator of 10 corresponds to quorum being 10% of total supply. The denominator can be customized by overriding quorumDenominator.

Returns the current quorum numerator. See quorumDenominator.

Returns the quorum numerator at a specific timepoint. See quorumDenominator.

Returns the quorum denominator. Defaults to 100, but may be overridden.

Returns the quorum for a timepoint, in terms of number of votes: supply * numerator / denominator.

Changes the quorum numerator.

Emits a QuorumNumeratorUpdated event.

Requirements:

Changes the quorum numerator.

Emits a QuorumNumeratorUpdated event.

Requirements:

The quorum set is not a valid fraction.

Initialize the governor with an accessManager and initial base delay.

Returns the accessManager instance associated to this governor.

Base delay that will be applied to all function calls. Some may be further delayed by their associated AccessManager authority; in this case the final delay will be the maximum of the base delay and the one demanded by the authority.

Change the value of baseDelaySeconds. This operation can only be invoked through a governance proposal.

Change the value of baseDelaySeconds. Internal function without access control.

Check if restrictions from the associated accessManager are ignored for a target function. Returns true when the target function will be invoked directly regardless of AccessManager settings for the function. See setAccessManagerIgnored and Security Considerations above.

Configure whether restrictions from the associated accessManager are ignored for a target function. See Security Considerations above.

Internal version of setAccessManagerIgnored without access restriction.

Public accessor to check the execution plan, including the number of seconds that the proposal will be delayed since queuing, an array indicating which of the proposal actions will be executed indirectly through the associated accessManager, and another indicating which will be scheduled in queue. Note that those that must be scheduled are cancellable by AccessManager guardians.

See IGovernor.proposalNeedsQueuing.

See IGovernor.propose

Mechanism to queue a proposal, potentially scheduling some of its operations in the AccessManager.

Mechanism to execute a proposal, potentially going through AccessManager.execute for delayed operations.

See {IGovernor-_cancel}

Set the timelock.

Overridden version of the Governor.state function that considers the status reported by the timelock.

Public accessor to check the address of the timelock

See IGovernor.proposalNeedsQueuing.

Function to queue a proposal to the timelock.

Overridden version of the Governor._executeOperations function that runs the already queued proposal through the timelock.

Overridden version of the Governor._cancel function to cancel the timelocked proposal if it has already been queued.

Address through which the governor executes action. In this case, the timelock.

Public endpoint to update the underlying timelock instance. Restricted to the timelock itself, so updates must be proposed, scheduled, and executed through governance proposals.

Emitted when the timelock controller used for proposal execution is modified.

Set the timelock.

Overridden version of the Governor.state function with added support for the Expired state.

Public accessor to check the address of the timelock

See IGovernor.proposalNeedsQueuing.

Function to queue a proposal to the timelock.

Overridden version of the Governor._executeOperations function that run the already queued proposal through the timelock.

Overridden version of the Governor._cancel function to cancel the timelocked proposal if it has already been queued.

Address through which the governor executes action. In this case, the timelock.

Accept admin right over the timelock.

Public endpoint to update the underlying timelock instance. Restricted to the timelock itself, so updates must be proposed, scheduled, and executed through governance proposals.

For security reasons, the timelock must be handed over to another admin before setting up a new one. The two operations (hand over the timelock) and do the update can be batched in a single proposal.

Note that if the timelock admin has been handed over in a previous operation, we refuse updates made through the timelock if admin of the timelock has already been accepted and the operation is executed outside the scope of governance.

Emitted when the timelock controller used for proposal execution is modified.

Initialize the governance parameters.

See IGovernor.votingDelay.

See IGovernor.votingPeriod.

See Governor.proposalThreshold.

Update the voting delay. This operation can only be performed through a governance proposal.

Emits a VotingDelaySet event.

Update the voting period. This operation can only be performed through a governance proposal.

Emits a VotingPeriodSet event.

Update the proposal threshold. This operation can only be performed through a governance proposal.

Emits a ProposalThresholdSet event.

Internal setter for the voting delay.

Emits a VotingDelaySet event.

Internal setter for the voting period.

Emits a VotingPeriodSet event.

Internal setter for the proposal threshold.

Emits a ProposalThresholdSet event.

Initializes the vote extension parameter: the time in either number of blocks or seconds (depending on the governor clock mode) that is required to pass since the moment a proposal reaches quorum until its voting period ends. If necessary the voting period will be extended beyond the one set during proposal creation.

Returns the proposal deadline, which may have been extended beyond that set at proposal creation, if the proposal reached quorum late in the voting period. See Governor.proposalDeadline.

Casts a vote and detects if it caused quorum to be reached, potentially extending the voting period. See Governor._castVote.

May emit a ProposalExtended event.

Returns the current value of the vote extension parameter: the number of blocks that are required to pass from the time a proposal reaches quorum until its voting period ends.

Changes the lateQuorumVoteExtension. This operation can only be performed by the governance executor, generally through a governance proposal.

Emits a LateQuorumVoteExtensionSet event.

Changes the lateQuorumVoteExtension. This is an internal function that can be exposed in a public function like setLateQuorumVoteExtension if another access control mechanism is needed.

Emits a LateQuorumVoteExtensionSet event.

Emitted when a proposal deadline is pushed back due to reaching quorum late in its voting period.

Emitted when the lateQuorumVoteExtension parameter is changed.

Hook into the proposing mechanism

Version of {IGovernorTimelock-queue} with only proposalId as an argument.

Version of IGovernor.execute with only proposalId as an argument.

ProposalId version of IGovernor.cancel.

Returns the number of stored proposals.

Returns the details of a proposalId. Reverts if proposalId is not a known proposal.

Returns the details (including the proposalId) of a proposal given its sequential index.

Clock used for flagging checkpoints. Can be overridden to implement timestamp based checkpoints (and voting), in which case CLOCK_MODE should be overridden as well to match.

Machine-readable description of the clock as specified in EIP-6372.

Returns the current amount of votes that account has.

Returns the amount of votes that account had at a specific moment in the past. If the clock() is configured to use block numbers, this will return the value at the end of the corresponding block.

Requirements:

Returns the total supply of votes available at a specific moment in the past. If the clock() is configured to use block numbers, this will return the value at the end of the corresponding block.

Requirements:

Returns the current total supply of votes.

Returns the delegate that account has chosen.

Delegates votes from the sender to delegatee.

Delegates votes from signer to delegatee.

Delegate all of account’s voting units to `delegatee.

Emits events IVotes.DelegateChanged and IVotes.DelegateVotesChanged.

Transfers, mints, or burns voting units. To register a mint, from should be zero. To register a burn, to should be zero. Total supply of voting units will be adjusted with mints and burns.

Get number of checkpoints for account.

Get the pos-th checkpoint for account.

Must return the voting units held by an account.

The clock was incorrectly modified.

Lookup to future votes is not available.

Modifier to make a function callable only by a certain role. In addition to checking the sender’s role, address(0) 's role is also considered. Granting a role to address(0) is equivalent to enabling this role for everyone.

Initializes the contract with the following parameters:

Contract might receive/hold ETH as part of the maintenance process.

See IERC165.supportsInterface.

Returns whether an id corresponds to a registered operation. This includes both Waiting, Ready, and Done operations.

Returns whether an operation is pending or not. Note that a "pending" operation may also be "ready".

Returns whether an operation is ready for execution. Note that a "ready" operation is also "pending".

Returns whether an operation is done or not.

Returns the timestamp at which an operation becomes ready (0 for unset operations, 1 for done operations).

Returns operation state.

Returns the minimum delay in seconds for an operation to become valid.

This value can be changed by executing an operation that calls updateDelay.

Returns the identifier of an operation containing a single transaction.

Returns the identifier of an operation containing a batch of transactions.

Schedule an operation containing a single transaction.

Emits CallSalt if salt is nonzero, and CallScheduled.

Requirements:

Schedule an operation containing a batch of transactions.

Emits CallSalt if salt is nonzero, and one CallScheduled event per transaction in the batch.

Requirements:

Cancel an operation.

Requirements:

Execute an (ready) operation containing a single transaction.

Emits a CallExecuted event.

Requirements:

Execute an (ready) operation containing a batch of transactions.

Emits one CallExecuted event per transaction in the batch.

Requirements:

Execute an operation’s call.

Changes the minimum timelock duration for future operations.

Emits a MinDelayChange event.

Requirements:

Encodes a OperationState into a bytes32 representation where each bit enabled corresponds to the underlying position in the OperationState enum. For example:

0x000…​1000 ^{^^}----- …​ ^---- Done ^--- Ready ^-- Waiting ^- Unset

Emitted when a call is scheduled as part of operation id.

Emitted when a call is performed as part of operation id.

Emitted when new proposal is scheduled with non-zero salt.

Emitted when operation id is cancelled.

Emitted when the minimum delay for future operations is modified.

Mismatch between the parameters length for an operation call.

The schedule operation doesn’t meet the minimum delay.

The current state of an operation is not as required. The expectedStates is a bitmap with the bits enabled for each OperationState enum position counting from right to left.

See _encodeStateBitmap.

The predecessor to an operation not yet done.

The caller account is not authorized.