Governance

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 Governor._executor. The executor is only able to invoke these functions during the execution of the governor's AccessManager.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 Governor.name and Governor.version

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

Returns true if this contract implements the interface defined by interfaceId. See the corresponding ERC section to learn more about how these ids are created.

This function call must use less than 30 000 gas.

Name of the governor instance (used in building the EIP-712 domain separator).

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

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 IGovernor.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.

Function used to get 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 Governor.proposalSnapshot and Governor.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.

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 AccessManager.execute operation. See Governor.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.

Hook that should be called every time the tally for a proposal is updated.

Note: This function must run successfully. Reverts will result in the bricking of governance

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 Governor._isValidDescriptionForProposer.

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

Emits a IGovernor.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 IGovernor.ProposalQueued event.

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 Governor.queue function will revert.

NOTE: Calling this function directly will NOT check the current state of the proposal, or emit the ProposalQueued event. Queuing a proposal should be done using Governor.queue.

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 IGovernor.ProposalExecuted event.

NOTE: Some modules can modify the requirements for execution, for example by adding an additional timelock.

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

NOTE: Calling this function directly will NOT check the current state of the proposal, set the executed flag to true or emit the ProposalExecuted event. Executing a proposal should be done using AccessManager.execute.

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 IGovernor.ProposalCanceled event.

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.

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.

Cast a vote

Emits a IGovernor.VoteCast event.

Cast a vote with a reason

Emits a IGovernor.VoteCast event.

Cast a vote with a reason and additional encoded parameters

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

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

Emits a IGovernor.VoteCast event.

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

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

Validate the signature used in Governor.castVoteBySig function.

Validate the signature used in Governor.castVoteWithReasonAndParamsBySig function.

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 Governor._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 Governor._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

Check that the current state of a proposal matches the requirements described by the allowedStates bitmap. This bitmap should be built using _encodeStateBitmap.

If requirements are not met, reverts with a IGovernor.GovernorUnexpectedProposalState error.

Check if the caller can cancel the proposal with the given proposalId.

The default implementation allows the proposal proposer to cancel the proposal during the pending state.

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 ERC-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.

NOTE: While this interface returns a uint256, timepoints are stored as uint48 following the ERC-6372 clock type. Consequently this value must fit in a uint48 (when added to the current clock). See IERC6372.clock.

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

NOTE: The Governor.votingDelay can delay the start of the vote. This must be considered when setting the voting duration compared to the voting delay.

NOTE: This value is stored when the proposal is submitted so that possible changes to the value do not affect proposals that have already been submitted. The type used to save it is a uint32. Consequently, while this interface returns a uint256, the value it returns should fit in a uint32.

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

NOTE: The timepoint parameter corresponds to the snapshot used for counting vote. This allows to scale the quorum depending on values such as the totalSupply of a token at this timepoint (see ERC20Votes).

Name of the governor instance (used in building the EIP-712 domain separator).

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

A description of the possible support values for Governor.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.

• support=bravo refers to the vote options 0 = Against, 1 = For, 2 = Abstain, as in GovernorBravo.
• quorum=bravo means that only For votes are counted towards quorum.
• quorum=for,abstain means that both For and Abstain votes are counted towards 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:

• params=fractional might refer to a scheme where votes are divided fractionally between for/against/abstain.
• params=erc721 might refer to a scheme where specific NFTs are delegated to vote.

NOTE: The string can be decoded by the standard URLSearchParams JavaScript class.

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

NOTE: For all off-chain and external calls, use Governor.getProposalId.

Function used to get 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 Governor.proposalSnapshot and Governor.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 ERC-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.

NOTE: While this interface returns a uint256, timepoints are stored as uint48 following the ERC-6372 clock type. Consequently this value must fit in a uint48 (when added to the current clock). See IERC6372.clock.

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

NOTE: The Governor.votingDelay can delay the start of the vote. This must be considered when setting the voting duration compared to the voting delay.

NOTE: This value is stored when the proposal is submitted so that possible changes to the value do not affect proposals that have already been submitted. The type used to save it is a uint32. Consequently, while this interface returns a uint256, the value it returns should fit in a uint32.

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

NOTE: The timepoint parameter corresponds to the snapshot used for counting vote. This allows to scale the quorum depending on values such as the totalSupply of a token at this timepoint (see ERC20Votes).

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 IGovernor.ProposalCreated event.

NOTE: The state of the Governor and targets may change between the proposal creation and its execution. This may be the result of third party actions on the targeted contracts, or other governor proposals. For example, the balance of this contract could be updated or its access control permissions may be modified, possibly compromising the proposal's ability to execute successfully (e.g. the governor doesn't have enough value to cover a proposal with multiple transfers).

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 IGovernor.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 IGovernor.ProposalExecuted event.

NOTE: Some modules can modify the requirements for execution, for example by adding an additional timelock.

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 IGovernor.ProposalCanceled event.

Cast a vote

Emits a IGovernor.VoteCast event.

Cast a vote with a reason

Emits a IGovernor.VoteCast event.

Cast a vote with a reason and additional encoded parameters

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

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

Emits a IGovernor.VoteCast event.

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

Emits a IGovernor.VoteCast or IGovernor.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 interpretation 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 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.

NOTE: If expectedState is bytes32(0), the proposal is expected to not be in any state (i.e. not exist). This is the case when a proposal that is expected to be unset is already initiated (the proposal is duplicated).

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.

The provided params buffer is not supported by the 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.

The given account is unable to cancel the proposal with given proposalId.

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:

• minDelay: initial minimum delay in seconds for operations
• proposers: accounts to be granted proposer and canceller roles
• executors: accounts to be granted executor role
• admin: optional account to be granted admin role; disable with zero address

without being subject to delay, but this role should be subsequently renounced in favor of administration through timelocked proposals. Previous versions of this contract would assign this admin to the deployer automatically and should be renounced as well.

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

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 TimelockController.CallSalt if salt is nonzero, and TimelockController.CallScheduled.

Requirements:

• the caller must have the 'proposer' role.

Schedule an operation containing a batch of transactions.

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

Requirements:

• the caller must have the 'proposer' role.

Cancel an operation.

Requirements:

• the caller must have the 'canceller' role.

Execute an (ready) operation containing a single transaction.

Emits a TimelockController.CallExecuted event.

Requirements:

• the caller must have the 'executor' role.

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

Emits one TimelockController.CallExecuted event per transaction in the batch.

Requirements:

• the caller must have the 'executor' role.

Execute an operation's call.

Changes the minimum timelock duration for future operations.

Emits a TimelockController.MinDelayChange event.

Requirements:

• the caller must be the timelock itself. This can only be achieved by scheduling and later executing an operation where the timelock is the target and the data is the ABI-encoded call to this function.

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 Governor._encodeStateBitmap.

The predecessor to an operation not yet done.

The caller account is not authorized.

A description of the possible support values for Governor.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.

• support=bravo refers to the vote options 0 = Against, 1 = For, 2 = Abstain, as in GovernorBravo.
• quorum=bravo means that only For votes are counted towards quorum.
• quorum=for,abstain means that both For and Abstain votes are counted towards 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:

• params=fractional might refer to a scheme where votes are divided fractionally between for/against/abstain.
• params=erc721 might refer to a scheme where specific NFTs are delegated to vote.

NOTE: The string can be decoded by the standard URLSearchParams JavaScript class.

Returns whether account has cast a vote on proposalId.

Get the number of votes already cast by account for a proposal with proposalId. Useful for integrations that allow delegates to cast rolling, partial votes.

Get current distribution of votes for a given proposal.

Amount of votes already cast passes the threshold limit.

See Governor._voteSucceeded. In this module, forVotes must be > againstVotes.

See Governor._countVote. Function that records the delegate's votes.

Executing this function consumes (part of) the delegate's weight on the proposal. This weight can be distributed amongst the 3 options (Against, For, Abstain) by specifying a fractional support.

This counting module supports two vote casting modes: nominal and fractional.

• Nominal: A nominal vote is cast by setting support to one of the 3 bravo options (Against, For, Abstain).
• Fractional: A fractional vote is cast by setting support to type(uint8).max (255).

Casting a nominal vote requires params to be empty and consumes the delegate's full remaining weight on the proposal for the specified support option. This is similar to the GovernorCountingSimple module and follows the VoteType enum from Governor Bravo. As a consequence, no vote weight remains unspent so no further voting is possible (for this proposalId and this account).

Casting a fractional vote consumes a fraction of the delegate's remaining weight on the proposal according to the weights the delegate assigns to each support option (Against, For, Abstain respectively). The sum total of the three decoded vote weights must be less than or equal to the delegate's remaining weight on the proposal (i.e. their checkpointed total weight minus votes already cast on the proposal). This format can be produced using:

abi.encodePacked(uint128(againstVotes), uint128(forVotes), uint128(abstainVotes))

NOTE: Consider that fractional voting restricts the number of casted votes (in each category) to 128 bits. Depending on how many decimals the underlying token has, a single voter may require to split their vote into multiple vote operations. For precision higher than ~30 decimals, large token holders may require a potentially large number of calls to cast all their votes. The voter has the possibility to cast all the remaining votes in a single operation using the traditional "bravo" vote.

A fractional vote params uses more votes than are available for that user.

A description of the possible support values for Governor.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.

• support=bravo refers to the vote options 0 = Against, 1 = For, 2 = Abstain, as in GovernorBravo.
• quorum=bravo means that only For votes are counted towards quorum.
• quorum=for,abstain means that both For and Abstain votes are counted towards 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:

• params=fractional might refer to a scheme where votes are divided fractionally between for/against/abstain.
• params=erc721 might refer to a scheme where specific NFTs are delegated to vote.

NOTE: The string can be decoded by the standard URLSearchParams JavaScript class.

See IGovernor.hasVoted.

NOTE: Calling Governor.castVote (or similar) casts a vote using the voting power that is delegated to the voter. Conversely, calling GovernorCountingOverridable.castOverrideVote (or similar) uses the voting power of the account itself, from its asset balances. Casting an "override vote" does not count as voting and won't be reflected by this getter. Consider using GovernorCountingOverridable.hasVotedOverride to check if an account has casted an "override vote" for a given proposal id.

Check if an account has overridden their delegate for a proposal.

Accessor to the internal vote counts.

Amount of votes already cast passes the threshold limit.

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).

NOTE: called by Governor._castVote which emits the IGovernor.VoteCast (or IGovernor.VoteCastWithParams) event.

Variant of Governor._countVote that deals with vote overrides.

NOTE: See IGovernor.hasVoted for more details about the difference between Governor.castVote and GovernorCountingOverridable.castOverrideVote.

Variant of Governor._castVote that deals with vote overrides. Returns the overridden weight.

Public function for casting an override vote. Returns the overridden weight.

Public function for casting an override vote using a voter's signature. Returns the overridden weight.

The votes casted by delegate were reduced by weight after an override vote was casted by the original token holder

A delegated vote on proposalId was overridden by weight

A description of the possible support values for Governor.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.

• support=bravo refers to the vote options 0 = Against, 1 = For, 2 = Abstain, as in GovernorBravo.
• quorum=bravo means that only For votes are counted towards quorum.
• quorum=for,abstain means that both For and Abstain votes are counted towards 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:

• params=fractional might refer to a scheme where votes are divided fractionally between for/against/abstain.
• params=erc721 might refer to a scheme where specific NFTs are delegated to vote.

NOTE: The string can be decoded by the standard URLSearchParams JavaScript class.

Returns whether account has cast a vote on proposalId.

Accessor to the internal vote counts.

Amount of votes already cast passes the threshold limit.

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).

Check the signature against keyed nonce and falls back to the traditional nonce.

NOTE: This function won't call super._validateVoteSig if the keyed nonce is valid. Side effects may be skipped depending on the linearization of the function.

Check the signature against keyed nonce and falls back to the traditional nonce.

NOTE: This function won't call super._validateExtendedVoteSig if the keyed nonce is valid. Side effects may be skipped depending on the linearization of the function.

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.

Vote tally updated and detects if it caused quorum to be reached, potentially extending the voting period.

May emit a GovernorPreventLateQuorum.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 GovernorPreventLateQuorum.lateQuorumVoteExtension. This operation can only be performed by the governance executor, generally through a governance proposal.

Emits a GovernorPreventLateQuorum.LateQuorumVoteExtensionSet event.

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

Emits a GovernorPreventLateQuorum.LateQuorumVoteExtensionSet event.

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

Emitted when the GovernorPreventLateQuorum.lateQuorumVoteExtension parameter is changed.

Getter that returns the address of the proposal guardian.

Update the proposal guardian's address. This operation can only be performed through a governance proposal.

Emits a GovernorProposalGuardian.ProposalGuardianSet event.

Internal setter for the proposal guardian.

Emits a GovernorProposalGuardian.ProposalGuardianSet event.

Override Governor._validateCancel to implement the extended cancellation logic.

• The GovernorProposalGuardian.proposalGuardian can cancel any proposal at any point.
• If no proposal guardian is set, the IGovernor.proposalProposer can cancel their proposals at any point.
• In any case, permissions defined in Governor._validateCancel (or another override) remains valid.

Returns the latest proposal id. A return value of 0 means no proposals have been created yet.

See IGovernor-_propose. Hook into the proposing mechanism to increment proposal count.

Internal function to set the GovernorSequentialProposalId.latestProposalId. This function is helpful when transitioning from another governance system. The next proposal id will be newLatestProposalId + 1.

May only call this function if the current value of GovernorSequentialProposalId.latestProposalId is 0.

The GovernorSequentialProposalId.latestProposalId may only be initialized if it hasn't been set yet (through initialization or the creation of a proposal).

Initialize the governance parameters.

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

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

Emits a GovernorSettings.VotingDelaySet event.

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

Emits a GovernorSettings.VotingPeriodSet event.

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

Emits a GovernorSettings.ProposalThresholdSet event.

Internal setter for the voting delay.

Emits a GovernorSettings.VotingDelaySet event.

Internal setter for the voting period.

Emits a GovernorSettings.VotingPeriodSet event.

Internal setter for the proposal threshold.

Emits a GovernorSettings.ProposalThresholdSet event.

Hook into the proposing mechanism

Version of IGovernor.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.

Minimum number of cast votes required for a proposal to reach super quorum. Only FOR votes are counted towards the super quorum. Once the super quorum is reached, an active proposal can proceed to the next state without waiting for the proposal deadline.

NOTE: The timepoint parameter corresponds to the snapshot used for counting the vote. This enables scaling of the quorum depending on values such as the totalSupply of a token at this timepoint (see ERC20Votes).

NOTE: Make sure the value specified for the super quorum is greater than Governor.quorum, otherwise, it may be possible to pass a proposal with less votes than the default quorum.

Accessor to the internal vote counts. This must be implemented by the counting module. Counting modules that don't implement this function are incompatible with this module

Overridden version of the Governor.state function that checks if the proposal has reached the super quorum.

NOTE: If the proposal reaches super quorum but Governor._voteSucceeded returns false, eg, assuming the super quorum has been set low enough that both FOR and AGAINST votes have exceeded it and AGAINST votes exceed FOR votes, the proposal continues to be active until Governor._voteSucceeded returns true or the proposal deadline is reached. This means that with a low super quorum it is also possible that a vote can succeed prematurely before enough AGAINST voters have a chance to vote. Hence, it is recommended to set a high enough super quorum to avoid these types of scenarios.