{"constructor_args":"0x0000000000000000000000000000000000000000000000000000000000001c20000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000094bee6b74ec29d32869ae3140a659cac048288200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","is_partially_verified":true,"is_changed_bytecode":false,"abi":[{"inputs":[{"internalType":"uint256","name":"minDelay","type":"uint256"},{"internalType":"address[]","name":"proposers","type":"address[]"},{"internalType":"address[]","name":"executors","type":"address[]"},{"internalType":"address","name":"admin","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"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":"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":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","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":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","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"}],"conflicting_implementations":null,"certified":false,"additional_sources":[{"file_path":"contracts/external/openzeppelin/contracts/access/AccessControl.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (access/AccessControl.sol)\n\npragma solidity ^0.8.0;\n\nimport \"contracts/external/openzeppelin/contracts/access/IAccessControl.sol\";\nimport \"contracts/external/openzeppelin/contracts/utils/Context.sol\";\nimport \"contracts/external/openzeppelin/contracts/utils/Strings.sol\";\nimport \"contracts/external/openzeppelin/contracts/utils/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 * ```\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 * ```\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.\n */\nabstract contract AccessControl is Context, IAccessControl, ERC165 {\n  struct RoleData {\n    mapping(address => bool) members;\n    bytes32 adminRole;\n  }\n\n  mapping(bytes32 => 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 a standardized message including the required role.\n   *\n   * The format of the revert reason is given by the following regular expression:\n   *\n   *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n   *\n   * _Available since v4.1._\n   */\n  modifier onlyRole(bytes32 role) {\n    _checkRole(role, _msgSender());\n    _;\n  }\n\n  /**\n   * @dev See {IERC165-supportsInterface}.\n   */\n  function supportsInterface(bytes4 interfaceId)\n    public\n    view\n    virtual\n    override\n    returns (bool)\n  {\n    return\n      interfaceId == type(IAccessControl).interfaceId ||\n      super.supportsInterface(interfaceId);\n  }\n\n  /**\n   * @dev Returns `true` if `account` has been granted `role`.\n   */\n  function hasRole(bytes32 role, address account)\n    public\n    view\n    virtual\n    override\n    returns (bool)\n  {\n    return _roles[role].members[account];\n  }\n\n  /**\n   * @dev Revert with a standard message if `account` is missing `role`.\n   *\n   * The format of the revert reason is given by the following regular expression:\n   *\n   *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n   */\n  function _checkRole(bytes32 role, address account) internal view virtual {\n    if (!hasRole(role, account)) {\n      revert(\n        string(\n          abi.encodePacked(\n            \"AccessControl: account \",\n            Strings.toHexString(uint160(account), 20),\n            \" is missing role \",\n            Strings.toHexString(uint256(role), 32)\n          )\n        )\n      );\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)\n    public\n    view\n    virtual\n    override\n    returns (bytes32)\n  {\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  function grantRole(bytes32 role, address account)\n    public\n    virtual\n    override\n    onlyRole(getRoleAdmin(role))\n  {\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  function revokeRole(bytes32 role, address account)\n    public\n    virtual\n    override\n    onlyRole(getRoleAdmin(role))\n  {\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 `account`.\n   */\n  function renounceRole(bytes32 role, address account) public virtual override {\n    require(\n      account == _msgSender(),\n      \"AccessControl: can only renounce roles for self\"\n    );\n\n    _revokeRole(role, account);\n  }\n\n  /**\n   * @dev Grants `role` to `account`.\n   *\n   * If `account` had not been already granted `role`, emits a {RoleGranted}\n   * event. Note that unlike {grantRole}, this function doesn't perform any\n   * checks on the calling account.\n   *\n   * [WARNING]\n   * ====\n   * This function should only be called from the constructor when setting\n   * up the initial roles for the system.\n   *\n   * Using this function in any other way is effectively circumventing the admin\n   * system imposed by {AccessControl}.\n   * ====\n   *\n   * NOTE: This function is deprecated in favor of {_grantRole}.\n   */\n  function _setupRole(bytes32 role, address account) internal virtual {\n    _grantRole(role, account);\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 Grants `role` to `account`.\n   *\n   * Internal function without access restriction.\n   */\n  function _grantRole(bytes32 role, address account) internal virtual {\n    if (!hasRole(role, account)) {\n      _roles[role].members[account] = true;\n      emit RoleGranted(role, account, _msgSender());\n    }\n  }\n\n  /**\n   * @dev Revokes `role` from `account`.\n   *\n   * Internal function without access restriction.\n   */\n  function _revokeRole(bytes32 role, address account) internal virtual {\n    if (hasRole(role, account)) {\n      _roles[role].members[account] = false;\n      emit RoleRevoked(role, account, _msgSender());\n    }\n  }\n}\n"},{"file_path":"contracts/external/openzeppelin/contracts/access/AccessControlEnumerable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (access/AccessControlEnumerable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"contracts/external/openzeppelin/contracts/access/IAccessControlEnumerable.sol\";\nimport \"contracts/external/openzeppelin/contracts/access/AccessControl.sol\";\nimport \"contracts/external/openzeppelin/contracts/utils/EnumerableSet.sol\";\n\n/**\n * @dev Extension of {AccessControl} that allows enumerating the members of each role.\n */\nabstract contract AccessControlEnumerable is\n  IAccessControlEnumerable,\n  AccessControl\n{\n  using EnumerableSet for EnumerableSet.AddressSet;\n\n  mapping(bytes32 => EnumerableSet.AddressSet) private _roleMembers;\n\n  /**\n   * @dev See {IERC165-supportsInterface}.\n   */\n  function supportsInterface(bytes4 interfaceId)\n    public\n    view\n    virtual\n    override\n    returns (bool)\n  {\n    return\n      interfaceId == type(IAccessControlEnumerable).interfaceId ||\n      super.supportsInterface(interfaceId);\n  }\n\n  /**\n   * @dev Returns one of the accounts that have `role`. `index` must be a\n   * value between 0 and {getRoleMemberCount}, non-inclusive.\n   *\n   * Role bearers are not sorted in any particular way, and their ordering may\n   * change at any point.\n   *\n   * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure\n   * you perform all queries on the same block. See the following\n   * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]\n   * for more information.\n   */\n  function getRoleMember(bytes32 role, uint256 index)\n    public\n    view\n    virtual\n    override\n    returns (address)\n  {\n    return _roleMembers[role].at(index);\n  }\n\n  /**\n   * @dev Returns the number of accounts that have `role`. Can be used\n   * together with {getRoleMember} to enumerate all bearers of a role.\n   */\n  function getRoleMemberCount(bytes32 role)\n    public\n    view\n    virtual\n    override\n    returns (uint256)\n  {\n    return _roleMembers[role].length();\n  }\n\n  /**\n   * @dev Overload {_grantRole} to track enumerable memberships\n   */\n  function _grantRole(bytes32 role, address account) internal virtual override {\n    super._grantRole(role, account);\n    _roleMembers[role].add(account);\n  }\n\n  /**\n   * @dev Overload {_revokeRole} to track enumerable memberships\n   */\n  function _revokeRole(bytes32 role, address account)\n    internal\n    virtual\n    override\n  {\n    super._revokeRole(role, account);\n    _roleMembers[role].remove(account);\n  }\n}\n"},{"file_path":"contracts/external/openzeppelin/contracts/access/IAccessControl.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControl {\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 signaling this.\n   *\n   * _Available since v3.1._\n   */\n  event RoleAdminChanged(\n    bytes32 indexed role,\n    bytes32 indexed previousAdminRole,\n    bytes32 indexed newAdminRole\n  );\n\n  /**\n   * @dev Emitted when `account` is granted `role`.\n   *\n   * `sender` is the account that originated the contract call, an admin role\n   * bearer except when using {AccessControl-_setupRole}.\n   */\n  event RoleGranted(\n    bytes32 indexed role,\n    address indexed account,\n    address indexed sender\n  );\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(\n    bytes32 indexed role,\n    address indexed account,\n    address indexed sender\n  );\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 `account`.\n   */\n  function renounceRole(bytes32 role, address account) external;\n}\n"},{"file_path":"contracts/external/openzeppelin/contracts/access/IAccessControlEnumerable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControlEnumerable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"contracts/external/openzeppelin/contracts/access/IAccessControl.sol\";\n\n/**\n * @dev External interface of AccessControlEnumerable declared to support ERC165 detection.\n */\ninterface IAccessControlEnumerable is IAccessControl {\n  /**\n   * @dev Returns one of the accounts that have `role`. `index` must be a\n   * value between 0 and {getRoleMemberCount}, non-inclusive.\n   *\n   * Role bearers are not sorted in any particular way, and their ordering may\n   * change at any point.\n   *\n   * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure\n   * you perform all queries on the same block. See the following\n   * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]\n   * for more information.\n   */\n  function getRoleMember(bytes32 role, uint256 index)\n    external\n    view\n    returns (address);\n\n  /**\n   * @dev Returns the number of accounts that have `role`. Can be used\n   * together with {getRoleMember} to enumerate all bearers of a role.\n   */\n  function getRoleMemberCount(bytes32 role) external view returns (uint256);\n}\n"},{"file_path":"contracts/external/openzeppelin/contracts/utils/Address.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n  /**\n   * @dev Returns true if `account` is a contract.\n   *\n   * [IMPORTANT]\n   * ====\n   * It is unsafe to assume that an address for which this function returns\n   * false is an externally-owned account (EOA) and not a contract.\n   *\n   * Among others, `isContract` will return false for the following\n   * types of addresses:\n   *\n   *  - an externally-owned account\n   *  - a contract in construction\n   *  - an address where a contract will be created\n   *  - an address where a contract lived, but was destroyed\n   * ====\n   *\n   * [IMPORTANT]\n   * ====\n   * You shouldn't rely on `isContract` to protect against flash loan attacks!\n   *\n   * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n   * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n   * constructor.\n   * ====\n   */\n  function isContract(address account) internal view returns (bool) {\n    // This method relies on extcodesize/address.code.length, which returns 0\n    // for contracts in construction, since the code is only stored at the end\n    // of the constructor execution.\n\n    return account.code.length > 0;\n  }\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://diligence.consensys.net/posts/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.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n   */\n  function sendValue(address payable recipient, uint256 amount) internal {\n    require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n    (bool success, ) = recipient.call{value: amount}(\"\");\n    require(\n      success,\n      \"Address: unable to send value, recipient may have reverted\"\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, it is bubbled up by this\n   * function (like regular Solidity function calls).\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   * _Available since v3.1._\n   */\n  function functionCall(address target, bytes memory data)\n    internal\n    returns (bytes memory)\n  {\n    return functionCall(target, data, \"Address: low-level call failed\");\n  }\n\n  /**\n   * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n   * `errorMessage` as a fallback revert reason when `target` reverts.\n   *\n   * _Available since v3.1._\n   */\n  function functionCall(\n    address target,\n    bytes memory data,\n    string memory errorMessage\n  ) internal returns (bytes memory) {\n    return functionCallWithValue(target, data, 0, errorMessage);\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   * _Available since v3.1._\n   */\n  function functionCallWithValue(\n    address target,\n    bytes memory data,\n    uint256 value\n  ) internal returns (bytes memory) {\n    return\n      functionCallWithValue(\n        target,\n        data,\n        value,\n        \"Address: low-level call with value failed\"\n      );\n  }\n\n  /**\n   * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n   * with `errorMessage` as a fallback revert reason when `target` reverts.\n   *\n   * _Available since v3.1._\n   */\n  function functionCallWithValue(\n    address target,\n    bytes memory data,\n    uint256 value,\n    string memory errorMessage\n  ) internal returns (bytes memory) {\n    require(\n      address(this).balance >= value,\n      \"Address: insufficient balance for call\"\n    );\n    require(isContract(target), \"Address: call to non-contract\");\n\n    (bool success, bytes memory returndata) = target.call{value: value}(data);\n    return verifyCallResult(success, returndata, errorMessage);\n  }\n\n  /**\n   * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n   * but performing a static call.\n   *\n   * _Available since v3.3._\n   */\n  function functionStaticCall(address target, bytes memory data)\n    internal\n    view\n    returns (bytes memory)\n  {\n    return\n      functionStaticCall(target, data, \"Address: low-level static call failed\");\n  }\n\n  /**\n   * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n   * but performing a static call.\n   *\n   * _Available since v3.3._\n   */\n  function functionStaticCall(\n    address target,\n    bytes memory data,\n    string memory errorMessage\n  ) internal view returns (bytes memory) {\n    require(isContract(target), \"Address: static call to non-contract\");\n\n    (bool success, bytes memory returndata) = target.staticcall(data);\n    return verifyCallResult(success, returndata, errorMessage);\n  }\n\n  /**\n   * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n   * but performing a delegate call.\n   *\n   * _Available since v3.4._\n   */\n  function functionDelegateCall(address target, bytes memory data)\n    internal\n    returns (bytes memory)\n  {\n    return\n      functionDelegateCall(\n        target,\n        data,\n        \"Address: low-level delegate call failed\"\n      );\n  }\n\n  /**\n   * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n   * but performing a delegate call.\n   *\n   * _Available since v3.4._\n   */\n  function functionDelegateCall(\n    address target,\n    bytes memory data,\n    string memory errorMessage\n  ) internal returns (bytes memory) {\n    require(isContract(target), \"Address: delegate call to non-contract\");\n\n    (bool success, bytes memory returndata) = target.delegatecall(data);\n    return verifyCallResult(success, returndata, errorMessage);\n  }\n\n  /**\n   * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n   * revert reason using the provided one.\n   *\n   * _Available since v4.3._\n   */\n  function verifyCallResult(\n    bool success,\n    bytes memory returndata,\n    string memory errorMessage\n  ) internal pure returns (bytes memory) {\n    if (success) {\n      return returndata;\n    } else {\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\n        assembly {\n          let returndata_size := mload(returndata)\n          revert(add(32, returndata), returndata_size)\n        }\n      } else {\n        revert(errorMessage);\n      }\n    }\n  }\n}\n"},{"file_path":"contracts/external/openzeppelin/contracts/utils/Context.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\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"},{"file_path":"contracts/external/openzeppelin/contracts/utils/ERC165.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.0;\n\nimport \"contracts/external/openzeppelin/contracts/utils/IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 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 *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165 is IERC165 {\n  /**\n   * @dev See {IERC165-supportsInterface}.\n   */\n  function supportsInterface(bytes4 interfaceId)\n    public\n    view\n    virtual\n    override\n    returns (bool)\n  {\n    return interfaceId == type(IERC165).interfaceId;\n  }\n}\n"},{"file_path":"contracts/external/openzeppelin/contracts/utils/EnumerableSet.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/structs/EnumerableSet.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for managing\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\n * types.\n *\n * Sets have the following properties:\n *\n * - Elements are added, removed, and checked for existence in constant time\n * (O(1)).\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\n *\n * ```\n * contract Example {\n *     // Add the library methods\n *     using EnumerableSet for EnumerableSet.AddressSet;\n *\n *     // Declare a set state variable\n *     EnumerableSet.AddressSet private mySet;\n * }\n * ```\n *\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\n * and `uint256` (`UintSet`) are supported.\n */\nlibrary EnumerableSet {\n  // To implement this library for multiple types with as little code\n  // repetition as possible, we write it in terms of a generic Set type with\n  // bytes32 values.\n  // The Set implementation uses private functions, and user-facing\n  // implementations (such as AddressSet) are just wrappers around the\n  // underlying Set.\n  // This means that we can only create new EnumerableSets for types that fit\n  // in bytes32.\n\n  struct Set {\n    // Storage of set values\n    bytes32[] _values;\n    // Position of the value in the `values` array, plus 1 because index 0\n    // means a value is not in the set.\n    mapping(bytes32 => uint256) _indexes;\n  }\n\n  /**\n   * @dev Add a value to a set. O(1).\n   *\n   * Returns true if the value was added to the set, that is if it was not\n   * already present.\n   */\n  function _add(Set storage set, bytes32 value) private returns (bool) {\n    if (!_contains(set, value)) {\n      set._values.push(value);\n      // The value is stored at length-1, but we add 1 to all indexes\n      // and use 0 as a sentinel value\n      set._indexes[value] = set._values.length;\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * @dev Removes a value from a set. O(1).\n   *\n   * Returns true if the value was removed from the set, that is if it was\n   * present.\n   */\n  function _remove(Set storage set, bytes32 value) private returns (bool) {\n    // We read and store the value's index to prevent multiple reads from the same storage slot\n    uint256 valueIndex = set._indexes[value];\n\n    if (valueIndex != 0) {\n      // Equivalent to contains(set, value)\n      // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\n      // the array, and then remove the last element (sometimes called as 'swap and pop').\n      // This modifies the order of the array, as noted in {at}.\n\n      uint256 toDeleteIndex = valueIndex - 1;\n      uint256 lastIndex = set._values.length - 1;\n\n      if (lastIndex != toDeleteIndex) {\n        bytes32 lastvalue = set._values[lastIndex];\n\n        // Move the last value to the index where the value to delete is\n        set._values[toDeleteIndex] = lastvalue;\n        // Update the index for the moved value\n        set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\n      }\n\n      // Delete the slot where the moved value was stored\n      set._values.pop();\n\n      // Delete the index for the deleted slot\n      delete set._indexes[value];\n\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * @dev Returns true if the value is in the set. O(1).\n   */\n  function _contains(Set storage set, bytes32 value)\n    private\n    view\n    returns (bool)\n  {\n    return set._indexes[value] != 0;\n  }\n\n  /**\n   * @dev Returns the number of values on the set. O(1).\n   */\n  function _length(Set storage set) private view returns (uint256) {\n    return set._values.length;\n  }\n\n  /**\n   * @dev Returns the value stored at position `index` in the set. O(1).\n   *\n   * Note that there are no guarantees on the ordering of values inside the\n   * array, and it may change when more values are added or removed.\n   *\n   * Requirements:\n   *\n   * - `index` must be strictly less than {length}.\n   */\n  function _at(Set storage set, uint256 index) private view returns (bytes32) {\n    return set._values[index];\n  }\n\n  /**\n   * @dev Return the entire set in an array\n   *\n   * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n   * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n   * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n   * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n   */\n  function _values(Set storage set) private view returns (bytes32[] memory) {\n    return set._values;\n  }\n\n  // Bytes32Set\n\n  struct Bytes32Set {\n    Set _inner;\n  }\n\n  /**\n   * @dev Add a value to a set. O(1).\n   *\n   * Returns true if the value was added to the set, that is if it was not\n   * already present.\n   */\n  function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n    return _add(set._inner, value);\n  }\n\n  /**\n   * @dev Removes a value from a set. O(1).\n   *\n   * Returns true if the value was removed from the set, that is if it was\n   * present.\n   */\n  function remove(Bytes32Set storage set, bytes32 value)\n    internal\n    returns (bool)\n  {\n    return _remove(set._inner, value);\n  }\n\n  /**\n   * @dev Returns true if the value is in the set. O(1).\n   */\n  function contains(Bytes32Set storage set, bytes32 value)\n    internal\n    view\n    returns (bool)\n  {\n    return _contains(set._inner, value);\n  }\n\n  /**\n   * @dev Returns the number of values in the set. O(1).\n   */\n  function length(Bytes32Set storage set) internal view returns (uint256) {\n    return _length(set._inner);\n  }\n\n  /**\n   * @dev Returns the value stored at position `index` in the set. O(1).\n   *\n   * Note that there are no guarantees on the ordering of values inside the\n   * array, and it may change when more values are added or removed.\n   *\n   * Requirements:\n   *\n   * - `index` must be strictly less than {length}.\n   */\n  function at(Bytes32Set storage set, uint256 index)\n    internal\n    view\n    returns (bytes32)\n  {\n    return _at(set._inner, index);\n  }\n\n  /**\n   * @dev Return the entire set in an array\n   *\n   * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n   * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n   * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n   * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n   */\n  function values(Bytes32Set storage set)\n    internal\n    view\n    returns (bytes32[] memory)\n  {\n    return _values(set._inner);\n  }\n\n  // AddressSet\n\n  struct AddressSet {\n    Set _inner;\n  }\n\n  /**\n   * @dev Add a value to a set. O(1).\n   *\n   * Returns true if the value was added to the set, that is if it was not\n   * already present.\n   */\n  function add(AddressSet storage set, address value) internal returns (bool) {\n    return _add(set._inner, bytes32(uint256(uint160(value))));\n  }\n\n  /**\n   * @dev Removes a value from a set. O(1).\n   *\n   * Returns true if the value was removed from the set, that is if it was\n   * present.\n   */\n  function remove(AddressSet storage set, address value)\n    internal\n    returns (bool)\n  {\n    return _remove(set._inner, bytes32(uint256(uint160(value))));\n  }\n\n  /**\n   * @dev Returns true if the value is in the set. O(1).\n   */\n  function contains(AddressSet storage set, address value)\n    internal\n    view\n    returns (bool)\n  {\n    return _contains(set._inner, bytes32(uint256(uint160(value))));\n  }\n\n  /**\n   * @dev Returns the number of values in the set. O(1).\n   */\n  function length(AddressSet storage set) internal view returns (uint256) {\n    return _length(set._inner);\n  }\n\n  /**\n   * @dev Returns the value stored at position `index` in the set. O(1).\n   *\n   * Note that there are no guarantees on the ordering of values inside the\n   * array, and it may change when more values are added or removed.\n   *\n   * Requirements:\n   *\n   * - `index` must be strictly less than {length}.\n   */\n  function at(AddressSet storage set, uint256 index)\n    internal\n    view\n    returns (address)\n  {\n    return address(uint160(uint256(_at(set._inner, index))));\n  }\n\n  /**\n   * @dev Return the entire set in an array\n   *\n   * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n   * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n   * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n   * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n   */\n  function values(AddressSet storage set)\n    internal\n    view\n    returns (address[] memory)\n  {\n    bytes32[] memory store = _values(set._inner);\n    address[] memory result;\n\n    assembly {\n      result := store\n    }\n\n    return result;\n  }\n\n  // UintSet\n\n  struct UintSet {\n    Set _inner;\n  }\n\n  /**\n   * @dev Add a value to a set. O(1).\n   *\n   * Returns true if the value was added to the set, that is if it was not\n   * already present.\n   */\n  function add(UintSet storage set, uint256 value) internal returns (bool) {\n    return _add(set._inner, bytes32(value));\n  }\n\n  /**\n   * @dev Removes a value from a set. O(1).\n   *\n   * Returns true if the value was removed from the set, that is if it was\n   * present.\n   */\n  function remove(UintSet storage set, uint256 value) internal returns (bool) {\n    return _remove(set._inner, bytes32(value));\n  }\n\n  /**\n   * @dev Returns true if the value is in the set. O(1).\n   */\n  function contains(UintSet storage set, uint256 value)\n    internal\n    view\n    returns (bool)\n  {\n    return _contains(set._inner, bytes32(value));\n  }\n\n  /**\n   * @dev Returns the number of values on the set. O(1).\n   */\n  function length(UintSet storage set) internal view returns (uint256) {\n    return _length(set._inner);\n  }\n\n  /**\n   * @dev Returns the value stored at position `index` in the set. O(1).\n   *\n   * Note that there are no guarantees on the ordering of values inside the\n   * array, and it may change when more values are added or removed.\n   *\n   * Requirements:\n   *\n   * - `index` must be strictly less than {length}.\n   */\n  function at(UintSet storage set, uint256 index)\n    internal\n    view\n    returns (uint256)\n  {\n    return uint256(_at(set._inner, index));\n  }\n\n  /**\n   * @dev Return the entire set in an array\n   *\n   * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n   * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n   * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n   * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n   */\n  function values(UintSet storage set)\n    internal\n    view\n    returns (uint256[] memory)\n  {\n    bytes32[] memory store = _values(set._inner);\n    uint256[] memory result;\n\n    assembly {\n      result := store\n    }\n\n    return result;\n  }\n}\n"},{"file_path":"contracts/external/openzeppelin/contracts/utils/IERC165.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\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[EIP 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":"contracts/external/openzeppelin/contracts/utils/Strings.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n  bytes16 private constant _HEX_SYMBOLS = \"0123456789abcdef\";\n\n  /**\n   * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n   */\n  function toString(uint256 value) internal pure returns (string memory) {\n    // Inspired by OraclizeAPI's implementation - MIT licence\n    // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\n\n    if (value == 0) {\n      return \"0\";\n    }\n    uint256 temp = value;\n    uint256 digits;\n    while (temp != 0) {\n      digits++;\n      temp /= 10;\n    }\n    bytes memory buffer = new bytes(digits);\n    while (value != 0) {\n      digits -= 1;\n      buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\n      value /= 10;\n    }\n    return string(buffer);\n  }\n\n  /**\n   * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n   */\n  function toHexString(uint256 value) internal pure returns (string memory) {\n    if (value == 0) {\n      return \"0x00\";\n    }\n    uint256 temp = value;\n    uint256 length = 0;\n    while (temp != 0) {\n      length++;\n      temp >>= 8;\n    }\n    return toHexString(value, length);\n  }\n\n  /**\n   * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n   */\n  function toHexString(uint256 value, uint256 length)\n    internal\n    pure\n    returns (string memory)\n  {\n    bytes memory buffer = new bytes(2 * length + 2);\n    buffer[0] = \"0\";\n    buffer[1] = \"x\";\n    for (uint256 i = 2 * length + 1; i > 1; --i) {\n      buffer[i] = _HEX_SYMBOLS[value & 0xf];\n      value >>= 4;\n    }\n    require(value == 0, \"Strings: hex length insufficient\");\n    return string(buffer);\n  }\n}\n"}],"is_verified_via_sourcify":false,"can_be_visualized_via_sol2uml":true,"evm_version":"shanghai","language":"solidity","is_verified_via_eth_bytecode_db":false,"is_fully_verified":false,"license_type":"none","is_blueprint":false,"name":"TimelockController","creation_bytecode":"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","external_libraries":[],"proxy_type":null,"implementations":[],"verified_at":"2026-05-08T14:05:39.508583Z","is_verified_via_verifier_alliance":false,"compiler_version":"v0.8.22+commit.4fc1097e","decoded_constructor_args":[["7200",{"internalType":"uint256","name":"minDelay","type":"uint256"}],[[],{"internalType":"address[]","name":"proposers","type":"address[]"}],[[],{"internalType":"address[]","name":"executors","type":"address[]"}],["0x094Bee6b74Ec29D32869ae3140A659cAc0482882",{"internalType":"address","name":"admin","type":"address"}]],"sourcify_repo_url":null,"optimization_runs":200,"compiler_settings":{"evmVersion":"shanghai","libraries":{},"metadata":{"appendCBOR":true,"bytecodeHash":"ipfs","useLiteralContent":false},"optimizer":{"enabled":true,"runs":200},"outputSelection":{"*":{"":["*"],"*":["*"]}},"remappings":["eth-gas-reporter/=node_modules/eth-gas-reporter/","forge-tests/=forge-tests/","lib/=lib/","@aragon/=node_modules/@aragon/","@ensdomains/=node_modules/@ensdomains/","@openzeppelin/=node_modules/@openzeppelin/","@uniswap/=node_modules/@uniswap/","forge-std/=lib/forge-std/src/","hardhat-deploy/=node_modules/hardhat-deploy/","hardhat/=node_modules/hardhat/","math/=node_modules/@aragon/os/contracts/lib/math/","misc/=node_modules/@aragon/os/contracts/lib/misc/","solidity-bytes-utils/=node_modules/solidity-bytes-utils/","standards/=node_modules/@aragon/os/contracts/lib/standards/","token/=node_modules/@aragon/os/contracts/lib/token/","truffle/=node_modules/truffle/"],"viaIR":false},"is_verified":true,"verified_twin_address_hash":null,"optimization_enabled":true,"deployed_bytecode":"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","source_code":"// Copied from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/d9933585b6c134589d6819909a932de4c1a0db7f/contracts/governance/TimelockController.sol\n// NOTE: Removed inheritance of `ERC721Holder` and `ERC1155Holder`, as our TimelockController\n//       is intended to be used for administrative tasks only. Also changed from using AccessControl\n//       to using AccessControlEnumerable, as this aligns better with our standards.\n\n// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (governance/TimelockController.sol)\n\npragma solidity ^0.8.20;\n\nimport {AccessControlEnumerable} from \"contracts/external/openzeppelin/contracts/access/AccessControlEnumerable.sol\";\nimport {Address} from \"contracts/external/openzeppelin/contracts/utils/Address.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 AccessControlEnumerable {\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    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(\n        bytes4 interfaceId\n    ) public view virtual override(AccessControlEnumerable) 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, \"Error: call failed\");\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}","creation_status":"success","file_path":"contracts/external/openzeppelin/contracts/security/TimelockController.sol"}