{"file_path":"contracts/STBTv2.sol","creation_status":"success","source_code":"// SPDX-License-Identifier: GPL-3.0\npragma solidity ^0.8.7;\n\nimport \"@openzeppelin/contracts/proxy/Proxy.sol\";\nimport \"@openzeppelin/contracts/governance/TimelockController.sol\";\nimport \"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\";\n\nimport \"./interfaces/ISTBT.sol\";\n\n\ncontract STBTv2 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    AggregatorV3Interface internal immutable reserveFeed;\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    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    constructor(address addr) {\n        reserveFeed = AggregatorV3Interface(addr);\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    /**\n     * Returns the latest price\n     */\n    function getLatestReserve() public view returns (int) {\n        // prettier-ignore\n        (\n            /*uint80 roundID*/,\n            int reserve,\n            /*uint startedAt*/,\n            /*uint timeStamp*/,\n            /*uint80 answeredInRound*/\n        ) = reserveFeed.latestRoundData();\n\n        return reserve;\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        require(newTotalSupply <= uint(getLatestReserve()), \"STBT: EXCEED_RESERVE\");\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            uint _totalSupply = totalSupply + _value;\n            require(_totalSupply <= uint(getLatestReserve()), \"STBT: EXCEED_RESERVE\");\n            totalSupply = _totalSupply;\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":{"evmVersion":"shanghai","libraries":{},"metadata":{"bytecodeHash":"ipfs","useLiteralContent":true},"optimizer":{"enabled":true,"runs":1000},"remappings":[]},"optimization_runs":1000,"sourcify_repo_url":"https://repo.sourcify.dev/contracts/full_match/1/0xE7EFc5060B6Ad57B68F5911eCa6c5cD1952Da152/","decoded_constructor_args":[["0xD7DbECFb1738Da6812b6dFD0fE4c424Cf7D184dc",{"internalType":"address","name":"addr","type":"address"}]],"compiler_version":"0.8.23+commit.f704f362","is_verified_via_verifier_alliance":false,"verified_at":"2025-11-17T02:48:53.783080Z","implementations":[],"proxy_type":null,"external_libraries":[],"creation_bytecode":"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","name":"STBTv2","is_blueprint":false,"license_type":"none","is_fully_verified":true,"is_verified_via_eth_bytecode_db":true,"language":"solidity","evm_version":"shanghai","can_be_visualized_via_sol2uml":true,"is_verified_via_sourcify":true,"additional_sources":[{"file_path":"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface AggregatorV3Interface {\n  function decimals() external view returns (uint8);\n\n  function description() external view returns (string memory);\n\n  function version() external view returns (uint256);\n\n  function getRoundData(uint80 _roundId)\n    external\n    view\n    returns (\n      uint80 roundId,\n      int256 answer,\n      uint256 startedAt,\n      uint256 updatedAt,\n      uint80 answeredInRound\n    );\n\n  function latestRoundData()\n    external\n    view\n    returns (\n      uint80 roundId,\n      int256 answer,\n      uint256 startedAt,\n      uint256 updatedAt,\n      uint80 answeredInRound\n    );\n}\n"},{"file_path":"@openzeppelin/contracts/access/AccessControl.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.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 * ```solidity\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```solidity\n * function foo() public {\n *     require(hasRole(MY_ROLE, msg.sender));\n *     ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\n * to enforce additional security measures for this role.\n */\nabstract contract AccessControl is Context, IAccessControl, ERC165 {\n    struct RoleData {\n        mapping(address => 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.9.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. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling 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.9.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\";\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 new proposal is scheduled with non-zero salt.\n     */\n    event CallSalt(bytes32 indexed id, bytes32 salt);\n\n    /**\n     * @dev Emitted when operation `id` is cancelled.\n     */\n    event Cancelled(bytes32 indexed id);\n\n    /**\n     * @dev Emitted when the minimum delay for future operations is modified.\n     */\n    event MinDelayChange(uint256 oldDuration, uint256 newDuration);\n\n    /**\n     * @dev Initializes the contract with the following parameters:\n     *\n     * - `minDelay`: initial minimum delay for operations\n     * - `proposers`: accounts to be granted proposer and canceller roles\n     * - `executors`: accounts to be granted executor role\n     * - `admin`: optional account to be granted admin role; disable with zero address\n     *\n     * IMPORTANT: The optional admin can aid with initial configuration of roles after deployment\n     * without being subject to delay, but this role should be subsequently renounced in favor of\n     * administration through timelocked proposals. Previous versions of this contract would assign\n     * this admin to the deployer automatically and should be renounced as well.\n     */\n    constructor(uint256 minDelay, address[] memory proposers, address[] memory executors, address admin) {\n        _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) {\n        return getTimestamp(id) > 0;\n    }\n\n    /**\n     * @dev Returns whether an operation is pending or not. Note that a \"pending\" operation may also be \"ready\".\n     */\n    function isOperationPending(bytes32 id) public view virtual returns (bool) {\n        return getTimestamp(id) > _DONE_TIMESTAMP;\n    }\n\n    /**\n     * @dev Returns whether an operation is ready for execution. Note that a \"ready\" operation is also \"pending\".\n     */\n    function isOperationReady(bytes32 id) public view virtual returns (bool) {\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) {\n        return getTimestamp(id) == _DONE_TIMESTAMP;\n    }\n\n    /**\n     * @dev Returns the timestamp at which an operation becomes ready (0 for\n     * unset operations, 1 for done operations).\n     */\n    function getTimestamp(bytes32 id) public view virtual returns (uint256) {\n        return _timestamps[id];\n    }\n\n    /**\n     * @dev Returns 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) {\n        return _minDelay;\n    }\n\n    /**\n     * @dev Returns the identifier of an operation containing a single\n     * transaction.\n     */\n    function hashOperation(\n        address target,\n        uint256 value,\n        bytes calldata data,\n        bytes32 predecessor,\n        bytes32 salt\n    ) public pure virtual returns (bytes32) {\n        return keccak256(abi.encode(target, value, data, predecessor, salt));\n    }\n\n    /**\n     * @dev Returns the identifier of an operation containing a batch of\n     * transactions.\n     */\n    function hashOperationBatch(\n        address[] calldata targets,\n        uint256[] calldata values,\n        bytes[] calldata payloads,\n        bytes32 predecessor,\n        bytes32 salt\n    ) public pure virtual returns (bytes32) {\n        return keccak256(abi.encode(targets, values, payloads, predecessor, salt));\n    }\n\n    /**\n     * @dev Schedule an operation containing a single transaction.\n     *\n     * Emits {CallSalt} if salt is nonzero, and {CallScheduled}.\n     *\n     * Requirements:\n     *\n     * - the caller must have the 'proposer' role.\n     */\n    function schedule(\n        address target,\n        uint256 value,\n        bytes calldata data,\n        bytes32 predecessor,\n        bytes32 salt,\n        uint256 delay\n    ) public virtual onlyRole(PROPOSER_ROLE) {\n        bytes32 id = hashOperation(target, value, data, predecessor, salt);\n        _schedule(id, delay);\n        emit CallScheduled(id, 0, target, value, data, predecessor, delay);\n        if (salt != bytes32(0)) {\n            emit CallSalt(id, salt);\n        }\n    }\n\n    /**\n     * @dev Schedule an operation containing a batch of transactions.\n     *\n     * Emits {CallSalt} if salt is nonzero, and one {CallScheduled} event per transaction in the batch.\n     *\n     * Requirements:\n     *\n     * - the caller must have the 'proposer' role.\n     */\n    function scheduleBatch(\n        address[] calldata targets,\n        uint256[] calldata values,\n        bytes[] calldata payloads,\n        bytes32 predecessor,\n        bytes32 salt,\n        uint256 delay\n    ) public virtual onlyRole(PROPOSER_ROLE) {\n        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        if (salt != bytes32(0)) {\n            emit CallSalt(id, salt);\n        }\n    }\n\n    /**\n     * @dev Schedule an operation that is to become valid after a given delay.\n     */\n    function _schedule(bytes32 id, uint256 delay) private {\n        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    // This function can reenter, but it doesn't pose a risk because _afterCall checks that the proposal is pending,\n    // thus any modifications to the operation during reentrancy should be caught.\n    // slither-disable-next-line reentrancy-eth\n    function executeBatch(\n        address[] calldata targets,\n        uint256[] calldata values,\n        bytes[] calldata payloads,\n        bytes32 predecessor,\n        bytes32 salt\n    ) public payable virtual onlyRoleOrOpenRole(EXECUTOR_ROLE) {\n        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(address target, uint256 value, bytes calldata data) 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(address, address, uint256, bytes memory) 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.9.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(address from, address to, uint256 amount) 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/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.9.0) (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./math/Math.sol\";\nimport \"./math/SignedMath.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 `int256` to its ASCII `string` decimal representation.\n     */\n    function toString(int256 value) internal pure returns (string memory) {\n        return string(abi.encodePacked(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value))));\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    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return keccak256(bytes(a)) == keccak256(bytes(b));\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.9.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(uint256 x, uint256 y, uint256 denominator) 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                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\n            require(denominator > prod1, \"Math: mulDiv overflow\");\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(uint256 x, uint256 y, uint256 denominator, Rounding rounding) 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 256, 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 << 3) < value ? 1 : 0);\n        }\n    }\n}\n"},{"file_path":"@openzeppelin/contracts/utils/math/SignedMath.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // must be unchecked in order to support `n = type(int256).min`\n            return uint256(n >= 0 ? n : -n);\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\nstruct 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\ninterface ISTBT is IERC20, IERC20Metadata, IERC1594, IERC1643, IERC1644 {\n    event InterestsDistributed(int interest, uint newTotalSupply, uint interestFromTime, uint interestToTime);\n    event TransferShares(address indexed from, address indexed to, uint256 sharesValue);\n\n    function issuer() external view returns (address); \n    function controller() external view returns (address); \n    function moderator() external view returns (address); \n    function totalShares() external view returns (uint);\n    function allowance(address _owner, address _spender) external view returns (uint256);\n    function permissions(address addr) external view returns (bool sendAllowed,\n                                                              bool receiveAllowed,\n                                                              uint64 expiryTime);\n    function lastDistributeTime() external view returns (uint64);\n    function minDistributeInterval() external view returns (uint64);\n    function maxDistributeRatio() external view returns (uint64);\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 getSharesByAmountRoundUp(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":"addr","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_controller","type":"address"},{"indexed":true,"internalType":"address","name":"_tokenHolder","type":"address"},{"indexed":false,"internalType":"uint256","name":"_value","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"_data","type":"bytes"},{"indexed":false,"internalType":"bytes","name":"_operatorData","type":"bytes"}],"name":"ControllerRedemption","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_controller","type":"address"},{"indexed":true,"internalType":"address","name":"_from","type":"address"},{"indexed":true,"internalType":"address","name":"_to","type":"address"},{"indexed":false,"internalType":"uint256","name":"_value","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"_data","type":"bytes"},{"indexed":false,"internalType":"bytes","name":"_operatorData","type":"bytes"}],"name":"ControllerTransfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"_name","type":"bytes32"},{"indexed":false,"internalType":"string","name":"_uri","type":"string"},{"indexed":false,"internalType":"bytes32","name":"_documentHash","type":"bytes32"}],"name":"DocumentRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"_name","type":"bytes32"},{"indexed":false,"internalType":"string","name":"_uri","type":"string"},{"indexed":false,"internalType":"bytes32","name":"_documentHash","type":"bytes32"}],"name":"DocumentUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"int256","name":"interest","type":"int256"},{"indexed":false,"internalType":"uint256","name":"newTotalSupply","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"interestFromTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"interestToTime","type":"uint256"}],"name":"InterestsDistributed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_operator","type":"address"},{"indexed":true,"internalType":"address","name":"_to","type":"address"},{"indexed":false,"internalType":"uint256","name":"_value","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"_data","type":"bytes"}],"name":"Issued","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_operator","type":"address"},{"indexed":true,"internalType":"address","name":"_from","type":"address"},{"indexed":false,"internalType":"uint256","name":"_value","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"_data","type":"bytes"}],"name":"Redeemed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"sharesValue","type":"uint256"}],"name":"TransferShares","type":"event"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"canTransfer","outputs":[{"internalType":"bool","name":"","type":"bool"},{"internalType":"uint8","name":"","type":"uint8"},{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_sender","type":"address"},{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"canTransferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"},{"internalType":"uint8","name":"","type":"uint8"},{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"controller","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenHolder","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"},{"internalType":"bytes","name":"_operatorData","type":"bytes"}],"name":"controllerRedeem","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"},{"internalType":"bytes","name":"_operatorData","type":"bytes"}],"name":"controllerTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"_distributedInterest","type":"int256"},{"internalType":"uint256","name":"interestFromTime","type":"uint256"},{"internalType":"uint256","name":"interestToTime","type":"uint256"}],"name":"distributeInterests","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"docIndexes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"documents","outputs":[{"internalType":"bytes32","name":"docHash","type":"bytes32"},{"internalType":"uint256","name":"lastModified","type":"uint256"},{"internalType":"string","name":"uri","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAllDocuments","outputs":[{"internalType":"bytes32[]","name":"","type":"bytes32[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_shares","type":"uint256"}],"name":"getAmountByShares","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_name","type":"bytes32"}],"name":"getDocument","outputs":[{"internalType":"string","name":"","type":"string"},{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLatestReserve","outputs":[{"internalType":"int256","name":"","type":"int256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"getSharesByAmount","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"getSharesByAmountRoundUp","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isControllable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"isIssuable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenHolder","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"issue","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"issuer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastDistributeTime","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxDistributeRatio","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minDistributeInterval","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"moderator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"permissions","outputs":[{"internalType":"bool","name":"sendAllowed","type":"bool"},{"internalType":"bool","name":"receiveAllowed","type":"bool"},{"internalType":"uint64","name":"expiryTime","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"placeholders","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_value","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"redeem","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenHolder","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"redeemFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_name","type":"bytes32"}],"name":"removeDocument","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_controller","type":"address"}],"name":"setController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_name","type":"bytes32"},{"internalType":"string","name":"_uri","type":"string"},{"internalType":"bytes32","name":"_documentHash","type":"bytes32"}],"name":"setDocument","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_issuer","type":"address"}],"name":"setIssuer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"ratio","type":"uint64"}],"name":"setMaxDistributeRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"interval","type":"uint64"}],"name":"setMinDistributeInterval","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_moderator","type":"address"}],"name":"setModerator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"},{"components":[{"internalType":"bool","name":"sendAllowed","type":"bool"},{"internalType":"bool","name":"receiveAllowed","type":"bool"},{"internalType":"uint64","name":"expiryTime","type":"uint64"}],"internalType":"struct Permission","name":"permission","type":"tuple"}],"name":"setPermission","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"sharesOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_sender","type":"address"},{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"transferFromWithData","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"transferWithData","outputs":[],"stateMutability":"nonpayable","type":"function"}],"is_changed_bytecode":false,"is_partially_verified":false,"constructor_args":"0x000000000000000000000000d7dbecfb1738da6812b6dfd0fe4c424cf7d184dc"}