web3gbit-cli 1.0.0

package/lib/openzeppelin-contracts/test/governance/extensions/GovernorSequentialProposalId.test.js

@@ -0,0 +1,202 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+const { anyValue } = require('@nomicfoundation/hardhat-chai-matchers/withArgs');
+
+const { GovernorHelper } = require('../../helpers/governance');
+const { VoteType } = require('../../helpers/enums');
+const iterate = require('../../helpers/iterate');
+
+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 () {
+        for (const i of iterate.range(1, 10)) {
+          this.proposal.description = `<proposal description #${i}>`;
+
+          await expect(this.mock.hashProposal(...this.proposal.shortProposal)).to.eventually.equal(this.proposal.hash);
+          await expect(this.mock.getProposalId(...this.proposal.shortProposal)).revertedWithCustomError(
+            this.mock,
+            'GovernorNonexistentProposal',
+          );
+          await expect(this.mock.latestProposalId()).to.eventually.equal(i - 1);
+
+          await expect(this.helper.connect(this.proposer).propose())
+            .to.emit(this.mock, 'ProposalCreated')
+            .withArgs(
+              i,
+              this.proposer,
+              this.proposal.targets,
+              this.proposal.values,
+              this.proposal.signatures,
+              this.proposal.data,
+              anyValue,
+              anyValue,
+              this.proposal.description,
+            );
+
+          await expect(this.mock.hashProposal(...this.proposal.shortProposal)).to.eventually.equal(this.proposal.hash);
+          await expect(this.mock.getProposalId(...this.proposal.shortProposal)).to.eventually.equal(i);
+          await expect(this.mock.latestProposalId()).to.eventually.equal(i);
+        }
+      });
+
+      it('sequential proposal ids with offset start', async function () {
+        const offset = 69420;
+        await this.mock.$_initializeLatestProposalId(offset);
+
+        for (const i of iterate.range(offset + 1, offset + 10)) {
+          this.proposal.description = `<proposal description #${i}>`;
+
+          await expect(this.mock.hashProposal(...this.proposal.shortProposal)).to.eventually.equal(this.proposal.hash);
+          await expect(this.mock.getProposalId(...this.proposal.shortProposal)).revertedWithCustomError(
+            this.mock,
+            'GovernorNonexistentProposal',
+          );
+          await expect(this.mock.latestProposalId()).to.eventually.equal(i - 1);
+
+          await expect(this.helper.connect(this.proposer).propose())
+            .to.emit(this.mock, 'ProposalCreated')
+            .withArgs(
+              i,
+              this.proposer,
+              this.proposal.targets,
+              this.proposal.values,
+              this.proposal.signatures,
+              this.proposal.data,
+              anyValue,
+              anyValue,
+              this.proposal.description,
+            );
+
+          await expect(this.mock.hashProposal(...this.proposal.shortProposal)).to.eventually.equal(this.proposal.hash);
+          await expect(this.mock.getProposalId(...this.proposal.shortProposal)).to.eventually.equal(i);
+          await expect(this.mock.latestProposalId()).to.eventually.equal(i);
+        }
+      });
+
+      it('can only initialize latest proposal id from 0', async function () {
+        await this.helper.propose();
+        await expect(this.mock.latestProposalId()).to.eventually.equal(1);
+        await expect(this.mock.$_initializeLatestProposalId(2)).to.be.revertedWithCustomError(
+          this.mock,
+          'GovernorAlreadyInitializedLatestProposalId',
+        );
+      });
+
+      it('cannot repropose same proposal', async function () {
+        await this.helper.connect(this.proposer).propose();
+        await expect(this.helper.connect(this.proposer).propose())
+          .to.be.revertedWithCustomError(this.mock, 'GovernorUnexpectedProposalState')
+          .withArgs(await this.proposal.id, 0n, ethers.ZeroHash);
+      });
+
+      it('nominal workflow', async function () {
+        await this.helper.connect(this.proposer).propose();
+        await this.helper.waitForSnapshot();
+
+        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'), '');
+
+        await this.helper.waitForDeadline();
+
+        await expect(this.helper.execute())
+          .to.eventually.emit(this.mock, 'ProposalExecuted')
+          .withArgs(1)
+          .emit(this.receiver, 'MockFunctionCalled');
+      });
+    });
+  }
+});

package/lib/openzeppelin-contracts/test/governance/extensions/GovernorStorage.test.js

@@ -0,0 +1,175 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+const { anyValue } = require('@nomicfoundation/hardhat-chai-matchers/withArgs');
+const { PANIC_CODES } = require('@nomicfoundation/hardhat-chai-matchers/panic');
+
+const { GovernorHelper, timelockSalt } = require('../../helpers/governance');
+const { VoteType } = require('../../helpers/enums');
+
+const TOKENS = [
+  { Token: '$ERC20Votes', mode: 'blocknumber' },
+  { Token: '$ERC20VotesTimestampMock', mode: 'timestamp' },
+];
+
+const DEFAULT_ADMIN_ROLE = ethers.ZeroHash;
+const PROPOSER_ROLE = ethers.id('PROPOSER_ROLE');
+const EXECUTOR_ROLE = ethers.id('EXECUTOR_ROLE');
+const CANCELLER_ROLE = ethers.id('CANCELLER_ROLE');
+
+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');
+const delay = 3600n;
+
+describe('GovernorStorage', function () {
+  for (const { Token, mode } of TOKENS) {
+    const fixture = async () => {
+      const [deployer, owner, proposer, voter1, voter2, voter3, voter4] = await ethers.getSigners();
+      const receiver = await ethers.deployContract('CallReceiverMock');
+
+      const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, tokenName, version]);
+      const timelock = await ethers.deployContract('TimelockController', [delay, [], [], deployer]);
+      const mock = await ethers.deployContract('$GovernorStorageMock', [
+        name,
+        votingDelay,
+        votingPeriod,
+        0n,
+        timelock,
+        token,
+        0n,
+      ]);
+
+      await owner.sendTransaction({ to: timelock, value });
+      await token.$_mint(owner, tokenSupply);
+      await timelock.grantRole(PROPOSER_ROLE, mock);
+      await timelock.grantRole(PROPOSER_ROLE, owner);
+      await timelock.grantRole(CANCELLER_ROLE, mock);
+      await timelock.grantRole(CANCELLER_ROLE, owner);
+      await timelock.grantRole(EXECUTOR_ROLE, ethers.ZeroAddress);
+      await timelock.revokeRole(DEFAULT_ADMIN_ROLE, deployer);
+
+      const helper = new GovernorHelper(mock, mode);
+      await helper.connect(owner).delegate({ token, to: voter1, value: ethers.parseEther('10') });
+      await helper.connect(owner).delegate({ token, to: voter2, value: ethers.parseEther('7') });
+      await helper.connect(owner).delegate({ token, to: voter3, value: ethers.parseEther('5') });
+      await helper.connect(owner).delegate({ token, to: voter4, value: ethers.parseEther('2') });
+
+      return { deployer, owner, proposer, voter1, voter2, voter3, voter4, receiver, token, timelock, mock, helper };
+    };
+
+    describe(`using ${Token}`, function () {
+      beforeEach(async function () {
+        Object.assign(this, await loadFixture(fixture));
+        // initiate fresh proposal
+        this.proposal = this.helper.setProposal(
+          [
+            {
+              target: this.receiver.target,
+              data: this.receiver.interface.encodeFunctionData('mockFunction'),
+              value,
+            },
+          ],
+          '<proposal description>',
+        );
+        this.proposal.timelockid = await this.timelock.hashOperationBatch(
+          ...this.proposal.shortProposal.slice(0, 3),
+          ethers.ZeroHash,
+          timelockSalt(this.mock.target, this.proposal.shortProposal[3]),
+        );
+      });
+
+      describe('proposal indexing', function () {
+        it('before propose', async function () {
+          expect(await this.mock.proposalCount()).to.equal(0n);
+
+          await expect(this.mock.proposalDetailsAt(0n)).to.be.revertedWithPanic(PANIC_CODES.ARRAY_ACCESS_OUT_OF_BOUNDS);
+
+          await expect(this.mock.proposalDetails(this.proposal.id))
+            .to.be.revertedWithCustomError(this.mock, 'GovernorNonexistentProposal')
+            .withArgs(this.proposal.id);
+        });
+
+        it('after propose', async function () {
+          await this.helper.propose();
+
+          expect(await this.mock.proposalCount()).to.equal(1n);
+
+          expect(await this.mock.proposalDetailsAt(0n)).to.deep.equal([
+            this.proposal.id,
+            this.proposal.targets,
+            this.proposal.values,
+            this.proposal.data,
+            this.proposal.descriptionHash,
+          ]);
+
+          expect(await this.mock.proposalDetails(this.proposal.id)).to.deep.equal([
+            this.proposal.targets,
+            this.proposal.values,
+            this.proposal.data,
+            this.proposal.descriptionHash,
+          ]);
+        });
+      });
+
+      it('queue and execute by id', async function () {
+        await this.helper.propose();
+        await this.helper.waitForSnapshot();
+        await this.helper.connect(this.voter1).vote({ support: VoteType.For });
+        await this.helper.connect(this.voter2).vote({ support: VoteType.For });
+        await this.helper.connect(this.voter3).vote({ support: VoteType.Against });
+        await this.helper.connect(this.voter4).vote({ support: VoteType.Abstain });
+        await this.helper.waitForDeadline();
+
+        await expect(this.mock.queue(this.proposal.id))
+          .to.emit(this.mock, 'ProposalQueued')
+          .withArgs(this.proposal.id, anyValue)
+          .to.emit(this.timelock, 'CallScheduled')
+          .withArgs(this.proposal.timelockid, ...Array(6).fill(anyValue))
+          .to.emit(this.timelock, 'CallSalt')
+          .withArgs(this.proposal.timelockid, anyValue);
+
+        await this.helper.waitForEta();
+
+        await expect(this.mock.execute(this.proposal.id))
+          .to.emit(this.mock, 'ProposalExecuted')
+          .withArgs(this.proposal.id)
+          .to.emit(this.timelock, 'CallExecuted')
+          .withArgs(this.proposal.timelockid, ...Array(4).fill(anyValue))
+          .to.emit(this.receiver, 'MockFunctionCalled');
+      });
+
+      it('cancel by id', async function () {
+        await this.helper.connect(this.proposer).propose();
+        await expect(this.mock.connect(this.proposer).cancel(this.proposal.id))
+          .to.emit(this.mock, 'ProposalCanceled')
+          .withArgs(this.proposal.id);
+      });
+
+      describe('with non-existing proposalId', function () {
+        it('queue', async function () {
+          await expect(this.mock.queue(this.proposal.id))
+            .to.be.revertedWithCustomError(this.mock, 'GovernorNonexistentProposal')
+            .withArgs(this.proposal.id);
+        });
+
+        it('execute', async function () {
+          await expect(this.mock.execute(this.proposal.id))
+            .to.be.revertedWithCustomError(this.mock, 'GovernorNonexistentProposal')
+            .withArgs(this.proposal.id);
+        });
+
+        it('cancel', async function () {
+          await expect(this.mock.cancel(this.proposal.id))
+            .to.be.revertedWithCustomError(this.mock, 'GovernorNonexistentProposal')
+            .withArgs(this.proposal.id);
+        });
+      });
+    });
+  }
+});

package/lib/openzeppelin-contracts/test/governance/extensions/GovernorSuperQuorum.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 { ProposalState, VoteType } = require('../../helpers/enums');
+const time = require('../../helpers/time');
+
+const TOKENS = [
+  { Token: '$ERC20Votes', mode: 'blocknumber' },
+  { Token: '$ERC20VotesTimestampMock', mode: 'timestamp' },
+];
+
+const DEFAULT_ADMIN_ROLE = ethers.ZeroHash;
+const PROPOSER_ROLE = ethers.id('PROPOSER_ROLE');
+const EXECUTOR_ROLE = ethers.id('EXECUTOR_ROLE');
+const CANCELLER_ROLE = ethers.id('CANCELLER_ROLE');
+
+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 quorum = 10n;
+const superQuorum = 40n;
+const value = ethers.parseEther('1');
+const delay = time.duration.hours(1n);
+
+describe('GovernorSuperQuorum', function () {
+  for (const { Token, mode } of TOKENS) {
+    const fixture = async () => {
+      const [proposer, voter1, voter2, voter3, voter4, voter5] = await ethers.getSigners();
+      const receiver = await ethers.deployContract('CallReceiverMock');
+
+      const timelock = await ethers.deployContract('TimelockController', [delay, [], [], proposer]);
+      const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, tokenName, version]);
+      const mock = await ethers.deployContract('$GovernorSuperQuorumMock', [
+        name,
+        votingDelay, // initialVotingDelay
+        votingPeriod, // initialVotingPeriod
+        0n, // initialProposalThreshold
+        token,
+        timelock,
+        quorum,
+        superQuorum,
+      ]);
+
+      await proposer.sendTransaction({ to: timelock, value });
+      await token.$_mint(proposer, tokenSupply);
+      await timelock.grantRole(PROPOSER_ROLE, mock);
+      await timelock.grantRole(PROPOSER_ROLE, proposer);
+      await timelock.grantRole(CANCELLER_ROLE, mock);
+      await timelock.grantRole(CANCELLER_ROLE, proposer);
+      await timelock.grantRole(EXECUTOR_ROLE, ethers.ZeroAddress);
+      await timelock.revokeRole(DEFAULT_ADMIN_ROLE, proposer);
+
+      const helper = new GovernorHelper(mock, mode);
+      await helper.connect(proposer).delegate({ token, to: voter1, value: 40 });
+      await helper.connect(proposer).delegate({ token, to: voter2, value: 30 });
+      await helper.connect(proposer).delegate({ token, to: voter3, value: 20 });
+      await helper.connect(proposer).delegate({ token, to: voter4, value: 15 });
+      await helper.connect(proposer).delegate({ token, to: voter5, value: 5 });
+
+      return { proposer, voter1, voter2, voter3, voter4, voter5, receiver, token, mock, timelock, helper };
+    };
+
+    describe(`using ${Token}`, function () {
+      beforeEach(async function () {
+        Object.assign(this, await loadFixture(fixture));
+
+        // default proposal
+        this.proposal = this.helper.setProposal(
+          [
+            {
+              target: this.receiver.target,
+              value,
+              data: this.receiver.interface.encodeFunctionData('mockFunction'),
+            },
+          ],
+          '<proposal description>',
+        );
+      });
+
+      it('deployment check', async function () {
+        await expect(this.mock.name()).to.eventually.equal(name);
+        await expect(this.mock.token()).to.eventually.equal(this.token);
+        await expect(this.mock.quorum(0)).to.eventually.equal(quorum);
+        await expect(this.mock.superQuorum(0)).to.eventually.equal(superQuorum);
+      });
+
+      it('proposal succeeds early when super quorum is reached', async function () {
+        await this.helper.connect(this.proposer).propose();
+        await this.helper.waitForSnapshot();
+
+        // Vote with voter2 (30) - above quorum (10) but below super quorum (40)
+        await this.helper.connect(this.voter2).vote({ support: VoteType.For });
+        await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Active);
+
+        // Vote with voter3 (20) to reach super quorum (50 total > 40)
+        await this.helper.connect(this.voter3).vote({ support: VoteType.For });
+
+        await expect(this.mock.proposalEta(this.proposal.id)).to.eventually.equal(0);
+
+        // Should be succeeded since we reached super quorum and no eta is set
+        await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Succeeded);
+      });
+
+      it('proposal remains active if super quorum is not reached', async function () {
+        await this.helper.connect(this.proposer).propose();
+        await this.helper.waitForSnapshot();
+
+        // Vote with voter4 (15) - below super quorum (40) but above quorum (10)
+        await this.helper.connect(this.voter4).vote({ support: VoteType.For });
+        await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Active);
+
+        // Vote with voter5 (5) - still below super quorum (total 20 < 40)
+        await this.helper.connect(this.voter5).vote({ support: VoteType.For });
+        await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Active);
+
+        // Wait for deadline
+        await this.helper.waitForDeadline(1n);
+
+        // Should succeed since deadline passed and we have enough support (20 > 10 quorum)
+        await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Succeeded);
+      });
+
+      it('proposal remains active if super quorum is reached but vote fails', async function () {
+        await this.helper.connect(this.proposer).propose();
+        await this.helper.waitForSnapshot();
+
+        // Vote against with voter2 and voter3 (50)
+        await this.helper.connect(this.voter2).vote({ support: VoteType.Against });
+        await this.helper.connect(this.voter3).vote({ support: VoteType.Against });
+
+        // Vote for with voter1 (40) (reaching super quorum)
+        await this.helper.connect(this.voter1).vote({ support: VoteType.For });
+
+        // should be active since super quorum is reached but vote fails
+        await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Active);
+
+        // wait for deadline
+        await this.helper.waitForDeadline(1n);
+
+        // should be defeated since against votes are higher
+        await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Defeated);
+      });
+
+      it('proposal is queued if super quorum is reached and eta is set', async function () {
+        await this.helper.connect(this.proposer).propose();
+
+        await this.helper.waitForSnapshot();
+
+        // Vote with voter1 (40) - reaching super quorum
+        await this.helper.connect(this.voter1).vote({ support: VoteType.For });
+
+        await this.helper.queue();
+
+        // Queueing should set eta
+        await expect(this.mock.proposalEta(this.proposal.id)).to.eventually.not.equal(0);
+
+        // Should be queued since we reached super quorum and eta is set
+        await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Queued);
+      });
+    });
+  }
+});

package/lib/openzeppelin-contracts/test/governance/extensions/GovernorSuperQuorumGreaterThanQuorum.t.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {Test} from "forge-std/Test.sol";
+import {
+    GovernorVotesSuperQuorumFractionMock
+} from "../../../contracts/mocks/governance/GovernorVotesSuperQuorumFractionMock.sol";
+import {GovernorVotesQuorumFraction} from "../../../contracts/governance/extensions/GovernorVotesQuorumFraction.sol";
+import {
+    GovernorVotesSuperQuorumFraction
+} from "../../../contracts/governance/extensions/GovernorVotesSuperQuorumFraction.sol";
+import {GovernorSettings} from "../../../contracts/governance/extensions/GovernorSettings.sol";
+import {GovernorVotes} from "../../../contracts/governance/extensions/GovernorVotes.sol";
+import {Governor} from "../../../contracts/governance/Governor.sol";
+import {IVotes} from "../../../contracts/governance/utils/IVotes.sol";
+import {ERC20VotesExtendedTimestampMock} from "../../../contracts/mocks/token/ERC20VotesAdditionalCheckpointsMock.sol";
+import {EIP712} from "../../../contracts/utils/cryptography/EIP712.sol";
+import {ERC20} from "../../../contracts/token/ERC20/ERC20.sol";
+
+contract TokenMock is ERC20VotesExtendedTimestampMock {
+    constructor() ERC20("Mock Token", "MTK") EIP712("Mock Token", "1") {}
+}
+
+/**
+ * Main responsibility: expose the functions that are relevant to the simulation
+ */
+contract GovernorHandler is GovernorVotesSuperQuorumFractionMock {
+    constructor(
+        string memory name_,
+        uint48 votingDelay_,
+        uint32 votingPeriod_,
+        uint256 proposalThreshold_,
+        IVotes token_,
+        uint256 quorumNumerator_,
+        uint256 superQuorumNumerator_
+    )
+        Governor(name_)
+        GovernorSettings(votingDelay_, votingPeriod_, proposalThreshold_)
+        GovernorVotes(token_)
+        GovernorVotesQuorumFraction(quorumNumerator_)
+        GovernorVotesSuperQuorumFraction(superQuorumNumerator_)
+    {}
+
+    // solhint-disable-next-line func-name-mixedcase
+    function $_updateSuperQuorumNumerator(uint256 newSuperQuorumNumerator) public {
+        _updateSuperQuorumNumerator(newSuperQuorumNumerator);
+    }
+
+    // solhint-disable-next-line func-name-mixedcase
+    function $_updateQuorumNumerator(uint256 newQuorumNumerator) public {
+        _updateQuorumNumerator(newQuorumNumerator);
+    }
+}
+
+contract GovernorSuperQuorumGreaterThanQuorum is Test {
+    GovernorHandler private _governorHandler;
+
+    function setUp() external {
+        _governorHandler = new GovernorHandler(
+            "GovernorName",
+            0, // votingDelay
+            1e4, // votingPeriod
+            0, // proposalThreshold
+            new TokenMock(), // token
+            10, // quorumNumerator
+            50 // superQuorumNumerator
+        );
+
+        // limit the fuzzer scope
+        bytes4[] memory selectors = new bytes4[](2);
+        selectors[0] = GovernorHandler.$_updateSuperQuorumNumerator.selector;
+        selectors[1] = GovernorHandler.$_updateQuorumNumerator.selector;
+
+        targetContract(address(_governorHandler));
+        targetSelector(FuzzSelector(address(_governorHandler), selectors));
+    }
+
+    // solhint-disable-next-line func-name-mixedcase
+    function invariant_superQuorumGreaterThanQuorum() external view {
+        assertGe(_governorHandler.superQuorumNumerator(), _governorHandler.quorumNumerator());
+    }
+}