371 lines
10 KiB
Solidity
371 lines
10 KiB
Solidity
// SPDX-License-Identifier: MIT
|
|
pragma solidity 0.8.10;
|
|
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
|
|
|
|
/**
|
|
* MultiSigWallet with timelocker
|
|
*/
|
|
contract BEMultiSigWallet is AccessControlEnumerable {
|
|
bytes32 public constant PROPOSER_ROLE = keccak256("PROPOSER_ROLE");
|
|
bytes32 public constant EXECUTOR_ROLE = keccak256("EXECUTOR_ROLE");
|
|
bytes32 public constant CONFIRM_ROLE = keccak256("CONFIRM_ROLE");
|
|
uint256 internal constant _DONE_TIMESTAMP = uint256(1);
|
|
|
|
mapping(bytes32 => uint256) private _timestamps;
|
|
mapping(bytes32 => mapping(address => bool)) public confirmations;
|
|
uint256 public minDelay;
|
|
uint256 public required;
|
|
|
|
/**
|
|
* @dev Emitted when a call is scheduled as part of operation `id`.
|
|
*/
|
|
event ScheduleAdded(bytes32 indexed id);
|
|
|
|
/**
|
|
* @dev Emitted when a call is performed as part of operation `id`.
|
|
*/
|
|
event ScheduleExecuted(bytes32 indexed id);
|
|
|
|
/**
|
|
* @dev Emitted when operation `id` is cancelled.
|
|
*/
|
|
event Cancelled(bytes32 indexed id);
|
|
|
|
event Confirmation(address indexed sender, bytes32[] ids);
|
|
|
|
event Revocation(address indexed sender, bytes32[] ids);
|
|
|
|
/**
|
|
* @dev Emitted when the minimum delay for future operations is modified.
|
|
*/
|
|
event MinDelayChange(uint256 oldDuration, uint256 newDuration);
|
|
/**
|
|
* @dev Emitted when the number of required confimations is modified.
|
|
*/
|
|
event RequirementChange(uint256 oldDuration, uint256 newDuration);
|
|
|
|
modifier onlyWallet() {
|
|
require(
|
|
msg.sender == address(this),
|
|
"BEMultiSigWallet: caller must be wallet"
|
|
);
|
|
_;
|
|
}
|
|
|
|
/**
|
|
* @dev Initializes the contract with a given `minDelay`.
|
|
*/
|
|
constructor(
|
|
uint256 _minDelay,
|
|
uint256 _required,
|
|
address[] memory proposers,
|
|
address[] memory confirmers,
|
|
address[] memory executors
|
|
) {
|
|
_setRoleAdmin(PROPOSER_ROLE, DEFAULT_ADMIN_ROLE);
|
|
_setRoleAdmin(EXECUTOR_ROLE, DEFAULT_ADMIN_ROLE);
|
|
_setRoleAdmin(CONFIRM_ROLE, DEFAULT_ADMIN_ROLE);
|
|
|
|
// deployer + self administration
|
|
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
|
|
_setupRole(DEFAULT_ADMIN_ROLE, address(this));
|
|
|
|
// register proposers
|
|
for (uint256 i = 0; i < proposers.length; ++i) {
|
|
_setupRole(PROPOSER_ROLE, proposers[i]);
|
|
}
|
|
|
|
// register confirmers
|
|
for (uint256 i = 0; i < confirmers.length; ++i) {
|
|
_setupRole(CONFIRM_ROLE, confirmers[i]);
|
|
}
|
|
|
|
// register executors
|
|
for (uint256 i = 0; i < executors.length; ++i) {
|
|
_setupRole(EXECUTOR_ROLE, executors[i]);
|
|
}
|
|
|
|
minDelay = _minDelay;
|
|
emit MinDelayChange(0, minDelay);
|
|
required = _required;
|
|
emit RequirementChange(0, required);
|
|
}
|
|
|
|
/**
|
|
* @dev Modifier to make a function callable only by a certain role. In
|
|
* addition to checking the sender's role, `address(0)` 's role is also
|
|
* considered. Granting a role to `address(0)` is equivalent to enabling
|
|
* this role for everyone.
|
|
*/
|
|
modifier onlyRoleOrOpenRole(bytes32 role) {
|
|
if (!hasRole(role, address(0))) {
|
|
_checkRole(role, _msgSender());
|
|
}
|
|
_;
|
|
}
|
|
|
|
/**
|
|
* @dev Contract might receive/hold ETH as part of the maintenance process.
|
|
*/
|
|
receive() external payable {}
|
|
|
|
/**
|
|
* @dev Returns whether an id correspond to a registered operation. This
|
|
* includes both Pending, Ready and Done operations.
|
|
*/
|
|
function isOperation(bytes32 id) public view virtual returns (bool pending) {
|
|
return getTimestamp(id) > 0;
|
|
}
|
|
|
|
/**
|
|
* @dev Returns whether an operation is pending or not.
|
|
*/
|
|
function isOperationPending(
|
|
bytes32 id
|
|
) public view virtual returns (bool pending) {
|
|
return getTimestamp(id) > _DONE_TIMESTAMP;
|
|
}
|
|
|
|
/**
|
|
* @dev Returns whether an operation is confirmed or not.
|
|
*/
|
|
function isConfirmed(bytes32 id) public view returns (bool ready) {
|
|
uint256 count = 0;
|
|
uint256 confirmCount = getRoleMemberCount(CONFIRM_ROLE);
|
|
for (uint256 i = 0; i < confirmCount; i++) {
|
|
if (confirmations[id][getRoleMember(CONFIRM_ROLE, i)]) count += 1;
|
|
if (count == required) return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Returns whether an operation is ready or not.
|
|
*/
|
|
function isOperationReady(
|
|
bytes32 id
|
|
) public view virtual returns (bool ready) {
|
|
uint256 timestamp = getTimestamp(id);
|
|
return timestamp > _DONE_TIMESTAMP && timestamp <= block.timestamp;
|
|
}
|
|
|
|
/**
|
|
* @dev Returns whether an operation is done or not.
|
|
*/
|
|
function isOperationDone(bytes32 id) public view virtual returns (bool done) {
|
|
return getTimestamp(id) == _DONE_TIMESTAMP;
|
|
}
|
|
|
|
/**
|
|
* @dev Returns the timestamp at with an operation becomes ready (0 for
|
|
* unset operations, 1 for done operations).
|
|
*/
|
|
function getTimestamp(
|
|
bytes32 id
|
|
) public view virtual returns (uint256 timestamp) {
|
|
return _timestamps[id];
|
|
}
|
|
|
|
/**
|
|
* @dev Returns the identifier of an operation containing a batch of
|
|
* transactions.
|
|
*/
|
|
function hashOperation(
|
|
address[] calldata targets,
|
|
uint256[] calldata values,
|
|
bytes[] calldata datas,
|
|
bytes32 predecessor,
|
|
bytes32 salt
|
|
) public pure virtual returns (bytes32 hash) {
|
|
return keccak256(abi.encode(targets, values, datas, predecessor, salt));
|
|
}
|
|
|
|
/**
|
|
* @dev Schedule an operation containing a batch of transactions.
|
|
*
|
|
* Emits one {ScheduleAdded} event per transaction in the batch.
|
|
*
|
|
* Requirements:
|
|
*
|
|
* - the caller must have the 'proposer' role.
|
|
*/
|
|
function schedule(
|
|
address[] calldata targets,
|
|
uint256[] calldata values,
|
|
bytes[] calldata datas,
|
|
bytes32 predecessor,
|
|
bytes32 salt,
|
|
uint256 delay
|
|
) external virtual onlyRoleOrOpenRole(PROPOSER_ROLE) {
|
|
require(
|
|
targets.length > 0,
|
|
"BEMultiSigWallet: no transactions to schedule"
|
|
);
|
|
require(
|
|
targets.length == values.length,
|
|
"BEMultiSigWallet: length mismatch"
|
|
);
|
|
require(
|
|
targets.length == datas.length,
|
|
"BEMultiSigWallet: length mismatch"
|
|
);
|
|
|
|
bytes32 id = hashOperation(targets, values, datas, predecessor, salt);
|
|
_schedule(id, delay);
|
|
emit ScheduleAdded(id);
|
|
}
|
|
|
|
/**
|
|
* @dev Schedule an operation that is to becomes valid after a given delay.
|
|
*/
|
|
function _schedule(bytes32 id, uint256 delay) private {
|
|
require(!isOperation(id), "BEMultiSigWallet: operation already scheduled");
|
|
require(delay >= minDelay, "BEMultiSigWallet: insufficient delay");
|
|
_timestamps[id] = block.timestamp + delay;
|
|
}
|
|
|
|
/**
|
|
* @dev Cancel an operation.
|
|
*
|
|
* Requirements:
|
|
*
|
|
* - the caller must have the 'proposer' role.
|
|
*/
|
|
function cancel(
|
|
bytes32 id
|
|
) external virtual onlyRoleOrOpenRole(PROPOSER_ROLE) {
|
|
require(
|
|
isOperationPending(id),
|
|
"BEMultiSigWallet: operation cannot be cancelled"
|
|
);
|
|
delete _timestamps[id];
|
|
|
|
emit Cancelled(id);
|
|
}
|
|
|
|
/**
|
|
* @dev Allows an executor to confirm multiple transactions.
|
|
*/
|
|
function confirmTransaction(
|
|
bytes32[] calldata ids
|
|
) external onlyRoleOrOpenRole(CONFIRM_ROLE) {
|
|
require(ids.length > 0, "BEMultiSigWallet: empty ids");
|
|
for (uint256 i = 0; i < ids.length; ++i) {
|
|
require(
|
|
isOperationPending(ids[i]),
|
|
"BEMultiSigWallet: operation not exist or finished"
|
|
);
|
|
confirmations[ids[i]][msg.sender] = true;
|
|
}
|
|
emit Confirmation(msg.sender, ids);
|
|
}
|
|
|
|
/**
|
|
* @dev Allows an executor to revoke multiple confirmations for a transaction.
|
|
*/
|
|
function revokeConfirmation(
|
|
bytes32[] calldata ids
|
|
) external onlyRoleOrOpenRole(CONFIRM_ROLE) {
|
|
require(ids.length > 0, "BEMultiSigWallet: empty ids");
|
|
for (uint256 i = 0; i < ids.length; ++i) {
|
|
require(
|
|
isOperationPending(ids[i]),
|
|
"BEMultiSigWallet: operation not exist or finished"
|
|
);
|
|
confirmations[ids[i]][msg.sender] = false;
|
|
}
|
|
emit Revocation(msg.sender, ids);
|
|
}
|
|
|
|
/**
|
|
* @dev Execute an (ready) operation containing a batch of transactions.
|
|
*
|
|
* Emits one {CallExecuted} event per transaction in the batch.
|
|
*
|
|
* Requirements:
|
|
*
|
|
* - the caller must have the 'executor' role.
|
|
*/
|
|
function execute(
|
|
address[] calldata targets,
|
|
uint256[] calldata values,
|
|
bytes[] calldata datas,
|
|
bytes32 predecessor,
|
|
bytes32 salt
|
|
) external payable virtual onlyRoleOrOpenRole(EXECUTOR_ROLE) {
|
|
require(targets.length > 0, "BEMultiSigWallet: no calls to make");
|
|
require(
|
|
targets.length == values.length,
|
|
"BEMultiSigWallet: length mismatch"
|
|
);
|
|
require(
|
|
targets.length == datas.length,
|
|
"BEMultiSigWallet: length mismatch"
|
|
);
|
|
|
|
bytes32 id = hashOperation(targets, values, datas, predecessor, salt);
|
|
_beforeCall(id, predecessor);
|
|
for (uint256 i = 0; i < targets.length; ++i) {
|
|
_call(targets[i], values[i], datas[i]);
|
|
}
|
|
_afterCall(id);
|
|
emit ScheduleExecuted(id);
|
|
}
|
|
|
|
/**
|
|
* @dev Checks before execution of an operation's calls.
|
|
*/
|
|
function _beforeCall(bytes32 id, bytes32 predecessor) private view {
|
|
require(isOperationReady(id), "BEMultiSigWallet: operation is not ready");
|
|
require(
|
|
isConfirmed(id),
|
|
"BEMultiSigWallet: operation not reach required confirmations"
|
|
);
|
|
require(
|
|
predecessor == bytes32(0) || isOperationDone(predecessor),
|
|
"BEMultiSigWallet: missing dependency"
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @dev Checks after execution of an operation's calls.
|
|
*/
|
|
function _afterCall(bytes32 id) private {
|
|
require(isOperationReady(id), "BEMultiSigWallet: operation is not ready");
|
|
_timestamps[id] = _DONE_TIMESTAMP;
|
|
}
|
|
|
|
/**
|
|
* @dev Execute an operation's call.
|
|
*
|
|
* Emits a {CallExecuted} event.
|
|
*/
|
|
function _call(address target, uint256 value, bytes calldata data) private {
|
|
(bool success, ) = target.call{value: value}(data);
|
|
require(success, "BEMultiSigWallet: underlying transaction reverted");
|
|
}
|
|
|
|
/**
|
|
* @dev Changes the minimum wallet duration for future operations.
|
|
*
|
|
* Emits a {MinDelayChange} event.
|
|
*
|
|
* Requirements:
|
|
*
|
|
* - the caller must be the wallet itself. This can only be achieved by scheduling and later executing
|
|
* an operation where the wallet is the target and the data is the ABI-encoded call to this function.
|
|
*/
|
|
function changeDelay(uint256 _minDelay) external virtual onlyWallet {
|
|
emit MinDelayChange(minDelay, _minDelay);
|
|
minDelay = _minDelay;
|
|
}
|
|
|
|
/**
|
|
* @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
|
|
* @param _required Number of required confirmations.
|
|
*/
|
|
function changeRequirement(uint256 _required) external virtual onlyWallet {
|
|
emit RequirementChange(required, _required);
|
|
required = _required;
|
|
}
|
|
}
|