You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
245 lines
9.5 KiB
245 lines
9.5 KiB
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, 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);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
});
|
|
|