Governor Sequential Proposal id

contracts/governance/Governor.sol

@@ -128,7 +128,7 @@ abstract contract Governor is Context, ERC165, EIP712, Nonces, IGovernor, IERC72
         uint256[] memory values,
         bytes[] memory calldatas,
         bytes32 descriptionHash
-    ) public pure virtual returns (uint256) {
+    ) public virtual returns (uint256) {
         return uint256(keccak256(abi.encode(targets, values, calldatas, descriptionHash)));
     }
 

contracts/governance/IGovernor.sol

@@ -210,7 +210,7 @@ interface IGovernor is IERC165, IERC6372 {
         uint256[] memory values,
         bytes[] memory calldatas,
         bytes32 descriptionHash
-    ) external pure returns (uint256);
+    ) external returns (uint256);
 
     /**
      * @notice module:core

contracts/governance/extensions/GovernorSequentialProposalId.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {Governor} from "../Governor.sol";
+
+abstract contract GovernorSequentialProposalId is Governor {
+    uint256 private _numberOfProposals;
+    mapping(uint256 proposalHash => uint256 proposalId) private _proposalIds;
+
+    function hashProposal(
+        address[] memory targets,
+        uint256[] memory values,
+        bytes[] memory calldatas,
+        bytes32 descriptionHash
+    ) public virtual override returns (uint256) {
+        uint256 proposalHash = super.hashProposal(targets, values, calldatas, descriptionHash);
+
+        uint256 storedProposalId = _proposalIds[proposalHash];
+        return storedProposalId == 0
+            ? (_proposalIds[proposalHash] = ++_numberOfProposals)
+            : storedProposalId;
+    }
+}

contracts/mocks/governance/GovernorSequentialProposalIdMock.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {Governor} from "../../governance/Governor.sol";
+import {GovernorSettings} from "../../governance/extensions/GovernorSettings.sol";
+import {GovernorCountingSimple} from "../../governance/extensions/GovernorCountingSimple.sol";
+import {GovernorVotesQuorumFraction} from "../../governance/extensions/GovernorVotesQuorumFraction.sol";
+import {GovernorSequentialProposalId} from "../../governance/extensions/GovernorSequentialProposalId.sol";
+
+abstract contract GovernorSequentialProposalIdMock is
+    GovernorSettings,
+    GovernorVotesQuorumFraction,
+    GovernorCountingSimple,
+    GovernorSequentialProposalId
+{
+    function proposalThreshold() public view override(Governor, GovernorSettings) returns (uint256) {
+        return super.proposalThreshold();
+    }
+
+    function hashProposal(
+        address[] memory targets,
+        uint256[] memory values,
+        bytes[] memory calldatas,
+        bytes32 descriptionHash
+    ) public virtual override(Governor, GovernorSequentialProposalId) returns (uint256) {
+        return super.hashProposal(targets, values, calldatas, descriptionHash);
+    }
+}

test/governance/extensions/GovernorSequentialProposalId.test.js

@@ -0,0 +1,168 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const { GovernorHelper } = require('../../helpers/governance');
+const { VoteType } = require('../../helpers/enums');
+const time = require('../../helpers/time');
+
+const TOKENS = [
+  { Token: '$ERC20Votes', mode: 'blocknumber' },
+  { Token: '$ERC20VotesTimestampMock', mode: 'timestamp' },
+];
+
+const name = 'OZ-Governor';
+const version = '1';
+const tokenName = 'MockToken';
+const tokenSymbol = 'MTKN';
+const tokenSupply = ethers.parseEther('100');
+const votingDelay = 4n;
+const votingPeriod = 16n;
+const value = ethers.parseEther('1');
+
+async function deployToken(contractName) {
+  try {
+    return await ethers.deployContract(contractName, [tokenName, tokenSymbol, tokenName, version]);
+  } catch (error) {
+    if (error.message == 'incorrect number of arguments to constructor') {
+      // ERC20VotesLegacyMock has a different construction that uses version='1' by default.
+      return ethers.deployContract(contractName, [tokenName, tokenSymbol, tokenName]);
+    }
+    throw error;
+  }
+}
+
+describe('GovernorSequentialProposalId', function () {
+  for (const { Token, mode } of TOKENS) {
+    const fixture = async () => {
+      const [owner, proposer, voter1, voter2, voter3, voter4, userEOA] = await ethers.getSigners();
+      const receiver = await ethers.deployContract('CallReceiverMock');
+
+      const token = await deployToken(Token, [tokenName, tokenSymbol, version]);
+      const mock = await ethers.deployContract('$GovernorSequentialProposalIdMock', [
+        name, // name
+        votingDelay, // initialVotingDelay
+        votingPeriod, // initialVotingPeriod
+        0n, // initialProposalThreshold
+        token, // tokenAddress
+        10n, // quorumNumeratorValue
+      ]);
+
+      await owner.sendTransaction({ to: mock, value });
+      await token.$_mint(owner, tokenSupply);
+
+      const helper = new GovernorHelper(mock, mode);
+      await helper.connect(owner).delegate({ token: token, to: voter1, value: ethers.parseEther('10') });
+      await helper.connect(owner).delegate({ token: token, to: voter2, value: ethers.parseEther('7') });
+      await helper.connect(owner).delegate({ token: token, to: voter3, value: ethers.parseEther('5') });
+      await helper.connect(owner).delegate({ token: token, to: voter4, value: ethers.parseEther('2') });
+
+      return {
+        owner,
+        proposer,
+        voter1,
+        voter2,
+        voter3,
+        voter4,
+        userEOA,
+        receiver,
+        token,
+        mock,
+        helper,
+      };
+    };
+
+    describe(`using ${Token}`, function () {
+      beforeEach(async function () {
+        Object.assign(this, await loadFixture(fixture));
+
+        this.proposal = this.helper.setProposal(
+          [
+            {
+              target: this.receiver.target,
+              data: this.receiver.interface.encodeFunctionData('mockFunction'),
+              value,
+            },
+          ],
+          '<proposal description>',
+        );
+      });
+
+      it('sequential proposal ids', async function () {
+        const txPropose = await this.helper.connect(this.proposer).propose();
+        const timepoint = await time.clockFromReceipt[mode](txPropose);
+
+        await expect(txPropose)
+          .to.emit(this.mock, 'ProposalCreated')
+          .withArgs(
+            1,
+            this.proposer,
+            this.proposal.targets,
+            this.proposal.values,
+            this.proposal.signatures,
+            this.proposal.data,
+            timepoint + votingDelay,
+            timepoint + votingDelay + votingPeriod,
+            this.proposal.description,
+          );
+
+        this.proposal = this.helper.setProposal(
+          [
+            {
+              target: this.receiver.target,
+              data: this.receiver.interface.encodeFunctionData('mockFunction'),
+              value,
+            },
+          ],
+          '<proposal description 2>',
+        );
+        const txPropose2 = await this.helper.connect(this.proposer).propose();
+        const timepoint2 = await time.clockFromReceipt[mode](txPropose2);
+
+        await expect(txPropose2)
+          .to.emit(this.mock, 'ProposalCreated')
+          .withArgs(
+            2,
+            this.proposer,
+            this.proposal.targets,
+            this.proposal.values,
+            this.proposal.signatures,
+            this.proposal.data,
+            timepoint2 + votingDelay,
+            timepoint2 + votingDelay + votingPeriod,
+            this.proposal.description,
+          );
+      });
+
+      it('nominal workflow', async function () {
+        await this.helper.connect(this.proposer).propose();
+        let timepoint = await this.mock.proposalSnapshot(1);
+        time.increaseTo[mode](timepoint);
+
+        await expect(this.mock.connect(this.voter1).castVote(1, VoteType.For))
+          .to.emit(this.mock, 'VoteCast')
+          .withArgs(this.voter1, 1, VoteType.For, ethers.parseEther('10'), '');
+
+        await expect(this.mock.connect(this.voter2).castVote(1, VoteType.For))
+          .to.emit(this.mock, 'VoteCast')
+          .withArgs(this.voter2, 1, VoteType.For, ethers.parseEther('7'), '');
+
+        await expect(this.mock.connect(this.voter3).castVote(1, VoteType.For))
+          .to.emit(this.mock, 'VoteCast')
+          .withArgs(this.voter3, 1, VoteType.For, ethers.parseEther('5'), '');
+
+        await expect(this.mock.connect(this.voter4).castVote(1, VoteType.Abstain))
+          .to.emit(this.mock, 'VoteCast')
+          .withArgs(this.voter4, 1, VoteType.Abstain, ethers.parseEther('2'), '');
+
+        timepoint = await this.mock.proposalDeadline(1);
+        time.increaseTo[mode](timepoint);
+
+        expect(this.helper.execute())
+          .to.eventually.emit(this.mock, 'ProposalExecuted')
+          .withArgs(1)
+          .emit(this.receiver, 'MockFunctionCalled');
+      });
+    });
+  }
+});