web3gbit-cli 1.0.0

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

@@ -0,0 +1,160 @@
+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 name = 'OZ-Governor';
+const version = '1';
+const tokenName = 'MockToken';
+const tokenSymbol = 'MTKN';
+const tokenSupply = ethers.parseEther('100');
+const quorumRatio = 8n; // percents
+const superQuorumRatio = 50n; // percents
+const newSuperQuorumRatio = 15n; // percents
+const votingDelay = 4n;
+const votingPeriod = 16n;
+const value = ethers.parseEther('1');
+
+describe('GovernorVotesSuperQuorumFraction', function () {
+  for (const { Token, mode } of TOKENS) {
+    const fixture = async () => {
+      const [owner, voter1, voter2, voter3, voter4] = await ethers.getSigners();
+      const receiver = await ethers.deployContract('CallReceiverMock');
+
+      const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, tokenName, version]);
+      const mock = await ethers.deployContract('$GovernorVotesSuperQuorumFractionMock', [
+        name,
+        votingDelay,
+        votingPeriod,
+        0n,
+        token,
+        quorumRatio,
+        superQuorumRatio,
+      ]);
+
+      await owner.sendTransaction({ to: mock, value });
+      await token.$_mint(owner, tokenSupply);
+
+      const helper = new GovernorHelper(mock, mode);
+      await helper.connect(owner).delegate({ token, to: voter1, value: ethers.parseEther('30') });
+      await helper.connect(owner).delegate({ token, to: voter2, value: ethers.parseEther('20') });
+      await helper.connect(owner).delegate({ token, to: voter3, value: ethers.parseEther('15') });
+      await helper.connect(owner).delegate({ token, to: voter4, value: ethers.parseEther('5') });
+
+      return { owner, voter1, voter2, voter3, voter4, receiver, token, mock, 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.votingDelay()).to.eventually.equal(votingDelay);
+        await expect(this.mock.votingPeriod()).to.eventually.equal(votingPeriod);
+        await expect(this.mock.quorumNumerator()).to.eventually.equal(quorumRatio);
+        await expect(this.mock.superQuorumNumerator()).to.eventually.equal(superQuorumRatio);
+        await expect(this.mock.quorumDenominator()).to.eventually.equal(100n);
+        await expect(time.clock[mode]().then(clock => this.mock.superQuorum(clock - 1n))).to.eventually.equal(
+          (tokenSupply * superQuorumRatio) / 100n,
+        );
+      });
+
+      it('proposal remains active until super quorum is reached', async function () {
+        await this.helper.propose();
+        await this.helper.waitForSnapshot();
+
+        // Vote with voter1 (30%) - above quorum (8%) but below super quorum (50%)
+        await this.helper.connect(this.voter1).vote({ support: VoteType.For });
+
+        // Check proposal is still active
+        await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Active);
+
+        // Vote with voter2 (20%) - now matches super quorum
+        await this.helper.connect(this.voter2).vote({ support: VoteType.For });
+
+        // Proposal should no longer be active
+        await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Succeeded);
+      });
+
+      describe('super quorum updates', function () {
+        it('updateSuperQuorumNumerator is protected', async function () {
+          await expect(this.mock.connect(this.owner).updateSuperQuorumNumerator(newSuperQuorumRatio))
+            .to.be.revertedWithCustomError(this.mock, 'GovernorOnlyExecutor')
+            .withArgs(this.owner);
+        });
+
+        it('can update super quorum through governance', async function () {
+          this.helper.setProposal(
+            [
+              {
+                target: this.mock.target,
+                data: this.mock.interface.encodeFunctionData('updateSuperQuorumNumerator', [newSuperQuorumRatio]),
+              },
+            ],
+            '<proposal description>',
+          );
+
+          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.waitForDeadline();
+
+          await expect(this.helper.execute())
+            .to.emit(this.mock, 'SuperQuorumNumeratorUpdated')
+            .withArgs(superQuorumRatio, newSuperQuorumRatio);
+
+          await expect(this.mock.superQuorumNumerator()).to.eventually.equal(newSuperQuorumRatio);
+        });
+
+        it('cannot set super quorum below quorum', async function () {
+          const invalidSuperQuorum = quorumRatio - 1n;
+
+          await expect(this.mock.$_updateSuperQuorumNumerator(invalidSuperQuorum))
+            .to.be.revertedWithCustomError(this.mock, 'GovernorInvalidSuperQuorumTooSmall')
+            .withArgs(invalidSuperQuorum, quorumRatio);
+        });
+
+        it('cannot set super quorum above denominator', async function () {
+          const denominator = await this.mock.quorumDenominator();
+          const invalidSuperQuorum = BigInt(denominator) + 1n;
+
+          await expect(this.mock.$_updateSuperQuorumNumerator(invalidSuperQuorum))
+            .to.be.revertedWithCustomError(this.mock, 'GovernorInvalidSuperQuorumFraction')
+            .withArgs(invalidSuperQuorum, denominator);
+        });
+
+        it('cannot set quorum above super quorum', async function () {
+          const invalidQuorum = superQuorumRatio + 1n;
+
+          await expect(this.mock.$_updateQuorumNumerator(invalidQuorum))
+            .to.be.revertedWithCustomError(this.mock, 'GovernorInvalidQuorumTooLarge')
+            .withArgs(invalidQuorum, superQuorumRatio);
+        });
+      });
+    });
+  }
+});

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

@@ -0,0 +1,245 @@
+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 { getDomain, ExtendedBallot } = require('../../helpers/eip712');
+
+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');
+
+const params = {
+  decoded: [42n, 'These are my params'],
+  encoded: ethers.AbiCoder.defaultAbiCoder().encode(['uint256', 'string'], [42n, 'These are my params']),
+};
+
+describe('GovernorWithParams', function () {
+  for (const { Token, mode } of TOKENS) {
+    const fixture = async () => {
+      const [owner, proposer, voter1, voter2, voter3, voter4, other] = await ethers.getSigners();
+      const receiver = await ethers.deployContract('CallReceiverMock');
+
+      const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, tokenName, version]);
+      const mock = await ethers.deployContract('$GovernorWithParamsMock', [name, token]);
+
+      await owner.sendTransaction({ to: mock, value });
+      await token.$_mint(owner, tokenSupply);
+
+      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 { owner, proposer, voter1, voter2, voter3, voter4, other, receiver, token, mock, 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 () {
+        expect(await this.mock.name()).to.equal(name);
+        expect(await this.mock.token()).to.equal(this.token);
+        expect(await this.mock.votingDelay()).to.equal(votingDelay);
+        expect(await this.mock.votingPeriod()).to.equal(votingPeriod);
+      });
+
+      it('nominal is unaffected', async function () {
+        await this.helper.connect(this.proposer).propose();
+        await this.helper.waitForSnapshot();
+        await this.helper.connect(this.voter1).vote({ support: VoteType.For, reason: 'This is nice' });
+        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 this.helper.execute();
+
+        expect(await this.mock.hasVoted(this.proposal.id, this.owner)).to.be.false;
+        expect(await this.mock.hasVoted(this.proposal.id, this.voter1)).to.be.true;
+        expect(await this.mock.hasVoted(this.proposal.id, this.voter2)).to.be.true;
+        expect(await ethers.provider.getBalance(this.mock)).to.equal(0n);
+        expect(await ethers.provider.getBalance(this.receiver)).to.equal(value);
+      });
+
+      it('Voting with params is properly supported', async function () {
+        await this.helper.connect(this.proposer).propose();
+        await this.helper.waitForSnapshot();
+
+        const weight = ethers.parseEther('7') - params.decoded[0];
+
+        await expect(
+          this.helper.connect(this.voter2).vote({
+            support: VoteType.For,
+            reason: 'no particular reason',
+            params: params.encoded,
+          }),
+        )
+          .to.emit(this.mock, 'CountParams')
+          .withArgs(...params.decoded)
+          .to.emit(this.mock, 'VoteCastWithParams')
+          .withArgs(
+            this.voter2.address,
+            this.proposal.id,
+            VoteType.For,
+            weight,
+            'no particular reason',
+            params.encoded,
+          );
+
+        expect(await this.mock.proposalVotes(this.proposal.id)).to.deep.equal([0n, weight, 0n]);
+      });
+
+      describe('voting by signature', function () {
+        it('supports EOA signatures', async function () {
+          await this.token.connect(this.voter2).delegate(this.other);
+
+          // Run proposal
+          await this.helper.propose();
+          await this.helper.waitForSnapshot();
+
+          // Prepare vote
+          const weight = ethers.parseEther('7') - params.decoded[0];
+          const nonce = await this.mock.nonces(this.other);
+          const data = {
+            proposalId: this.proposal.id,
+            support: VoteType.For,
+            voter: this.other.address,
+            nonce,
+            reason: 'no particular reason',
+            params: params.encoded,
+            signature: (contract, message) =>
+              getDomain(contract).then(domain => this.other.signTypedData(domain, { ExtendedBallot }, message)),
+          };
+
+          // Vote
+          await expect(this.helper.vote(data))
+            .to.emit(this.mock, 'CountParams')
+            .withArgs(...params.decoded)
+            .to.emit(this.mock, 'VoteCastWithParams')
+            .withArgs(data.voter, data.proposalId, data.support, weight, data.reason, data.params);
+
+          expect(await this.mock.proposalVotes(this.proposal.id)).to.deep.equal([0n, weight, 0n]);
+          expect(await this.mock.nonces(this.other)).to.equal(nonce + 1n);
+        });
+
+        it('supports EIP-1271 signature signatures', async function () {
+          const wallet = await ethers.deployContract('ERC1271WalletMock', [this.other]);
+          await this.token.connect(this.voter2).delegate(wallet);
+
+          // Run proposal
+          await this.helper.propose();
+          await this.helper.waitForSnapshot();
+
+          // Prepare vote
+          const weight = ethers.parseEther('7') - params.decoded[0];
+          const nonce = await this.mock.nonces(this.other);
+          const data = {
+            proposalId: this.proposal.id,
+            support: VoteType.For,
+            voter: wallet.target,
+            nonce,
+            reason: 'no particular reason',
+            params: params.encoded,
+            signature: (contract, message) =>
+              getDomain(contract).then(domain => this.other.signTypedData(domain, { ExtendedBallot }, message)),
+          };
+
+          // Vote
+          await expect(this.helper.vote(data))
+            .to.emit(this.mock, 'CountParams')
+            .withArgs(...params.decoded)
+            .to.emit(this.mock, 'VoteCastWithParams')
+            .withArgs(data.voter, data.proposalId, data.support, weight, data.reason, data.params);
+
+          expect(await this.mock.proposalVotes(this.proposal.id)).to.deep.equal([0n, weight, 0n]);
+          expect(await this.mock.nonces(wallet)).to.equal(nonce + 1n);
+        });
+
+        it('reverts if signature does not match signer', async function () {
+          await this.token.connect(this.voter2).delegate(this.other);
+
+          // Run proposal
+          await this.helper.propose();
+          await this.helper.waitForSnapshot();
+
+          // Prepare vote
+          const nonce = await this.mock.nonces(this.other);
+          const data = {
+            proposalId: this.proposal.id,
+            support: VoteType.For,
+            voter: this.other.address,
+            nonce,
+            reason: 'no particular reason',
+            params: params.encoded,
+            // tampered signature
+            signature: (contract, message) =>
+              getDomain(contract)
+                .then(domain => this.other.signTypedData(domain, { ExtendedBallot }, message))
+                .then(signature => {
+                  const tamperedSig = ethers.toBeArray(signature);
+                  tamperedSig[42] ^= 0xff;
+                  return ethers.hexlify(tamperedSig);
+                }),
+          };
+
+          // Vote
+          await expect(this.helper.vote(data))
+            .to.be.revertedWithCustomError(this.mock, 'GovernorInvalidSignature')
+            .withArgs(data.voter);
+        });
+
+        it('reverts if vote nonce is incorrect', async function () {
+          await this.token.connect(this.voter2).delegate(this.other);
+
+          // Run proposal
+          await this.helper.propose();
+          await this.helper.waitForSnapshot();
+
+          // Prepare vote
+          const nonce = await this.mock.nonces(this.other);
+          const data = {
+            proposalId: this.proposal.id,
+            support: VoteType.For,
+            voter: this.other.address,
+            nonce: nonce + 1n,
+            reason: 'no particular reason',
+            params: params.encoded,
+            signature: (contract, message) =>
+              getDomain(contract).then(domain => this.other.signTypedData(domain, { ExtendedBallot }, message)),
+          };
+
+          // Vote
+          await expect(this.helper.vote(data))
+            .to.be.revertedWithCustomError(this.mock, 'GovernorInvalidSignature')
+            .withArgs(data.voter);
+        });
+      });
+    });
+  }
+});

package/lib/openzeppelin-contracts/test/governance/utils/ERC6372.behavior.js

@@ -0,0 +1,28 @@
+const { expect } = require('chai');
+const time = require('../../helpers/time');
+
+function shouldBehaveLikeERC6372(mode = 'blocknumber') {
+  describe(`ERC-6372 behavior in ${mode} mode`, function () {
+    beforeEach(async function () {
+      this.mock = this.mock ?? this.token ?? this.votes;
+    });
+
+    it('should have a correct clock value', async function () {
+      const currentClock = await this.mock.clock();
+      const expectedClock = await time.clock[mode]();
+      expect(currentClock).to.equal(expectedClock, `Clock mismatch in ${mode} mode`);
+    });
+
+    it('should have the correct CLOCK_MODE parameters', async function () {
+      const clockModeParams = new URLSearchParams(await this.mock.CLOCK_MODE());
+      const expectedFromValue = mode === 'blocknumber' ? 'default' : null;
+
+      expect(clockModeParams.get('mode')).to.equal(mode, `Expected mode to be ${mode}`);
+      expect(clockModeParams.get('from')).to.equal(expectedFromValue, `Expected 'from' to be ${expectedFromValue}`);
+    });
+  });
+}
+
+module.exports = {
+  shouldBehaveLikeERC6372,
+};