Add timestamp based governor with EIP-6372 and EIP-5805

contracts/governance/Governor.sol

@@ -12,7 +12,6 @@ import "../utils/math/SafeCast.sol";
 import "../utils/structs/DoubleEndedQueue.sol";
 import "../utils/Address.sol";
 import "../utils/Context.sol";
-import "../utils/Timers.sol";
 import "./IGovernor.sol";
 
 /**
@@ -29,22 +28,27 @@ import "./IGovernor.sol";
 abstract contract Governor is Context, ERC165, EIP712, IGovernor, IERC721Receiver, IERC1155Receiver {
     using DoubleEndedQueue for DoubleEndedQueue.Bytes32Deque;
     using SafeCast for uint256;
-    using Timers for Timers.BlockNumber;
 
     bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,uint8 support)");
     bytes32 public constant EXTENDED_BALLOT_TYPEHASH =
         keccak256("ExtendedBallot(uint256 proposalId,uint8 support,string reason,bytes params)");
 
     struct ProposalCore {
-        Timers.BlockNumber voteStart;
-        Timers.BlockNumber voteEnd;
+        // --- start retyped from Timers.BlockNumber at offset 0x00 ---
+        uint64 voteStart;
+        address proposer;
+        bytes4 __gap_unused0;
+        // --- start retyped from Timers.BlockNumber at offset 0x20 ---
+        uint64 voteEnd;
+        bytes24 __gap_unused1;
+        // --- Remaining fields starting at offset 0x40 ---------------
         bool executed;
         bool canceled;
-        address proposer;
     }
 
     string private _name;
 
+    /// @custom:oz-retyped-from mapping(uint256 => Governor.ProposalCore)
     mapping(uint256 => ProposalCore) private _proposals;
 
     // This queue keeps track of the governor operating on itself. Calls to functions protected by the
@@ -97,10 +101,13 @@ abstract contract Governor is Context, ERC165, EIP712, IGovernor, IERC721Receive
             interfaceId ==
             (type(IGovernor).interfaceId ^
                 this.cancel.selector ^
+                this.clock.selector ^
+                this.CLOCK_MODE.selector ^
                 this.castVoteWithReasonAndParams.selector ^
                 this.castVoteWithReasonAndParamsBySig.selector ^
                 this.getVotesWithParams.selector) ||
-            interfaceId == (type(IGovernor).interfaceId ^ this.cancel.selector) ||
+            interfaceId ==
+            (type(IGovernor).interfaceId ^ this.cancel.selector ^ this.clock.selector ^ this.CLOCK_MODE.selector) ||
             interfaceId == type(IGovernor).interfaceId ||
             interfaceId == type(IERC1155Receiver).interfaceId ||
             super.supportsInterface(interfaceId);
@@ -162,13 +169,15 @@ abstract contract Governor is Context, ERC165, EIP712, IGovernor, IERC721Receive
             revert("Governor: unknown proposal id");
         }
 
-        if (snapshot >= block.number) {
+        uint256 timepoint = clock();
+
+        if (snapshot >= timepoint) {
             return ProposalState.Pending;
         }
 
         uint256 deadline = proposalDeadline(proposalId);
 
-        if (deadline >= block.number) {
+        if (deadline >= timepoint) {
             return ProposalState.Active;
         }
 
@@ -183,14 +192,14 @@ abstract contract Governor is Context, ERC165, EIP712, IGovernor, IERC721Receive
      * @dev See {IGovernor-proposalSnapshot}.
      */
     function proposalSnapshot(uint256 proposalId) public view virtual override returns (uint256) {
-        return _proposals[proposalId].voteStart.getDeadline();
+        return _proposals[proposalId].voteStart;
     }
 
     /**
      * @dev See {IGovernor-proposalDeadline}.
      */
     function proposalDeadline(uint256 proposalId) public view virtual override returns (uint256) {
-        return _proposals[proposalId].voteEnd.getDeadline();
+        return _proposals[proposalId].voteEnd;
     }
 
     /**
@@ -211,13 +220,9 @@ abstract contract Governor is Context, ERC165, EIP712, IGovernor, IERC721Receive
     function _voteSucceeded(uint256 proposalId) internal view virtual returns (bool);
 
     /**
-     * @dev Get the voting weight of `account` at a specific `blockNumber`, for a vote as described by `params`.
+     * @dev Get the voting weight of `account` at a specific `timepoint`, for a vote as described by `params`.
      */
-    function _getVotes(
-        address account,
-        uint256 blockNumber,
-        bytes memory params
-    ) internal view virtual returns (uint256);
+    function _getVotes(address account, uint256 timepoint, bytes memory params) internal view virtual returns (uint256);
 
     /**
      * @dev Register a vote for `proposalId` by `account` with a given `support`, voting `weight` and voting `params`.
@@ -252,9 +257,10 @@ abstract contract Governor is Context, ERC165, EIP712, IGovernor, IERC721Receive
         string memory description
     ) public virtual override returns (uint256) {
         address proposer = _msgSender();
+        uint256 timepoint = clock();
 
         require(
-            getVotes(proposer, block.number - 1) >= proposalThreshold(),
+            getVotes(proposer, timepoint - 1) >= proposalThreshold(),
             "Governor: proposer votes below proposal threshold"
         );
 
@@ -263,16 +269,14 @@ abstract contract Governor is Context, ERC165, EIP712, IGovernor, IERC721Receive
         require(targets.length == values.length, "Governor: invalid proposal length");
         require(targets.length == calldatas.length, "Governor: invalid proposal length");
         require(targets.length > 0, "Governor: empty proposal");
+        require(_proposals[proposalId].proposer == address(0), "Governor: proposal already exists");
 
-        ProposalCore storage proposal = _proposals[proposalId];
-        require(proposal.voteStart.isUnset(), "Governor: proposal already exists");
-
-        uint64 snapshot = block.number.toUint64() + votingDelay().toUint64();
-        uint64 deadline = snapshot + votingPeriod().toUint64();
+        uint256 snapshot = timepoint + votingDelay();
+        uint256 deadline = snapshot + votingPeriod();
 
-        proposal.voteStart.setDeadline(snapshot);
-        proposal.voteEnd.setDeadline(deadline);
-        proposal.proposer = proposer;
+        _proposals[proposalId].proposer = proposer;
+        _proposals[proposalId].voteStart = snapshot;
+        _proposals[proposalId].voteEnd = deadline;
 
         emit ProposalCreated(
             proposalId,
@@ -416,19 +420,19 @@ abstract contract Governor is Context, ERC165, EIP712, IGovernor, IERC721Receive
     /**
      * @dev See {IGovernor-getVotes}.
      */
-    function getVotes(address account, uint256 blockNumber) public view virtual override returns (uint256) {
-        return _getVotes(account, blockNumber, _defaultParams());
+    function getVotes(address account, uint256 timepoint) public view virtual override returns (uint256) {
+        return _getVotes(account, timepoint, _defaultParams());
     }
 
     /**
      * @dev See {IGovernor-getVotesWithParams}.
      */
     function getVotesWithParams(
         address account,
-        uint256 blockNumber,
+        uint256 timepoint,
         bytes memory params
     ) public view virtual override returns (uint256) {
-        return _getVotes(account, blockNumber, params);
+        return _getVotes(account, timepoint, params);
     }
 
     /**
@@ -546,7 +550,7 @@ abstract contract Governor is Context, ERC165, EIP712, IGovernor, IERC721Receive
         ProposalCore storage proposal = _proposals[proposalId];
         require(state(proposalId) == ProposalState.Active, "Governor: vote not currently active");
 
-        uint256 weight = _getVotes(account, proposal.voteStart.getDeadline(), params);
+        uint256 weight = _getVotes(account, proposal.voteStart, params);
         _countVote(proposalId, account, support, weight, params);
 
         if (params.length == 0) {

contracts/governance/IGovernor.sol

@@ -3,14 +3,15 @@
 
 pragma solidity ^0.8.0;
 
-import "../utils/introspection/ERC165.sol";
+import "../interfaces/IERC165.sol";
+import "../interfaces/IERC6372.sol";
 
 /**
  * @dev Interface of the {Governor} core.
  *
  * _Available since v4.3._
  */
-abstract contract IGovernor is IERC165 {
+abstract contract IGovernor is IERC165, IERC6372 {
     enum ProposalState {
         Pending,
         Active,
@@ -81,6 +82,19 @@ abstract contract IGovernor is IERC165 {
      */
     function version() public view virtual returns (string memory);
 
+    /**
+     * @notice module:core
+     * @dev See EIP-6372.
+     */
+    function clock() public view virtual override returns (uint48);
+
+    /**
+     * @notice module:core
+     * @dev See EIP-6372.
+     */
+    // solhint-disable-next-line func-name-mixedcase
+    function CLOCK_MODE() public view virtual override returns (string memory);
+
     /**
      * @notice module:voting
      * @dev A description of the possible `support` values for {castVote} and the way these votes are counted, meant to
@@ -104,7 +118,7 @@ abstract contract IGovernor is IERC165 {
      * JavaScript class.
      */
     // solhint-disable-next-line func-name-mixedcase
-    function COUNTING_MODE() public pure virtual returns (string memory);
+    function COUNTING_MODE() public view virtual returns (string memory);
 
     /**
      * @notice module:core
@@ -158,27 +172,27 @@ abstract contract IGovernor is IERC165 {
      * @notice module:user-config
      * @dev Minimum number of cast voted required for a proposal to be successful.
      *
-     * Note: The `blockNumber` parameter corresponds to the snapshot used for counting vote. This allows to scale the
+     * 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 block (see {ERC20Votes}).
      */
-    function quorum(uint256 blockNumber) public view virtual returns (uint256);
+    function quorum(uint256 timepoint) public view virtual returns (uint256);
 
     /**
      * @notice module:reputation
-     * @dev Voting power of an `account` at a specific `blockNumber`.
+     * @dev 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.
      */
-    function getVotes(address account, uint256 blockNumber) public view virtual returns (uint256);
+    function getVotes(address account, uint256 timepoint) public view virtual returns (uint256);
 
     /**
      * @notice module:reputation
-     * @dev Voting power of an `account` at a specific `blockNumber` given additional encoded parameters.
+     * @dev Voting power of an `account` at a specific `timepoint` given additional encoded parameters.
      */
     function getVotesWithParams(
         address account,
-        uint256 blockNumber,
+        uint256 timepoint,
         bytes memory params
     ) public view virtual returns (uint256);
 

contracts/governance/README.adoc

@@ -48,7 +48,7 @@ In addition to modules and extensions, the core contract requires a few virtual
 
 * <<Governor-votingDelay-,`votingDelay()`>>: Delay (in number of blocks) since the proposal is submitted until voting power is fixed and voting starts. This can be used to enforce a delay after a proposal is published for users to buy tokens, or delegate their votes.
 * <<Governor-votingPeriod-,`votingPeriod()`>>: Delay (in number of blocks) since the proposal starts until voting ends.
-* <<Governor-quorum-uint256-,`quorum(uint256 blockNumber)`>>: Quorum required for a proposal to be successful. This function includes a `blockNumber` argument so the quorum can adapt through time, for example, to follow a token's `totalSupply`.
+* <<Governor-quorum-uint256-,`quorum(uint256 timepoint)`>>: Quorum required for a proposal to be successful. This function includes a `timepoint` argument (see EIP-6372) so the quorum can adapt through time, for example, to follow a token's `totalSupply`.
 
 NOTE: Functions of the `Governor` contract do not include access control. If you want to restrict access, you should add these checks by overloading the particular functions. Among these, {Governor-_cancel} is internal by default, and you will have to expose it (with the right access control mechanism) yourself if this function is needed.
 

contracts/governance/compatibility/GovernorCompatibilityBravo.sol

@@ -103,7 +103,7 @@ abstract contract GovernorCompatibilityBravo is IGovernorTimelock, IGovernorComp
         ProposalDetails storage details = _proposalDetails[proposalId];
 
         require(
-            _msgSender() == details.proposer || getVotes(details.proposer, block.number - 1) < proposalThreshold(),
+            _msgSender() == details.proposer || getVotes(details.proposer, clock() - 1) < proposalThreshold(),
             "GovernorBravo: proposer above threshold"
         );
 
@@ -225,7 +225,7 @@ abstract contract GovernorCompatibilityBravo is IGovernorTimelock, IGovernorComp
      * @dev See {IGovernorCompatibilityBravo-quorumVotes}.
      */
     function quorumVotes() public view virtual override returns (uint256) {
-        return quorum(block.number - 1);
+        return quorum(clock() - 1);
     }
 
     // ==================================================== Voting ====================================================

contracts/governance/extensions/GovernorPreventLateQuorum.sol

@@ -19,10 +19,11 @@ import "../../utils/math/Math.sol";
  */
 abstract contract GovernorPreventLateQuorum is Governor {
     using SafeCast for uint256;
-    using Timers for Timers.BlockNumber;
 
     uint64 private _voteExtension;
-    mapping(uint256 => Timers.BlockNumber) private _extendedDeadlines;
+
+    /// @custom:oz-retyped-from mapping(uint256 => Timers.BlockNumber)
+    mapping(uint256 => uint64) private _extendedDeadlines;
 
     /// @dev Emitted when a proposal deadline is pushed back due to reaching quorum late in its voting period.
     event ProposalExtended(uint256 indexed proposalId, uint64 extendedDeadline);
@@ -44,7 +45,7 @@ abstract contract GovernorPreventLateQuorum is Governor {
      * proposal reached quorum late in the voting period. See {Governor-proposalDeadline}.
      */
     function proposalDeadline(uint256 proposalId) public view virtual override returns (uint256) {
-        return Math.max(super.proposalDeadline(proposalId), _extendedDeadlines[proposalId].getDeadline());
+        return Math.max(super.proposalDeadline(proposalId), _extendedDeadlines[proposalId]);
     }
 
     /**
@@ -62,16 +63,14 @@ abstract contract GovernorPreventLateQuorum is Governor {
     ) internal virtual override returns (uint256) {
         uint256 result = super._castVote(proposalId, account, support, reason, params);
 
-        Timers.BlockNumber storage extendedDeadline = _extendedDeadlines[proposalId];
-
-        if (extendedDeadline.isUnset() && _quorumReached(proposalId)) {
-            uint64 extendedDeadlineValue = block.number.toUint64() + lateQuorumVoteExtension();
+        if (_extendedDeadlines[proposalId] == 0 && _quorumReached(proposalId)) {
+            uint64 extendedDeadline = clock() + lateQuorumVoteExtension();
 
-            if (extendedDeadlineValue > proposalDeadline(proposalId)) {
-                emit ProposalExtended(proposalId, extendedDeadlineValue);
+            if (extendedDeadline > proposalDeadline(proposalId)) {
+                emit ProposalExtended(proposalId, extendedDeadline);
             }
 
-            extendedDeadline.setDeadline(extendedDeadlineValue);
+            _extendedDeadlines[proposalId] = extendedDeadline;
         }
 
         return result;

contracts/governance/extensions/GovernorTimelockCompound.sol

@@ -22,15 +22,11 @@ import "../../vendor/compound/ICompoundTimelock.sol";
  */
 abstract contract GovernorTimelockCompound is IGovernorTimelock, Governor {
     using SafeCast for uint256;
-    using Timers for Timers.Timestamp;
-
-    struct ProposalTimelock {
-        Timers.Timestamp timer;
-    }
 
     ICompoundTimelock private _timelock;
 
-    mapping(uint256 => ProposalTimelock) private _proposalTimelocks;
+    /// @custom:oz-retyped-from mapping(uint256 => Timers.Timestamp)
+    mapping(uint256 => uint64) private _proposalTimelocks;
 
     /**
      * @dev Emitted when the timelock controller used for proposal execution is modified.
@@ -82,7 +78,7 @@ abstract contract GovernorTimelockCompound is IGovernorTimelock, Governor {
      * @dev Public accessor to check the eta of a queued proposal
      */
     function proposalEta(uint256 proposalId) public view virtual override returns (uint256) {
-        return _proposalTimelocks[proposalId].timer.getDeadline();
+        return _proposalTimelocks[proposalId];
     }
 
     /**
@@ -99,7 +95,8 @@ abstract contract GovernorTimelockCompound is IGovernorTimelock, Governor {
         require(state(proposalId) == ProposalState.Succeeded, "Governor: proposal not successful");
 
         uint256 eta = block.timestamp + _timelock.delay();
-        _proposalTimelocks[proposalId].timer.setDeadline(eta.toUint64());
+        _proposalTimelocks[proposalId] = eta;
+
         for (uint256 i = 0; i < targets.length; ++i) {
             require(
                 !_timelock.queuedTransactions(keccak256(abi.encode(targets[i], values[i], "", calldatas[i], eta))),
@@ -148,7 +145,7 @@ abstract contract GovernorTimelockCompound is IGovernorTimelock, Governor {
             for (uint256 i = 0; i < targets.length; ++i) {
                 _timelock.cancelTransaction(targets[i], values[i], "", calldatas[i], eta);
             }
-            _proposalTimelocks[proposalId].timer.reset();
+            delete _proposalTimelocks[proposalId];
         }
 
         return proposalId;