Migrate AccessManager tests to ethers (#4710)
Co-authored-by: Hadrien Croubois <hadrien.croubois@gmail.com>
This commit is contained in:
Ernesto García
GitHub
@ -52,7 +52,7 @@ contract AuthorityNoResponse {
|
||||
function canCall(address /* caller */, address /* target */, bytes4 /* selector */) external view {}
|
||||
}
|
||||
|
||||
contract AuthoritiyObserveIsConsuming {
|
||||
contract AuthorityObserveIsConsuming {
|
||||
event ConsumeScheduledOpCalled(address caller, bytes data, bytes4 isConsuming);
|
||||
|
||||
function canCall(
|
||||
|
||||
@ -13,6 +13,12 @@ describe('Ownable', function () {
|
||||
Object.assign(this, await loadFixture(fixture));
|
||||
});
|
||||
|
||||
it('emits ownership transfer events during construction', async function () {
|
||||
await expect(await this.ownable.deploymentTransaction())
|
||||
.to.emit(this.ownable, 'OwnershipTransferred')
|
||||
.withArgs(ethers.ZeroAddress, this.owner.address);
|
||||
});
|
||||
|
||||
it('rejects zero address for initialOwner', async function () {
|
||||
await expect(ethers.deployContract('$Ownable', [ethers.ZeroAddress]))
|
||||
.to.be.revertedWithCustomError({ interface: this.ownable.interface }, 'OwnableInvalidOwner')
|
||||
|
||||
@ -1,142 +1,145 @@
|
||||
const { expectEvent, time, expectRevert } = require('@openzeppelin/test-helpers');
|
||||
const { selector } = require('../../helpers/methods');
|
||||
const { expectRevertCustomError } = require('../../helpers/customError');
|
||||
const {
|
||||
time: { setNextBlockTimestamp },
|
||||
} = require('@nomicfoundation/hardhat-network-helpers');
|
||||
const { bigint: time } = require('../../helpers/time');
|
||||
const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
|
||||
const { impersonate } = require('../../helpers/account');
|
||||
const { ethers } = require('hardhat');
|
||||
|
||||
const AccessManaged = artifacts.require('$AccessManagedTarget');
|
||||
const AccessManager = artifacts.require('$AccessManager');
|
||||
async function fixture() {
|
||||
const [admin, roleMember, other] = await ethers.getSigners();
|
||||
|
||||
const AuthoritiyObserveIsConsuming = artifacts.require('$AuthoritiyObserveIsConsuming');
|
||||
const authority = await ethers.deployContract('$AccessManager', [admin]);
|
||||
const managed = await ethers.deployContract('$AccessManagedTarget', [authority]);
|
||||
|
||||
contract('AccessManaged', function (accounts) {
|
||||
const [admin, roleMember, other] = accounts;
|
||||
const anotherAuthority = await ethers.deployContract('$AccessManager', [admin]);
|
||||
const authorityObserveIsConsuming = await ethers.deployContract('$AuthorityObserveIsConsuming');
|
||||
|
||||
await impersonate(authority.target);
|
||||
const authorityAsSigner = await ethers.getSigner(authority.target);
|
||||
|
||||
return {
|
||||
roleMember,
|
||||
other,
|
||||
authorityAsSigner,
|
||||
authority,
|
||||
managed,
|
||||
authorityObserveIsConsuming,
|
||||
anotherAuthority,
|
||||
};
|
||||
}
|
||||
|
||||
describe('AccessManaged', function () {
|
||||
beforeEach(async function () {
|
||||
this.authority = await AccessManager.new(admin);
|
||||
this.managed = await AccessManaged.new(this.authority.address);
|
||||
Object.assign(this, await loadFixture(fixture));
|
||||
});
|
||||
|
||||
it('sets authority and emits AuthorityUpdated event during construction', async function () {
|
||||
await expectEvent.inConstruction(this.managed, 'AuthorityUpdated', {
|
||||
authority: this.authority.address,
|
||||
});
|
||||
expect(await this.managed.authority()).to.eq(this.authority.address);
|
||||
await expect(await this.managed.deploymentTransaction())
|
||||
.to.emit(this.managed, 'AuthorityUpdated')
|
||||
.withArgs(this.authority.target);
|
||||
});
|
||||
|
||||
describe('restricted modifier', function () {
|
||||
const method = 'fnRestricted()';
|
||||
|
||||
beforeEach(async function () {
|
||||
this.selector = selector(method);
|
||||
this.role = web3.utils.toBN(42);
|
||||
await this.authority.$_setTargetFunctionRole(this.managed.address, this.selector, this.role);
|
||||
await this.authority.$_grantRole(this.role, roleMember, 0, 0);
|
||||
this.selector = this.managed.fnRestricted.getFragment().selector;
|
||||
this.role = 42n;
|
||||
await this.authority.$_setTargetFunctionRole(this.managed, this.selector, this.role);
|
||||
await this.authority.$_grantRole(this.role, this.roleMember, 0, 0);
|
||||
});
|
||||
|
||||
it('succeeds when role is granted without execution delay', async function () {
|
||||
await this.managed.methods[method]({ from: roleMember });
|
||||
await this.managed.connect(this.roleMember)[this.selector]();
|
||||
});
|
||||
|
||||
it('reverts when role is not granted', async function () {
|
||||
await expectRevertCustomError(this.managed.methods[method]({ from: other }), 'AccessManagedUnauthorized', [
|
||||
other,
|
||||
]);
|
||||
await expect(this.managed.connect(this.other)[this.selector]())
|
||||
.to.be.revertedWithCustomError(this.managed, 'AccessManagedUnauthorized')
|
||||
.withArgs(this.other.address);
|
||||
});
|
||||
|
||||
it('panics in short calldata', async function () {
|
||||
// We avoid adding the `restricted` modifier to the fallback function because other tests may depend on it
|
||||
// being accessible without restrictions. We check for the internal `_checkCanCall` instead.
|
||||
await expectRevert.unspecified(this.managed.$_checkCanCall(other, '0x1234'));
|
||||
await expect(this.managed.$_checkCanCall(this.roleMember, '0x1234')).to.be.reverted;
|
||||
});
|
||||
|
||||
describe('when role is granted with execution delay', function () {
|
||||
beforeEach(async function () {
|
||||
const executionDelay = web3.utils.toBN(911);
|
||||
await this.authority.$_grantRole(this.role, roleMember, 0, executionDelay);
|
||||
const executionDelay = 911n;
|
||||
await this.authority.$_grantRole(this.role, this.roleMember, 0, executionDelay);
|
||||
});
|
||||
|
||||
it('reverts if the operation is not scheduled', async function () {
|
||||
const calldata = this.managed.contract.methods[method]().encodeABI();
|
||||
const opId = await this.authority.hashOperation(roleMember, this.managed.address, calldata);
|
||||
const fn = this.managed.interface.getFunction(this.selector);
|
||||
const calldata = this.managed.interface.encodeFunctionData(fn, []);
|
||||
const opId = await this.authority.hashOperation(this.roleMember, this.managed, calldata);
|
||||
|
||||
await expectRevertCustomError(this.managed.methods[method]({ from: roleMember }), 'AccessManagerNotScheduled', [
|
||||
opId,
|
||||
]);
|
||||
await expect(this.managed.connect(this.roleMember)[this.selector]())
|
||||
.to.be.revertedWithCustomError(this.authority, 'AccessManagerNotScheduled')
|
||||
.withArgs(opId);
|
||||
});
|
||||
|
||||
it('succeeds if the operation is scheduled', async function () {
|
||||
// Arguments
|
||||
const delay = time.duration.hours(12);
|
||||
const calldata = this.managed.contract.methods[method]().encodeABI();
|
||||
const fn = this.managed.interface.getFunction(this.selector);
|
||||
const calldata = this.managed.interface.encodeFunctionData(fn, []);
|
||||
|
||||
// Schedule
|
||||
const timestamp = await time.latest();
|
||||
const scheduledAt = timestamp.addn(1);
|
||||
const when = scheduledAt.add(delay);
|
||||
await setNextBlockTimestamp(scheduledAt);
|
||||
await this.authority.schedule(this.managed.address, calldata, when, {
|
||||
from: roleMember,
|
||||
});
|
||||
const timestamp = await time.clock.timestamp();
|
||||
const scheduledAt = timestamp + 1n;
|
||||
const when = scheduledAt + delay;
|
||||
await time.forward.timestamp(scheduledAt, false);
|
||||
await this.authority.connect(this.roleMember).schedule(this.managed, calldata, when);
|
||||
|
||||
// Set execution date
|
||||
await setNextBlockTimestamp(when);
|
||||
await time.forward.timestamp(when, false);
|
||||
|
||||
// Shouldn't revert
|
||||
await this.managed.methods[method]({ from: roleMember });
|
||||
await this.managed.connect(this.roleMember)[this.selector]();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('setAuthority', function () {
|
||||
beforeEach(async function () {
|
||||
this.newAuthority = await AccessManager.new(admin);
|
||||
});
|
||||
|
||||
it('reverts if the caller is not the authority', async function () {
|
||||
await expectRevertCustomError(this.managed.setAuthority(other, { from: other }), 'AccessManagedUnauthorized', [
|
||||
other,
|
||||
]);
|
||||
await expect(this.managed.connect(this.other).setAuthority(this.other))
|
||||
.to.be.revertedWithCustomError(this.managed, 'AccessManagedUnauthorized')
|
||||
.withArgs(this.other.address);
|
||||
});
|
||||
|
||||
it('reverts if the new authority is not a valid authority', async function () {
|
||||
await impersonate(this.authority.address);
|
||||
await expectRevertCustomError(
|
||||
this.managed.setAuthority(other, { from: this.authority.address }),
|
||||
'AccessManagedInvalidAuthority',
|
||||
[other],
|
||||
);
|
||||
await expect(this.managed.connect(this.authorityAsSigner).setAuthority(this.other))
|
||||
.to.be.revertedWithCustomError(this.managed, 'AccessManagedInvalidAuthority')
|
||||
.withArgs(this.other.address);
|
||||
});
|
||||
|
||||
it('sets authority and emits AuthorityUpdated event', async function () {
|
||||
await impersonate(this.authority.address);
|
||||
const { receipt } = await this.managed.setAuthority(this.newAuthority.address, { from: this.authority.address });
|
||||
await expectEvent(receipt, 'AuthorityUpdated', {
|
||||
authority: this.newAuthority.address,
|
||||
});
|
||||
expect(await this.managed.authority()).to.eq(this.newAuthority.address);
|
||||
await expect(this.managed.connect(this.authorityAsSigner).setAuthority(this.anotherAuthority))
|
||||
.to.emit(this.managed, 'AuthorityUpdated')
|
||||
.withArgs(this.anotherAuthority.target);
|
||||
|
||||
expect(await this.managed.authority()).to.equal(this.anotherAuthority.target);
|
||||
});
|
||||
});
|
||||
|
||||
describe('isConsumingScheduledOp', function () {
|
||||
beforeEach(async function () {
|
||||
this.authority = await AuthoritiyObserveIsConsuming.new();
|
||||
this.managed = await AccessManaged.new(this.authority.address);
|
||||
await this.managed.connect(this.authorityAsSigner).setAuthority(this.authorityObserveIsConsuming);
|
||||
});
|
||||
|
||||
it('returns bytes4(0) when not consuming operation', async function () {
|
||||
expect(await this.managed.isConsumingScheduledOp()).to.eq('0x00000000');
|
||||
expect(await this.managed.isConsumingScheduledOp()).to.equal('0x00000000');
|
||||
});
|
||||
|
||||
it('returns isConsumingScheduledOp selector when consuming operation', async function () {
|
||||
const receipt = await this.managed.fnRestricted({ from: other });
|
||||
await expectEvent.inTransaction(receipt.tx, this.authority, 'ConsumeScheduledOpCalled', {
|
||||
caller: other,
|
||||
data: this.managed.contract.methods.fnRestricted().encodeABI(),
|
||||
isConsuming: selector('isConsumingScheduledOp()'),
|
||||
});
|
||||
const isConsumingScheduledOp = this.managed.interface.getFunction('isConsumingScheduledOp()');
|
||||
const fnRestricted = this.managed.fnRestricted.getFragment();
|
||||
await expect(this.managed.connect(this.other).fnRestricted())
|
||||
.to.emit(this.authorityObserveIsConsuming, 'ConsumeScheduledOpCalled')
|
||||
.withArgs(
|
||||
this.other.address,
|
||||
this.managed.interface.encodeFunctionData(fnRestricted, []),
|
||||
isConsumingScheduledOp.selector,
|
||||
);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
@ -1,5 +1,3 @@
|
||||
const { mine } = require('@nomicfoundation/hardhat-network-helpers');
|
||||
const { expectRevertCustomError } = require('../../helpers/customError');
|
||||
const {
|
||||
LIKE_COMMON_IS_EXECUTING,
|
||||
LIKE_COMMON_GET_ACCESS,
|
||||
@ -18,13 +16,9 @@ const {
|
||||
*/
|
||||
function shouldBehaveLikeDelayedAdminOperation() {
|
||||
const getAccessPath = LIKE_COMMON_GET_ACCESS;
|
||||
getAccessPath.requiredRoleIsGranted.roleGrantingIsDelayed.callerHasAnExecutionDelay.afterGrantDelay = function () {
|
||||
beforeEach('consume previously set grant delay', async function () {
|
||||
// Consume previously set delay
|
||||
await mine();
|
||||
});
|
||||
testAsDelayedOperation();
|
||||
};
|
||||
testAsDelayedOperation.mineDelay = true;
|
||||
getAccessPath.requiredRoleIsGranted.roleGrantingIsDelayed.callerHasAnExecutionDelay.afterGrantDelay =
|
||||
testAsDelayedOperation;
|
||||
getAccessPath.requiredRoleIsGranted.roleGrantingIsNotDelayed.callerHasAnExecutionDelay = function () {
|
||||
beforeEach('set execution delay', async function () {
|
||||
this.scheduleIn = this.executionDelay; // For testAsDelayedOperation
|
||||
@ -42,14 +36,12 @@ function shouldBehaveLikeDelayedAdminOperation() {
|
||||
testAsHasRole({
|
||||
publicRoleIsRequired() {
|
||||
it('reverts as AccessManagerUnauthorizedAccount', async function () {
|
||||
await expectRevertCustomError(
|
||||
web3.eth.sendTransaction({ to: this.target.address, data: this.calldata, from: this.caller }),
|
||||
'AccessManagerUnauthorizedAccount',
|
||||
[
|
||||
this.caller,
|
||||
await expect(this.caller.sendTransaction({ to: this.target, data: this.calldata }))
|
||||
.to.be.revertedWithCustomError(this.target, 'AccessManagerUnauthorizedAccount')
|
||||
.withArgs(
|
||||
this.caller.address,
|
||||
this.roles.ADMIN.id, // Although PUBLIC is required, target function role doesn't apply to admin ops
|
||||
],
|
||||
);
|
||||
);
|
||||
});
|
||||
},
|
||||
specificRoleIsRequired: getAccessPath,
|
||||
@ -63,19 +55,20 @@ function shouldBehaveLikeDelayedAdminOperation() {
|
||||
*/
|
||||
function shouldBehaveLikeNotDelayedAdminOperation() {
|
||||
const getAccessPath = LIKE_COMMON_GET_ACCESS;
|
||||
getAccessPath.requiredRoleIsGranted.roleGrantingIsDelayed.callerHasAnExecutionDelay.afterGrantDelay = function () {
|
||||
beforeEach('set execution delay', async function () {
|
||||
await mine();
|
||||
this.scheduleIn = this.executionDelay; // For testAsSchedulableOperation
|
||||
});
|
||||
testAsSchedulableOperation(LIKE_COMMON_SCHEDULABLE);
|
||||
};
|
||||
getAccessPath.requiredRoleIsGranted.roleGrantingIsNotDelayed.callerHasAnExecutionDelay = function () {
|
||||
beforeEach('set execution delay', async function () {
|
||||
this.scheduleIn = this.executionDelay; // For testAsSchedulableOperation
|
||||
});
|
||||
testAsSchedulableOperation(LIKE_COMMON_SCHEDULABLE);
|
||||
};
|
||||
|
||||
function testScheduleOperation(mineDelay) {
|
||||
return function self() {
|
||||
self.mineDelay = mineDelay;
|
||||
beforeEach('set execution delay', async function () {
|
||||
this.scheduleIn = this.executionDelay; // For testAsSchedulableOperation
|
||||
});
|
||||
testAsSchedulableOperation(LIKE_COMMON_SCHEDULABLE);
|
||||
};
|
||||
}
|
||||
|
||||
getAccessPath.requiredRoleIsGranted.roleGrantingIsDelayed.callerHasAnExecutionDelay.afterGrantDelay =
|
||||
testScheduleOperation(true);
|
||||
getAccessPath.requiredRoleIsGranted.roleGrantingIsNotDelayed.callerHasAnExecutionDelay = testScheduleOperation(false);
|
||||
|
||||
beforeEach('set target as manager', function () {
|
||||
this.target = this.manager;
|
||||
@ -87,11 +80,12 @@ function shouldBehaveLikeNotDelayedAdminOperation() {
|
||||
testAsHasRole({
|
||||
publicRoleIsRequired() {
|
||||
it('reverts as AccessManagerUnauthorizedAccount', async function () {
|
||||
await expectRevertCustomError(
|
||||
web3.eth.sendTransaction({ to: this.target.address, data: this.calldata, from: this.caller }),
|
||||
'AccessManagerUnauthorizedAccount',
|
||||
[this.caller, this.roles.ADMIN.id], // Although PUBLIC_ROLE is required, admin ops are not subject to target function roles
|
||||
);
|
||||
await expect(this.caller.sendTransaction({ to: this.target, data: this.calldata }))
|
||||
.to.be.revertedWithCustomError(this.target, 'AccessManagerUnauthorizedAccount')
|
||||
.withArgs(
|
||||
this.caller.address,
|
||||
this.roles.ADMIN.id, // Although PUBLIC_ROLE is required, admin ops are not subject to target function roles
|
||||
);
|
||||
});
|
||||
},
|
||||
specificRoleIsRequired: getAccessPath,
|
||||
@ -105,19 +99,17 @@ function shouldBehaveLikeNotDelayedAdminOperation() {
|
||||
*/
|
||||
function shouldBehaveLikeRoleAdminOperation(roleAdmin) {
|
||||
const getAccessPath = LIKE_COMMON_GET_ACCESS;
|
||||
getAccessPath.requiredRoleIsGranted.roleGrantingIsDelayed.callerHasAnExecutionDelay.afterGrantDelay = function () {
|
||||
beforeEach('set operation delay', async function () {
|
||||
await mine();
|
||||
this.scheduleIn = this.executionDelay; // For testAsSchedulableOperation
|
||||
});
|
||||
testAsSchedulableOperation(LIKE_COMMON_SCHEDULABLE);
|
||||
};
|
||||
getAccessPath.requiredRoleIsGranted.roleGrantingIsNotDelayed.callerHasAnExecutionDelay = function () {
|
||||
|
||||
function afterGrantDelay() {
|
||||
afterGrantDelay.mineDelay = true;
|
||||
beforeEach('set execution delay', async function () {
|
||||
this.scheduleIn = this.executionDelay; // For testAsSchedulableOperation
|
||||
});
|
||||
testAsSchedulableOperation(LIKE_COMMON_SCHEDULABLE);
|
||||
};
|
||||
}
|
||||
|
||||
getAccessPath.requiredRoleIsGranted.roleGrantingIsDelayed.callerHasAnExecutionDelay.afterGrantDelay = afterGrantDelay;
|
||||
getAccessPath.requiredRoleIsGranted.roleGrantingIsNotDelayed.callerHasAnExecutionDelay = afterGrantDelay;
|
||||
|
||||
beforeEach('set target as manager', function () {
|
||||
this.target = this.manager;
|
||||
@ -129,11 +121,9 @@ function shouldBehaveLikeRoleAdminOperation(roleAdmin) {
|
||||
testAsHasRole({
|
||||
publicRoleIsRequired() {
|
||||
it('reverts as AccessManagerUnauthorizedAccount', async function () {
|
||||
await expectRevertCustomError(
|
||||
web3.eth.sendTransaction({ to: this.target.address, data: this.calldata, from: this.caller }),
|
||||
'AccessManagerUnauthorizedAccount',
|
||||
[this.caller, roleAdmin], // Role admin ops require the role's admin
|
||||
);
|
||||
await expect(this.caller.sendTransaction({ to: this.target, data: this.calldata }))
|
||||
.to.be.revertedWithCustomError(this.target, 'AccessManagerUnauthorizedAccount')
|
||||
.withArgs(this.caller.address, roleAdmin);
|
||||
});
|
||||
},
|
||||
specificRoleIsRequired: getAccessPath,
|
||||
@ -150,11 +140,9 @@ function shouldBehaveLikeRoleAdminOperation(roleAdmin) {
|
||||
function shouldBehaveLikeAManagedRestrictedOperation() {
|
||||
function revertUnauthorized() {
|
||||
it('reverts as AccessManagedUnauthorized', async function () {
|
||||
await expectRevertCustomError(
|
||||
web3.eth.sendTransaction({ to: this.target.address, data: this.calldata, from: this.caller }),
|
||||
'AccessManagedUnauthorized',
|
||||
[this.caller],
|
||||
);
|
||||
await expect(this.caller.sendTransaction({ to: this.target, data: this.calldata }))
|
||||
.to.be.revertedWithCustomError(this.target, 'AccessManagedUnauthorized')
|
||||
.withArgs(this.caller.address);
|
||||
});
|
||||
}
|
||||
|
||||
@ -166,20 +154,19 @@ function shouldBehaveLikeAManagedRestrictedOperation() {
|
||||
revertUnauthorized;
|
||||
getAccessPath.requiredRoleIsNotGranted = revertUnauthorized;
|
||||
|
||||
getAccessPath.requiredRoleIsGranted.roleGrantingIsDelayed.callerHasAnExecutionDelay.afterGrantDelay = function () {
|
||||
beforeEach('consume previously set grant delay', async function () {
|
||||
// Consume previously set delay
|
||||
await mine();
|
||||
this.scheduleIn = this.executionDelay; // For testAsSchedulableOperation
|
||||
});
|
||||
testAsSchedulableOperation(LIKE_COMMON_SCHEDULABLE);
|
||||
};
|
||||
getAccessPath.requiredRoleIsGranted.roleGrantingIsNotDelayed.callerHasAnExecutionDelay = function () {
|
||||
beforeEach('consume previously set grant delay', async function () {
|
||||
this.scheduleIn = this.executionDelay; // For testAsSchedulableOperation
|
||||
});
|
||||
testAsSchedulableOperation(LIKE_COMMON_SCHEDULABLE);
|
||||
};
|
||||
function testScheduleOperation(mineDelay) {
|
||||
return function self() {
|
||||
self.mineDelay = mineDelay;
|
||||
beforeEach('sets execution delay', async function () {
|
||||
this.scheduleIn = this.executionDelay; // For testAsSchedulableOperation
|
||||
});
|
||||
testAsSchedulableOperation(LIKE_COMMON_SCHEDULABLE);
|
||||
};
|
||||
}
|
||||
|
||||
getAccessPath.requiredRoleIsGranted.roleGrantingIsDelayed.callerHasAnExecutionDelay.afterGrantDelay =
|
||||
testScheduleOperation(true);
|
||||
getAccessPath.requiredRoleIsGranted.roleGrantingIsNotDelayed.callerHasAnExecutionDelay = testScheduleOperation(false);
|
||||
|
||||
const isExecutingPath = LIKE_COMMON_IS_EXECUTING;
|
||||
isExecutingPath.notExecuting = revertUnauthorized;
|
||||
@ -191,11 +178,11 @@ function shouldBehaveLikeAManagedRestrictedOperation() {
|
||||
callerIsNotTheManager: {
|
||||
publicRoleIsRequired() {
|
||||
it('succeeds called directly', async function () {
|
||||
await web3.eth.sendTransaction({ to: this.target.address, data: this.calldata, from: this.caller });
|
||||
await this.caller.sendTransaction({ to: this.target, data: this.calldata });
|
||||
});
|
||||
|
||||
it('succeeds via execute', async function () {
|
||||
await this.manager.execute(this.target.address, this.calldata, { from: this.caller });
|
||||
await this.manager.connect(this.caller).execute(this.target, this.calldata);
|
||||
});
|
||||
},
|
||||
specificRoleIsRequired: getAccessPath,
|
||||
|
||||
@ -1,27 +1,22 @@
|
||||
const { setStorageAt } = require('@nomicfoundation/hardhat-network-helpers');
|
||||
const {
|
||||
time: { setNextBlockTimestamp },
|
||||
} = require('@nomicfoundation/hardhat-network-helpers');
|
||||
const { time } = require('@openzeppelin/test-helpers');
|
||||
const { EXECUTION_ID_STORAGE_SLOT, EXPIRATION, scheduleOperation } = require('../../helpers/access-manager');
|
||||
const { EXECUTION_ID_STORAGE_SLOT, EXPIRATION, prepareOperation } = require('../../helpers/access-manager');
|
||||
const { impersonate } = require('../../helpers/account');
|
||||
const { expectRevertCustomError } = require('../../helpers/customError');
|
||||
const { bigint: time } = require('../../helpers/time');
|
||||
const { ethers } = require('hardhat');
|
||||
|
||||
// ============ COMMON PREDICATES ============
|
||||
|
||||
const LIKE_COMMON_IS_EXECUTING = {
|
||||
executing() {
|
||||
it('succeeds', async function () {
|
||||
await web3.eth.sendTransaction({ to: this.target.address, data: this.calldata, from: this.caller });
|
||||
await this.caller.sendTransaction({ to: this.target, data: this.calldata });
|
||||
});
|
||||
},
|
||||
notExecuting() {
|
||||
it('reverts as AccessManagerUnauthorizedAccount', async function () {
|
||||
await expectRevertCustomError(
|
||||
web3.eth.sendTransaction({ to: this.target.address, data: this.calldata, from: this.caller }),
|
||||
'AccessManagerUnauthorizedAccount',
|
||||
[this.caller, this.role.id],
|
||||
);
|
||||
await expect(this.caller.sendTransaction({ to: this.target, data: this.calldata }))
|
||||
.to.be.revertedWithCustomError(this.manager, 'AccessManagerUnauthorizedAccount')
|
||||
.withArgs(this.caller.address, this.role.id);
|
||||
});
|
||||
},
|
||||
};
|
||||
@ -32,11 +27,9 @@ const LIKE_COMMON_GET_ACCESS = {
|
||||
callerHasAnExecutionDelay: {
|
||||
beforeGrantDelay() {
|
||||
it('reverts as AccessManagerUnauthorizedAccount', async function () {
|
||||
await expectRevertCustomError(
|
||||
web3.eth.sendTransaction({ to: this.target.address, data: this.calldata, from: this.caller }),
|
||||
'AccessManagerUnauthorizedAccount',
|
||||
[this.caller, this.role.id],
|
||||
);
|
||||
await expect(this.caller.sendTransaction({ to: this.target, data: this.calldata }))
|
||||
.to.be.revertedWithCustomError(this.manager, 'AccessManagerUnauthorizedAccount')
|
||||
.withArgs(this.caller.address, this.role.id);
|
||||
});
|
||||
},
|
||||
afterGrantDelay: undefined, // Diverges if there's an operation delay or not
|
||||
@ -44,20 +37,18 @@ const LIKE_COMMON_GET_ACCESS = {
|
||||
callerHasNoExecutionDelay: {
|
||||
beforeGrantDelay() {
|
||||
it('reverts as AccessManagerUnauthorizedAccount', async function () {
|
||||
await expectRevertCustomError(
|
||||
web3.eth.sendTransaction({ to: this.target.address, data: this.calldata, from: this.caller }),
|
||||
'AccessManagerUnauthorizedAccount',
|
||||
[this.caller, this.role.id],
|
||||
);
|
||||
await expect(this.caller.sendTransaction({ to: this.target, data: this.calldata }))
|
||||
.to.be.revertedWithCustomError(this.manager, 'AccessManagerUnauthorizedAccount')
|
||||
.withArgs(this.caller.address, this.role.id);
|
||||
});
|
||||
},
|
||||
afterGrantDelay() {
|
||||
it('succeeds called directly', async function () {
|
||||
await web3.eth.sendTransaction({ to: this.target.address, data: this.calldata, from: this.caller });
|
||||
await this.caller.sendTransaction({ to: this.target, data: this.calldata });
|
||||
});
|
||||
|
||||
it('succeeds via execute', async function () {
|
||||
await this.manager.execute(this.target.address, this.calldata, { from: this.caller });
|
||||
await this.manager.connect(this.caller).execute(this.target, this.calldata);
|
||||
});
|
||||
},
|
||||
},
|
||||
@ -66,22 +57,20 @@ const LIKE_COMMON_GET_ACCESS = {
|
||||
callerHasAnExecutionDelay: undefined, // Diverges if there's an operation to schedule or not
|
||||
callerHasNoExecutionDelay() {
|
||||
it('succeeds called directly', async function () {
|
||||
await web3.eth.sendTransaction({ to: this.target.address, data: this.calldata, from: this.caller });
|
||||
await this.caller.sendTransaction({ to: this.target, data: this.calldata });
|
||||
});
|
||||
|
||||
it('succeeds via execute', async function () {
|
||||
await this.manager.execute(this.target.address, this.calldata, { from: this.caller });
|
||||
await this.manager.connect(this.caller).execute(this.target, this.calldata);
|
||||
});
|
||||
},
|
||||
},
|
||||
},
|
||||
requiredRoleIsNotGranted() {
|
||||
it('reverts as AccessManagerUnauthorizedAccount', async function () {
|
||||
await expectRevertCustomError(
|
||||
web3.eth.sendTransaction({ to: this.target.address, data: this.calldata, from: this.caller }),
|
||||
'AccessManagerUnauthorizedAccount',
|
||||
[this.caller, this.role.id],
|
||||
);
|
||||
await expect(this.caller.sendTransaction({ to: this.target, data: this.calldata }))
|
||||
.to.be.revertedWithCustomError(this.manager, 'AccessManagerUnauthorizedAccount')
|
||||
.withArgs(this.caller.address, this.role.id);
|
||||
});
|
||||
},
|
||||
};
|
||||
@ -90,39 +79,33 @@ const LIKE_COMMON_SCHEDULABLE = {
|
||||
scheduled: {
|
||||
before() {
|
||||
it('reverts as AccessManagerNotReady', async function () {
|
||||
await expectRevertCustomError(
|
||||
web3.eth.sendTransaction({ to: this.target.address, data: this.calldata, from: this.caller }),
|
||||
'AccessManagerNotReady',
|
||||
[this.operationId],
|
||||
);
|
||||
await expect(this.caller.sendTransaction({ to: this.target, data: this.calldata }))
|
||||
.to.be.revertedWithCustomError(this.manager, 'AccessManagerNotReady')
|
||||
.withArgs(this.operationId);
|
||||
});
|
||||
},
|
||||
after() {
|
||||
it('succeeds called directly', async function () {
|
||||
await web3.eth.sendTransaction({ to: this.target.address, data: this.calldata, from: this.caller });
|
||||
await this.caller.sendTransaction({ to: this.target, data: this.calldata });
|
||||
});
|
||||
|
||||
it('succeeds via execute', async function () {
|
||||
await this.manager.execute(this.target.address, this.calldata, { from: this.caller });
|
||||
await this.manager.connect(this.caller).execute(this.target, this.calldata);
|
||||
});
|
||||
},
|
||||
expired() {
|
||||
it('reverts as AccessManagerExpired', async function () {
|
||||
await expectRevertCustomError(
|
||||
web3.eth.sendTransaction({ to: this.target.address, data: this.calldata, from: this.caller }),
|
||||
'AccessManagerExpired',
|
||||
[this.operationId],
|
||||
);
|
||||
await expect(this.caller.sendTransaction({ to: this.target, data: this.calldata }))
|
||||
.to.be.revertedWithCustomError(this.manager, 'AccessManagerExpired')
|
||||
.withArgs(this.operationId);
|
||||
});
|
||||
},
|
||||
},
|
||||
notScheduled() {
|
||||
it('reverts as AccessManagerNotScheduled', async function () {
|
||||
await expectRevertCustomError(
|
||||
web3.eth.sendTransaction({ to: this.target.address, data: this.calldata, from: this.caller }),
|
||||
'AccessManagerNotScheduled',
|
||||
[this.operationId],
|
||||
);
|
||||
await expect(this.caller.sendTransaction({ to: this.target, data: this.calldata }))
|
||||
.to.be.revertedWithCustomError(this.manager, 'AccessManagerNotScheduled')
|
||||
.withArgs(this.operationId);
|
||||
});
|
||||
},
|
||||
};
|
||||
@ -135,7 +118,7 @@ const LIKE_COMMON_SCHEDULABLE = {
|
||||
function testAsClosable({ closed, open }) {
|
||||
describe('when the manager is closed', function () {
|
||||
beforeEach('close', async function () {
|
||||
await this.manager.$_setTargetClosed(this.target.address, true);
|
||||
await this.manager.$_setTargetClosed(this.target, true);
|
||||
});
|
||||
|
||||
closed();
|
||||
@ -143,7 +126,7 @@ function testAsClosable({ closed, open }) {
|
||||
|
||||
describe('when the manager is open', function () {
|
||||
beforeEach('open', async function () {
|
||||
await this.manager.$_setTargetClosed(this.target.address, false);
|
||||
await this.manager.$_setTargetClosed(this.target, false);
|
||||
});
|
||||
|
||||
open();
|
||||
@ -157,13 +140,13 @@ function testAsClosable({ closed, open }) {
|
||||
*/
|
||||
function testAsDelay(type, { before, after }) {
|
||||
beforeEach('define timestamp when delay takes effect', async function () {
|
||||
const timestamp = await time.latest();
|
||||
this.delayEffect = timestamp.add(this.delay);
|
||||
const timestamp = await time.clock.timestamp();
|
||||
this.delayEffect = timestamp + this.delay;
|
||||
});
|
||||
|
||||
describe(`when ${type} delay has not taken effect yet`, function () {
|
||||
beforeEach(`set next block timestamp before ${type} takes effect`, async function () {
|
||||
await setNextBlockTimestamp(this.delayEffect.subn(1));
|
||||
await time.forward.timestamp(this.delayEffect - 1n, !!before.mineDelay);
|
||||
});
|
||||
|
||||
before();
|
||||
@ -171,7 +154,7 @@ function testAsDelay(type, { before, after }) {
|
||||
|
||||
describe(`when ${type} delay has taken effect`, function () {
|
||||
beforeEach(`set next block timestamp when ${type} takes effect`, async function () {
|
||||
await setNextBlockTimestamp(this.delayEffect);
|
||||
await time.forward.timestamp(this.delayEffect, !!after.mineDelay);
|
||||
});
|
||||
|
||||
after();
|
||||
@ -186,21 +169,25 @@ function testAsDelay(type, { before, after }) {
|
||||
function testAsSchedulableOperation({ scheduled: { before, after, expired }, notScheduled }) {
|
||||
describe('when operation is scheduled', function () {
|
||||
beforeEach('schedule operation', async function () {
|
||||
await impersonate(this.caller); // May be a contract
|
||||
const { operationId } = await scheduleOperation(this.manager, {
|
||||
if (this.caller.target) {
|
||||
await impersonate(this.caller.target);
|
||||
this.caller = await ethers.getSigner(this.caller.target);
|
||||
}
|
||||
const { operationId, schedule } = await prepareOperation(this.manager, {
|
||||
caller: this.caller,
|
||||
target: this.target.address,
|
||||
target: this.target,
|
||||
calldata: this.calldata,
|
||||
delay: this.scheduleIn,
|
||||
});
|
||||
await schedule();
|
||||
this.operationId = operationId;
|
||||
});
|
||||
|
||||
describe('when operation is not ready for execution', function () {
|
||||
beforeEach('set next block time before operation is ready', async function () {
|
||||
this.scheduledAt = await time.latest();
|
||||
this.scheduledAt = await time.clock.timestamp();
|
||||
const schedule = await this.manager.getSchedule(this.operationId);
|
||||
await setNextBlockTimestamp(schedule.subn(1));
|
||||
await time.forward.timestamp(schedule - 1n, !!before.mineDelay);
|
||||
});
|
||||
|
||||
before();
|
||||
@ -208,9 +195,9 @@ function testAsSchedulableOperation({ scheduled: { before, after, expired }, not
|
||||
|
||||
describe('when operation is ready for execution', function () {
|
||||
beforeEach('set next block time when operation is ready for execution', async function () {
|
||||
this.scheduledAt = await time.latest();
|
||||
this.scheduledAt = await time.clock.timestamp();
|
||||
const schedule = await this.manager.getSchedule(this.operationId);
|
||||
await setNextBlockTimestamp(schedule);
|
||||
await time.forward.timestamp(schedule, !!after.mineDelay);
|
||||
});
|
||||
|
||||
after();
|
||||
@ -218,9 +205,9 @@ function testAsSchedulableOperation({ scheduled: { before, after, expired }, not
|
||||
|
||||
describe('when operation has expired', function () {
|
||||
beforeEach('set next block time when operation expired', async function () {
|
||||
this.scheduledAt = await time.latest();
|
||||
this.scheduledAt = await time.clock.timestamp();
|
||||
const schedule = await this.manager.getSchedule(this.operationId);
|
||||
await setNextBlockTimestamp(schedule.add(EXPIRATION));
|
||||
await time.forward.timestamp(schedule + EXPIRATION, !!expired.mineDelay);
|
||||
});
|
||||
|
||||
expired();
|
||||
@ -229,10 +216,10 @@ function testAsSchedulableOperation({ scheduled: { before, after, expired }, not
|
||||
|
||||
describe('when operation is not scheduled', function () {
|
||||
beforeEach('set expected operationId', async function () {
|
||||
this.operationId = await this.manager.hashOperation(this.caller, this.target.address, this.calldata);
|
||||
this.operationId = await this.manager.hashOperation(this.caller, this.target, this.calldata);
|
||||
|
||||
// Assert operation is not scheduled
|
||||
expect(await this.manager.getSchedule(this.operationId)).to.be.bignumber.equal(web3.utils.toBN(0));
|
||||
expect(await this.manager.getSchedule(this.operationId)).to.equal(0n);
|
||||
});
|
||||
|
||||
notScheduled();
|
||||
@ -245,16 +232,22 @@ function testAsSchedulableOperation({ scheduled: { before, after, expired }, not
|
||||
function testAsRestrictedOperation({ callerIsTheManager: { executing, notExecuting }, callerIsNotTheManager }) {
|
||||
describe('when the call comes from the manager (msg.sender == manager)', function () {
|
||||
beforeEach('define caller as manager', async function () {
|
||||
this.caller = this.manager.address;
|
||||
await impersonate(this.caller);
|
||||
this.caller = this.manager;
|
||||
if (this.caller.target) {
|
||||
await impersonate(this.caller.target);
|
||||
this.caller = await ethers.getSigner(this.caller.target);
|
||||
}
|
||||
});
|
||||
|
||||
describe('when _executionId is in storage for target and selector', function () {
|
||||
beforeEach('set _executionId flag from calldata and target', async function () {
|
||||
const executionId = web3.utils.keccak256(
|
||||
web3.eth.abi.encodeParameters(['address', 'bytes4'], [this.target.address, this.calldata.substring(0, 10)]),
|
||||
const executionId = ethers.keccak256(
|
||||
ethers.AbiCoder.defaultAbiCoder().encode(
|
||||
['address', 'bytes4'],
|
||||
[this.target.target, this.calldata.substring(0, 10)],
|
||||
),
|
||||
);
|
||||
await setStorageAt(this.manager.address, EXECUTION_ID_STORAGE_SLOT, executionId);
|
||||
await setStorageAt(this.manager.target, EXECUTION_ID_STORAGE_SLOT, executionId);
|
||||
});
|
||||
|
||||
executing();
|
||||
@ -279,8 +272,8 @@ function testAsDelayedOperation() {
|
||||
describe('with operation delay', function () {
|
||||
describe('when operation delay is greater than execution delay', function () {
|
||||
beforeEach('set operation delay', async function () {
|
||||
this.operationDelay = this.executionDelay.add(time.duration.hours(1));
|
||||
await this.manager.$_setTargetAdminDelay(this.target.address, this.operationDelay);
|
||||
this.operationDelay = this.executionDelay + time.duration.hours(1);
|
||||
await this.manager.$_setTargetAdminDelay(this.target, this.operationDelay);
|
||||
this.scheduleIn = this.operationDelay; // For testAsSchedulableOperation
|
||||
});
|
||||
|
||||
@ -289,8 +282,8 @@ function testAsDelayedOperation() {
|
||||
|
||||
describe('when operation delay is shorter than execution delay', function () {
|
||||
beforeEach('set operation delay', async function () {
|
||||
this.operationDelay = this.executionDelay.sub(time.duration.hours(1));
|
||||
await this.manager.$_setTargetAdminDelay(this.target.address, this.operationDelay);
|
||||
this.operationDelay = this.executionDelay - time.duration.hours(1);
|
||||
await this.manager.$_setTargetAdminDelay(this.target, this.operationDelay);
|
||||
this.scheduleIn = this.executionDelay; // For testAsSchedulableOperation
|
||||
});
|
||||
|
||||
@ -300,8 +293,8 @@ function testAsDelayedOperation() {
|
||||
|
||||
describe('without operation delay', function () {
|
||||
beforeEach('set operation delay', async function () {
|
||||
this.operationDelay = web3.utils.toBN(0);
|
||||
await this.manager.$_setTargetAdminDelay(this.target.address, this.operationDelay);
|
||||
this.operationDelay = 0n;
|
||||
await this.manager.$_setTargetAdminDelay(this.target, this.operationDelay);
|
||||
this.scheduleIn = this.executionDelay; // For testAsSchedulableOperation
|
||||
});
|
||||
|
||||
@ -344,9 +337,9 @@ function testAsHasRole({ publicRoleIsRequired, specificRoleIsRequired }) {
|
||||
describe('when the function requires the caller to be granted with the PUBLIC_ROLE', function () {
|
||||
beforeEach('set target function role as PUBLIC_ROLE', async function () {
|
||||
this.role = this.roles.PUBLIC;
|
||||
await this.manager.$_setTargetFunctionRole(this.target.address, this.calldata.substring(0, 10), this.role.id, {
|
||||
from: this.roles.ADMIN.members[0],
|
||||
});
|
||||
await this.manager
|
||||
.connect(this.roles.ADMIN.members[0])
|
||||
.$_setTargetFunctionRole(this.target, this.calldata.substring(0, 10), this.role.id);
|
||||
});
|
||||
|
||||
publicRoleIsRequired();
|
||||
@ -354,9 +347,9 @@ function testAsHasRole({ publicRoleIsRequired, specificRoleIsRequired }) {
|
||||
|
||||
describe('when the function requires the caller to be granted with a role other than PUBLIC_ROLE', function () {
|
||||
beforeEach('set target function role as PUBLIC_ROLE', async function () {
|
||||
await this.manager.$_setTargetFunctionRole(this.target.address, this.calldata.substring(0, 10), this.role.id, {
|
||||
from: this.roles.ADMIN.members[0],
|
||||
});
|
||||
await this.manager
|
||||
.connect(this.roles.ADMIN.members[0])
|
||||
.$_setTargetFunctionRole(this.target, this.calldata.substring(0, 10), this.role.id);
|
||||
});
|
||||
|
||||
testAsGetAccess(specificRoleIsRequired);
|
||||
@ -400,7 +393,7 @@ function testAsGetAccess({
|
||||
|
||||
describe('when caller has no execution delay', function () {
|
||||
beforeEach('set role and delay', async function () {
|
||||
this.executionDelay = web3.utils.toBN(0);
|
||||
this.executionDelay = 0n;
|
||||
await this.manager.$_grantRole(this.role.id, this.caller, this.grantDelay, this.executionDelay);
|
||||
});
|
||||
|
||||
@ -410,7 +403,7 @@ function testAsGetAccess({
|
||||
|
||||
describe('when role granting is not delayed', function () {
|
||||
beforeEach('define delay', function () {
|
||||
this.grantDelay = web3.utils.toBN(0);
|
||||
this.grantDelay = 0n;
|
||||
});
|
||||
|
||||
describe('when caller has an execution delay', function () {
|
||||
@ -424,7 +417,7 @@ function testAsGetAccess({
|
||||
|
||||
describe('when caller has no execution delay', function () {
|
||||
beforeEach('set role and delay', async function () {
|
||||
this.executionDelay = web3.utils.toBN(0);
|
||||
this.executionDelay = 0n;
|
||||
await this.manager.$_grantRole(this.role.id, this.caller, this.grantDelay, this.executionDelay);
|
||||
});
|
||||
|
||||
@ -439,7 +432,7 @@ function testAsGetAccess({
|
||||
// Although this is highly unlikely, we check for it here to avoid false positives.
|
||||
beforeEach('assert role is unset', async function () {
|
||||
const { since } = await this.manager.getAccess(this.role.id, this.caller);
|
||||
expect(since).to.be.bignumber.equal(web3.utils.toBN(0));
|
||||
expect(since).to.equal(0n);
|
||||
});
|
||||
|
||||
requiredRoleIsNotGranted();
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,68 +1,81 @@
|
||||
require('@openzeppelin/test-helpers');
|
||||
const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
|
||||
const { ethers } = require('hardhat');
|
||||
|
||||
const AuthorityUtils = artifacts.require('$AuthorityUtils');
|
||||
const NotAuthorityMock = artifacts.require('NotAuthorityMock');
|
||||
const AuthorityNoDelayMock = artifacts.require('AuthorityNoDelayMock');
|
||||
const AuthorityDelayMock = artifacts.require('AuthorityDelayMock');
|
||||
const AuthorityNoResponse = artifacts.require('AuthorityNoResponse');
|
||||
async function fixture() {
|
||||
const [user, other] = await ethers.getSigners();
|
||||
|
||||
contract('AuthorityUtils', function (accounts) {
|
||||
const [user, other] = accounts;
|
||||
const mock = await ethers.deployContract('$AuthorityUtils');
|
||||
const notAuthorityMock = await ethers.deployContract('NotAuthorityMock');
|
||||
const authorityNoDelayMock = await ethers.deployContract('AuthorityNoDelayMock');
|
||||
const authorityDelayMock = await ethers.deployContract('AuthorityDelayMock');
|
||||
const authorityNoResponse = await ethers.deployContract('AuthorityNoResponse');
|
||||
|
||||
return {
|
||||
user,
|
||||
other,
|
||||
mock,
|
||||
notAuthorityMock,
|
||||
authorityNoDelayMock,
|
||||
authorityDelayMock,
|
||||
authorityNoResponse,
|
||||
};
|
||||
}
|
||||
|
||||
describe('AuthorityUtils', function () {
|
||||
beforeEach(async function () {
|
||||
this.mock = await AuthorityUtils.new();
|
||||
Object.assign(this, await loadFixture(fixture));
|
||||
});
|
||||
|
||||
describe('canCallWithDelay', function () {
|
||||
describe('when authority does not have a canCall function', function () {
|
||||
beforeEach(async function () {
|
||||
this.authority = await NotAuthorityMock.new();
|
||||
this.authority = this.notAuthorityMock;
|
||||
});
|
||||
|
||||
it('returns (immediate = 0, delay = 0)', async function () {
|
||||
const { immediate, delay } = await this.mock.$canCallWithDelay(
|
||||
this.authority.address,
|
||||
user,
|
||||
other,
|
||||
this.authority,
|
||||
this.user,
|
||||
this.other,
|
||||
'0x12345678',
|
||||
);
|
||||
expect(immediate).to.equal(false);
|
||||
expect(delay).to.be.bignumber.equal('0');
|
||||
expect(delay).to.be.equal(0n);
|
||||
});
|
||||
});
|
||||
|
||||
describe('when authority has no delay', function () {
|
||||
beforeEach(async function () {
|
||||
this.authority = await AuthorityNoDelayMock.new();
|
||||
this.authority = this.authorityNoDelayMock;
|
||||
this.immediate = true;
|
||||
await this.authority._setImmediate(this.immediate);
|
||||
});
|
||||
|
||||
it('returns (immediate, delay = 0)', async function () {
|
||||
const { immediate, delay } = await this.mock.$canCallWithDelay(
|
||||
this.authority.address,
|
||||
user,
|
||||
other,
|
||||
this.authority,
|
||||
this.user,
|
||||
this.other,
|
||||
'0x12345678',
|
||||
);
|
||||
expect(immediate).to.equal(this.immediate);
|
||||
expect(delay).to.be.bignumber.equal('0');
|
||||
expect(delay).to.be.equal(0n);
|
||||
});
|
||||
});
|
||||
|
||||
describe('when authority replies with a delay', function () {
|
||||
beforeEach(async function () {
|
||||
this.authority = await AuthorityDelayMock.new();
|
||||
this.authority = this.authorityDelayMock;
|
||||
});
|
||||
|
||||
for (const immediate of [true, false]) {
|
||||
for (const delay of ['0', '42']) {
|
||||
for (const delay of [0n, 42n]) {
|
||||
it(`returns (immediate=${immediate}, delay=${delay})`, async function () {
|
||||
await this.authority._setImmediate(immediate);
|
||||
await this.authority._setDelay(delay);
|
||||
const result = await this.mock.$canCallWithDelay(this.authority.address, user, other, '0x12345678');
|
||||
const result = await this.mock.$canCallWithDelay(this.authority, this.user, this.other, '0x12345678');
|
||||
expect(result.immediate).to.equal(immediate);
|
||||
expect(result.delay).to.be.bignumber.equal(delay);
|
||||
expect(result.delay).to.be.equal(delay);
|
||||
});
|
||||
}
|
||||
}
|
||||
@ -70,18 +83,18 @@ contract('AuthorityUtils', function (accounts) {
|
||||
|
||||
describe('when authority replies with empty data', function () {
|
||||
beforeEach(async function () {
|
||||
this.authority = await AuthorityNoResponse.new();
|
||||
this.authority = this.authorityNoResponse;
|
||||
});
|
||||
|
||||
it('returns (immediate = 0, delay = 0)', async function () {
|
||||
const { immediate, delay } = await this.mock.$canCallWithDelay(
|
||||
this.authority.address,
|
||||
user,
|
||||
other,
|
||||
this.authority,
|
||||
this.user,
|
||||
this.other,
|
||||
'0x12345678',
|
||||
);
|
||||
expect(immediate).to.equal(false);
|
||||
expect(delay).to.be.bignumber.equal('0');
|
||||
expect(delay).to.be.equal(0n);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
@ -1,23 +1,23 @@
|
||||
const { time } = require('@openzeppelin/test-helpers');
|
||||
const { MAX_UINT64 } = require('./constants');
|
||||
const { namespaceSlot } = require('./namespaced-storage');
|
||||
const {
|
||||
time: { setNextBlockTimestamp },
|
||||
} = require('@nomicfoundation/hardhat-network-helpers');
|
||||
bigint: { MAX_UINT64 },
|
||||
} = require('./constants');
|
||||
const { namespaceSlot } = require('./namespaced-storage');
|
||||
const { bigint: time } = require('./time');
|
||||
const { keccak256, AbiCoder } = require('ethers');
|
||||
|
||||
function buildBaseRoles() {
|
||||
const roles = {
|
||||
ADMIN: {
|
||||
id: web3.utils.toBN(0),
|
||||
id: 0n,
|
||||
},
|
||||
SOME_ADMIN: {
|
||||
id: web3.utils.toBN(17),
|
||||
id: 17n,
|
||||
},
|
||||
SOME_GUARDIAN: {
|
||||
id: web3.utils.toBN(35),
|
||||
id: 35n,
|
||||
},
|
||||
SOME: {
|
||||
id: web3.utils.toBN(42),
|
||||
id: 42n,
|
||||
},
|
||||
PUBLIC: {
|
||||
id: MAX_UINT64,
|
||||
@ -53,23 +53,27 @@ const CONSUMING_SCHEDULE_STORAGE_SLOT = namespaceSlot('AccessManaged', 0n);
|
||||
/**
|
||||
* @requires this.{manager, caller, target, calldata}
|
||||
*/
|
||||
async function scheduleOperation(manager, { caller, target, calldata, delay }) {
|
||||
const timestamp = await time.latest();
|
||||
const scheduledAt = timestamp.addn(1);
|
||||
await setNextBlockTimestamp(scheduledAt); // Fix next block timestamp for predictability
|
||||
const { receipt } = await manager.schedule(target, calldata, scheduledAt.add(delay), {
|
||||
from: caller,
|
||||
});
|
||||
async function prepareOperation(manager, { caller, target, calldata, delay }) {
|
||||
const timestamp = await time.clock.timestamp();
|
||||
const scheduledAt = timestamp + 1n;
|
||||
await time.forward.timestamp(scheduledAt, false); // Fix next block timestamp for predictability
|
||||
|
||||
return {
|
||||
receipt,
|
||||
schedule: () => manager.connect(caller).schedule(target, calldata, scheduledAt + delay),
|
||||
scheduledAt,
|
||||
operationId: hashOperation(caller, target, calldata),
|
||||
};
|
||||
}
|
||||
|
||||
const lazyGetAddress = addressable => addressable.address ?? addressable.target ?? addressable;
|
||||
|
||||
const hashOperation = (caller, target, data) =>
|
||||
web3.utils.keccak256(web3.eth.abi.encodeParameters(['address', 'address', 'bytes'], [caller, target, data]));
|
||||
keccak256(
|
||||
AbiCoder.defaultAbiCoder().encode(
|
||||
['address', 'address', 'bytes'],
|
||||
[lazyGetAddress(caller), lazyGetAddress(target), data],
|
||||
),
|
||||
);
|
||||
|
||||
module.exports = {
|
||||
buildBaseRoles,
|
||||
@ -78,6 +82,6 @@ module.exports = {
|
||||
EXPIRATION,
|
||||
EXECUTION_ID_STORAGE_SLOT,
|
||||
CONSUMING_SCHEDULE_STORAGE_SLOT,
|
||||
scheduleOperation,
|
||||
prepareOperation,
|
||||
hashOperation,
|
||||
};
|
||||
|
||||
@ -1,5 +1,12 @@
|
||||
// TODO: deprecate the old version in favor of this one
|
||||
const bigint = {
|
||||
MAX_UINT48: 2n ** 48n - 1n,
|
||||
MAX_UINT64: 2n ** 64n - 1n,
|
||||
};
|
||||
|
||||
// TODO: remove toString() when bigint are supported
|
||||
module.exports = {
|
||||
MAX_UINT48: (2n ** 48n - 1n).toString(),
|
||||
MAX_UINT64: (2n ** 64n - 1n).toString(),
|
||||
MAX_UINT48: bigint.MAX_UINT48.toString(),
|
||||
MAX_UINT64: bigint.MAX_UINT64.toString(),
|
||||
bigint,
|
||||
};
|
||||
|
||||
@ -1,16 +1,14 @@
|
||||
const { keccak256, id, toBeHex, MaxUint256 } = require('ethers');
|
||||
const { artifacts } = require('hardhat');
|
||||
|
||||
function namespaceId(contractName) {
|
||||
return `openzeppelin.storage.${contractName}`;
|
||||
}
|
||||
|
||||
function namespaceLocation(id) {
|
||||
const hashIdBN = web3.utils.toBN(web3.utils.keccak256(id)).subn(1); // keccak256(id) - 1
|
||||
const hashIdHex = web3.utils.padLeft(web3.utils.numberToHex(hashIdBN), 64);
|
||||
|
||||
const mask = BigInt(web3.utils.padLeft('0x00', 64, 'f')); // ~0xff
|
||||
|
||||
return BigInt(web3.utils.keccak256(hashIdHex)) & mask;
|
||||
function namespaceLocation(value) {
|
||||
const hashIdBN = BigInt(id(value)) - 1n; // keccak256(id) - 1
|
||||
const mask = MaxUint256 - 0xffn; // ~0xff
|
||||
return BigInt(keccak256(toBeHex(hashIdBN, 32))) & mask;
|
||||
}
|
||||
|
||||
function namespaceSlot(contractName, offset) {
|
||||
|
||||
Reference in New Issue
Block a user