{"file_path":"src/l2/SUsds.sol","creation_status":"success","source_code":"// SPDX-License-Identifier: AGPL-3.0-or-later\n\n/// SUsds.sol -- SUsds token\n\n// Copyright (C) 2017, 2018, 2019 dbrock, rain, mrchico\n// Copyright (C) 2024 Dai Foundation\n//\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU Affero General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU Affero General Public License for more details.\n//\n// You should have received a copy of the GNU Affero General Public License\n// along with this program.  If not, see <https://www.gnu.org/licenses/>.\n\npragma solidity ^0.8.21;\n\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\";\n\ninterface IERC1271 {\n    function isValidSignature(\n        bytes32,\n        bytes memory\n    ) external view returns (bytes4);\n}\n\ncontract SUsds is UUPSUpgradeable {\n    mapping (address => uint256) public wards;\n\n    // --- ERC20 Data ---\n    string  public constant name     = \"Savings USDS\";\n    string  public constant symbol   = \"sUSDS\";\n    string  public constant version  = \"1\";\n    uint8   public constant decimals = 18;\n    uint256 public totalSupply;\n\n    mapping (address => uint256)                      public balanceOf;\n    mapping (address => mapping (address => uint256)) public allowance;\n    mapping (address => uint256)                      public nonces;\n\n    // --- Events ---\n    event Rely(address indexed usr);\n    event Deny(address indexed usr);\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    // --- EIP712 niceties ---\n    bytes32 public constant PERMIT_TYPEHASH = keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\");\n\n    modifier auth {\n        require(wards[msg.sender] == 1, \"SUsds/not-authorized\");\n        _;\n    }\n\n    constructor() {\n        _disableInitializers(); // Avoid initializing in the context of the implementation\n    }\n\n    // --- Upgradability ---\n\n    function initialize() initializer external {\n        __UUPSUpgradeable_init();\n\n        wards[msg.sender] = 1;\n        emit Rely(msg.sender);\n    }\n\n    function _authorizeUpgrade(address newImplementation) internal override auth {}\n\n    function getImplementation() external view returns (address) {\n        return ERC1967Utils.getImplementation();\n    }\n\n    function _calculateDomainSeparator(uint256 chainId) private view returns (bytes32) {\n        return keccak256(\n            abi.encode(\n                keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"),\n                keccak256(bytes(name)),\n                keccak256(bytes(version)),\n                chainId,\n                address(this)\n            )\n        );\n    }\n\n    function DOMAIN_SEPARATOR() external view returns (bytes32) {\n        return _calculateDomainSeparator(block.chainid);\n    }\n\n    // --- Administration ---\n    function rely(address usr) external auth {\n        wards[usr] = 1;\n        emit Rely(usr);\n    }\n\n    function deny(address usr) external auth {\n        wards[usr] = 0;\n        emit Deny(usr);\n    }\n\n    // --- ERC20 Mutations ---\n    function transfer(address to, uint256 value) external returns (bool) {\n        require(to != address(0) && to != address(this), \"SUsds/invalid-address\");\n        uint256 balance = balanceOf[msg.sender];\n        require(balance >= value, \"SUsds/insufficient-balance\");\n\n        unchecked {\n            balanceOf[msg.sender] = balance - value;\n            balanceOf[to] += value; // note: we don't need an overflow check here b/c sum of all balances == totalSupply\n        }\n\n        emit Transfer(msg.sender, to, value);\n\n        return true;\n    }\n\n    function transferFrom(address from, address to, uint256 value) external returns (bool) {\n        require(to != address(0) && to != address(this), \"SUsds/invalid-address\");\n        uint256 balance = balanceOf[from];\n        require(balance >= value, \"SUsds/insufficient-balance\");\n\n        if (from != msg.sender) {\n            uint256 allowed = allowance[from][msg.sender];\n            if (allowed != type(uint256).max) {\n                require(allowed >= value, \"SUsds/insufficient-allowance\");\n\n                unchecked {\n                    allowance[from][msg.sender] = allowed - value;\n                }\n            }\n        }\n\n        unchecked {\n            balanceOf[from] = balance - value;\n            balanceOf[to] += value; // note: we don't need an overflow check here b/c sum of all balances == totalSupply\n        }\n\n        emit Transfer(from, to, value);\n\n        return true;\n    }\n\n    function approve(address spender, uint256 value) external returns (bool) {\n        allowance[msg.sender][spender] = value;\n\n        emit Approval(msg.sender, spender, value);\n\n        return true;\n    }\n\n    // --- Mint/Burn ---\n    function mint(address to, uint256 value) external auth {\n        require(to != address(0) && to != address(this), \"SUsds/invalid-address\");\n        unchecked {\n            balanceOf[to] = balanceOf[to] + value; // note: we don't need an overflow check here b/c balanceOf[to] <= totalSupply and there is an overflow check below\n        }\n        totalSupply = totalSupply + value;\n\n        emit Transfer(address(0), to, value);\n    }\n\n    function burn(address from, uint256 value) external {\n        uint256 balance = balanceOf[from];\n        require(balance >= value, \"SUsds/insufficient-balance\");\n\n        if (from != msg.sender) {\n            uint256 allowed = allowance[from][msg.sender];\n            if (allowed != type(uint256).max) {\n                require(allowed >= value, \"SUsds/insufficient-allowance\");\n\n                unchecked {\n                    allowance[from][msg.sender] = allowed - value;\n                }\n            }\n        }\n\n        unchecked {\n            balanceOf[from] = balance - value; // note: we don't need overflow checks b/c require(balance >= value) and balance <= totalSupply\n            totalSupply     = totalSupply - value;\n        }\n\n        emit Transfer(from, address(0), value);\n    }\n\n    // --- Approve by signature ---\n    function _isValidSignature(\n        address signer,\n        bytes32 digest,\n        bytes memory signature\n    ) internal view returns (bool valid) {\n        if (signature.length == 65) {\n            bytes32 r;\n            bytes32 s;\n            uint8 v;\n            assembly {\n                r := mload(add(signature, 0x20))\n                s := mload(add(signature, 0x40))\n                v := byte(0, mload(add(signature, 0x60)))\n            }\n            if (signer == ecrecover(digest, v, r, s)) {\n                return true;\n            }\n        }\n\n        if (signer.code.length > 0) {\n            (bool success, bytes memory result) = signer.staticcall(\n                abi.encodeCall(IERC1271.isValidSignature, (digest, signature))\n            );\n            valid = (success &&\n                result.length == 32 &&\n                abi.decode(result, (bytes4)) == IERC1271.isValidSignature.selector);\n        }\n    }\n\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        bytes memory signature\n    ) public {\n        require(block.timestamp <= deadline, \"SUsds/permit-expired\");\n        require(owner != address(0), \"SUsds/invalid-owner\");\n\n        uint256 nonce;\n        unchecked { nonce = nonces[owner]++; }\n\n        bytes32 digest =\n            keccak256(abi.encodePacked(\n                \"\\x19\\x01\",\n                _calculateDomainSeparator(block.chainid),\n                keccak256(abi.encode(\n                    PERMIT_TYPEHASH,\n                    owner,\n                    spender,\n                    value,\n                    nonce,\n                    deadline\n                ))\n            ));\n\n        require(_isValidSignature(owner, digest, signature), \"SUsds/invalid-permit\");\n\n        allowance[owner][spender] = value;\n        emit Approval(owner, spender, value);\n    }\n\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external {\n        permit(owner, spender, value, deadline, abi.encodePacked(r, s, v));\n    }\n}\n","deployed_bytecode":"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","optimization_enabled":true,"verified_twin_address_hash":null,"is_verified":true,"github_repository_metadata":null,"compiler_settings":{"evmVersion":"shanghai","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",":@openzeppelin/contracts/=lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/",":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",":openzeppelin-contracts/=lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/"]},"optimization_runs":200,"sourcify_repo_url":"https://repo.sourcify.dev/contracts/partial_match/42161/0x5Aee6b37d6E31860804575AeE3e2f368A0a428E7/","decoded_constructor_args":null,"compiler_version":"0.8.21+commit.d9974bed","is_verified_via_verifier_alliance":false,"verified_at":"2025-02-18T16:46:12.711617Z","implementations":[],"proxy_type":null,"external_libraries":[],"creation_bytecode":"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","name":"SUsds","is_blueprint":false,"license_type":"none","is_fully_verified":false,"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":"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```solidity\n * contract MyToken is ERC20Upgradeable {\n *     function initialize() initializer public {\n *         __ERC20_init(\"MyToken\", \"MTK\");\n *     }\n * }\n *\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n *     function initializeV2() reinitializer(2) public {\n *         __ERC20Permit_init(\"MyToken\");\n *     }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n *     _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n    /**\n     * @dev Storage of the initializable contract.\n     *\n     * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions\n     * when using with upgradeable contracts.\n     *\n     * @custom:storage-location erc7201:openzeppelin.storage.Initializable\n     */\n    struct InitializableStorage {\n        /**\n         * @dev Indicates that the contract has been initialized.\n         */\n        uint64 _initialized;\n        /**\n         * @dev Indicates that the contract is in the process of being initialized.\n         */\n        bool _initializing;\n    }\n\n    // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.Initializable\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;\n\n    /**\n     * @dev The contract is already initialized.\n     */\n    error InvalidInitialization();\n\n    /**\n     * @dev The contract is not initializing.\n     */\n    error NotInitializing();\n\n    /**\n     * @dev Triggered when the contract has been initialized or reinitialized.\n     */\n    event Initialized(uint64 version);\n\n    /**\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n     * `onlyInitializing` functions can be used to initialize parent contracts.\n     *\n     * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any\n     * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in\n     * production.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier initializer() {\n        // solhint-disable-next-line var-name-mixedcase\n        InitializableStorage storage $ = _getInitializableStorage();\n\n        // Cache values to avoid duplicated sloads\n        bool isTopLevelCall = !$._initializing;\n        uint64 initialized = $._initialized;\n\n        // Allowed calls:\n        // - initialSetup: the contract is not in the initializing state and no previous version was\n        //                 initialized\n        // - construction: the contract is initialized at version 1 (no reininitialization) and the\n        //                 current contract is just being deployed\n        bool initialSetup = initialized == 0 && isTopLevelCall;\n        bool construction = initialized == 1 && address(this).code.length == 0;\n\n        if (!initialSetup && !construction) {\n            revert InvalidInitialization();\n        }\n        $._initialized = 1;\n        if (isTopLevelCall) {\n            $._initializing = true;\n        }\n        _;\n        if (isTopLevelCall) {\n            $._initializing = false;\n            emit Initialized(1);\n        }\n    }\n\n    /**\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n     * used to initialize parent contracts.\n     *\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n     * are added through upgrades and that require initialization.\n     *\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\n     *\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n     * a contract, executing them in the right order is up to the developer or operator.\n     *\n     * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier reinitializer(uint64 version) {\n        // solhint-disable-next-line var-name-mixedcase\n        InitializableStorage storage $ = _getInitializableStorage();\n\n        if ($._initializing || $._initialized >= version) {\n            revert InvalidInitialization();\n        }\n        $._initialized = version;\n        $._initializing = true;\n        _;\n        $._initializing = false;\n        emit Initialized(version);\n    }\n\n    /**\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\n     */\n    modifier onlyInitializing() {\n        _checkInitializing();\n        _;\n    }\n\n    /**\n     * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.\n     */\n    function _checkInitializing() internal view virtual {\n        if (!_isInitializing()) {\n            revert NotInitializing();\n        }\n    }\n\n    /**\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n     * through proxies.\n     *\n     * Emits an {Initialized} event the first time it is successfully executed.\n     */\n    function _disableInitializers() internal virtual {\n        // solhint-disable-next-line var-name-mixedcase\n        InitializableStorage storage $ = _getInitializableStorage();\n\n        if ($._initializing) {\n            revert InvalidInitialization();\n        }\n        if ($._initialized != type(uint64).max) {\n            $._initialized = type(uint64).max;\n            emit Initialized(type(uint64).max);\n        }\n    }\n\n    /**\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\n     */\n    function _getInitializedVersion() internal view returns (uint64) {\n        return _getInitializableStorage()._initialized;\n    }\n\n    /**\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n     */\n    function _isInitializing() internal view returns (bool) {\n        return _getInitializableStorage()._initializing;\n    }\n\n    /**\n     * @dev Returns a pointer to the storage namespace.\n     */\n    // solhint-disable-next-line var-name-mixedcase\n    function _getInitializableStorage() private pure returns (InitializableStorage storage $) {\n        assembly {\n            $.slot := INITIALIZABLE_STORAGE\n        }\n    }\n}\n"},{"file_path":"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/UUPSUpgradeable.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC1822Proxiable} from \"@openzeppelin/contracts/interfaces/draft-IERC1822.sol\";\nimport {ERC1967Utils} from \"@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol\";\nimport {Initializable} from \"./Initializable.sol\";\n\n/**\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\n *\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\n * `UUPSUpgradeable` with a custom implementation of upgrades.\n *\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\n */\nabstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable {\n    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\n    address private immutable __self = address(this);\n\n    /**\n     * @dev The version of the upgrade interface of the contract. If this getter is missing, both `upgradeTo(address)`\n     * and `upgradeToAndCall(address,bytes)` are present, and `upgradeTo` must be used if no function should be called,\n     * while `upgradeToAndCall` will invoke the `receive` function if the second argument is the empty byte string.\n     * If the getter returns `\"5.0.0\"`, only `upgradeToAndCall(address,bytes)` is present, and the second argument must\n     * be the empty byte string if no function should be called, making it impossible to invoke the `receive` function\n     * during an upgrade.\n     */\n    string public constant UPGRADE_INTERFACE_VERSION = \"5.0.0\";\n\n    /**\n     * @dev The call is from an unauthorized context.\n     */\n    error UUPSUnauthorizedCallContext();\n\n    /**\n     * @dev The storage `slot` is unsupported as a UUID.\n     */\n    error UUPSUnsupportedProxiableUUID(bytes32 slot);\n\n    /**\n     * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\n     * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case\n     * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\n     * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\n     * fail.\n     */\n    modifier onlyProxy() {\n        _checkProxy();\n        _;\n    }\n\n    /**\n     * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\n     * callable on the implementing contract but not through proxies.\n     */\n    modifier notDelegated() {\n        _checkNotDelegated();\n        _;\n    }\n\n    function __UUPSUpgradeable_init() internal onlyInitializing {\n    }\n\n    function __UUPSUpgradeable_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the\n     * implementation. It is used to validate the implementation's compatibility when performing an upgrade.\n     *\n     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n     * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\n     */\n    function proxiableUUID() external view virtual notDelegated returns (bytes32) {\n        return ERC1967Utils.IMPLEMENTATION_SLOT;\n    }\n\n    /**\n     * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\n     * encoded in `data`.\n     *\n     * Calls {_authorizeUpgrade}.\n     *\n     * Emits an {Upgraded} event.\n     *\n     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall\n     */\n    function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {\n        _authorizeUpgrade(newImplementation);\n        _upgradeToAndCallUUPS(newImplementation, data);\n    }\n\n    /**\n     * @dev Reverts if the execution is not performed via delegatecall or the execution\n     * context is not of a proxy with an ERC1967-compliant implementation pointing to self.\n     * See {_onlyProxy}.\n     */\n    function _checkProxy() internal view virtual {\n        if (\n            address(this) == __self || // Must be called through delegatecall\n            ERC1967Utils.getImplementation() != __self // Must be called through an active proxy\n        ) {\n            revert UUPSUnauthorizedCallContext();\n        }\n    }\n\n    /**\n     * @dev Reverts if the execution is performed via delegatecall.\n     * See {notDelegated}.\n     */\n    function _checkNotDelegated() internal view virtual {\n        if (address(this) != __self) {\n            // Must not be called through delegatecall\n            revert UUPSUnauthorizedCallContext();\n        }\n    }\n\n    /**\n     * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\n     * {upgradeToAndCall}.\n     *\n     * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\n     *\n     * ```solidity\n     * function _authorizeUpgrade(address) internal onlyOwner {}\n     * ```\n     */\n    function _authorizeUpgrade(address newImplementation) internal virtual;\n\n    /**\n     * @dev Performs an implementation upgrade with a security check for UUPS proxies, and additional setup call.\n     *\n     * As a security check, {proxiableUUID} is invoked in the new implementation, and the return value\n     * is expected to be the implementation slot in ERC1967.\n     *\n     * Emits an {IERC1967-Upgraded} event.\n     */\n    function _upgradeToAndCallUUPS(address newImplementation, bytes memory data) private {\n        try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {\n            if (slot != ERC1967Utils.IMPLEMENTATION_SLOT) {\n                revert UUPSUnsupportedProxiableUUID(slot);\n            }\n            ERC1967Utils.upgradeToAndCall(newImplementation, data);\n        } catch {\n            // The implementation is not UUPS\n            revert ERC1967Utils.ERC1967InvalidImplementation(newImplementation);\n        }\n    }\n}\n"},{"file_path":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/draft-IERC1822.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC1822.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\n * proxy whose upgrades are fully controlled by the current implementation.\n */\ninterface IERC1822Proxiable {\n    /**\n     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\n     * address.\n     *\n     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n     * function revert if invoked through a proxy.\n     */\n    function proxiableUUID() external view returns (bytes32);\n}\n"},{"file_path":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/ERC1967/ERC1967Utils.sol)\n\npragma solidity ^0.8.20;\n\nimport {IBeacon} from \"../beacon/IBeacon.sol\";\nimport {Address} from \"../../utils/Address.sol\";\nimport {StorageSlot} from \"../../utils/StorageSlot.sol\";\n\n/**\n * @dev This abstract contract provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\n */\nlibrary ERC1967Utils {\n    // We re-declare ERC-1967 events here because they can't be used directly from IERC1967.\n    // This will be fixed in Solidity 0.8.21. At that point we should remove these events.\n    /**\n     * @dev Emitted when the implementation is upgraded.\n     */\n    event Upgraded(address indexed implementation);\n\n    /**\n     * @dev Emitted when the admin account has changed.\n     */\n    event AdminChanged(address previousAdmin, address newAdmin);\n\n    /**\n     * @dev Emitted when the beacon is changed.\n     */\n    event BeaconUpgraded(address indexed beacon);\n\n    /**\n     * @dev Storage slot with the address of the current implementation.\n     * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1.\n     */\n    // solhint-disable-next-line private-vars-leading-underscore\n    bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n    /**\n     * @dev The `implementation` of the proxy is invalid.\n     */\n    error ERC1967InvalidImplementation(address implementation);\n\n    /**\n     * @dev The `admin` of the proxy is invalid.\n     */\n    error ERC1967InvalidAdmin(address admin);\n\n    /**\n     * @dev The `beacon` of the proxy is invalid.\n     */\n    error ERC1967InvalidBeacon(address beacon);\n\n    /**\n     * @dev An upgrade function sees `msg.value > 0` that may be lost.\n     */\n    error ERC1967NonPayable();\n\n    /**\n     * @dev Returns the current implementation address.\n     */\n    function getImplementation() internal view returns (address) {\n        return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new address in the EIP1967 implementation slot.\n     */\n    function _setImplementation(address newImplementation) private {\n        if (newImplementation.code.length == 0) {\n            revert ERC1967InvalidImplementation(newImplementation);\n        }\n        StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation;\n    }\n\n    /**\n     * @dev Performs implementation upgrade with additional setup call if data is nonempty.\n     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected\n     * to avoid stuck value in the contract.\n     *\n     * Emits an {IERC1967-Upgraded} event.\n     */\n    function upgradeToAndCall(address newImplementation, bytes memory data) internal {\n        _setImplementation(newImplementation);\n        emit Upgraded(newImplementation);\n\n        if (data.length > 0) {\n            Address.functionDelegateCall(newImplementation, data);\n        } else {\n            _checkNonPayable();\n        }\n    }\n\n    /**\n     * @dev Storage slot with the admin of the contract.\n     * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1.\n     */\n    // solhint-disable-next-line private-vars-leading-underscore\n    bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n    /**\n     * @dev Returns the current admin.\n     *\n     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using\n     * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\n     * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\n     */\n    function getAdmin() internal view returns (address) {\n        return StorageSlot.getAddressSlot(ADMIN_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new address in the EIP1967 admin slot.\n     */\n    function _setAdmin(address newAdmin) private {\n        if (newAdmin == address(0)) {\n            revert ERC1967InvalidAdmin(address(0));\n        }\n        StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin;\n    }\n\n    /**\n     * @dev Changes the admin of the proxy.\n     *\n     * Emits an {IERC1967-AdminChanged} event.\n     */\n    function changeAdmin(address newAdmin) internal {\n        emit AdminChanged(getAdmin(), newAdmin);\n        _setAdmin(newAdmin);\n    }\n\n    /**\n     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n     * This is the keccak-256 hash of \"eip1967.proxy.beacon\" subtracted by 1.\n     */\n    // solhint-disable-next-line private-vars-leading-underscore\n    bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n    /**\n     * @dev Returns the current beacon.\n     */\n    function getBeacon() internal view returns (address) {\n        return StorageSlot.getAddressSlot(BEACON_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new beacon in the EIP1967 beacon slot.\n     */\n    function _setBeacon(address newBeacon) private {\n        if (newBeacon.code.length == 0) {\n            revert ERC1967InvalidBeacon(newBeacon);\n        }\n\n        StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon;\n\n        address beaconImplementation = IBeacon(newBeacon).implementation();\n        if (beaconImplementation.code.length == 0) {\n            revert ERC1967InvalidImplementation(beaconImplementation);\n        }\n    }\n\n    /**\n     * @dev Change the beacon and trigger a setup call if data is nonempty.\n     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected\n     * to avoid stuck value in the contract.\n     *\n     * Emits an {IERC1967-BeaconUpgraded} event.\n     *\n     * CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since\n     * it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for\n     * efficiency.\n     */\n    function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal {\n        _setBeacon(newBeacon);\n        emit BeaconUpgraded(newBeacon);\n\n        if (data.length > 0) {\n            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\n        } else {\n            _checkNonPayable();\n        }\n    }\n\n    /**\n     * @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract\n     * if an upgrade doesn't perform an initialization call.\n     */\n    function _checkNonPayable() private {\n        if (msg.value > 0) {\n            revert ERC1967NonPayable();\n        }\n    }\n}\n"},{"file_path":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/IBeacon.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeacon {\n    /**\n     * @dev Must return an address that can be used as a delegate call target.\n     *\n     * {UpgradeableBeacon} will check that this address is a contract.\n     */\n    function implementation() external view returns (address);\n}\n"},{"file_path":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev The ETH balance of the account is not enough to perform the operation.\n     */\n    error AddressInsufficientBalance(address account);\n\n    /**\n     * @dev There's no code at `target` (it is not a contract).\n     */\n    error AddressEmptyCode(address target);\n\n    /**\n     * @dev A call to an address target failed. The target may have reverted.\n     */\n    error FailedInnerCall();\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        if (address(this).balance < amount) {\n            revert AddressInsufficientBalance(address(this));\n        }\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        if (!success) {\n            revert FailedInnerCall();\n        }\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason or custom error, it is bubbled\n     * up by this function (like regular Solidity function calls). However, if\n     * the call reverted with no returned reason, this function reverts with a\n     * {FailedInnerCall} error.\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        if (address(this).balance < value) {\n            revert AddressInsufficientBalance(address(this));\n        }\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\n     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an\n     * unsuccessful call.\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata\n    ) internal view returns (bytes memory) {\n        if (!success) {\n            _revert(returndata);\n        } else {\n            // only check if target is a contract if the call was successful and the return data is empty\n            // otherwise we already know that it was a contract\n            if (returndata.length == 0 && target.code.length == 0) {\n                revert AddressEmptyCode(target);\n            }\n            return returndata;\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\n     * revert reason or with a default {FailedInnerCall} error.\n     */\n    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\n        if (!success) {\n            _revert(returndata);\n        } else {\n            return returndata;\n        }\n    }\n\n    /**\n     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.\n     */\n    function _revert(bytes memory returndata) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert FailedInnerCall();\n        }\n    }\n}\n"},{"file_path":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol)\n// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```solidity\n * contract ERC1967 {\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n *     function _getImplementation() internal view returns (address) {\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n *     }\n *\n *     function _setImplementation(address newImplementation) internal {\n *         require(newImplementation.code.length > 0);\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n *     }\n * }\n * ```\n */\nlibrary StorageSlot {\n    struct AddressSlot {\n        address value;\n    }\n\n    struct BooleanSlot {\n        bool value;\n    }\n\n    struct Bytes32Slot {\n        bytes32 value;\n    }\n\n    struct Uint256Slot {\n        uint256 value;\n    }\n\n    struct StringSlot {\n        string value;\n    }\n\n    struct BytesSlot {\n        bytes value;\n    }\n\n    /**\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n     */\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `StringSlot` with member `value` located at `slot`.\n     */\n    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.\n     */\n    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := store.slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BytesSlot` with member `value` located at `slot`.\n     */\n    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.\n     */\n    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := store.slot\n        }\n    }\n}\n"}],"certified":false,"conflicting_implementations":null,"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"implementation","type":"address"}],"name":"ERC1967InvalidImplementation","type":"error"},{"inputs":[],"name":"ERC1967NonPayable","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[],"name":"UUPSUnauthorizedCallContext","type":"error"},{"inputs":[{"internalType":"bytes32","name":"slot","type":"bytes32"}],"name":"UUPSUnsupportedProxiableUUID","type":"error"},{"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":true,"internalType":"address","name":"usr","type":"address"}],"name":"Deny","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"usr","type":"address"}],"name":"Rely","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":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UPGRADE_INTERFACE_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"usr","type":"address"}],"name":"deny","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"usr","type":"address"}],"name":"rely","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","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"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"wards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}],"is_changed_bytecode":false,"is_partially_verified":true,"package_name":null,"constructor_args":null}