{"file_path":"contracts/governance/ToriTimelock.sol","creation_status":"success","source_code":"// SPDX-License-Identifier: GPL-3.0\npragma solidity 0.8.28;\n\nimport \"@openzeppelin/contracts/governance/TimelockController.sol\";\n\ncontract ToriTimelock is TimelockController {\n    uint256 public constant MIN_DELAY = 1 days;\n    uint256 public constant MAX_DELAY = 30 days;\n\n    constructor(\n        uint256 minDelay,\n        address timelockAdmin,\n        address canceller\n    ) TimelockController(\n        minDelay,\n        _toArray(timelockAdmin),\n        _toArray(timelockAdmin),\n        address(this)\n    ) {\n        require(minDelay >= MIN_DELAY, \"Delay too short\");\n        require(minDelay <= MAX_DELAY, \"Delay too long\");\n        require(timelockAdmin != address(0), \"Invalid timelock admin\");\n        require(canceller != address(0), \"Invalid canceller\");\n\n        _revokeRole(CANCELLER_ROLE, timelockAdmin); // remove timelockAdmin's canceller role\n        _grantRole(CANCELLER_ROLE, canceller); // grant canceller role to canceller\n\n        _revokeRole(DEFAULT_ADMIN_ROLE, address(this)); // renounce temp admin\n    }\n\n    function _toArray(address addr) private pure returns (address[] memory) {\n        address[] memory arr = new address[](1);\n        arr[0] = addr;\n        return arr;\n    }\n\n    function _execute(address target, uint256 value, bytes calldata data) internal override {\n        if (target == address(this) && data.length >= 4 && bytes4(data[:4]) == this.updateDelay.selector) {\n            uint256 newDelay = abi.decode(data[4:], (uint256));\n            require(newDelay >= MIN_DELAY, \"Delay too short\");\n            require(newDelay <= MAX_DELAY, \"Delay too long\");\n        }\n        super._execute(target, value, data);\n    }\n\n    function getOperationStateString(bytes32 id) external view returns (string memory state) {\n        OperationState opState = getOperationState(id);\n\n        if (opState == OperationState.Unset) return \"Unset\";\n        if (opState == OperationState.Waiting) return \"Waiting\";\n        if (opState == OperationState.Ready) return \"Ready\";\n        if (opState == OperationState.Done) return \"Done\";\n\n        return \"Unknown\";\n    }\n\n    function getTimeRemaining(bytes32 id) external view returns (uint256 remaining) {\n        uint256 timestamp = getTimestamp(id);\n\n        if (timestamp == 0 || timestamp == 1) return 0; // Unset or Done\n        if (block.timestamp >= timestamp) return 0; // Ready\n\n        return timestamp - block.timestamp;\n    }\n}\n","deployed_bytecode":"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","optimization_enabled":true,"verified_twin_address_hash":null,"is_verified":true,"compiler_settings":{"evmVersion":"cancun","libraries":{},"optimizer":{"enabled":true,"runs":200},"outputSelection":{"*":{"":["*"],"*":["*"]}}},"optimization_runs":200,"sourcify_repo_url":null,"decoded_constructor_args":[["86400",{"internalType":"uint256","name":"minDelay","type":"uint256"}],["0x0C6Bbfd2d5666d44bf28580eDEec0263692C8316",{"internalType":"address","name":"timelockAdmin","type":"address"}],["0x60226Cbb34445143E5F923ABe2D42e5DF852d065",{"internalType":"address","name":"canceller","type":"address"}]],"compiler_version":"v0.8.28+commit.7893614a","is_verified_via_verifier_alliance":false,"verified_at":"2026-06-11T13:05:48.434022Z","implementations":[],"proxy_type":null,"external_libraries":[],"creation_bytecode":"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","name":"ToriTimelock","is_blueprint":false,"license_type":"none","is_fully_verified":true,"is_verified_via_eth_bytecode_db":false,"language":"solidity","evm_version":"cancun","can_be_visualized_via_sol2uml":true,"is_verified_via_sourcify":false,"additional_sources":[{"file_path":"@openzeppelin/contracts/utils/introspection/IERC165.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},{"file_path":"@openzeppelin/contracts/access/AccessControl.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (access/AccessControl.sol)\n\npragma solidity ^0.8.20;\n\nimport {IAccessControl} from \"./IAccessControl.sol\";\nimport {Context} from \"../utils/Context.sol\";\nimport {IERC165, ERC165} from \"../utils/introspection/ERC165.sol\";\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```solidity\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```solidity\n * function foo() public {\n *     require(hasRole(MY_ROLE, msg.sender));\n *     ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\n * to enforce additional security measures for this role.\n */\nabstract contract AccessControl is Context, IAccessControl, ERC165 {\n    struct RoleData {\n        mapping(address account => bool) hasRole;\n        bytes32 adminRole;\n    }\n\n    mapping(bytes32 role => RoleData) private _roles;\n\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n    /**\n     * @dev Modifier that checks that an account has a specific role. Reverts\n     * with an {AccessControlUnauthorizedAccount} error including the required role.\n     */\n    modifier onlyRole(bytes32 role) {\n        _checkRole(role);\n        _;\n    }\n\n    /// @inheritdoc IERC165\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) public view virtual returns (bool) {\n        return _roles[role].hasRole[account];\n    }\n\n    /**\n     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`\n     * is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.\n     */\n    function _checkRole(bytes32 role) internal view virtual {\n        _checkRole(role, _msgSender());\n    }\n\n    /**\n     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`\n     * is missing `role`.\n     */\n    function _checkRole(bytes32 role, address account) internal view virtual {\n        if (!hasRole(role, account)) {\n            revert AccessControlUnauthorizedAccount(account, role);\n        }\n    }\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {\n        return _roles[role].adminRole;\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been revoked `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `callerConfirmation`.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function renounceRole(bytes32 role, address callerConfirmation) public virtual {\n        if (callerConfirmation != _msgSender()) {\n            revert AccessControlBadConfirmation();\n        }\n\n        _revokeRole(role, callerConfirmation);\n    }\n\n    /**\n     * @dev Sets `adminRole` as ``role``'s admin role.\n     *\n     * Emits a {RoleAdminChanged} event.\n     */\n    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n        bytes32 previousAdminRole = getRoleAdmin(role);\n        _roles[role].adminRole = adminRole;\n        emit RoleAdminChanged(role, previousAdminRole, adminRole);\n    }\n\n    /**\n     * @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function _grantRole(bytes32 role, address account) internal virtual returns (bool) {\n        if (!hasRole(role, account)) {\n            _roles[role].hasRole[account] = true;\n            emit RoleGranted(role, account, _msgSender());\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * @dev Attempts to revoke `role` from `account` and returns a boolean indicating if `role` was revoked.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {\n        if (hasRole(role, account)) {\n            _roles[role].hasRole[account] = false;\n            emit RoleRevoked(role, account, _msgSender());\n            return true;\n        } else {\n            return false;\n        }\n    }\n}\n"},{"file_path":"@openzeppelin/contracts/utils/Errors.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Collection of common custom errors used in multiple contracts\n *\n * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.\n * It is recommended to avoid relying on the error API for critical functionality.\n *\n * _Available since v5.1._\n */\nlibrary Errors {\n    /**\n     * @dev The ETH balance of the account is not enough to perform the operation.\n     */\n    error InsufficientBalance(uint256 balance, uint256 needed);\n\n    /**\n     * @dev A call to an address target failed. The target may have reverted.\n     */\n    error FailedCall();\n\n    /**\n     * @dev The deployment failed.\n     */\n    error FailedDeployment();\n\n    /**\n     * @dev A necessary precompile is missing.\n     */\n    error MissingPrecompile(address);\n}\n"},{"file_path":"@openzeppelin/contracts/utils/introspection/ERC165.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n */\nabstract contract ERC165 is IERC165 {\n    /// @inheritdoc IERC165\n    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n"},{"file_path":"@openzeppelin/contracts/access/IAccessControl.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (access/IAccessControl.sol)\n\npragma solidity >=0.8.4;\n\n/**\n * @dev External interface of AccessControl declared to support ERC-165 detection.\n */\ninterface IAccessControl {\n    /**\n     * @dev The `account` is missing a role.\n     */\n    error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);\n\n    /**\n     * @dev The caller of a function is not the expected one.\n     *\n     * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.\n     */\n    error AccessControlBadConfirmation();\n\n    /**\n     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n     *\n     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n     * {RoleAdminChanged} not being emitted to signal this.\n     */\n    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n    /**\n     * @dev Emitted when `account` is granted `role`.\n     *\n     * `sender` is the account that originated the contract call. This account bears the admin role (for the granted role).\n     * Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.\n     */\n    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Emitted when `account` is revoked `role`.\n     *\n     * `sender` is the account that originated the contract call:\n     *   - if using `revokeRole`, it is the admin role bearer\n     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)\n     */\n    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) external view returns (bool);\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function grantRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function revokeRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been granted `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `callerConfirmation`.\n     */\n    function renounceRole(bytes32 role, address callerConfirmation) external;\n}\n"},{"file_path":"@openzeppelin/contracts/governance/TimelockController.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (governance/TimelockController.sol)\n\npragma solidity ^0.8.20;\n\nimport {AccessControl} from \"../access/AccessControl.sol\";\nimport {ERC721Holder} from \"../token/ERC721/utils/ERC721Holder.sol\";\nimport {ERC1155Holder} from \"../token/ERC1155/utils/ERC1155Holder.sol\";\nimport {Address} from \"../utils/Address.sol\";\nimport {IERC165} from \"../utils/introspection/ERC165.sol\";\n\n/**\n * @dev Contract module which acts as a timelocked controller. When set as the\n * owner of an `Ownable` smart contract, it enforces a timelock on all\n * `onlyOwner` maintenance operations. This gives time for users of the\n * controlled contract to exit before a potentially dangerous maintenance\n * operation is applied.\n *\n * By default, this contract is self administered, meaning administration tasks\n * have to go through the timelock process. The proposer (resp executor) role\n * is in charge of proposing (resp executing) operations. A common use case is\n * to position this {TimelockController} as the owner of a smart contract, with\n * a multisig or a DAO as the sole proposer.\n */\ncontract TimelockController is AccessControl, ERC721Holder, ERC1155Holder {\n    bytes32 public constant PROPOSER_ROLE = keccak256(\"PROPOSER_ROLE\");\n    bytes32 public constant EXECUTOR_ROLE = keccak256(\"EXECUTOR_ROLE\");\n    bytes32 public constant CANCELLER_ROLE = keccak256(\"CANCELLER_ROLE\");\n    uint256 internal constant _DONE_TIMESTAMP = uint256(1);\n\n    mapping(bytes32 id => uint256) private _timestamps;\n    uint256 private _minDelay;\n\n    enum OperationState {\n        Unset,\n        Waiting,\n        Ready,\n        Done\n    }\n\n    /**\n     * @dev Mismatch between the parameters length for an operation call.\n     */\n    error TimelockInvalidOperationLength(uint256 targets, uint256 payloads, uint256 values);\n\n    /**\n     * @dev The schedule operation doesn't meet the minimum delay.\n     */\n    error TimelockInsufficientDelay(uint256 delay, uint256 minDelay);\n\n    /**\n     * @dev The current state of an operation is not as required.\n     * The `expectedStates` is a bitmap with the bits enabled for each OperationState enum position\n     * counting from right to left.\n     *\n     * See {_encodeStateBitmap}.\n     */\n    error TimelockUnexpectedOperationState(bytes32 operationId, bytes32 expectedStates);\n\n    /**\n     * @dev The predecessor to an operation not yet done.\n     */\n    error TimelockUnexecutedPredecessor(bytes32 predecessorId);\n\n    /**\n     * @dev The caller account is not authorized.\n     */\n    error TimelockUnauthorizedCaller(address caller);\n\n    /**\n     * @dev Emitted when a call is scheduled as part of operation `id`.\n     */\n    event CallScheduled(\n        bytes32 indexed id,\n        uint256 indexed index,\n        address target,\n        uint256 value,\n        bytes data,\n        bytes32 predecessor,\n        uint256 delay\n    );\n\n    /**\n     * @dev Emitted when a call is performed as part of operation `id`.\n     */\n    event CallExecuted(bytes32 indexed id, uint256 indexed index, address target, uint256 value, bytes data);\n\n    /**\n     * @dev Emitted when new proposal is scheduled with non-zero salt.\n     */\n    event CallSalt(bytes32 indexed id, bytes32 salt);\n\n    /**\n     * @dev Emitted when operation `id` is cancelled.\n     */\n    event Cancelled(bytes32 indexed id);\n\n    /**\n     * @dev Emitted when the minimum delay for future operations is modified.\n     */\n    event MinDelayChange(uint256 oldDuration, uint256 newDuration);\n\n    /**\n     * @dev Initializes the contract with the following parameters:\n     *\n     * - `minDelay`: initial minimum delay in seconds for operations\n     * - `proposers`: accounts to be granted proposer and canceller roles\n     * - `executors`: accounts to be granted executor role\n     * - `admin`: optional account to be granted admin role; disable with zero address\n     *\n     * IMPORTANT: The optional admin can aid with initial configuration of roles after deployment\n     * without being subject to delay, but this role should be subsequently renounced in favor of\n     * administration through timelocked proposals. Previous versions of this contract would assign\n     * this admin to the deployer automatically and should be renounced as well.\n     */\n    constructor(uint256 minDelay, address[] memory proposers, address[] memory executors, address admin) {\n        // self administration\n        _grantRole(DEFAULT_ADMIN_ROLE, address(this));\n\n        // optional admin\n        if (admin != address(0)) {\n            _grantRole(DEFAULT_ADMIN_ROLE, admin);\n        }\n\n        // register proposers and cancellers\n        for (uint256 i = 0; i < proposers.length; ++i) {\n            _grantRole(PROPOSER_ROLE, proposers[i]);\n            _grantRole(CANCELLER_ROLE, proposers[i]);\n        }\n\n        // register executors\n        for (uint256 i = 0; i < executors.length; ++i) {\n            _grantRole(EXECUTOR_ROLE, executors[i]);\n        }\n\n        _minDelay = minDelay;\n        emit MinDelayChange(0, minDelay);\n    }\n\n    /**\n     * @dev Modifier to make a function callable only by a certain role. In\n     * addition to checking the sender's role, `address(0)` 's role is also\n     * considered. Granting a role to `address(0)` is equivalent to enabling\n     * this role for everyone.\n     */\n    modifier onlyRoleOrOpenRole(bytes32 role) {\n        if (!hasRole(role, address(0))) {\n            _checkRole(role, _msgSender());\n        }\n        _;\n    }\n\n    /**\n     * @dev Contract might receive/hold ETH as part of the maintenance process.\n     */\n    receive() external payable virtual {}\n\n    /// @inheritdoc IERC165\n    function supportsInterface(\n        bytes4 interfaceId\n    ) public view virtual override(AccessControl, ERC1155Holder) returns (bool) {\n        return super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev Returns whether an id corresponds to a registered operation. This\n     * includes both Waiting, Ready, and Done operations.\n     */\n    function isOperation(bytes32 id) public view returns (bool) {\n        return getOperationState(id) != OperationState.Unset;\n    }\n\n    /**\n     * @dev Returns whether an operation is pending or not. Note that a \"pending\" operation may also be \"ready\".\n     */\n    function isOperationPending(bytes32 id) public view returns (bool) {\n        OperationState state = getOperationState(id);\n        return state == OperationState.Waiting || state == OperationState.Ready;\n    }\n\n    /**\n     * @dev Returns whether an operation is ready for execution. Note that a \"ready\" operation is also \"pending\".\n     */\n    function isOperationReady(bytes32 id) public view returns (bool) {\n        return getOperationState(id) == OperationState.Ready;\n    }\n\n    /**\n     * @dev Returns whether an operation is done or not.\n     */\n    function isOperationDone(bytes32 id) public view returns (bool) {\n        return getOperationState(id) == OperationState.Done;\n    }\n\n    /**\n     * @dev Returns the timestamp at which an operation becomes ready (0 for\n     * unset operations, 1 for done operations).\n     */\n    function getTimestamp(bytes32 id) public view virtual returns (uint256) {\n        return _timestamps[id];\n    }\n\n    /**\n     * @dev Returns operation state.\n     */\n    function getOperationState(bytes32 id) public view virtual returns (OperationState) {\n        uint256 timestamp = getTimestamp(id);\n        if (timestamp == 0) {\n            return OperationState.Unset;\n        } else if (timestamp == _DONE_TIMESTAMP) {\n            return OperationState.Done;\n        } else if (timestamp > block.timestamp) {\n            return OperationState.Waiting;\n        } else {\n            return OperationState.Ready;\n        }\n    }\n\n    /**\n     * @dev Returns the minimum delay in seconds for an operation to become valid.\n     *\n     * This value can be changed by executing an operation that calls `updateDelay`.\n     */\n    function getMinDelay() public view virtual returns (uint256) {\n        return _minDelay;\n    }\n\n    /**\n     * @dev Returns the identifier of an operation containing a single\n     * transaction.\n     */\n    function hashOperation(\n        address target,\n        uint256 value,\n        bytes calldata data,\n        bytes32 predecessor,\n        bytes32 salt\n    ) public pure virtual returns (bytes32) {\n        return keccak256(abi.encode(target, value, data, predecessor, salt));\n    }\n\n    /**\n     * @dev Returns the identifier of an operation containing a batch of\n     * transactions.\n     */\n    function hashOperationBatch(\n        address[] calldata targets,\n        uint256[] calldata values,\n        bytes[] calldata payloads,\n        bytes32 predecessor,\n        bytes32 salt\n    ) public pure virtual returns (bytes32) {\n        return keccak256(abi.encode(targets, values, payloads, predecessor, salt));\n    }\n\n    /**\n     * @dev Schedule an operation containing a single transaction.\n     *\n     * Emits {CallSalt} if salt is nonzero, and {CallScheduled}.\n     *\n     * Requirements:\n     *\n     * - the caller must have the 'proposer' role.\n     */\n    function schedule(\n        address target,\n        uint256 value,\n        bytes calldata data,\n        bytes32 predecessor,\n        bytes32 salt,\n        uint256 delay\n    ) public virtual onlyRole(PROPOSER_ROLE) {\n        bytes32 id = hashOperation(target, value, data, predecessor, salt);\n        _schedule(id, delay);\n        emit CallScheduled(id, 0, target, value, data, predecessor, delay);\n        if (salt != bytes32(0)) {\n            emit CallSalt(id, salt);\n        }\n    }\n\n    /**\n     * @dev Schedule an operation containing a batch of transactions.\n     *\n     * Emits {CallSalt} if salt is nonzero, and one {CallScheduled} event per transaction in the batch.\n     *\n     * Requirements:\n     *\n     * - the caller must have the 'proposer' role.\n     */\n    function scheduleBatch(\n        address[] calldata targets,\n        uint256[] calldata values,\n        bytes[] calldata payloads,\n        bytes32 predecessor,\n        bytes32 salt,\n        uint256 delay\n    ) public virtual onlyRole(PROPOSER_ROLE) {\n        if (targets.length != values.length || targets.length != payloads.length) {\n            revert TimelockInvalidOperationLength(targets.length, payloads.length, values.length);\n        }\n\n        bytes32 id = hashOperationBatch(targets, values, payloads, predecessor, salt);\n        _schedule(id, delay);\n        for (uint256 i = 0; i < targets.length; ++i) {\n            emit CallScheduled(id, i, targets[i], values[i], payloads[i], predecessor, delay);\n        }\n        if (salt != bytes32(0)) {\n            emit CallSalt(id, salt);\n        }\n    }\n\n    /**\n     * @dev Schedule an operation that is to become valid after a given delay.\n     */\n    function _schedule(bytes32 id, uint256 delay) private {\n        if (isOperation(id)) {\n            revert TimelockUnexpectedOperationState(id, _encodeStateBitmap(OperationState.Unset));\n        }\n        uint256 minDelay = getMinDelay();\n        if (delay < minDelay) {\n            revert TimelockInsufficientDelay(delay, minDelay);\n        }\n        _timestamps[id] = block.timestamp + delay;\n    }\n\n    /**\n     * @dev Cancel an operation.\n     *\n     * Requirements:\n     *\n     * - the caller must have the 'canceller' role.\n     */\n    function cancel(bytes32 id) public virtual onlyRole(CANCELLER_ROLE) {\n        if (!isOperationPending(id)) {\n            revert TimelockUnexpectedOperationState(\n                id,\n                _encodeStateBitmap(OperationState.Waiting) | _encodeStateBitmap(OperationState.Ready)\n            );\n        }\n        delete _timestamps[id];\n\n        emit Cancelled(id);\n    }\n\n    /**\n     * @dev Execute an (ready) operation containing a single transaction.\n     *\n     * Emits a {CallExecuted} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have the 'executor' role.\n     */\n    // This function can reenter, but it doesn't pose a risk because _afterCall checks that the proposal is pending,\n    // thus any modifications to the operation during reentrancy should be caught.\n    // slither-disable-next-line reentrancy-eth\n    function execute(\n        address target,\n        uint256 value,\n        bytes calldata payload,\n        bytes32 predecessor,\n        bytes32 salt\n    ) public payable virtual onlyRoleOrOpenRole(EXECUTOR_ROLE) {\n        bytes32 id = hashOperation(target, value, payload, predecessor, salt);\n\n        _beforeCall(id, predecessor);\n        _execute(target, value, payload);\n        emit CallExecuted(id, 0, target, value, payload);\n        _afterCall(id);\n    }\n\n    /**\n     * @dev Execute an (ready) operation containing a batch of transactions.\n     *\n     * Emits one {CallExecuted} event per transaction in the batch.\n     *\n     * Requirements:\n     *\n     * - the caller must have the 'executor' role.\n     */\n    // This function can reenter, but it doesn't pose a risk because _afterCall checks that the proposal is pending,\n    // thus any modifications to the operation during reentrancy should be caught.\n    // slither-disable-next-line reentrancy-eth\n    function executeBatch(\n        address[] calldata targets,\n        uint256[] calldata values,\n        bytes[] calldata payloads,\n        bytes32 predecessor,\n        bytes32 salt\n    ) public payable virtual onlyRoleOrOpenRole(EXECUTOR_ROLE) {\n        if (targets.length != values.length || targets.length != payloads.length) {\n            revert TimelockInvalidOperationLength(targets.length, payloads.length, values.length);\n        }\n\n        bytes32 id = hashOperationBatch(targets, values, payloads, predecessor, salt);\n\n        _beforeCall(id, predecessor);\n        for (uint256 i = 0; i < targets.length; ++i) {\n            address target = targets[i];\n            uint256 value = values[i];\n            bytes calldata payload = payloads[i];\n            _execute(target, value, payload);\n            emit CallExecuted(id, i, target, value, payload);\n        }\n        _afterCall(id);\n    }\n\n    /**\n     * @dev Execute an operation's call.\n     */\n    function _execute(address target, uint256 value, bytes calldata data) internal virtual {\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        Address.verifyCallResult(success, returndata);\n    }\n\n    /**\n     * @dev Checks before execution of an operation's calls.\n     */\n    function _beforeCall(bytes32 id, bytes32 predecessor) private view {\n        if (!isOperationReady(id)) {\n            revert TimelockUnexpectedOperationState(id, _encodeStateBitmap(OperationState.Ready));\n        }\n        if (predecessor != bytes32(0) && !isOperationDone(predecessor)) {\n            revert TimelockUnexecutedPredecessor(predecessor);\n        }\n    }\n\n    /**\n     * @dev Checks after execution of an operation's calls.\n     */\n    function _afterCall(bytes32 id) private {\n        if (!isOperationReady(id)) {\n            revert TimelockUnexpectedOperationState(id, _encodeStateBitmap(OperationState.Ready));\n        }\n        _timestamps[id] = _DONE_TIMESTAMP;\n    }\n\n    /**\n     * @dev Changes the minimum timelock duration for future operations.\n     *\n     * Emits a {MinDelayChange} event.\n     *\n     * Requirements:\n     *\n     * - the caller must be the timelock itself. This can only be achieved by scheduling and later executing\n     * an operation where the timelock is the target and the data is the ABI-encoded call to this function.\n     */\n    function updateDelay(uint256 newDelay) external virtual {\n        address sender = _msgSender();\n        if (sender != address(this)) {\n            revert TimelockUnauthorizedCaller(sender);\n        }\n        emit MinDelayChange(_minDelay, newDelay);\n        _minDelay = newDelay;\n    }\n\n    /**\n     * @dev Encodes a `OperationState` into a `bytes32` representation where each bit enabled corresponds to\n     * the underlying position in the `OperationState` enum. For example:\n     *\n     * 0x000...1000\n     *   ^^^^^^----- ...\n     *         ^---- Done\n     *          ^--- Ready\n     *           ^-- Waiting\n     *            ^- Unset\n     */\n    function _encodeStateBitmap(OperationState operationState) internal pure returns (bytes32) {\n        return bytes32(1 << uint8(operationState));\n    }\n}\n"},{"file_path":"@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC1155/IERC1155Receiver.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC165} from \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Interface that must be implemented by smart contracts in order to receive\n * ERC-1155 token transfers.\n */\ninterface IERC1155Receiver is IERC165 {\n    /**\n     * @dev Handles the receipt of a single ERC-1155 token type. This function is\n     * called at the end of a `safeTransferFrom` after the balance has been updated.\n     *\n     * NOTE: To accept the transfer, this must return\n     * `bytes4(keccak256(\"onERC1155Received(address,address,uint256,uint256,bytes)\"))`\n     * (i.e. 0xf23a6e61, or its own function selector).\n     *\n     * @param operator The address which initiated the transfer (i.e. msg.sender)\n     * @param from The address which previously owned the token\n     * @param id The ID of the token being transferred\n     * @param value The amount of tokens being transferred\n     * @param data Additional data with no specified format\n     * @return `bytes4(keccak256(\"onERC1155Received(address,address,uint256,uint256,bytes)\"))` if transfer is allowed\n     */\n    function onERC1155Received(\n        address operator,\n        address from,\n        uint256 id,\n        uint256 value,\n        bytes calldata data\n    ) external returns (bytes4);\n\n    /**\n     * @dev Handles the receipt of a multiple ERC-1155 token types. This function\n     * is called at the end of a `safeBatchTransferFrom` after the balances have\n     * been updated.\n     *\n     * NOTE: To accept the transfer(s), this must return\n     * `bytes4(keccak256(\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\"))`\n     * (i.e. 0xbc197c81, or its own function selector).\n     *\n     * @param operator The address which initiated the batch transfer (i.e. msg.sender)\n     * @param from The address which previously owned the token\n     * @param ids An array containing ids of each token being transferred (order and length must match values array)\n     * @param values An array containing amounts of each token being transferred (order and length must match ids array)\n     * @param data Additional data with no specified format\n     * @return `bytes4(keccak256(\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\"))` if transfer is allowed\n     */\n    function onERC1155BatchReceived(\n        address operator,\n        address from,\n        uint256[] calldata ids,\n        uint256[] calldata values,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},{"file_path":"@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC1155/utils/ERC1155Holder.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165, ERC165} from \"../../../utils/introspection/ERC165.sol\";\nimport {IERC1155Receiver} from \"../IERC1155Receiver.sol\";\n\n/**\n * @dev Simple implementation of `IERC1155Receiver` that will allow a contract to hold ERC-1155 tokens.\n *\n * IMPORTANT: When inheriting this contract, you must include a way to use the received tokens, otherwise they will be\n * stuck.\n */\nabstract contract ERC1155Holder is ERC165, IERC1155Receiver {\n    /// @inheritdoc IERC165\n    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\n        return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    function onERC1155Received(\n        address,\n        address,\n        uint256,\n        uint256,\n        bytes memory\n    ) public virtual override returns (bytes4) {\n        return this.onERC1155Received.selector;\n    }\n\n    function onERC1155BatchReceived(\n        address,\n        address,\n        uint256[] memory,\n        uint256[] memory,\n        bytes memory\n    ) public virtual override returns (bytes4) {\n        return this.onERC1155BatchReceived.selector;\n    }\n}\n"},{"file_path":"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC721/IERC721Receiver.sol)\n\npragma solidity >=0.5.0;\n\n/**\n * @title ERC-721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC-721 asset contracts.\n */\ninterface IERC721Receiver {\n    /**\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n     * by `operator` from `from`, this function is called.\n     *\n     * It must return its Solidity selector to confirm the token transfer.\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be\n     * reverted.\n     *\n     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},{"file_path":"@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/utils/ERC721Holder.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC721Receiver} from \"../IERC721Receiver.sol\";\n\n/**\n * @dev Implementation of the {IERC721Receiver} interface.\n *\n * Accepts all token transfers.\n * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or\n * {IERC721-setApprovalForAll}.\n */\nabstract contract ERC721Holder is IERC721Receiver {\n    /**\n     * @dev See {IERC721Receiver-onERC721Received}.\n     *\n     * Always returns `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) {\n        return this.onERC721Received.selector;\n    }\n}\n"},{"file_path":"@openzeppelin/contracts/utils/Address.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/Address.sol)\n\npragma solidity ^0.8.20;\n\nimport {Errors} from \"./Errors.sol\";\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev There's no code at `target` (it is not a contract).\n     */\n    error AddressEmptyCode(address target);\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        if (address(this).balance < amount) {\n            revert Errors.InsufficientBalance(address(this).balance, amount);\n        }\n\n        (bool success, bytes memory returndata) = recipient.call{value: amount}(\"\");\n        if (!success) {\n            _revert(returndata);\n        }\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason or custom error, it is bubbled\n     * up by this function (like regular Solidity function calls). However, if\n     * the call reverted with no returned reason, this function reverts with a\n     * {Errors.FailedCall} error.\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        if (address(this).balance < value) {\n            revert Errors.InsufficientBalance(address(this).balance, value);\n        }\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\n     * was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case\n     * of an unsuccessful call.\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata\n    ) internal view returns (bytes memory) {\n        if (!success) {\n            _revert(returndata);\n        } else {\n            // only check if target is a contract if the call was successful and the return data is empty\n            // otherwise we already know that it was a contract\n            if (returndata.length == 0 && target.code.length == 0) {\n                revert AddressEmptyCode(target);\n            }\n            return returndata;\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\n     * revert reason or with a default {Errors.FailedCall} error.\n     */\n    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\n        if (!success) {\n            _revert(returndata);\n        } else {\n            return returndata;\n        }\n    }\n\n    /**\n     * @dev Reverts with returndata if present. Otherwise reverts with {Errors.FailedCall}.\n     */\n    function _revert(bytes memory returndata) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            assembly (\"memory-safe\") {\n                revert(add(returndata, 0x20), mload(returndata))\n            }\n        } else {\n            revert Errors.FailedCall();\n        }\n    }\n}\n"},{"file_path":"@openzeppelin/contracts/utils/Context.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"}],"certified":false,"conflicting_implementations":null,"abi":[{"inputs":[{"internalType":"uint256","name":"minDelay","type":"uint256"},{"internalType":"address","name":"timelockAdmin","type":"address"},{"internalType":"address","name":"canceller","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccessControlBadConfirmation","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bytes32","name":"neededRole","type":"bytes32"}],"name":"AccessControlUnauthorizedAccount","type":"error"},{"inputs":[],"name":"FailedCall","type":"error"},{"inputs":[{"internalType":"uint256","name":"delay","type":"uint256"},{"internalType":"uint256","name":"minDelay","type":"uint256"}],"name":"TimelockInsufficientDelay","type":"error"},{"inputs":[{"internalType":"uint256","name":"targets","type":"uint256"},{"internalType":"uint256","name":"payloads","type":"uint256"},{"internalType":"uint256","name":"values","type":"uint256"}],"name":"TimelockInvalidOperationLength","type":"error"},{"inputs":[{"internalType":"address","name":"caller","type":"address"}],"name":"TimelockUnauthorizedCaller","type":"error"},{"inputs":[{"internalType":"bytes32","name":"predecessorId","type":"bytes32"}],"name":"TimelockUnexecutedPredecessor","type":"error"},{"inputs":[{"internalType":"bytes32","name":"operationId","type":"bytes32"},{"internalType":"bytes32","name":"expectedStates","type":"bytes32"}],"name":"TimelockUnexpectedOperationState","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"id","type":"bytes32"},{"indexed":true,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":false,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"CallExecuted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"id","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"salt","type":"bytes32"}],"name":"CallSalt","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"id","type":"bytes32"},{"indexed":true,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":false,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"},{"indexed":false,"internalType":"bytes32","name":"predecessor","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"delay","type":"uint256"}],"name":"CallScheduled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"Cancelled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldDuration","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newDuration","type":"uint256"}],"name":"MinDelayChange","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"inputs":[],"name":"CANCELLER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"EXECUTOR_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_DELAY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIN_DELAY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PROPOSER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"cancel","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"payload","type":"bytes"},{"internalType":"bytes32","name":"predecessor","type":"bytes32"},{"internalType":"bytes32","name":"salt","type":"bytes32"}],"name":"execute","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address[]","name":"targets","type":"address[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"bytes[]","name":"payloads","type":"bytes[]"},{"internalType":"bytes32","name":"predecessor","type":"bytes32"},{"internalType":"bytes32","name":"salt","type":"bytes32"}],"name":"executeBatch","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"getMinDelay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"getOperationState","outputs":[{"internalType":"enum TimelockController.OperationState","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"getOperationStateString","outputs":[{"internalType":"string","name":"state","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"getTimeRemaining","outputs":[{"internalType":"uint256","name":"remaining","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"getTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"bytes32","name":"predecessor","type":"bytes32"},{"internalType":"bytes32","name":"salt","type":"bytes32"}],"name":"hashOperation","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address[]","name":"targets","type":"address[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"bytes[]","name":"payloads","type":"bytes[]"},{"internalType":"bytes32","name":"predecessor","type":"bytes32"},{"internalType":"bytes32","name":"salt","type":"bytes32"}],"name":"hashOperationBatch","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"isOperation","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"isOperationDone","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"isOperationPending","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"isOperationReady","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"callerConfirmation","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"bytes32","name":"predecessor","type":"bytes32"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256","name":"delay","type":"uint256"}],"name":"schedule","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"targets","type":"address[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"bytes[]","name":"payloads","type":"bytes[]"},{"internalType":"bytes32","name":"predecessor","type":"bytes32"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256","name":"delay","type":"uint256"}],"name":"scheduleBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"newDelay","type":"uint256"}],"name":"updateDelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}],"is_changed_bytecode":false,"is_partially_verified":false,"constructor_args":"0x00000000000000000000000000000000000000000000000000000000000151800000000000000000000000000c6bbfd2d5666d44bf28580edeec0263692c831600000000000000000000000060226cbb34445143e5f923abe2d42e5df852d065"}