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.
864 lines
34 KiB
864 lines
34 KiB
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 { hashOperation } = require('../../helpers/access-manager');
|
|
const { max } = require('../../helpers/math');
|
|
const { selector } = require('../../helpers/methods');
|
|
const { ProposalState, VoteType } = require('../../helpers/enums');
|
|
const time = require('../../helpers/time');
|
|
|
|
function prepareOperation({ sender, target, value = 0n, data = '0x' }) {
|
|
return {
|
|
id: hashOperation(sender, target, data),
|
|
operation: { target, value, data },
|
|
selector: data.slice(0, 10).padEnd(10, '0'),
|
|
};
|
|
}
|
|
|
|
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');
|
|
|
|
describe('GovernorTimelockAccess', function () {
|
|
for (const { Token, mode } of TOKENS) {
|
|
const fixture = async () => {
|
|
const [admin, voter1, voter2, voter3, voter4, other] = await ethers.getSigners();
|
|
|
|
const manager = await ethers.deployContract('$AccessManager', [admin]);
|
|
const receiver = await ethers.deployContract('$AccessManagedTarget', [manager]);
|
|
|
|
const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, tokenName, version]);
|
|
const mock = await ethers.deployContract('$GovernorTimelockAccessMock', [
|
|
name,
|
|
votingDelay,
|
|
votingPeriod,
|
|
0n,
|
|
manager,
|
|
0n,
|
|
token,
|
|
0n,
|
|
]);
|
|
|
|
await admin.sendTransaction({ to: mock, value });
|
|
await token.$_mint(admin, tokenSupply);
|
|
|
|
const helper = new GovernorHelper(mock, mode);
|
|
await helper.connect(admin).delegate({ token, to: voter1, value: ethers.parseEther('10') });
|
|
await helper.connect(admin).delegate({ token, to: voter2, value: ethers.parseEther('7') });
|
|
await helper.connect(admin).delegate({ token, to: voter3, value: ethers.parseEther('5') });
|
|
await helper.connect(admin).delegate({ token, to: voter4, value: ethers.parseEther('2') });
|
|
|
|
return { admin, voter1, voter2, voter3, voter4, other, manager, receiver, token, mock, helper };
|
|
};
|
|
|
|
describe(`using ${Token}`, function () {
|
|
beforeEach(async function () {
|
|
Object.assign(this, await loadFixture(fixture));
|
|
|
|
// restricted proposal
|
|
this.restricted = prepareOperation({
|
|
sender: this.mock.target,
|
|
target: this.receiver.target,
|
|
data: this.receiver.interface.encodeFunctionData('fnRestricted'),
|
|
});
|
|
|
|
this.unrestricted = prepareOperation({
|
|
sender: this.mock.target,
|
|
target: this.receiver.target,
|
|
data: this.receiver.interface.encodeFunctionData('fnUnrestricted'),
|
|
});
|
|
|
|
this.fallback = prepareOperation({
|
|
sender: this.mock.target,
|
|
target: this.receiver.target,
|
|
data: '0x1234',
|
|
});
|
|
});
|
|
|
|
it('accepts ether transfers', async function () {
|
|
await this.admin.sendTransaction({ to: this.mock, value: 1n });
|
|
});
|
|
|
|
it('post 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);
|
|
expect(await this.mock.quorum(0n)).to.equal(0n);
|
|
|
|
expect(await this.mock.accessManager()).to.equal(this.manager);
|
|
});
|
|
|
|
it('sets base delay (seconds)', async function () {
|
|
const baseDelay = time.duration.hours(10n);
|
|
|
|
// Only through governance
|
|
await expect(this.mock.connect(this.voter1).setBaseDelaySeconds(baseDelay))
|
|
.to.be.revertedWithCustomError(this.mock, 'GovernorOnlyExecutor')
|
|
.withArgs(this.voter1);
|
|
|
|
this.proposal = await this.helper.setProposal(
|
|
[
|
|
{
|
|
target: this.mock.target,
|
|
data: this.mock.interface.encodeFunctionData('setBaseDelaySeconds', [baseDelay]),
|
|
},
|
|
],
|
|
'descr',
|
|
);
|
|
|
|
await this.helper.propose();
|
|
await this.helper.waitForSnapshot();
|
|
await this.helper.connect(this.voter1).vote({ support: VoteType.For });
|
|
await this.helper.waitForDeadline();
|
|
|
|
await expect(this.helper.execute()).to.emit(this.mock, 'BaseDelaySet').withArgs(0n, baseDelay);
|
|
|
|
expect(await this.mock.baseDelaySeconds()).to.equal(baseDelay);
|
|
});
|
|
|
|
it('sets access manager ignored', async function () {
|
|
const selectors = ['0x12345678', '0x87654321', '0xabcdef01'];
|
|
|
|
// Only through governance
|
|
await expect(this.mock.connect(this.voter1).setAccessManagerIgnored(this.other, selectors, true))
|
|
.to.be.revertedWithCustomError(this.mock, 'GovernorOnlyExecutor')
|
|
.withArgs(this.voter1);
|
|
|
|
// Ignore
|
|
await this.helper.setProposal(
|
|
[
|
|
{
|
|
target: this.mock.target,
|
|
data: this.mock.interface.encodeFunctionData('setAccessManagerIgnored', [
|
|
this.other.address,
|
|
selectors,
|
|
true,
|
|
]),
|
|
},
|
|
],
|
|
'descr',
|
|
);
|
|
await this.helper.propose();
|
|
await this.helper.waitForSnapshot();
|
|
await this.helper.connect(this.voter1).vote({ support: VoteType.For });
|
|
await this.helper.waitForDeadline();
|
|
|
|
const ignoreReceipt = this.helper.execute();
|
|
for (const selector of selectors) {
|
|
await expect(ignoreReceipt)
|
|
.to.emit(this.mock, 'AccessManagerIgnoredSet')
|
|
.withArgs(this.other, selector, true);
|
|
expect(await this.mock.isAccessManagerIgnored(this.other, selector)).to.be.true;
|
|
}
|
|
|
|
// Unignore
|
|
await this.helper.setProposal(
|
|
[
|
|
{
|
|
target: this.mock.target,
|
|
data: this.mock.interface.encodeFunctionData('setAccessManagerIgnored', [
|
|
this.other.address,
|
|
selectors,
|
|
false,
|
|
]),
|
|
},
|
|
],
|
|
'descr',
|
|
);
|
|
|
|
await this.helper.propose();
|
|
await this.helper.waitForSnapshot();
|
|
await this.helper.connect(this.voter1).vote({ support: VoteType.For });
|
|
await this.helper.waitForDeadline();
|
|
|
|
const unignoreReceipt = this.helper.execute();
|
|
for (const selector of selectors) {
|
|
await expect(unignoreReceipt)
|
|
.to.emit(this.mock, 'AccessManagerIgnoredSet')
|
|
.withArgs(this.other, selector, false);
|
|
expect(await this.mock.isAccessManagerIgnored(this.other, selector)).to.be.false;
|
|
}
|
|
});
|
|
|
|
it('sets access manager ignored when target is the governor', async function () {
|
|
const selectors = ['0x12345678', '0x87654321', '0xabcdef01'];
|
|
|
|
await this.helper.setProposal(
|
|
[
|
|
{
|
|
target: this.mock.target,
|
|
data: this.mock.interface.encodeFunctionData('setAccessManagerIgnored', [
|
|
this.mock.target,
|
|
selectors,
|
|
true,
|
|
]),
|
|
},
|
|
],
|
|
'descr',
|
|
);
|
|
|
|
await this.helper.propose();
|
|
await this.helper.waitForSnapshot();
|
|
await this.helper.connect(this.voter1).vote({ support: VoteType.For });
|
|
await this.helper.waitForDeadline();
|
|
|
|
const tx = this.helper.execute();
|
|
for (const selector of selectors) {
|
|
await expect(tx).to.emit(this.mock, 'AccessManagerIgnoredSet').withArgs(this.mock, selector, true);
|
|
expect(await this.mock.isAccessManagerIgnored(this.mock, selector)).to.be.true;
|
|
}
|
|
});
|
|
|
|
it('does not need to queue proposals with no delay', async function () {
|
|
const roleId = 1n;
|
|
const executionDelay = 0n;
|
|
const baseDelay = 0n;
|
|
|
|
// Set execution delay
|
|
await this.manager.connect(this.admin).setTargetFunctionRole(this.receiver, [this.restricted.selector], roleId);
|
|
await this.manager.connect(this.admin).grantRole(roleId, this.mock, executionDelay);
|
|
|
|
// Set base delay
|
|
await this.mock.$_setBaseDelaySeconds(baseDelay);
|
|
|
|
await this.helper.setProposal([this.restricted.operation], 'descr');
|
|
await this.helper.propose();
|
|
expect(await this.mock.proposalNeedsQueuing(this.helper.currentProposal.id)).to.be.false;
|
|
});
|
|
|
|
it('needs to queue proposals with any delay', async function () {
|
|
const roleId = 1n;
|
|
const delays = [
|
|
[time.duration.hours(1n), time.duration.hours(2n)],
|
|
[time.duration.hours(2n), time.duration.hours(1n)],
|
|
];
|
|
|
|
for (const [executionDelay, baseDelay] of delays) {
|
|
// Set execution delay
|
|
await this.manager
|
|
.connect(this.admin)
|
|
.setTargetFunctionRole(this.receiver, [this.restricted.selector], roleId);
|
|
await this.manager.connect(this.admin).grantRole(roleId, this.mock, executionDelay);
|
|
|
|
// Set base delay
|
|
await this.mock.$_setBaseDelaySeconds(baseDelay);
|
|
|
|
await this.helper.setProposal(
|
|
[this.restricted.operation],
|
|
`executionDelay=${executionDelay.toString()}}baseDelay=${baseDelay.toString()}}`,
|
|
);
|
|
await this.helper.propose();
|
|
expect(await this.mock.proposalNeedsQueuing(this.helper.currentProposal.id)).to.be.true;
|
|
}
|
|
});
|
|
|
|
describe('execution plan', function () {
|
|
it('returns plan for delayed operations', async function () {
|
|
const roleId = 1n;
|
|
const delays = [
|
|
[time.duration.hours(1n), time.duration.hours(2n)],
|
|
[time.duration.hours(2n), time.duration.hours(1n)],
|
|
];
|
|
|
|
for (const [executionDelay, baseDelay] of delays) {
|
|
// Set execution delay
|
|
await this.manager
|
|
.connect(this.admin)
|
|
.setTargetFunctionRole(this.receiver, [this.restricted.selector], roleId);
|
|
await this.manager.connect(this.admin).grantRole(roleId, this.mock, executionDelay);
|
|
|
|
// Set base delay
|
|
await this.mock.$_setBaseDelaySeconds(baseDelay);
|
|
|
|
this.proposal = await this.helper.setProposal(
|
|
[this.restricted.operation],
|
|
`executionDelay=${executionDelay.toString()}}baseDelay=${baseDelay.toString()}}`,
|
|
);
|
|
await this.helper.propose();
|
|
|
|
expect(await this.mock.proposalExecutionPlan(this.proposal.id)).to.deep.equal([
|
|
max(baseDelay, executionDelay),
|
|
[true],
|
|
[true],
|
|
]);
|
|
}
|
|
});
|
|
|
|
it('returns plan for not delayed operations', async function () {
|
|
const roleId = 1n;
|
|
const executionDelay = 0n;
|
|
const baseDelay = 0n;
|
|
|
|
// Set execution delay
|
|
await this.manager
|
|
.connect(this.admin)
|
|
.setTargetFunctionRole(this.receiver, [this.restricted.selector], roleId);
|
|
await this.manager.connect(this.admin).grantRole(roleId, this.mock, executionDelay);
|
|
|
|
// Set base delay
|
|
await this.mock.$_setBaseDelaySeconds(baseDelay);
|
|
|
|
this.proposal = await this.helper.setProposal([this.restricted.operation], `descr`);
|
|
await this.helper.propose();
|
|
|
|
expect(await this.mock.proposalExecutionPlan(this.proposal.id)).to.deep.equal([0n, [true], [false]]);
|
|
});
|
|
|
|
it('returns plan for an operation ignoring the manager', async function () {
|
|
await this.mock.$_setAccessManagerIgnored(this.receiver, this.restricted.selector, true);
|
|
|
|
const roleId = 1n;
|
|
const delays = [
|
|
[time.duration.hours(1n), time.duration.hours(2n)],
|
|
[time.duration.hours(2n), time.duration.hours(1n)],
|
|
];
|
|
|
|
for (const [executionDelay, baseDelay] of delays) {
|
|
// Set execution delay
|
|
await this.manager
|
|
.connect(this.admin)
|
|
.setTargetFunctionRole(this.receiver, [this.restricted.selector], roleId);
|
|
await this.manager.connect(this.admin).grantRole(roleId, this.mock, executionDelay);
|
|
|
|
// Set base delay
|
|
await this.mock.$_setBaseDelaySeconds(baseDelay);
|
|
|
|
this.proposal = await this.helper.setProposal(
|
|
[this.restricted.operation],
|
|
`executionDelay=${executionDelay.toString()}}baseDelay=${baseDelay.toString()}}`,
|
|
);
|
|
await this.helper.propose();
|
|
|
|
expect(await this.mock.proposalExecutionPlan(this.proposal.id)).to.deep.equal([
|
|
baseDelay,
|
|
[false],
|
|
[false],
|
|
]);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('base delay only', function () {
|
|
for (const [delay, queue] of [
|
|
[0, true],
|
|
[0, false],
|
|
[1000, true],
|
|
]) {
|
|
it(`delay ${delay}, ${queue ? 'with' : 'without'} queuing`, async function () {
|
|
await this.mock.$_setBaseDelaySeconds(delay);
|
|
|
|
this.proposal = await this.helper.setProposal([this.unrestricted.operation], 'descr');
|
|
|
|
await this.helper.propose();
|
|
await this.helper.waitForSnapshot();
|
|
await this.helper.connect(this.voter1).vote({ support: VoteType.For });
|
|
await this.helper.waitForDeadline();
|
|
if (await this.mock.proposalNeedsQueuing(this.proposal.id)) {
|
|
expect(await this.helper.queue())
|
|
.to.emit(this.mock, 'ProposalQueued')
|
|
.withArgs(this.proposal.id, anyValue);
|
|
}
|
|
if (delay > 0) {
|
|
await this.helper.waitForEta();
|
|
}
|
|
await expect(this.helper.execute())
|
|
.to.emit(this.mock, 'ProposalExecuted')
|
|
.withArgs(this.proposal.id)
|
|
.to.emit(this.receiver, 'CalledUnrestricted');
|
|
});
|
|
}
|
|
});
|
|
|
|
it('reverts when an operation is executed before eta', async function () {
|
|
const delay = time.duration.hours(2n);
|
|
await this.mock.$_setBaseDelaySeconds(delay);
|
|
|
|
this.proposal = await this.helper.setProposal([this.unrestricted.operation], 'descr');
|
|
|
|
await this.helper.propose();
|
|
await this.helper.waitForSnapshot();
|
|
await this.helper.connect(this.voter1).vote({ support: VoteType.For });
|
|
await this.helper.waitForDeadline();
|
|
await this.helper.queue();
|
|
await expect(this.helper.execute())
|
|
.to.be.revertedWithCustomError(this.mock, 'GovernorUnmetDelay')
|
|
.withArgs(this.proposal.id, await this.mock.proposalEta(this.proposal.id));
|
|
});
|
|
|
|
it('reverts with a proposal including multiple operations but one of those was cancelled in the manager', async function () {
|
|
const delay = time.duration.hours(2n);
|
|
const roleId = 1n;
|
|
|
|
await this.manager.connect(this.admin).setTargetFunctionRole(this.receiver, [this.restricted.selector], roleId);
|
|
await this.manager.connect(this.admin).grantRole(roleId, this.mock, delay);
|
|
|
|
// Set proposals
|
|
const original = new GovernorHelper(this.mock, mode);
|
|
await original.setProposal([this.restricted.operation, this.unrestricted.operation], 'descr');
|
|
|
|
// Go through all the governance process
|
|
await original.propose();
|
|
await original.waitForSnapshot();
|
|
await original.connect(this.voter1).vote({ support: VoteType.For });
|
|
await original.waitForDeadline();
|
|
await original.queue();
|
|
await original.waitForEta();
|
|
|
|
// Suddenly cancel one of the proposed operations in the manager
|
|
await this.manager
|
|
.connect(this.admin)
|
|
.cancel(this.mock, this.restricted.operation.target, this.restricted.operation.data);
|
|
|
|
// Reschedule the same operation in a different proposal to avoid "AccessManagerNotScheduled" error
|
|
const rescheduled = new GovernorHelper(this.mock, mode);
|
|
await rescheduled.setProposal([this.restricted.operation], 'descr');
|
|
await rescheduled.propose();
|
|
await rescheduled.waitForSnapshot();
|
|
await rescheduled.connect(this.voter1).vote({ support: VoteType.For });
|
|
await rescheduled.waitForDeadline();
|
|
await rescheduled.queue(); // This will schedule it again in the manager
|
|
await rescheduled.waitForEta();
|
|
|
|
// Attempt to execute
|
|
await expect(original.execute())
|
|
.to.be.revertedWithCustomError(this.mock, 'GovernorMismatchedNonce')
|
|
.withArgs(original.currentProposal.id, 1, 2);
|
|
});
|
|
|
|
it('single operation with access manager delay', async function () {
|
|
const delay = 1000n;
|
|
const roleId = 1n;
|
|
|
|
await this.manager.connect(this.admin).setTargetFunctionRole(this.receiver, [this.restricted.selector], roleId);
|
|
await this.manager.connect(this.admin).grantRole(roleId, this.mock, delay);
|
|
|
|
this.proposal = await this.helper.setProposal([this.restricted.operation], 'descr');
|
|
|
|
await this.helper.propose();
|
|
await this.helper.waitForSnapshot();
|
|
await this.helper.connect(this.voter1).vote({ support: VoteType.For });
|
|
await this.helper.waitForDeadline();
|
|
const txQueue = await this.helper.queue();
|
|
await this.helper.waitForEta();
|
|
const txExecute = await this.helper.execute();
|
|
|
|
await expect(txQueue)
|
|
.to.emit(this.mock, 'ProposalQueued')
|
|
.withArgs(this.proposal.id, anyValue)
|
|
.to.emit(this.manager, 'OperationScheduled')
|
|
.withArgs(
|
|
this.restricted.id,
|
|
1n,
|
|
(await time.clockFromReceipt.timestamp(txQueue)) + delay,
|
|
this.mock.target,
|
|
this.restricted.operation.target,
|
|
this.restricted.operation.data,
|
|
);
|
|
|
|
await expect(txExecute)
|
|
.to.emit(this.mock, 'ProposalExecuted')
|
|
.withArgs(this.proposal.id)
|
|
.to.emit(this.manager, 'OperationExecuted')
|
|
.withArgs(this.restricted.id, 1n)
|
|
.to.emit(this.receiver, 'CalledRestricted');
|
|
});
|
|
|
|
it('bundle of varied operations', async function () {
|
|
const managerDelay = 1000n;
|
|
const roleId = 1n;
|
|
const baseDelay = managerDelay * 2n;
|
|
|
|
await this.mock.$_setBaseDelaySeconds(baseDelay);
|
|
|
|
await this.manager.connect(this.admin).setTargetFunctionRole(this.receiver, [this.restricted.selector], roleId);
|
|
await this.manager.connect(this.admin).grantRole(roleId, this.mock, managerDelay);
|
|
|
|
this.proposal = await this.helper.setProposal(
|
|
[this.restricted.operation, this.unrestricted.operation, this.fallback.operation],
|
|
'descr',
|
|
);
|
|
|
|
await this.helper.propose();
|
|
await this.helper.waitForSnapshot();
|
|
await this.helper.connect(this.voter1).vote({ support: VoteType.For });
|
|
await this.helper.waitForDeadline();
|
|
const txQueue = await this.helper.queue();
|
|
await this.helper.waitForEta();
|
|
const txExecute = await this.helper.execute();
|
|
|
|
await expect(txQueue)
|
|
.to.emit(this.mock, 'ProposalQueued')
|
|
.withArgs(this.proposal.id, anyValue)
|
|
.to.emit(this.manager, 'OperationScheduled')
|
|
.withArgs(
|
|
this.restricted.id,
|
|
1n,
|
|
(await time.clockFromReceipt.timestamp(txQueue)) + baseDelay,
|
|
this.mock.target,
|
|
this.restricted.operation.target,
|
|
this.restricted.operation.data,
|
|
);
|
|
|
|
await expect(txExecute)
|
|
.to.emit(this.mock, 'ProposalExecuted')
|
|
.withArgs(this.proposal.id)
|
|
.to.emit(this.manager, 'OperationExecuted')
|
|
.withArgs(this.restricted.id, 1n)
|
|
.to.emit(this.receiver, 'CalledRestricted')
|
|
.to.emit(this.receiver, 'CalledUnrestricted')
|
|
.to.emit(this.receiver, 'CalledFallback');
|
|
});
|
|
|
|
describe('cancel', function () {
|
|
const delay = 1000n;
|
|
const roleId = 1n;
|
|
|
|
beforeEach(async function () {
|
|
await this.manager
|
|
.connect(this.admin)
|
|
.setTargetFunctionRole(this.receiver, [this.restricted.selector], roleId);
|
|
await this.manager.connect(this.admin).grantRole(roleId, this.mock, delay);
|
|
});
|
|
|
|
it('cancels restricted with delay after queue (internal)', async function () {
|
|
this.proposal = await this.helper.setProposal([this.restricted.operation], 'descr');
|
|
|
|
await this.helper.propose();
|
|
await this.helper.waitForSnapshot();
|
|
await this.helper.connect(this.voter1).vote({ support: VoteType.For });
|
|
await this.helper.waitForDeadline();
|
|
await this.helper.queue();
|
|
|
|
await expect(this.helper.cancel('internal'))
|
|
.to.emit(this.mock, 'ProposalCanceled')
|
|
.withArgs(this.proposal.id)
|
|
.to.emit(this.manager, 'OperationCanceled')
|
|
.withArgs(this.restricted.id, 1n);
|
|
|
|
await this.helper.waitForEta();
|
|
|
|
await expect(this.helper.execute())
|
|
.to.be.revertedWithCustomError(this.mock, 'GovernorUnexpectedProposalState')
|
|
.withArgs(
|
|
this.proposal.id,
|
|
ProposalState.Canceled,
|
|
GovernorHelper.proposalStatesToBitMap([ProposalState.Succeeded, ProposalState.Queued]),
|
|
);
|
|
});
|
|
|
|
it('cancels restricted with queueing if the same operation is part of a more recent proposal (internal)', async function () {
|
|
// Set proposals
|
|
const original = new GovernorHelper(this.mock, mode);
|
|
await original.setProposal([this.restricted.operation], 'descr');
|
|
|
|
// Go through all the governance process
|
|
await original.propose();
|
|
await original.waitForSnapshot();
|
|
await original.connect(this.voter1).vote({ support: VoteType.For });
|
|
await original.waitForDeadline();
|
|
await original.queue();
|
|
|
|
// Cancel the operation in the manager
|
|
await this.manager
|
|
.connect(this.admin)
|
|
.cancel(this.mock, this.restricted.operation.target, this.restricted.operation.data);
|
|
|
|
// Another proposal is added with the same operation
|
|
const rescheduled = new GovernorHelper(this.mock, mode);
|
|
await rescheduled.setProposal([this.restricted.operation], 'another descr');
|
|
|
|
// Queue the new proposal
|
|
await rescheduled.propose();
|
|
await rescheduled.waitForSnapshot();
|
|
await rescheduled.connect(this.voter1).vote({ support: VoteType.For });
|
|
await rescheduled.waitForDeadline();
|
|
await rescheduled.queue(); // This will schedule it again in the manager
|
|
|
|
// Cancel
|
|
const eta = await this.mock.proposalEta(rescheduled.currentProposal.id);
|
|
|
|
await expect(original.cancel('internal'))
|
|
.to.emit(this.mock, 'ProposalCanceled')
|
|
.withArgs(original.currentProposal.id);
|
|
|
|
await time.clock.timestamp().then(clock => time.increaseTo.timestamp(max(clock + 1n, eta)));
|
|
|
|
await expect(original.execute())
|
|
.to.be.revertedWithCustomError(this.mock, 'GovernorUnexpectedProposalState')
|
|
.withArgs(
|
|
original.currentProposal.id,
|
|
ProposalState.Canceled,
|
|
GovernorHelper.proposalStatesToBitMap([ProposalState.Succeeded, ProposalState.Queued]),
|
|
);
|
|
});
|
|
|
|
it('cancels unrestricted with queueing (internal)', async function () {
|
|
this.proposal = await this.helper.setProposal([this.unrestricted.operation], 'descr');
|
|
|
|
await this.helper.propose();
|
|
await this.helper.waitForSnapshot();
|
|
await this.helper.connect(this.voter1).vote({ support: VoteType.For });
|
|
await this.helper.waitForDeadline();
|
|
await this.helper.queue();
|
|
|
|
const eta = await this.mock.proposalEta(this.proposal.id);
|
|
|
|
await expect(this.helper.cancel('internal'))
|
|
.to.emit(this.mock, 'ProposalCanceled')
|
|
.withArgs(this.proposal.id);
|
|
|
|
await time.clock.timestamp().then(clock => time.increaseTo.timestamp(max(clock + 1n, eta)));
|
|
|
|
await expect(this.helper.execute())
|
|
.to.be.revertedWithCustomError(this.mock, 'GovernorUnexpectedProposalState')
|
|
.withArgs(
|
|
this.proposal.id,
|
|
ProposalState.Canceled,
|
|
GovernorHelper.proposalStatesToBitMap([ProposalState.Succeeded, ProposalState.Queued]),
|
|
);
|
|
});
|
|
|
|
it('cancels unrestricted without queueing (internal)', async function () {
|
|
this.proposal = await this.helper.setProposal([this.unrestricted.operation], 'descr');
|
|
|
|
await this.helper.propose();
|
|
await this.helper.waitForSnapshot();
|
|
await this.helper.connect(this.voter1).vote({ support: VoteType.For });
|
|
await this.helper.waitForDeadline();
|
|
|
|
await expect(this.helper.cancel('internal'))
|
|
.to.emit(this.mock, 'ProposalCanceled')
|
|
.withArgs(this.proposal.id);
|
|
|
|
await expect(this.helper.execute())
|
|
.to.be.revertedWithCustomError(this.mock, 'GovernorUnexpectedProposalState')
|
|
.withArgs(
|
|
this.proposal.id,
|
|
ProposalState.Canceled,
|
|
GovernorHelper.proposalStatesToBitMap([ProposalState.Succeeded, ProposalState.Queued]),
|
|
);
|
|
});
|
|
|
|
it('cancels calls already canceled by guardian', async function () {
|
|
const operationA = { target: this.receiver.target, data: this.restricted.selector + '00' };
|
|
const operationB = { target: this.receiver.target, data: this.restricted.selector + '01' };
|
|
const operationC = { target: this.receiver.target, data: this.restricted.selector + '02' };
|
|
const operationAId = hashOperation(this.mock.target, operationA.target, operationA.data);
|
|
const operationBId = hashOperation(this.mock.target, operationB.target, operationB.data);
|
|
|
|
const proposal1 = new GovernorHelper(this.mock, mode);
|
|
const proposal2 = new GovernorHelper(this.mock, mode);
|
|
proposal1.setProposal([operationA, operationB], 'proposal A+B');
|
|
proposal2.setProposal([operationA, operationC], 'proposal A+C');
|
|
|
|
for (const p of [proposal1, proposal2]) {
|
|
await p.propose();
|
|
await p.waitForSnapshot();
|
|
await p.connect(this.voter1).vote({ support: VoteType.For });
|
|
await p.waitForDeadline();
|
|
}
|
|
|
|
// Can queue the first proposal
|
|
await proposal1.queue();
|
|
|
|
// Cannot queue the second proposal: operation A already scheduled with delay
|
|
await expect(proposal2.queue())
|
|
.to.be.revertedWithCustomError(this.manager, 'AccessManagerAlreadyScheduled')
|
|
.withArgs(operationAId);
|
|
|
|
// Admin cancels operation B on the manager
|
|
await this.manager.connect(this.admin).cancel(this.mock, operationB.target, operationB.data);
|
|
|
|
// Still cannot queue the second proposal: operation A already scheduled with delay
|
|
await expect(proposal2.queue())
|
|
.to.be.revertedWithCustomError(this.manager, 'AccessManagerAlreadyScheduled')
|
|
.withArgs(operationAId);
|
|
|
|
await proposal1.waitForEta();
|
|
|
|
// Cannot execute first proposal: operation B has been canceled
|
|
await expect(proposal1.execute())
|
|
.to.be.revertedWithCustomError(this.manager, 'AccessManagerNotScheduled')
|
|
.withArgs(operationBId);
|
|
|
|
// Cancel the first proposal to release operation A
|
|
await proposal1.cancel('internal');
|
|
|
|
// can finally queue the second proposal
|
|
await proposal2.queue();
|
|
|
|
await proposal2.waitForEta();
|
|
|
|
// Can execute second proposal
|
|
await proposal2.execute();
|
|
});
|
|
});
|
|
|
|
describe('ignore AccessManager', function () {
|
|
it('defaults', async function () {
|
|
expect(await this.mock.isAccessManagerIgnored(this.receiver, this.restricted.selector)).to.be.false;
|
|
expect(await this.mock.isAccessManagerIgnored(this.mock, '0x12341234')).to.be.true;
|
|
});
|
|
|
|
it('internal setter', async function () {
|
|
await expect(this.mock.$_setAccessManagerIgnored(this.receiver, this.restricted.selector, true))
|
|
.to.emit(this.mock, 'AccessManagerIgnoredSet')
|
|
.withArgs(this.receiver, this.restricted.selector, true);
|
|
|
|
expect(await this.mock.isAccessManagerIgnored(this.receiver, this.restricted.selector)).to.be.true;
|
|
|
|
await expect(this.mock.$_setAccessManagerIgnored(this.mock, '0x12341234', false))
|
|
.to.emit(this.mock, 'AccessManagerIgnoredSet')
|
|
.withArgs(this.mock, '0x12341234', false);
|
|
|
|
expect(await this.mock.isAccessManagerIgnored(this.mock, '0x12341234')).to.be.false;
|
|
});
|
|
|
|
it('external setter', async function () {
|
|
const setAccessManagerIgnored = (...args) =>
|
|
this.mock.interface.encodeFunctionData('setAccessManagerIgnored', args);
|
|
|
|
await this.helper.setProposal(
|
|
[
|
|
{
|
|
target: this.mock.target,
|
|
data: setAccessManagerIgnored(
|
|
this.receiver.target,
|
|
[this.restricted.selector, this.unrestricted.selector],
|
|
true,
|
|
),
|
|
},
|
|
{
|
|
target: this.mock.target,
|
|
data: setAccessManagerIgnored(this.mock.target, ['0x12341234', '0x67896789'], false),
|
|
},
|
|
],
|
|
'descr',
|
|
);
|
|
|
|
await this.helper.propose();
|
|
await this.helper.waitForSnapshot();
|
|
await this.helper.connect(this.voter1).vote({ support: VoteType.For });
|
|
await this.helper.waitForDeadline();
|
|
|
|
await expect(this.helper.execute()).to.emit(this.mock, 'AccessManagerIgnoredSet');
|
|
|
|
expect(await this.mock.isAccessManagerIgnored(this.receiver, this.restricted.selector)).to.be.true;
|
|
expect(await this.mock.isAccessManagerIgnored(this.receiver, this.unrestricted.selector)).to.be.true;
|
|
expect(await this.mock.isAccessManagerIgnored(this.mock, '0x12341234')).to.be.false;
|
|
expect(await this.mock.isAccessManagerIgnored(this.mock, '0x67896789')).to.be.false;
|
|
});
|
|
|
|
it('locked function', async function () {
|
|
const setAccessManagerIgnored = selector('setAccessManagerIgnored(address,bytes4[],bool)');
|
|
|
|
await expect(
|
|
this.mock.$_setAccessManagerIgnored(this.mock, setAccessManagerIgnored, true),
|
|
).to.be.revertedWithCustomError(this.mock, 'GovernorLockedIgnore');
|
|
|
|
await this.mock.$_setAccessManagerIgnored(this.receiver, setAccessManagerIgnored, true);
|
|
});
|
|
|
|
it('ignores access manager', async function () {
|
|
const amount = 100n;
|
|
const target = this.token.target;
|
|
const data = this.token.interface.encodeFunctionData('transfer', [this.voter4.address, amount]);
|
|
const selector = data.slice(0, 10);
|
|
await this.token.$_mint(this.mock, amount);
|
|
|
|
const roleId = 1n;
|
|
await this.manager.connect(this.admin).setTargetFunctionRole(target, [selector], roleId);
|
|
await this.manager.connect(this.admin).grantRole(roleId, this.mock, 0);
|
|
|
|
await this.helper.setProposal([{ target, data }], 'descr #1');
|
|
await this.helper.propose();
|
|
await this.helper.waitForSnapshot();
|
|
await this.helper.connect(this.voter1).vote({ support: VoteType.For });
|
|
await this.helper.waitForDeadline();
|
|
|
|
await expect(this.helper.execute())
|
|
.to.be.revertedWithCustomError(this.token, 'ERC20InsufficientBalance')
|
|
.withArgs(this.manager, 0n, amount);
|
|
|
|
await this.mock.$_setAccessManagerIgnored(target, selector, true);
|
|
|
|
await this.helper.setProposal([{ target, data }], 'descr #2');
|
|
await this.helper.propose();
|
|
await this.helper.waitForSnapshot();
|
|
await this.helper.connect(this.voter1).vote({ support: VoteType.For });
|
|
await this.helper.waitForDeadline();
|
|
|
|
await expect(this.helper.execute()).to.emit(this.token, 'Transfer').withArgs(this.mock, this.voter4, amount);
|
|
});
|
|
});
|
|
|
|
describe('operating on an Ownable contract', function () {
|
|
const method = selector('$_checkOwner()');
|
|
|
|
beforeEach(async function () {
|
|
this.ownable = await ethers.deployContract('$Ownable', [this.manager]);
|
|
this.operation = {
|
|
target: this.ownable.target,
|
|
data: this.ownable.interface.encodeFunctionData('$_checkOwner'),
|
|
};
|
|
});
|
|
|
|
it('succeeds with delay', async function () {
|
|
const roleId = 1n;
|
|
const executionDelay = time.duration.hours(2n);
|
|
const baseDelay = time.duration.hours(1n);
|
|
|
|
// Set execution delay
|
|
await this.manager.connect(this.admin).setTargetFunctionRole(this.ownable, [method], roleId);
|
|
await this.manager.connect(this.admin).grantRole(roleId, this.mock, executionDelay);
|
|
|
|
// Set base delay
|
|
await this.mock.$_setBaseDelaySeconds(baseDelay);
|
|
|
|
await this.helper.setProposal([this.operation], `descr`);
|
|
await this.helper.propose();
|
|
await this.helper.waitForSnapshot();
|
|
await this.helper.connect(this.voter1).vote({ support: VoteType.For });
|
|
await this.helper.waitForDeadline();
|
|
await this.helper.queue();
|
|
await this.helper.waitForEta();
|
|
await this.helper.execute(); // Don't revert
|
|
});
|
|
|
|
it('succeeds without delay', async function () {
|
|
const roleId = 1n;
|
|
const executionDelay = 0n;
|
|
const baseDelay = 0n;
|
|
|
|
// Set execution delay
|
|
await this.manager.connect(this.admin).setTargetFunctionRole(this.ownable, [method], roleId);
|
|
await this.manager.connect(this.admin).grantRole(roleId, this.mock, executionDelay);
|
|
|
|
// Set base delay
|
|
await this.mock.$_setBaseDelaySeconds(baseDelay);
|
|
|
|
await this.helper.setProposal([this.operation], `descr`);
|
|
await this.helper.propose();
|
|
await this.helper.waitForSnapshot();
|
|
await this.helper.connect(this.voter1).vote({ support: VoteType.For });
|
|
await this.helper.waitForDeadline();
|
|
await this.helper.execute(); // Don't revert
|
|
});
|
|
});
|
|
});
|
|
}
|
|
});
|
|
|