{"file_path":"contracts/STBT.sol","creation_status":"success","source_code":"// SPDX-License-Identifier: GPL-3.0\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/proxy/Proxy.sol\";\nimport \"@openzeppelin/contracts/governance/TimelockController.sol\";\n\nimport \"./interfaces/ISTBT.sol\";\n\ncontract StbtTimelockController is TimelockController {\n\n    mapping (bytes4 => uint256) public delayMap;\n\n    constructor(\n        address[] memory proposers,\n        address[] memory executors,\n        address admin,\n        bytes4[] memory selectors,\n        uint256[] memory delays\n    ) TimelockController(0/*minDelay*/, proposers, executors, admin) {\n        require(selectors.length == delays.length, 'TimelockController: SELECTORS_DELAYS_LEN_NOT_MATCH');\n        for (uint256 i = 0; i < selectors.length; i++) {\n            delayMap[selectors[i]] = delays[i];\n        }\n    }\n\n    function updateDelay(uint256 /*newDelay*/) external override pure {\n        revert('TimelockController: UNSUPPORTED');\n    }\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 override pure {\n        revert('TimelockController: UNSUPPORTED');\n    }\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 override onlyRole(PROPOSER_ROLE) {\n\n        bytes4 sel = bytes4(data[0:4]);\n        uint256 delay = delayMap[sel];\n        require(delay > 0, 'TimelockController: UNKNOWN_SELECTOR');\n\n        super.schedule(target, value, data, predecessor, salt, delay);\n    }\n\n    // function schedule2(\n    //     address target,\n    //     bytes calldata data,\n    //     bytes32 predecessor,\n    //     bytes32 salt\n    // ) public {\n    //     schedule(target, 0, data, predecessor, salt, 0);\n    // }\n\n    // function cancelOperation(\n    //     address target,\n    //     uint256 value,\n    //     bytes calldata data,\n    //     bytes32 predecessor,\n    //     bytes32 salt\n    // ) public onlyRole(CANCELLER_ROLE) {\n\n    //     bytes32 id = hashOperation(target, value, data, predecessor, salt);\n    //     cancel(id);\n    // }\n\n    function _execute(\n        address target,\n        uint256 value,\n        bytes calldata data\n    ) internal override {\n        (bool success, ) = target.call{value: value}(data);\n        if (success == false) {\n            assembly {\n                let ptr := mload(0x40)\n                let size := returndatasize()\n                returndatacopy(ptr, 0, size)\n                revert(ptr, size)\n            }\n        }\n    }\n}\n\ncontract UpgradeableSTBT is Proxy {\n    // override\n    address public owner;\n    address public issuer;\n    address public controller;\n    address public moderator;\n    // new state below\n    address public implementation;\n\n    constructor(\n        address _owner,\n        address _issuer,\n        address _controller,\n        address _moderator,\n        address _impl\n    ){\n        owner = _owner;\n        issuer = _issuer;\n        controller = _controller;\n        moderator = _moderator;\n        implementation = _impl;\n    }\n\n    function resetImplementation(address _impl) external {\n        require(msg.sender == owner, \"STBT: NOT_OWNER\");\n        implementation = _impl;\n    }\n\n    function _implementation() internal view override returns (address) {\n        return implementation;\n    }\n}\n\ncontract STBT is Ownable, ISTBT {\n    // all the following three roles are contracts of governance/TimelockController.sol\n    address public issuer;\n    address public controller;\n    address public moderator;\n\n    uint[300] public placeholders;\n\n    uint public totalSupply;\n    uint public totalShares;\n    mapping(address => uint256) private shares;\n    mapping(address => mapping(address => uint256)) private allowances;\n    mapping(address => Permission) public permissions; // Address-specific transfer permissions\n\n    uint64 public lastDistributeTime;\n    uint64 public minDistributeInterval;\n    uint64 public maxDistributeRatio;\n\n    struct Document {\n        bytes32 docHash;\n        uint256 lastModified;\n        string uri;\n    }\n    bytes32[] docNames;\n    // doc name => doc detail\n    mapping(bytes32 => Document) public documents;\n    // doc name => doc name index in docNames\n    mapping(bytes32 => uint256) public docIndexes;\n\n    // EIP-1066 status code\n    uint8 private constant Success = 0x01;\n    uint8 private constant UpperLimit = 0x06;\n    uint8 private constant PermissionRequested = 0x13;\n    uint8 private constant RevokedOrBanned = 0x16;\n\n    event InterestsDistributed(int interest, uint newTotalSupply, uint interestFromTime, uint interestToTime);\n    event TransferShares(address indexed from, address indexed to, uint256 sharesValue);\n\n    modifier onlyIssuer() {\n        require(msg.sender == issuer, 'STBT: NOT_ISSUER');\n        _;\n    }\n\n    modifier onlyController() {\n        require(msg.sender == controller, 'STBT: NOT_CONTROLLER');\n        _;\n    }\n\n    modifier onlyModerator() {\n        require(msg.sender == moderator, 'STBT: NOT_MODERATOR');\n        _;\n    }\n\n    function setIssuer(address _issuer) public onlyOwner {\n        issuer = _issuer;\n    }\n\n    function setController(address _controller) public onlyOwner {\n        controller = _controller;\n    }\n\n    function setModerator(address _moderator) public onlyOwner {\n        moderator = _moderator;\n    }\n\n    function setMinDistributeInterval(uint64 interval) public onlyOwner {\n        minDistributeInterval = interval;\n    }\n\n    function setMaxDistributeRatio(uint64 ratio) public onlyOwner {\n        maxDistributeRatio = ratio;\n    }\n\n    function setPermission(address addr, Permission calldata permission) public onlyModerator {\n        permissions[addr] = permission;\n    }\n\n    function name() public pure returns (string memory) {\n        return \"Short-term Treasury Bill Token\";\n    }\n\n    function symbol() public pure returns (string memory) {\n        return \"STBT\";\n    }\n\n    function decimals() public pure returns (uint8) {\n        return 18;\n    }\n\n    function balanceOf(address _account) public view returns (uint256) {\n        return getAmountByShares(shares[_account]);\n    }\n\n    function transfer(address _recipient, uint256 _amount) public returns (bool) {\n        _transferWithCheck(msg.sender, _recipient, _amount);\n        return true;\n    }\n\n    function allowance(address _owner, address _spender) public view returns (uint256) {\n        return allowances[_owner][_spender];\n    }\n\n    function approve(address _spender, uint256 _amount) public returns (bool) {\n        _approve(msg.sender, _spender, _amount);\n        return true;\n    }\n\n    function transferFrom(address _sender, address _recipient, uint256 _amount) public returns (bool) {\n        uint256 currentAllowance = allowances[_sender][msg.sender];\n        require(currentAllowance >= _amount, \"STBT: TRANSFER_AMOUNT_EXCEEDS_ALLOWANCE\");\n\n        _transferWithCheck(_sender, _recipient, _amount);\n        _approve(_sender, msg.sender, currentAllowance - _amount);\n        return true;\n    }\n\n    function increaseAllowance(address _spender, uint256 _addedValue) public returns (bool) {\n        _approve(msg.sender, _spender, allowances[msg.sender][_spender] + _addedValue);\n        return true;\n    }\n\n    function decreaseAllowance(address _spender, uint256 _subtractedValue) public returns (bool) {\n        uint256 currentAllowance = allowances[msg.sender][_spender];\n        require(currentAllowance >= _subtractedValue, \"STBT: DECREASED_ALLOWANCE_BELOW_ZERO\");\n        _approve(msg.sender, _spender, currentAllowance - _subtractedValue);\n        return true;\n    }\n\n    function sharesOf(address _account) public view returns (uint256) {\n        return shares[_account];\n    }\n\n    function getSharesByAmountRoundUp(uint256 _amount) public view returns (uint256 result) {\n        uint _totalSupply = totalSupply;\n        return _totalSupply == 0 ? 0 : (_amount * totalShares + _totalSupply - 1) / _totalSupply;\n    }\n\n    function getSharesByAmount(uint256 _amount) public view returns (uint256 result) {\n        // unchecked {\n        //     result = _amount * totalShares / totalSupply; // divide-by-zero will return zero\n        // }\n        return totalSupply == 0 ? 0 : _amount * totalShares / totalSupply;\n    }\n\n    function getAmountByShares(uint256 _shares) public view returns (uint256 result) {\n        // unchecked {\n        //     result = _shares * totalSupply / totalShares; // divide-by-zero will return zero\n        // }\n        return totalShares == 0 ? 0 : _shares * totalSupply / totalShares;\n    }\n\n    function _transferWithCheck(address _sender, address _recipient, uint256 _amount) internal {\n        _checkSendPermission(_sender);\n        _checkReceivePermission(_recipient);\n        _transfer(_sender, _recipient, _amount);\n    }\n\n    function _checkSendPermission(address _sender) private view {\n        Permission memory permTx = permissions[_sender];\n        require(permTx.sendAllowed, 'STBT: NO_SEND_PERMISSION');\n        require(permTx.expiryTime == 0 || permTx.expiryTime > block.timestamp, 'STBT: SEND_PERMISSION_EXPIRED');\n    }\n    function _checkReceivePermission(address _recipient) private view {\n        Permission memory permRx = permissions[_recipient];\n        require(permRx.receiveAllowed, 'STBT: NO_RECEIVE_PERMISSION');\n        require(permRx.expiryTime == 0 || permRx.expiryTime > block.timestamp, 'STBT: RECEIVE_PERMISSION_EXPIRED');\n    }\n\n    function _transfer(address _sender, address _recipient, uint256 _amount) internal {\n        uint256 _sharesToTransfer = getSharesByAmount(_amount);\n        _transferShares(_sender, _recipient, _sharesToTransfer);\n        emit Transfer(_sender, _recipient, getAmountByShares(_sharesToTransfer));\n    }\n\n    function _approve(address _owner, address _spender, uint256 _amount) internal {\n        allowances[_owner][_spender] = _amount;\n        emit Approval(_owner, _spender, _amount);\n    }\n\n    function _transferShares(address _sender, address _recipient, uint256 _shares) internal {\n        require(_sender != address(0), \"STBT: TRANSFER_FROM_THE_ZERO_ADDRESS\");\n        require(_recipient != address(0), \"STBT: TRANSFER_TO_THE_ZERO_ADDRESS\");\n\n        uint256 currentSenderShares = shares[_sender];\n        require(_shares <= currentSenderShares, \"STBT: TRANSFER_AMOUNT_EXCEEDS_BALANCE\");\n\n        shares[_sender] = currentSenderShares - _shares;\n        shares[_recipient] = shares[_recipient] + _shares;\n        emit TransferShares(_sender, _recipient, _shares);\n    }\n\n    function _mintSharesWithCheck(address _recipient, uint256 _shares) internal returns (uint256 newTotalShares) {\n        require(_recipient != address(0), \"STBT: MINT_TO_THE_ZERO_ADDRESS\");\n        _checkReceivePermission(_recipient);\n\n        totalShares += _shares;\n\n        shares[_recipient] += _shares;\n        emit TransferShares(address(0), _recipient, _shares);\n        return totalShares;\n    }\n\n    function _burnSharesWithCheck(address _account, uint256 _shares) internal returns (uint256 newTotalShares) {\n        _checkSendPermission(_account);\n        return _burnShares(_account, _shares);\n    }\n\n    function _burnShares(address _account, uint256 _shares) internal returns (uint256 newTotalShares) {\n        require(_account != address(0), \"STBT: BURN_FROM_THE_ZERO_ADDRESS\");\n\n        uint256 accountShares = shares[_account];\n        require(_shares <= accountShares, \"STBT: BURN_AMOUNT_EXCEEDS_BALANCE\");\n\n        newTotalShares = totalShares - _shares;\n        totalShares = newTotalShares;\n\n        shares[_account] = accountShares - _shares;\n\n        emit TransferShares(_account, address(0), _shares);\n    }\n\n    function distributeInterests(int256 _distributedInterest, uint interestFromTime, uint interestToTime) external onlyIssuer {\n        uint oldTotalSupply = totalSupply;\n        uint newTotalSupply;\n        if(_distributedInterest > 0) {\n            require(oldTotalSupply * maxDistributeRatio >= uint(_distributedInterest) * (10 ** 18), 'STBT: MAX_DISTRIBUTE_RATIO_EXCEEDED');\n            newTotalSupply = oldTotalSupply + uint(_distributedInterest);\n        } else {\n            require(oldTotalSupply * maxDistributeRatio >= uint(-_distributedInterest) * (10 ** 18), 'STBT: MAX_DISTRIBUTE_RATIO_EXCEEDED');\n            newTotalSupply = oldTotalSupply - uint(-_distributedInterest);\n        }\n        totalSupply = newTotalSupply;\n        require(lastDistributeTime + minDistributeInterval < block.timestamp, 'STBT: MIN_DISTRIBUTE_INTERVAL_VIOLATED');\n        emit InterestsDistributed(_distributedInterest, newTotalSupply, interestFromTime, interestToTime);\n        lastDistributeTime = uint64(block.timestamp);\n    }\n\n    function isControllable() external pure returns (bool) {\n        return true;\n    }\n\n    function controllerTransfer(address _from, address _to, uint256 _value, bytes calldata _data, bytes calldata _operatorData) external onlyController {\n        _transfer(_from, _to, _value);\n        emit ControllerTransfer(msg.sender, _from, _to, _value, _data, _operatorData);\n    }\n\n    function controllerRedeem(address _tokenHolder, uint256 _value, bytes calldata _data, bytes calldata _operatorData) external onlyController {\n        uint sharesDelta = getSharesByAmountRoundUp(_value);\n        _burnShares(_tokenHolder, sharesDelta);\n        totalSupply -= _value;\n        _value = getAmountByShares(sharesDelta);\n        emit ControllerRedemption(msg.sender, _tokenHolder, _value, _data, _operatorData);\n        emit Transfer(_tokenHolder, address(0), _value);\n    }\n\n    // Transfers\n    function transferWithData(address _to, uint256 _value, bytes calldata /*_data*/) external {\n        transfer(_to, _value);\n    }\n\n    function transferFromWithData(address _from, address _to, uint256 _value, bytes calldata /*_data*/) external {\n        transferFrom(_from, _to, _value);\n    }\n\n    // Token Issuance\n    function isIssuable() external pure returns (bool) {\n        return true;\n    }\n\n    function issue(address _tokenHolder, uint256 _value, bytes calldata _data) external onlyIssuer {\n        if (_value == 0) {\n            return;\n        }\n        uint sharesDelta = getSharesByAmount(_value);\n        if (sharesDelta == 0) {\n            sharesDelta = _value;\n            totalSupply = _value;\n            lastDistributeTime = uint64(block.timestamp);\n        } else {\n            totalSupply += _value;\n        }\n        _mintSharesWithCheck(_tokenHolder, sharesDelta);\n        _value = getAmountByShares(sharesDelta);\n        emit Issued(msg.sender, _tokenHolder, _value, _data);\n        emit Transfer(address(0), _tokenHolder, _value);\n    }\n\n    // Token Redemption\n    function redeem(uint256 _value, bytes calldata _data) external onlyIssuer {\n        if (_value == 0) {\n            return;\n        }\n        uint sharesDelta = getSharesByAmountRoundUp(_value);\n        _burnSharesWithCheck(msg.sender, sharesDelta);\n        totalSupply -= _value;\n        _value = getAmountByShares(sharesDelta);\n        emit Redeemed(msg.sender, msg.sender, _value, _data);\n        emit Transfer(msg.sender, address(0), _value);\n    }\n\n    function redeemFrom(address _tokenHolder, uint256 _value, bytes calldata _data) external onlyIssuer {\n        uint256 currentAllowance = allowances[_tokenHolder][msg.sender];\n        require(currentAllowance >= _value, \"STBT: REDEEM_AMOUNT_EXCEEDS_ALLOWANCE\");\n\n        uint sharesDelta = getSharesByAmountRoundUp(_value);\n        _burnSharesWithCheck(_tokenHolder, sharesDelta);\n        totalSupply -= _value;\n        _value = getAmountByShares(sharesDelta);\n        emit Redeemed(msg.sender, _tokenHolder, _value, _data);\n        emit Transfer(_tokenHolder, address(0), _value);\n        _approve(_tokenHolder, msg.sender, currentAllowance - _value);\n    }\n\n\n    function _checkTransfer(address _sender, address _recipient, uint256 _amount, bytes calldata /*_data*/) internal view returns (bool, uint8, bytes32) {\n        Permission memory permTx = permissions[_sender];\n        Permission memory permRx = permissions[_recipient];\n        bool txOK = permTx.sendAllowed && (permTx.expiryTime == 0 || permTx.expiryTime > block.timestamp) &&\n        _sender != address(0);\n        if (!txOK) {\n            return (false, PermissionRequested, bytes32(bytes(\"CANNOT_SEND\")));\n        }\n        bool rxOK = permRx.receiveAllowed && (permRx.expiryTime == 0 || permRx.expiryTime > block.timestamp) &&\n        _recipient != address(0);\n        if (!rxOK) {\n            return (false, PermissionRequested, bytes32(bytes(\"CANNOT_RECEIVE\")));\n        }\n        uint256 _shares = getSharesByAmount(_amount);\n        uint256 currentSenderShares = shares[_sender];\n        if (_shares > currentSenderShares) {\n            return (false, UpperLimit, bytes32(bytes(\"SHARES_NOT_ENOUGH\")));\n        }\n        return (true, Success, bytes32(0));\n    }\n\n    function canTransfer(address _recipient, uint256 _amount, bytes calldata _data) external view returns (bool, uint8, bytes32) {\n        return _checkTransfer(msg.sender, _recipient, _amount, _data);\n    }\n\n    function canTransferFrom(address _sender, address _recipient, uint256 _amount, bytes calldata _data) external view returns (bool, uint8, bytes32) {\n        uint256 currentAllowance = allowances[_sender][msg.sender];\n        if (_amount > currentAllowance) {\n            return (false, UpperLimit, bytes32(bytes(\"ALLOWANCE_NOT_ENOUGH\")));\n        }\n        return _checkTransfer(_sender, _recipient, _amount, _data);\n    }\n\n    function setDocument(bytes32 _name, string calldata _uri, bytes32 _documentHash) external onlyOwner {\n        require(_name != bytes32(0), \"STBT: INVALID_DOC_NAME\");\n        require(bytes(_uri).length > 0, \"STBT: INVALID_URL\");\n        if (documents[_name].lastModified == uint256(0)) {\n            docNames.push(_name);\n            docIndexes[_name] = docNames.length;\n        }\n        documents[_name] = Document(_documentHash, block.timestamp, _uri);\n        emit DocumentUpdated(_name, _uri, _documentHash);\n    }\n\n    function removeDocument(bytes32 _name) external onlyOwner {\n        require(documents[_name].lastModified != uint256(0), \"STBT: DOC_NOT_EXIST\");\n        uint256 index = docIndexes[_name] - 1;\n        if (index != docNames.length - 1) {\n            docNames[index] = docNames[docNames.length - 1];\n            docIndexes[docNames[index]] = index + 1;\n        }\n        docNames.pop();\n        delete documents[_name];\n        emit DocumentRemoved(_name, documents[_name].uri, documents[_name].docHash);\n    }\n\n    function getDocument(bytes32 _name) external view returns (string memory, bytes32, uint256) {\n        return (\n        documents[_name].uri,\n        documents[_name].docHash,\n        documents[_name].lastModified\n        );\n    }\n\n    function getAllDocuments() external view returns (bytes32[] memory) {\n        return docNames;\n    }\n}\n\n\n","deployed_bytecode":"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","optimization_enabled":true,"verified_twin_address_hash":null,"is_verified":true,"compiler_settings":{"libraries":{},"optimizer":{"enabled":true,"runs":1000},"outputSelection":{"*":{"":["*"],"*":["*"]}}},"optimization_runs":1000,"sourcify_repo_url":null,"decoded_constructor_args":[[["0x1101914876D258142F6921B0C72A3B9E86005ac4"],{"internalType":"address[]","name":"proposers","type":"address[]"}],[["0x9D864189cFf8aCbAee4e9c13f265878b9A1f917A"],{"internalType":"address[]","name":"executors","type":"address[]"}],["0x0000000000000000000000000000000000000000",{"internalType":"address","name":"admin","type":"address"}],[["0x55cc4e57","0x92eefe9b","0x75bba189","0x322e654e","0x8db8df7f","0x010648ca","0xc3501848","0xf2fde38b","0x8feb4fce","0xbb3acde9","0xe77c646d","0x9675193c","0x32574d71","0x47e640c0","0xf282527a","0x2bc6acc3","0x2f2ff15d","0xd547741f"],{"internalType":"bytes4[]","name":"selectors","type":"bytes4[]"}],[["86400","86400","86400","14400","14400","1","1","86400","86400","14400","14400","14400","14400","1","14400","14400","14400","14400"],{"internalType":"uint256[]","name":"delays","type":"uint256[]"}]],"compiler_version":"v0.8.17+commit.8df45f5f","is_verified_via_verifier_alliance":true,"verified_at":"2023-09-14T16:41:06.927552Z","implementations":[],"proxy_type":null,"external_libraries":[],"creation_bytecode":"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","name":"StbtTimelockController","is_blueprint":false,"license_type":"none","is_fully_verified":true,"is_verified_via_eth_bytecode_db":true,"language":"solidity","evm_version":"default","can_be_visualized_via_sol2uml":true,"is_verified_via_sourcify":false,"additional_sources":[{"file_path":"@openzeppelin/contracts/access/AccessControl.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (access/AccessControl.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IAccessControl.sol\";\nimport \"../utils/Context.sol\";\nimport \"../utils/Strings.sol\";\nimport \"../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 * ```\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);\n        _;\n    }\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\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 override returns (bool) {\n        return _roles[role].members[account];\n    }\n\n    /**\n     * @dev Revert with a standard message if `_msgSender()` is missing `role`.\n     * Overriding this function changes the behavior of the {onlyRole} modifier.\n     *\n     * Format of the revert message is described in {_checkRole}.\n     *\n     * _Available since v4.6._\n     */\n    function _checkRole(bytes32 role) internal view virtual {\n        _checkRole(role, _msgSender());\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(account),\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) public view virtual override 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 override 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 override 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 `account`.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function renounceRole(bytes32 role, address account) public virtual override {\n        require(account == _msgSender(), \"AccessControl: can only renounce roles for self\");\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     * May emit a {RoleGranted} event.\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     * May emit a {RoleGranted} event.\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     * May emit a {RoleRevoked} event.\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":"@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(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, an admin role\n     * bearer except when using {AccessControl-_setupRole}.\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 `account`.\n     */\n    function renounceRole(bytes32 role, address account) external;\n}\n"},{"file_path":"@openzeppelin/contracts/access/Ownable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby removing any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"},{"file_path":"@openzeppelin/contracts/governance/TimelockController.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (governance/TimelockController.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../access/AccessControl.sol\";\nimport \"../token/ERC721/IERC721Receiver.sol\";\nimport \"../token/ERC1155/IERC1155Receiver.sol\";\nimport \"../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 *\n * _Available since v3.3._\n */\ncontract TimelockController is AccessControl, IERC721Receiver, IERC1155Receiver {\n    bytes32 public constant TIMELOCK_ADMIN_ROLE = keccak256(\"TIMELOCK_ADMIN_ROLE\");\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 => uint256) private _timestamps;\n    uint256 private _minDelay;\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 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 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(\n        uint256 minDelay,\n        address[] memory proposers,\n        address[] memory executors,\n        address admin\n    ) {\n        _setRoleAdmin(TIMELOCK_ADMIN_ROLE, TIMELOCK_ADMIN_ROLE);\n        _setRoleAdmin(PROPOSER_ROLE, TIMELOCK_ADMIN_ROLE);\n        _setRoleAdmin(EXECUTOR_ROLE, TIMELOCK_ADMIN_ROLE);\n        _setRoleAdmin(CANCELLER_ROLE, TIMELOCK_ADMIN_ROLE);\n\n        // self administration\n        _setupRole(TIMELOCK_ADMIN_ROLE, address(this));\n\n        // optional admin\n        if (admin != address(0)) {\n            _setupRole(TIMELOCK_ADMIN_ROLE, admin);\n        }\n\n        // register proposers and cancellers\n        for (uint256 i = 0; i < proposers.length; ++i) {\n            _setupRole(PROPOSER_ROLE, proposers[i]);\n            _setupRole(CANCELLER_ROLE, proposers[i]);\n        }\n\n        // register executors\n        for (uint256 i = 0; i < executors.length; ++i) {\n            _setupRole(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 {}\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, AccessControl) returns (bool) {\n        return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev Returns whether an id correspond to a registered operation. This\n     * includes both Pending, Ready and Done operations.\n     */\n    function isOperation(bytes32 id) public view virtual returns (bool registered) {\n        return getTimestamp(id) > 0;\n    }\n\n    /**\n     * @dev Returns whether an operation is pending or not.\n     */\n    function isOperationPending(bytes32 id) public view virtual returns (bool pending) {\n        return getTimestamp(id) > _DONE_TIMESTAMP;\n    }\n\n    /**\n     * @dev Returns whether an operation is ready or not.\n     */\n    function isOperationReady(bytes32 id) public view virtual returns (bool ready) {\n        uint256 timestamp = getTimestamp(id);\n        return timestamp > _DONE_TIMESTAMP && timestamp <= block.timestamp;\n    }\n\n    /**\n     * @dev Returns whether an operation is done or not.\n     */\n    function isOperationDone(bytes32 id) public view virtual returns (bool done) {\n        return getTimestamp(id) == _DONE_TIMESTAMP;\n    }\n\n    /**\n     * @dev Returns the timestamp at with an operation becomes ready (0 for\n     * unset operations, 1 for done operations).\n     */\n    function getTimestamp(bytes32 id) public view virtual returns (uint256 timestamp) {\n        return _timestamps[id];\n    }\n\n    /**\n     * @dev Returns the minimum delay 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 duration) {\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 hash) {\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 hash) {\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 a {CallScheduled} event.\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    }\n\n    /**\n     * @dev Schedule an operation containing a batch of transactions.\n     *\n     * Emits 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        require(targets.length == values.length, \"TimelockController: length mismatch\");\n        require(targets.length == payloads.length, \"TimelockController: length mismatch\");\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    }\n\n    /**\n     * @dev Schedule an operation that is to becomes valid after a given delay.\n     */\n    function _schedule(bytes32 id, uint256 delay) private {\n        require(!isOperation(id), \"TimelockController: operation already scheduled\");\n        require(delay >= getMinDelay(), \"TimelockController: insufficient delay\");\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        require(isOperationPending(id), \"TimelockController: operation cannot be cancelled\");\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    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        require(targets.length == values.length, \"TimelockController: length mismatch\");\n        require(targets.length == payloads.length, \"TimelockController: length mismatch\");\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(\n        address target,\n        uint256 value,\n        bytes calldata data\n    ) internal virtual {\n        (bool success, ) = target.call{value: value}(data);\n        require(success, \"TimelockController: underlying transaction reverted\");\n    }\n\n    /**\n     * @dev Checks before execution of an operation's calls.\n     */\n    function _beforeCall(bytes32 id, bytes32 predecessor) private view {\n        require(isOperationReady(id), \"TimelockController: operation is not ready\");\n        require(predecessor == bytes32(0) || isOperationDone(predecessor), \"TimelockController: missing dependency\");\n    }\n\n    /**\n     * @dev Checks after execution of an operation's calls.\n     */\n    function _afterCall(bytes32 id) private {\n        require(isOperationReady(id), \"TimelockController: operation is not ready\");\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        require(msg.sender == address(this), \"TimelockController: caller must be timelock\");\n        emit MinDelayChange(_minDelay, newDelay);\n        _minDelay = newDelay;\n    }\n\n    /**\n     * @dev See {IERC721Receiver-onERC721Received}.\n     */\n    function onERC721Received(\n        address,\n        address,\n        uint256,\n        bytes memory\n    ) public virtual override returns (bytes4) {\n        return this.onERC721Received.selector;\n    }\n\n    /**\n     * @dev See {IERC1155Receiver-onERC1155Received}.\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    /**\n     * @dev See {IERC1155Receiver-onERC1155BatchReceived}.\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/interfaces/IERC20Metadata.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (interfaces/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../token/ERC20/extensions/IERC20Metadata.sol\";\n"},{"file_path":"@openzeppelin/contracts/proxy/Proxy.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\n * be specified by overriding the virtual {_implementation} function.\n *\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\n * different contract through the {_delegate} function.\n *\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\n */\nabstract contract Proxy {\n    /**\n     * @dev Delegates the current call to `implementation`.\n     *\n     * This function does not return to its internal call site, it will return directly to the external caller.\n     */\n    function _delegate(address implementation) internal virtual {\n        assembly {\n            // Copy msg.data. We take full control of memory in this inline assembly\n            // block because it will not return to Solidity code. We overwrite the\n            // Solidity scratch pad at memory position 0.\n            calldatacopy(0, 0, calldatasize())\n\n            // Call the implementation.\n            // out and outsize are 0 because we don't know the size yet.\n            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\n\n            // Copy the returned data.\n            returndatacopy(0, 0, returndatasize())\n\n            switch result\n            // delegatecall returns 0 on error.\n            case 0 {\n                revert(0, returndatasize())\n            }\n            default {\n                return(0, returndatasize())\n            }\n        }\n    }\n\n    /**\n     * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function\n     * and {_fallback} should delegate.\n     */\n    function _implementation() internal view virtual returns (address);\n\n    /**\n     * @dev Delegates the current call to the address returned by `_implementation()`.\n     *\n     * This function does not return to its internal call site, it will return directly to the external caller.\n     */\n    function _fallback() internal virtual {\n        _beforeFallback();\n        _delegate(_implementation());\n    }\n\n    /**\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\n     * function in the contract matches the call data.\n     */\n    fallback() external payable virtual {\n        _fallback();\n    }\n\n    /**\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\n     * is empty.\n     */\n    receive() external payable virtual {\n        _fallback();\n    }\n\n    /**\n     * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\n     * call, or as part of the Solidity `fallback` or `receive` functions.\n     *\n     * If overridden should call `super._beforeFallback()`.\n     */\n    function _beforeFallback() internal virtual {}\n}\n"},{"file_path":"@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev _Available since v3.1._\n */\ninterface IERC1155Receiver is IERC165 {\n    /**\n     * @dev Handles the receipt of a single ERC1155 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 ERC1155 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/ERC20/IERC20.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `from` to `to` using the\n     * allowance mechanism. `amount` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(\n        address from,\n        address to,\n        uint256 amount\n    ) external returns (bool);\n}\n"},{"file_path":"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n"},{"file_path":"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @title ERC721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC721 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 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/utils/Address.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.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(success, \"Address: unable to send value, recipient may have reverted\");\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) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, \"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 functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\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(address(this).balance >= value, \"Address: insufficient balance for call\");\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, 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) internal view returns (bytes memory) {\n        return 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        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, 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) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\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        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n     *\n     * _Available since v4.8._\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        if (success) {\n            if (returndata.length == 0) {\n                // only check isContract if the call was successful and the return data is empty\n                // otherwise we already know that it was a contract\n                require(isContract(target), \"Address: call to non-contract\");\n            }\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason or 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            _revert(returndata, errorMessage);\n        }\n    }\n\n    function _revert(bytes memory returndata, string memory errorMessage) 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            /// @solidity memory-safe-assembly\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"},{"file_path":"@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":"@openzeppelin/contracts/utils/Strings.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./math/Math.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    bytes16 private constant _SYMBOLS = \"0123456789abcdef\";\n    uint8 private constant _ADDRESS_LENGTH = 20;\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        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            /// @solidity memory-safe-assembly\n            assembly {\n                ptr := add(buffer, add(32, length))\n            }\n            while (true) {\n                ptr--;\n                /// @solidity memory-safe-assembly\n                assembly {\n                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\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        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\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) internal pure returns (string memory) {\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] = _SYMBOLS[value & 0xf];\n            value >>= 4;\n        }\n        require(value == 0, \"Strings: hex length insufficient\");\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\n    }\n}\n"},{"file_path":"@openzeppelin/contracts/utils/introspection/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 \"./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) public view virtual override returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n"},{"file_path":"@openzeppelin/contracts/utils/introspection/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":"@openzeppelin/contracts/utils/math/Math.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Down, // Toward negative infinity\n        Up, // Toward infinity\n        Zero // Toward zero\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds up instead\n     * of rounding down.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a == 0 ? 0 : (a - 1) / b + 1;\n    }\n\n    /**\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\n     * with further edits by Uniswap Labs also under MIT license.\n     */\n    function mulDiv(\n        uint256 x,\n        uint256 y,\n        uint256 denominator\n    ) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2^256 + prod0.\n            uint256 prod0; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod0 := mul(x, y)\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\n            require(denominator > prod1);\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\n            // See https://cs.stackexchange.com/q/138556/92363.\n\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\n            uint256 twos = denominator & (~denominator + 1);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv = 1 mod 2^4.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\n            // in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(\n        uint256 x,\n        uint256 y,\n        uint256 denominator,\n        Rounding rounding\n    ) internal pure returns (uint256) {\n        uint256 result = mulDiv(x, y, denominator);\n        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\n            result += 1;\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\n     *\n     * Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        if (a == 0) {\n            return 0;\n        }\n\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n        //\n        // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n        //\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n        //\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n        uint256 result = 1 << (log2(a) >> 1);\n\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n        // into the expected uint128 result.\n        unchecked {\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            return min(result, a / result);\n        }\n    }\n\n    /**\n     * @notice Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 128;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 64;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 32;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 16;\n            }\n            if (value >> 8 > 0) {\n                value >>= 8;\n                result += 8;\n            }\n            if (value >> 4 > 0) {\n                value >>= 4;\n                result += 4;\n            }\n            if (value >> 2 > 0) {\n                value >>= 2;\n                result += 2;\n            }\n            if (value >> 1 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10**64) {\n                value /= 10**64;\n                result += 64;\n            }\n            if (value >= 10**32) {\n                value /= 10**32;\n                result += 32;\n            }\n            if (value >= 10**16) {\n                value /= 10**16;\n                result += 16;\n            }\n            if (value >= 10**8) {\n                value /= 10**8;\n                result += 8;\n            }\n            if (value >= 10**4) {\n                value /= 10**4;\n                result += 4;\n            }\n            if (value >= 10**2) {\n                value /= 10**2;\n                result += 2;\n            }\n            if (value >= 10**1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 16;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 8;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 4;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 2;\n            }\n            if (value >> 8 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);\n        }\n    }\n}\n"},{"file_path":"contracts/interfaces/ISTBT.sol","source_code":"// SPDX-License-Identifier: GPL-3.0\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/interfaces/IERC20Metadata.sol\";\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\n\ninterface IERC1644 is IERC20 {\n    // Controller Events\n    event ControllerTransfer(\n        address _controller,\n        address indexed _from,\n        address indexed _to,\n        uint256 _value,\n        bytes _data,\n        bytes _operatorData\n    );\n\n    event ControllerRedemption(\n        address _controller,\n        address indexed _tokenHolder,\n        uint256 _value,\n        bytes _data,\n        bytes _operatorData\n    );\n\n    // Controller Operation\n    function isControllable() external view returns (bool);\n    function controllerTransfer(address _from, address _to, uint256 _value, bytes calldata _data, bytes calldata _operatorData) external;\n    function controllerRedeem(address _tokenHolder, uint256 _value, bytes calldata _data, bytes calldata _operatorData) external;\n}\n\ninterface IERC1643 {\n    // Document Events\n    event DocumentRemoved(bytes32 indexed _name, string _uri, bytes32 _documentHash);\n    event DocumentUpdated(bytes32 indexed _name, string _uri, bytes32 _documentHash);\n\n    // Document Management\n    function getDocument(bytes32 _name) external view returns (string memory, bytes32, uint256);\n    function setDocument(bytes32 _name, string calldata _uri, bytes32 _documentHash) external;\n    function removeDocument(bytes32 _name) external;\n    function getAllDocuments() external view returns (bytes32[] memory);\n}\n\ninterface IERC1594 is IERC20 {\n    // Issuance / Redemption Events\n    event Issued(address indexed _operator, address indexed _to, uint256 _value, bytes _data);\n    event Redeemed(address indexed _operator, address indexed _from, uint256 _value, bytes _data);\n\n    // Transfers\n    function transferWithData(address _to, uint256 _value, bytes calldata _data) external;\n    function transferFromWithData(address _from, address _to, uint256 _value, bytes calldata _data) external;\n\n    // Token Issuance\n    function isIssuable() external view returns (bool);\n    function issue(address _tokenHolder, uint256 _value, bytes calldata _data) external;\n\n    // Token Redemption\n    function redeem(uint256 _value, bytes calldata _data) external;\n    function redeemFrom(address _tokenHolder, uint256 _value, bytes calldata _data) external;\n\n    // Transfer Validity\n    function canTransfer(address _to, uint256 _value, bytes calldata _data) external view returns (bool, uint8, bytes32);\n    function canTransferFrom(address _from, address _to, uint256 _value, bytes calldata _data) external view returns (bool, uint8, bytes32);\n}\n\ninterface ISTBT is IERC20, IERC20Metadata, IERC1594, IERC1643, IERC1644 {\n    struct Permission {\n        bool sendAllowed; // default: true\n        bool receiveAllowed;\n        // Address holder’s KYC will be validated till this time, after that the holder needs to re-KYC.\n        uint64 expiryTime; // default:0 validated forever\n    }\n\n    function setIssuer(address _issuer) external;\n    function setController(address _controller) external;\n    function setModerator(address _moderator) external;\n    function setMinDistributeInterval(uint64 interval) external;\n    function setMaxDistributeRatio(uint64 ratio) external;\n    function setPermission(address addr, Permission calldata permission) external;\n\n    function distributeInterests(int256 _distributedInterest, uint interestFromTime, uint interestToTime) external;\n\n    function increaseAllowance(address _spender, uint256 _addedValue) external returns (bool);\n    function decreaseAllowance(address _spender, uint256 _subtractedValue) external returns (bool);\n\n    function sharesOf(address _account) external view returns (uint256);\n    function getSharesByAmount(uint256 _amount) external view returns (uint256 result);\n    function getAmountByShares(uint256 _shares) external view returns (uint256 result);\n}\n"}],"certified":false,"conflicting_implementations":null,"abi":[{"inputs":[{"internalType":"address[]","name":"proposers","type":"address[]"},{"internalType":"address[]","name":"executors","type":"address[]"},{"internalType":"address","name":"admin","type":"address"},{"internalType":"bytes4[]","name":"selectors","type":"bytes4[]"},{"internalType":"uint256[]","name":"delays","type":"uint256[]"}],"stateMutability":"nonpayable","type":"constructor"},{"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":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":[],"name":"TIMELOCK_ADMIN_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":"bytes4","name":"","type":"bytes4"}],"name":"delayMap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"duration","type":"uint256"}],"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":"getTimestamp","outputs":[{"internalType":"uint256","name":"timestamp","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":"hash","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":"hash","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"isOperation","outputs":[{"internalType":"bool","name":"registered","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"isOperationDone","outputs":[{"internalType":"bool","name":"done","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"isOperationPending","outputs":[{"internalType":"bool","name":"pending","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"}],"name":"isOperationReady","outputs":[{"internalType":"bool","name":"ready","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":"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":"","type":"uint256"}],"name":"schedule","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"","type":"address[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes[]","name":"","type":"bytes[]"},{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"scheduleBatch","outputs":[],"stateMutability":"pure","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":"","type":"uint256"}],"name":"updateDelay","outputs":[],"stateMutability":"pure","type":"function"},{"stateMutability":"payable","type":"receive"}],"is_changed_bytecode":false,"is_partially_verified":false,"constructor_args":"0x00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000000010000000000000000000000001101914876d258142f6921b0c72a3b9e86005ac400000000000000000000000000000000000000000000000000000000000000010000000000000000000000009d864189cff8acbaee4e9c13f265878b9a1f917a000000000000000000000000000000000000000000000000000000000000001255cc4e570000000000000000000000000000000000000000000000000000000092eefe9b0000000000000000000000000000000000000000000000000000000075bba18900000000000000000000000000000000000000000000000000000000322e654e000000000000000000000000000000000000000000000000000000008db8df7f00000000000000000000000000000000000000000000000000000000010648ca00000000000000000000000000000000000000000000000000000000c350184800000000000000000000000000000000000000000000000000000000f2fde38b000000000000000000000000000000000000000000000000000000008feb4fce00000000000000000000000000000000000000000000000000000000bb3acde900000000000000000000000000000000000000000000000000000000e77c646d000000000000000000000000000000000000000000000000000000009675193c0000000000000000000000000000000000000000000000000000000032574d710000000000000000000000000000000000000000000000000000000047e640c000000000000000000000000000000000000000000000000000000000f282527a000000000000000000000000000000000000000000000000000000002bc6acc3000000000000000000000000000000000000000000000000000000002f2ff15d00000000000000000000000000000000000000000000000000000000d547741f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012000000000000000000000000000000000000000000000000000000000001518000000000000000000000000000000000000000000000000000000000000151800000000000000000000000000000000000000000000000000000000000015180000000000000000000000000000000000000000000000000000000000000384000000000000000000000000000000000000000000000000000000000000038400000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000151800000000000000000000000000000000000000000000000000000000000015180000000000000000000000000000000000000000000000000000000000000384000000000000000000000000000000000000000000000000000000000000038400000000000000000000000000000000000000000000000000000000000003840000000000000000000000000000000000000000000000000000000000000384000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000003840000000000000000000000000000000000000000000000000000000000000384000000000000000000000000000000000000000000000000000000000000038400000000000000000000000000000000000000000000000000000000000003840"}