Datasets:

Zellic
/

smart-contract-fiesta

	{
	"language": "Solidity",
	"sources": {
	"lib/base64/base64.sol": {
	"content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0;\n\n/// @title Base64\n/// @author Brecht Devos - <brecht@loopring.org>\n/// @notice Provides functions for encoding/decoding base64\nlibrary Base64 {\n string internal constant TABLE_ENCODE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n bytes internal constant TABLE_DECODE = hex\"0000000000000000000000000000000000000000000000000000000000000000\"\n hex\"00000000000000000000003e0000003f3435363738393a3b3c3d000000000000\"\n hex\"00000102030405060708090a0b0c0d0e0f101112131415161718190000000000\"\n hex\"001a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132330000000000\";\n\n function encode(bytes memory data) internal pure returns (string memory) {\n if (data.length == 0) return '';\n\n // load the table into memory\n string memory table = TABLE_ENCODE;\n\n // multiply by 4/3 rounded up\n uint256 encodedLen = 4 * ((data.length + 2) / 3);\n\n // add some extra buffer at the end required for the writing\n string memory result = new string(encodedLen + 32);\n\n assembly {\n // set the actual output length\n mstore(result, encodedLen)\n\n // prepare the lookup table\n let tablePtr := add(table, 1)\n\n // input ptr\n let dataPtr := data\n let endPtr := add(dataPtr, mload(data))\n\n // result ptr, jump over length\n let resultPtr := add(result, 32)\n\n // run over the input, 3 bytes at a time\n for {} lt(dataPtr, endPtr) {}\n {\n // read 3 bytes\n dataPtr := add(dataPtr, 3)\n let input := mload(dataPtr)\n\n // write 4 characters\n mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F))))\n resultPtr := add(resultPtr, 1)\n mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F))))\n resultPtr := add(resultPtr, 1)\n mstore8(resultPtr, mload(add(tablePtr, and(shr( 6, input), 0x3F))))\n resultPtr := add(resultPtr, 1)\n mstore8(resultPtr, mload(add(tablePtr, and( input, 0x3F))))\n resultPtr := add(resultPtr, 1)\n }\n\n // padding with '='\n switch mod(mload(data), 3)\n case 1 { mstore(sub(resultPtr, 2), shl(240, 0x3d3d)) }\n case 2 { mstore(sub(resultPtr, 1), shl(248, 0x3d)) }\n }\n\n return result;\n }\n\n function decode(string memory _data) internal pure returns (bytes memory) {\n bytes memory data = bytes(_data);\n\n if (data.length == 0) return new bytes(0);\n require(data.length % 4 == 0, \"invalid base64 decoder input\");\n\n // load the table into memory\n bytes memory table = TABLE_DECODE;\n\n // every 4 characters represent 3 bytes\n uint256 decodedLen = (data.length / 4) * 3;\n\n // add some extra buffer at the end required for the writing\n bytes memory result = new bytes(decodedLen + 32);\n\n assembly {\n // padding with '='\n let lastBytes := mload(add(data, mload(data)))\n if eq(and(lastBytes, 0xFF), 0x3d) {\n decodedLen := sub(decodedLen, 1)\n if eq(and(lastBytes, 0xFFFF), 0x3d3d) {\n decodedLen := sub(decodedLen, 1)\n }\n }\n\n // set the actual output length\n mstore(result, decodedLen)\n\n // prepare the lookup table\n let tablePtr := add(table, 1)\n\n // input ptr\n let dataPtr := data\n let endPtr := add(dataPtr, mload(data))\n\n // result ptr, jump over length\n let resultPtr := add(result, 32)\n\n // run over the input, 4 characters at a time\n for {} lt(dataPtr, endPtr) {}\n {\n // read 4 characters\n dataPtr := add(dataPtr, 4)\n let input := mload(dataPtr)\n\n // write 3 bytes\n let output := add(\n add(\n shl(18, and(mload(add(tablePtr, and(shr(24, input), 0xFF))), 0xFF)),\n shl(12, and(mload(add(tablePtr, and(shr(16, input), 0xFF))), 0xFF))),\n add(\n shl( 6, and(mload(add(tablePtr, and(shr( 8, input), 0xFF))), 0xFF)),\n and(mload(add(tablePtr, and( input , 0xFF))), 0xFF)\n )\n )\n mstore(resultPtr, shl(232, output))\n resultPtr := add(resultPtr, 3)\n }\n }\n\n return result;\n }\n}\n"
	},
	"lib/ethfs/packages/contracts/src/File.sol": {
	"content": "// SPDX-License-Identifier: Unlicense\npragma solidity ^0.8.13;\n\nstruct Content {\n bytes32 checksum;\n address pointer;\n}\n\nstruct File {\n uint256 size; // content length in bytes, max 24k\n Content[] contents;\n}\n\nfunction read(File memory file) view returns (string memory contents) {\n Content[] memory chunks = file.contents;\n\n // Adapted from https://gist.github.com/xtremetom/20411eb126aaf35f98c8a8ffa00123cd\n assembly {\n let len := mload(chunks)\n let totalSize := 0x20\n contents := mload(0x40)\n let size\n let chunk\n let pointer\n\n // loop through all pointer addresses\n // - get content\n // - get address\n // - get data size\n // - get code and add to contents\n // - update total size\n\n for { let i := 0 } lt(i, len) { i := add(i, 1) } {\n chunk := mload(add(chunks, add(0x20, mul(i, 0x20))))\n pointer := mload(add(chunk, 0x20))\n\n size := sub(extcodesize(pointer), 1)\n extcodecopy(pointer, add(contents, totalSize), 1, size)\n totalSize := add(totalSize, size)\n }\n\n // update contents size\n mstore(contents, sub(totalSize, 0x20))\n // store contents\n mstore(0x40, add(contents, and(add(totalSize, 0x1f), not(0x1f))))\n }\n}\n\nusing {\n read\n} for File global;\n"
	},
	"lib/ethfs/packages/contracts/src/IContentStore.sol": {
	"content": "// SPDX-License-Identifier: Unlicense\npragma solidity ^0.8.13;\n\ninterface IContentStore {\n event NewChecksum(bytes32 indexed checksum, uint256 contentSize);\n\n error ChecksumExists(bytes32 checksum);\n error ChecksumNotFound(bytes32 checksum);\n\n function pointers(bytes32 checksum) external view returns (address pointer);\n\n function checksumExists(bytes32 checksum) external view returns (bool);\n\n function contentLength(bytes32 checksum)\n external\n view\n returns (uint256 size);\n\n function addPointer(address pointer) external returns (bytes32 checksum);\n\n function addContent(bytes memory content)\n external\n returns (bytes32 checksum, address pointer);\n\n function getPointer(bytes32 checksum)\n external\n view\n returns (address pointer);\n}\n"
	},
	"lib/ethfs/packages/contracts/src/IFileStore.sol": {
	"content": "// SPDX-License-Identifier: Unlicense\npragma solidity ^0.8.13;\n\nimport {File} from \"./File.sol\";\nimport {IContentStore} from \"./IContentStore.sol\";\n\ninterface IFileStore {\n event FileCreated(\n string indexed indexedFilename,\n bytes32 indexed checksum,\n string filename,\n uint256 size,\n bytes metadata\n );\n event FileDeleted(\n string indexed indexedFilename,\n bytes32 indexed checksum,\n string filename\n );\n\n error FileNotFound(string filename);\n error FilenameExists(string filename);\n error EmptyFile();\n\n function contentStore() external view returns (IContentStore);\n\n function files(string memory filename)\n external\n view\n returns (bytes32 checksum);\n\n function fileExists(string memory filename) external view returns (bool);\n\n function getChecksum(string memory filename)\n external\n view\n returns (bytes32 checksum);\n\n function getFile(string memory filename)\n external\n view\n returns (File memory file);\n\n function createFile(string memory filename, bytes32[] memory checksums)\n external\n returns (File memory file);\n\n function createFile(\n string memory filename,\n bytes32[] memory checksums,\n bytes memory extraData\n ) external returns (File memory file);\n\n function deleteFile(string memory filename) external;\n}\n"
	},
	"lib/openzeppelin-contracts/contracts/interfaces/draft-IERC1822.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)\n\npragma solidity ^0.8.0;\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"
	},
	"lib/openzeppelin-contracts/contracts/proxy/Proxy.sol": {
	"content": "// 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"
	},
	"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\n\npragma solidity ^0.8.0;\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 * ```\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(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n * }\n * }\n * ```\n \n _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\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 /\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"
	},
	"lib/openzeppelin-contracts-upgradeable/contracts/access/Ownable2StepUpgradeable.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./OwnableUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/*\n @dev Contract module which provides 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} and {acceptOwnership}.\n \n This module is used through inheritance. It will make available all functions\n * from parent (Ownable).\n /\nabstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {\n function __Ownable2Step_init() internal onlyInitializing {\n __Ownable_init_unchained();\n }\n\n function __Ownable2Step_init_unchained() internal onlyInitializing {\n }\n address private _pendingOwner;\n\n event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\n\n /\n @dev Returns the address of the pending owner.\n /\n function pendingOwner() public view virtual returns (address) {\n return _pendingOwner;\n }\n\n /\n @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\n * Can only be called by the current owner.\n /\n function transferOwnership(address newOwner) public virtual override onlyOwner {\n _pendingOwner = newOwner;\n emit OwnershipTransferStarted(owner(), newOwner);\n }\n\n /\n @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\n * Internal function without access restriction.\n /\n function _transferOwnership(address newOwner) internal virtual override {\n delete _pendingOwner;\n super._transferOwnership(newOwner);\n }\n\n /\n @dev The new owner accepts the ownership transfer.\n /\n function acceptOwnership() external {\n address sender = _msgSender();\n require(pendingOwner() == sender, \"Ownable2Step: caller is not the new owner\");\n _transferOwnership(sender);\n }\n\n /\n @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n}\n"
	},
	"lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.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 OwnableUpgradeable is Initializable, ContextUpgradeable {\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 function __Ownable_init() internal onlyInitializing {\n __Ownable_init_unchained();\n }\n\n function __Ownable_init_unchained() internal onlyInitializing {\n _transferOwnership(_msgSender());\n }\n\n /\n @dev Throws if called by any account other than the owner.\n /\n modifier onlyOwner() {\n _checkOwner();\n _;\n }\n\n /\n @dev Returns the address of the current owner.\n /\n function owner() public view virtual returns (address) {\n return _owner;\n }\n\n /\n @dev Throws if the sender is not the owner.\n /\n function _checkOwner() internal view virtual {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n }\n\n /\n @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions anymore. Can only be called by the current owner.\n \n NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby removing any functionality that is only available to the owner.\n /\n function renounceOwnership() public virtual onlyOwner {\n _transferOwnership(address(0));\n }\n\n /\n @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n /\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n _transferOwnership(newOwner);\n }\n\n /\n @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Internal function without access restriction.\n /\n function _transferOwnership(address newOwner) internal virtual {\n address oldOwner = _owner;\n _owner = newOwner;\n emit OwnershipTransferred(oldOwner, newOwner);\n }\n\n /\n @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n}\n"
	},
	"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\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 * ```\n * contract MyToken is ERC20Upgradeable {\n * function initialize() initializer public {\n * __ERC20_init(\"MyToken\", \"MTK\");\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 Indicates that the contract has been initialized.\n * @custom:oz-retyped-from bool\n /\n uint8 private _initialized;\n\n /\n @dev Indicates that the contract is in the process of being initialized.\n /\n bool private _initializing;\n\n /\n @dev Triggered when the contract has been initialized or reinitialized.\n /\n event Initialized(uint8 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 functions marked with `initializer` can be nested in the context of a\n * constructor.\n \n Emits an {Initialized} event.\n /\n modifier initializer() {\n bool isTopLevelCall = !_initializing;\n require(\n (isTopLevelCall && _initialized < 1) \|\| (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n \"Initializable: contract is already initialized\"\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 255 will prevent any future reinitialization.\n \n Emits an {Initialized} event.\n /\n modifier reinitializer(uint8 version) {\n require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\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 require(_initializing, \"Initializable: contract is not initializing\");\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 require(!_initializing, \"Initializable: contract is initializing\");\n if (_initialized != type(uint8).max) {\n _initialized = type(uint8).max;\n emit Initialized(type(uint8).max);\n }\n }\n\n /\n @dev Internal function that returns the initialized version. Returns `_initialized`\n /\n function _getInitializedVersion() internal view returns (uint8) {\n return _initialized;\n }\n\n /\n @dev Internal function that returns the initialized version. Returns `_initializing`\n */\n function _isInitializing() internal view returns (bool) {\n return _initializing;\n }\n}\n"
	},
	"lib/openzeppelin-contracts-upgradeable/contracts/security/ReentrancyGuardUpgradeable.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\n\n/*\n @dev Contract module that helps prevent reentrant calls to a function.\n \n Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n \n Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n \n TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n /\nabstract contract ReentrancyGuardUpgradeable is Initializable {\n // Booleans are more expensive than uint256 or any type that takes up a full\n // word because each write operation emits an extra SLOAD to first read the\n // slot's contents, replace the bits taken up by the boolean, and then write\n // back. This is the compiler's defense against contract upgrades and\n // pointer aliasing, and it cannot be disabled.\n\n // The values being non-zero value makes deployment a bit more expensive,\n // but in exchange the refund on every call to nonReentrant will be lower in\n // amount. Since refunds are capped to a percentage of the total\n // transaction's gas, it is best to keep them low in cases like this one, to\n // increase the likelihood of the full refund coming into effect.\n uint256 private constant _NOT_ENTERED = 1;\n uint256 private constant _ENTERED = 2;\n\n uint256 private _status;\n\n function __ReentrancyGuard_init() internal onlyInitializing {\n __ReentrancyGuard_init_unchained();\n }\n\n function __ReentrancyGuard_init_unchained() internal onlyInitializing {\n _status = _NOT_ENTERED;\n }\n\n /\n @dev Prevents a contract from calling itself, directly or indirectly.\n * Calling a `nonReentrant` function from another `nonReentrant`\n * function is not supported. It is possible to prevent this from happening\n * by making the `nonReentrant` function external, and making it call a\n * `private` function that does the actual work.\n /\n modifier nonReentrant() {\n _nonReentrantBefore();\n _;\n _nonReentrantAfter();\n }\n\n function _nonReentrantBefore() private {\n // On the first call to nonReentrant, _status will be _NOT_ENTERED\n require(_status != _ENTERED, \"ReentrancyGuard: reentrant call\");\n\n // Any calls to nonReentrant after this point will fail\n _status = _ENTERED;\n }\n\n function _nonReentrantAfter() private {\n // By storing the original value once again, a refund is triggered (see\n // https://eips.ethereum.org/EIPS/eip-2200)\n _status = _NOT_ENTERED;\n }\n\n /\n @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n * `nonReentrant` function in the call stack.\n /\n function _reentrancyGuardEntered() internal view returns (bool) {\n return _status == _ENTERED;\n }\n\n /\n @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n}\n"
	},
	"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC721/ERC721Upgradeable.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/ERC721.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC721Upgradeable.sol\";\nimport \"./IERC721ReceiverUpgradeable.sol\";\nimport \"./extensions/IERC721MetadataUpgradeable.sol\";\nimport \"../../utils/AddressUpgradeable.sol\";\nimport \"../../utils/ContextUpgradeable.sol\";\nimport \"../../utils/StringsUpgradeable.sol\";\nimport \"../../utils/introspection/ERC165Upgradeable.sol\";\nimport \"../../proxy/utils/Initializable.sol\";\n\n/*\n @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\n * {ERC721Enumerable}.\n /\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\n using AddressUpgradeable for address;\n using StringsUpgradeable for uint256;\n\n // Token name\n string private _name;\n\n // Token symbol\n string private _symbol;\n\n // Mapping from token ID to owner address\n mapping(uint256 => address) private _owners;\n\n // Mapping owner address to token count\n mapping(address => uint256) private _balances;\n\n // Mapping from token ID to approved address\n mapping(uint256 => address) private _tokenApprovals;\n\n // Mapping from owner to operator approvals\n mapping(address => mapping(address => bool)) private _operatorApprovals;\n\n /\n @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\n /\n function __ERC721_init(string memory name_, string memory symbol_) internal onlyInitializing {\n __ERC721_init_unchained(name_, symbol_);\n }\n\n function __ERC721_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {\n _name = name_;\n _symbol = symbol_;\n }\n\n /\n @dev See {IERC165-supportsInterface}.\n /\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\n return\n interfaceId == type(IERC721Upgradeable).interfaceId \|\|\n interfaceId == type(IERC721MetadataUpgradeable).interfaceId \|\|\n super.supportsInterface(interfaceId);\n }\n\n /\n @dev See {IERC721-balanceOf}.\n /\n function balanceOf(address owner) public view virtual override returns (uint256) {\n require(owner != address(0), \"ERC721: address zero is not a valid owner\");\n return _balances[owner];\n }\n\n /\n @dev See {IERC721-ownerOf}.\n /\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\n address owner = _ownerOf(tokenId);\n require(owner != address(0), \"ERC721: invalid token ID\");\n return owner;\n }\n\n /\n @dev See {IERC721Metadata-name}.\n /\n function name() public view virtual override returns (string memory) {\n return _name;\n }\n\n /\n @dev See {IERC721Metadata-symbol}.\n /\n function symbol() public view virtual override returns (string memory) {\n return _symbol;\n }\n\n /\n @dev See {IERC721Metadata-tokenURI}.\n /\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\n _requireMinted(tokenId);\n\n string memory baseURI = _baseURI();\n return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : \"\";\n }\n\n /\n @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\n * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\n * by default, can be overridden in child contracts.\n /\n function _baseURI() internal view virtual returns (string memory) {\n return \"\";\n }\n\n /\n @dev See {IERC721-approve}.\n /\n function approve(address to, uint256 tokenId) public virtual override {\n address owner = ERC721Upgradeable.ownerOf(tokenId);\n require(to != owner, \"ERC721: approval to current owner\");\n\n require(\n _msgSender() == owner \|\| isApprovedForAll(owner, _msgSender()),\n \"ERC721: approve caller is not token owner or approved for all\"\n );\n\n _approve(to, tokenId);\n }\n\n /\n @dev See {IERC721-getApproved}.\n /\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\n _requireMinted(tokenId);\n\n return _tokenApprovals[tokenId];\n }\n\n /\n @dev See {IERC721-setApprovalForAll}.\n /\n function setApprovalForAll(address operator, bool approved) public virtual override {\n _setApprovalForAll(_msgSender(), operator, approved);\n }\n\n /\n @dev See {IERC721-isApprovedForAll}.\n /\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\n return _operatorApprovals[owner][operator];\n }\n\n /\n @dev See {IERC721-transferFrom}.\n /\n function transferFrom(\n address from,\n address to,\n uint256 tokenId\n ) public virtual override {\n //solhint-disable-next-line max-line-length\n require(_isApprovedOrOwner(_msgSender(), tokenId), \"ERC721: caller is not token owner or approved\");\n\n _transfer(from, to, tokenId);\n }\n\n /\n @dev See {IERC721-safeTransferFrom}.\n /\n function safeTransferFrom(\n address from,\n address to,\n uint256 tokenId\n ) public virtual override {\n safeTransferFrom(from, to, tokenId, \"\");\n }\n\n /\n @dev See {IERC721-safeTransferFrom}.\n /\n function safeTransferFrom(\n address from,\n address to,\n uint256 tokenId,\n bytes memory data\n ) public virtual override {\n require(_isApprovedOrOwner(_msgSender(), tokenId), \"ERC721: caller is not token owner or approved\");\n _safeTransfer(from, to, tokenId, data);\n }\n\n /\n @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n \n `data` is additional data, it has no specified format and it is sent in call to `to`.\n \n This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\n * implement alternative mechanisms to perform token transfer, such as signature-based.\n \n Requirements:\n \n - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must exist and be owned by `from`.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n \n Emits a {Transfer} event.\n /\n function _safeTransfer(\n address from,\n address to,\n uint256 tokenId,\n bytes memory data\n ) internal virtual {\n _transfer(from, to, tokenId);\n require(_checkOnERC721Received(from, to, tokenId, data), \"ERC721: transfer to non ERC721Receiver implementer\");\n }\n\n /\n @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist\n /\n function _ownerOf(uint256 tokenId) internal view virtual returns (address) {\n return _owners[tokenId];\n }\n\n /\n @dev Returns whether `tokenId` exists.\n \n Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\n \n Tokens start existing when they are minted (`_mint`),\n * and stop existing when they are burned (`_burn`).\n /\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\n return _ownerOf(tokenId) != address(0);\n }\n\n /\n @dev Returns whether `spender` is allowed to manage `tokenId`.\n \n Requirements:\n \n - `tokenId` must exist.\n /\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\n address owner = ERC721Upgradeable.ownerOf(tokenId);\n return (spender == owner \|\| isApprovedForAll(owner, spender) \|\| getApproved(tokenId) == spender);\n }\n\n /\n @dev Safely mints `tokenId` and transfers it to `to`.\n \n Requirements:\n \n - `tokenId` must not exist.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n \n Emits a {Transfer} event.\n /\n function _safeMint(address to, uint256 tokenId) internal virtual {\n _safeMint(to, tokenId, \"\");\n }\n\n /\n @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n /\n function _safeMint(\n address to,\n uint256 tokenId,\n bytes memory data\n ) internal virtual {\n _mint(to, tokenId);\n require(\n _checkOnERC721Received(address(0), to, tokenId, data),\n \"ERC721: transfer to non ERC721Receiver implementer\"\n );\n }\n\n /\n @dev Mints `tokenId` and transfers it to `to`.\n \n WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\n \n Requirements:\n \n - `tokenId` must not exist.\n * - `to` cannot be the zero address.\n \n Emits a {Transfer} event.\n /\n function _mint(address to, uint256 tokenId) internal virtual {\n require(to != address(0), \"ERC721: mint to the zero address\");\n require(!_exists(tokenId), \"ERC721: token already minted\");\n\n _beforeTokenTransfer(address(0), to, tokenId, 1);\n\n // Check that tokenId was not minted by `_beforeTokenTransfer` hook\n require(!_exists(tokenId), \"ERC721: token already minted\");\n\n unchecked {\n // Will not overflow unless all 2256 token ids are minted to the same owner.\n // Given that tokens are minted one by one, it is impossible in practice that\n // this ever happens. Might change if we allow batch minting.\n // The ERC fails to describe this case.\n _balances[to] += 1;\n }\n\n _owners[tokenId] = to;\n\n emit Transfer(address(0), to, tokenId);\n\n _afterTokenTransfer(address(0), to, tokenId, 1);\n }\n\n /\n @dev Destroys `tokenId`.\n * The approval is cleared when the token is burned.\n * This is an internal function that does not check if the sender is authorized to operate on the token.\n \n Requirements:\n \n - `tokenId` must exist.\n \n Emits a {Transfer} event.\n /\n function _burn(uint256 tokenId) internal virtual {\n address owner = ERC721Upgradeable.ownerOf(tokenId);\n\n _beforeTokenTransfer(owner, address(0), tokenId, 1);\n\n // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook\n owner = ERC721Upgradeable.ownerOf(tokenId);\n\n // Clear approvals\n delete _tokenApprovals[tokenId];\n\n unchecked {\n // Cannot overflow, as that would require more tokens to be burned/transferred\n // out than the owner initially received through minting and transferring in.\n _balances[owner] -= 1;\n }\n delete _owners[tokenId];\n\n emit Transfer(owner, address(0), tokenId);\n\n _afterTokenTransfer(owner, address(0), tokenId, 1);\n }\n\n /\n @dev Transfers `tokenId` from `from` to `to`.\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\n \n Requirements:\n \n - `to` cannot be the zero address.\n * - `tokenId` token must be owned by `from`.\n \n Emits a {Transfer} event.\n /\n function _transfer(\n address from,\n address to,\n uint256 tokenId\n ) internal virtual {\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \"ERC721: transfer from incorrect owner\");\n require(to != address(0), \"ERC721: transfer to the zero address\");\n\n _beforeTokenTransfer(from, to, tokenId, 1);\n\n // Check that tokenId was not transferred by `_beforeTokenTransfer` hook\n require(ERC721Upgradeable.ownerOf(tokenId) == from, \"ERC721: transfer from incorrect owner\");\n\n // Clear approvals from the previous owner\n delete _tokenApprovals[tokenId];\n\n unchecked {\n // `_balances[from]` cannot overflow for the same reason as described in `_burn`:\n // `from`'s balance is the number of token held, which is at least one before the current\n // transfer.\n // `_balances[to]` could overflow in the conditions described in `_mint`. That would require\n // all 2256 token ids to be minted, which in practice is impossible.\n _balances[from] -= 1;\n _balances[to] += 1;\n }\n _owners[tokenId] = to;\n\n emit Transfer(from, to, tokenId);\n\n _afterTokenTransfer(from, to, tokenId, 1);\n }\n\n /\n @dev Approve `to` to operate on `tokenId`\n \n Emits an {Approval} event.\n /\n function _approve(address to, uint256 tokenId) internal virtual {\n _tokenApprovals[tokenId] = to;\n emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\n }\n\n /\n @dev Approve `operator` to operate on all of `owner` tokens\n \n Emits an {ApprovalForAll} event.\n /\n function _setApprovalForAll(\n address owner,\n address operator,\n bool approved\n ) internal virtual {\n require(owner != operator, \"ERC721: approve to caller\");\n _operatorApprovals[owner][operator] = approved;\n emit ApprovalForAll(owner, operator, approved);\n }\n\n /\n @dev Reverts if the `tokenId` has not been minted yet.\n /\n function _requireMinted(uint256 tokenId) internal view virtual {\n require(_exists(tokenId), \"ERC721: invalid token ID\");\n }\n\n /\n @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\n * The call is not executed if the target address is not a contract.\n \n @param from address representing the previous owner of the given token ID\n * @param to target address that will receive the tokens\n * @param tokenId uint256 ID of the token to be transferred\n * @param data bytes optional data to send along with the call\n * @return bool whether the call correctly returned the expected magic value\n /\n function _checkOnERC721Received(\n address from,\n address to,\n uint256 tokenId,\n bytes memory data\n ) private returns (bool) {\n if (to.isContract()) {\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {\n return retval == IERC721ReceiverUpgradeable.onERC721Received.selector;\n } catch (bytes memory reason) {\n if (reason.length == 0) {\n revert(\"ERC721: transfer to non ERC721Receiver implementer\");\n } else {\n /// @solidity memory-safe-assembly\n assembly {\n revert(add(32, reason), mload(reason))\n }\n }\n }\n } else {\n return true;\n }\n }\n\n /\n @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is\n * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.\n \n Calling conditions:\n \n - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.\n * - When `from` is zero, the tokens will be minted for `to`.\n * - When `to` is zero, ``from``'s tokens will be burned.\n * - `from` and `to` are never both zero.\n * - `batchSize` is non-zero.\n \n To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n /\n function _beforeTokenTransfer(\n address from,\n address to,\n uint256, / firstTokenId /\n uint256 batchSize\n ) internal virtual {\n if (batchSize > 1) {\n if (from != address(0)) {\n _balances[from] -= batchSize;\n }\n if (to != address(0)) {\n _balances[to] += batchSize;\n }\n }\n }\n\n /\n @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is\n * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.\n \n Calling conditions:\n \n - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.\n * - When `from` is zero, the tokens were minted for `to`.\n * - When `to` is zero, ``from``'s tokens were burned.\n * - `from` and `to` are never both zero.\n * - `batchSize` is non-zero.\n \n To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n /\n function _afterTokenTransfer(\n address from,\n address to,\n uint256 firstTokenId,\n uint256 batchSize\n ) internal virtual {}\n\n /\n @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[44] private __gap;\n}\n"
	},
	"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC721/IERC721ReceiverUpgradeable.sol": {
	"content": "// 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 IERC721ReceiverUpgradeable {\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"
	},
	"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC721/IERC721Upgradeable.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165Upgradeable.sol\";\n\n/*\n @dev Required interface of an ERC721 compliant contract.\n /\ninterface IERC721Upgradeable is IERC165Upgradeable {\n /\n @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n /\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n /\n @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n /\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n /\n @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n /\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n /\n @dev Returns the number of tokens in ``owner``'s account.\n /\n function balanceOf(address owner) external view returns (uint256 balance);\n\n /\n @dev Returns the owner of the `tokenId` token.\n \n Requirements:\n \n - `tokenId` must exist.\n /\n function ownerOf(uint256 tokenId) external view returns (address owner);\n\n /\n @dev Safely transfers `tokenId` token from `from` to `to`.\n \n Requirements:\n \n - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must exist and be owned by `from`.\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n \n Emits a {Transfer} event.\n /\n function safeTransferFrom(\n address from,\n address to,\n uint256 tokenId,\n bytes calldata data\n ) external;\n\n /\n @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n \n Requirements:\n \n - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must exist and be owned by `from`.\n * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n \n Emits a {Transfer} event.\n /\n function safeTransferFrom(\n address from,\n address to,\n uint256 tokenId\n ) external;\n\n /\n @dev Transfers `tokenId` token from `from` to `to`.\n \n WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721\n * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must\n * understand this adds an external call which potentially creates a reentrancy vulnerability.\n \n Requirements:\n \n - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `tokenId` token must be owned by `from`.\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n \n Emits a {Transfer} event.\n /\n function transferFrom(\n address from,\n address to,\n uint256 tokenId\n ) external;\n\n /\n @dev Gives permission to `to` to transfer `tokenId` token to another account.\n * The approval is cleared when the token is transferred.\n \n Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n \n Requirements:\n \n - The caller must own the token or be an approved operator.\n * - `tokenId` must exist.\n \n Emits an {Approval} event.\n /\n function approve(address to, uint256 tokenId) external;\n\n /\n @dev Approve or remove `operator` as an operator for the caller.\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n \n Requirements:\n \n - The `operator` cannot be the caller.\n \n Emits an {ApprovalForAll} event.\n /\n function setApprovalForAll(address operator, bool _approved) external;\n\n /\n @dev Returns the account approved for `tokenId` token.\n \n Requirements:\n \n - `tokenId` must exist.\n /\n function getApproved(uint256 tokenId) external view returns (address operator);\n\n /\n @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n \n See {setApprovalForAll}\n */\n function isApprovedForAll(address owner, address operator) external view returns (bool);\n}\n"
	},
	"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC721/extensions/IERC721MetadataUpgradeable.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC721Upgradeable.sol\";\n\n/*\n @title ERC-721 Non-Fungible Token Standard, optional metadata extension\n * @dev See https://eips.ethereum.org/EIPS/eip-721\n /\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\n /\n @dev Returns the token collection name.\n /\n function name() external view returns (string memory);\n\n /\n @dev Returns the token collection symbol.\n /\n function symbol() external view returns (string memory);\n\n /\n @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\n */\n function tokenURI(uint256 tokenId) external view returns (string memory);\n}\n"
	},
	"lib/openzeppelin-contracts-upgradeable/contracts/utils/AddressUpgradeable.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/*\n @dev Collection of functions related to the address type\n /\nlibrary AddressUpgradeable {\n /\n @dev Returns true if `account` is a contract.\n \n [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n \n Among others, `isContract` will return false for the following\n * types of addresses:\n \n - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n \n [IMPORTANT]\n * ====\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\n \n Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n * constructor.\n * ====\n /\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize/address.code.length, which returns 0\n // for contracts in construction, since the code is only stored at the end\n // of the constructor execution.\n\n return account.code.length > 0;\n }\n\n /\n @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n \n https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n \n https://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.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n /\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /\n @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n \n If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n \n Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n \n Requirements:\n \n - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n \n _Available since v3.1._\n /\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n }\n\n /\n @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n \n _Available since v3.1._\n /\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /\n @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n \n Requirements:\n \n - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n \n _Available since v3.1._\n /\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /\n @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n \n _Available since v3.1._\n /\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /\n @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n \n _Available since v3.3._\n /\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /\n @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n \n _Available since v3.3._\n /\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /\n @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n \n _Available since v4.8._\n /\n function verifyCallResultFromTarget(\n address target,\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n if (success) {\n if (returndata.length == 0) {\n // only check isContract if the call was successful and the return data is empty\n // otherwise we already know that it was a contract\n require(isContract(target), \"Address: call to non-contract\");\n }\n return returndata;\n } else {\n _revert(returndata, errorMessage);\n }\n }\n\n /\n @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n * revert reason or using the provided one.\n \n _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n _revert(returndata, errorMessage);\n }\n }\n\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n}\n"
	},
	"lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\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 ContextUpgradeable is Initializable {\n function __Context_init() internal onlyInitializing {\n }\n\n function __Context_init_unchained() internal onlyInitializing {\n }\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 /\n @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[50] private __gap;\n}\n"
	},
	"lib/openzeppelin-contracts-upgradeable/contracts/utils/CountersUpgradeable.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)\n\npragma solidity ^0.8.0;\n\n/*\n @title Counters\n * @author Matt Condon (@shrugs)\n * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\n \n Include with `using Counters for Counters.Counter;`\n */\nlibrary CountersUpgradeable {\n struct Counter {\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\n // this feature: see https://github.com/ethereum/solidity/issues/4637\n uint256 _value; // default: 0\n }\n\n function current(Counter storage counter) internal view returns (uint256) {\n return counter._value;\n }\n\n function increment(Counter storage counter) internal {\n unchecked {\n counter._value += 1;\n }\n }\n\n function decrement(Counter storage counter) internal {\n uint256 value = counter._value;\n require(value > 0, \"Counter: decrement overflow\");\n unchecked {\n counter._value = value - 1;\n }\n }\n\n function reset(Counter storage counter) internal {\n counter._value = 0;\n }\n}\n"
	},
	"lib/openzeppelin-contracts-upgradeable/contracts/utils/StringsUpgradeable.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./math/MathUpgradeable.sol\";\n\n/*\n @dev String operations.\n /\nlibrary StringsUpgradeable {\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 = MathUpgradeable.log10(value) + 1;\n string memory buffer = new string(length);\n uint256 ptr;\n /// @solidity memory-safe-assembly\n assembly {\n ptr := add(buffer, add(32, length))\n }\n while (true) {\n ptr--;\n /// @solidity memory-safe-assembly\n assembly {\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\n }\n value /= 10;\n if (value == 0) break;\n }\n return buffer;\n }\n }\n\n /\n @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n /\n function toHexString(uint256 value) internal pure returns (string memory) {\n unchecked {\n return toHexString(value, MathUpgradeable.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"
	},
	"lib/openzeppelin-contracts-upgradeable/contracts/utils/introspection/ERC165Upgradeable.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165Upgradeable.sol\";\nimport \"../../proxy/utils/Initializable.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 ERC165Upgradeable is Initializable, IERC165Upgradeable {\n function __ERC165_init() internal onlyInitializing {\n }\n\n function __ERC165_init_unchained() internal onlyInitializing {\n }\n /\n @dev See {IERC165-supportsInterface}.\n /\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IERC165Upgradeable).interfaceId;\n }\n\n /\n @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[50] private __gap;\n}\n"
	},
	"lib/openzeppelin-contracts-upgradeable/contracts/utils/introspection/IERC165Upgradeable.sol": {
	"content": "// 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 IERC165Upgradeable {\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"
	},
	"lib/openzeppelin-contracts-upgradeable/contracts/utils/math/MathUpgradeable.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.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 MathUpgradeable {\n enum Rounding {\n Down, // Toward negative infinity\n Up, // Toward infinity\n Zero // Toward zero\n }\n\n /\n @dev Returns the largest of two numbers.\n /\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\n return a > b ? a : b;\n }\n\n /\n @dev Returns the smallest of two numbers.\n /\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\n return a < b ? a : b;\n }\n\n /\n @dev Returns the average of two numbers. The result is rounded towards\n * zero.\n /\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\n // (a + b) / 2 can overflow.\n return (a & b) + (a ^ b) / 2;\n }\n\n /\n @dev Returns the ceiling of the division of two numbers.\n \n This differs from standard division with `/` in that it rounds up instead\n * of rounding down.\n /\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n // (a + b - 1) / b can overflow on addition, so we distribute.\n return a == 0 ? 0 : (a - 1) / b + 1;\n }\n\n /\n @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\n * with further edits by Uniswap Labs also under MIT license.\n /\n function mulDiv(\n uint256 x,\n uint256 y,\n uint256 denominator\n ) internal pure returns (uint256 result) {\n unchecked {\n // 512-bit multiply [prod1 prod0] = x y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n // variables such that product = prod1 * 2^256 + prod0.\n uint256 prod0; // Least significant 256 bits of the product\n uint256 prod1; // Most significant 256 bits of the product\n assembly {\n let mm := mulmod(x, y, not(0))\n prod0 := mul(x, y)\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n }\n\n // Handle non-overflow cases, 256 by 256 division.\n if (prod1 == 0) {\n return prod0 / denominator;\n }\n\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\n require(denominator > prod1);\n\n ///////////////////////////////////////////////\n // 512 by 256 division.\n ///////////////////////////////////////////////\n\n // Make division exact by subtracting the remainder from [prod1 prod0].\n uint256 remainder;\n assembly {\n // Compute remainder using mulmod.\n remainder := mulmod(x, y, denominator)\n\n // Subtract 256 bit number from 512 bit number.\n prod1 := sub(prod1, gt(remainder, prod0))\n prod0 := sub(prod0, remainder)\n }\n\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\n // See https://cs.stackexchange.com/q/138556/92363.\n\n // Does not overflow because the denominator cannot be zero at this stage in the function.\n uint256 twos = denominator & (~denominator + 1);\n assembly {\n // Divide denominator by twos.\n denominator := div(denominator, twos)\n\n // Divide [prod1 prod0] by twos.\n prod0 := div(prod0, twos)\n\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n twos := add(div(sub(0, twos), twos), 1)\n }\n\n // Shift in bits from prod1 into prod0.\n prod0 \|= prod1 * twos;\n\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n // four bits. That is, denominator * inv = 1 mod 2^4.\n uint256 inverse = (3 * denominator) ^ 2;\n\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\n // in modular arithmetic, doubling the correct bits in each step.\n inverse = 2 - denominator inverse; // inverse mod 2^8\n inverse = 2 - denominator inverse; // inverse mod 2^16\n inverse = 2 - denominator inverse; // inverse mod 2^32\n inverse = 2 - denominator inverse; // inverse mod 2^64\n inverse = 2 - denominator inverse; // inverse mod 2^128\n inverse = 2 - denominator inverse; // inverse mod 2^256\n\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n // is no longer required.\n result = prod0 * inverse;\n return result;\n }\n }\n\n /*\n @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n /\n function mulDiv(\n uint256 x,\n uint256 y,\n uint256 denominator,\n Rounding rounding\n ) internal pure returns (uint256) {\n uint256 result = mulDiv(x, y, denominator);\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\n result += 1;\n }\n return result;\n }\n\n /\n @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\n \n Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n /\n function sqrt(uint256 a) internal pure returns (uint256) {\n if (a == 0) {\n return 0;\n }\n\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n //\n // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n // `msb(a) <= a < 2msb(a)`. This value can be written `msb(a)=2k` with `k=log2(a)`.\n //\n // This can be rewritten `2log2(a) <= a < 2(log2(a) + 1)`\n // → `sqrt(2k) <= 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 >= 1064) {\n value /= 1064;\n result += 64;\n }\n if (value >= 1032) {\n value /= 1032;\n result += 32;\n }\n if (value >= 1016) {\n value /= 1016;\n result += 16;\n }\n if (value >= 108) {\n value /= 108;\n result += 8;\n }\n if (value >= 104) {\n value /= 104;\n result += 4;\n }\n if (value >= 102) {\n value /= 102;\n result += 2;\n }\n if (value >= 101) {\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 && 10result < value ? 1 : 0);\n }\n }\n\n /\n @dev Return the log in base 256, rounded down, of a positive value.\n * Returns 0 if given 0.\n \n Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n /\n function log256(uint256 value) internal pure returns (uint256) {\n uint256 result = 0;\n unchecked {\n if (value >> 128 > 0) {\n value >>= 128;\n result += 16;\n }\n if (value >> 64 > 0) {\n value >>= 64;\n result += 8;\n }\n if (value >> 32 > 0) {\n value >>= 32;\n result += 4;\n }\n if (value >> 16 > 0) {\n value >>= 16;\n result += 2;\n }\n if (value >> 8 > 0) {\n result += 1;\n }\n }\n return result;\n }\n\n /\n @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n * Returns 0 if given 0.\n */\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = log256(value);\n return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\n }\n }\n}\n"
	},
	"lib/sstore2/contracts/SSTORE2.sol": {
	"content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./utils/Bytecode.sol\";\n\n/*\n @title A key-value storage with auto-generated keys for storing chunks of data with a lower write & read cost.\n @author Agustin Aguilar <aa@horizon.io>\n\n Readme: https://github.com/0xsequence/sstore2#readme\n/\nlibrary SSTORE2 {\n error WriteError();\n\n /*\n @notice Stores `_data` and returns `pointer` as key for later retrieval\n @dev The pointer is a contract address with `_data` as code\n @param _data to be written\n @return pointer Pointer to the written `_data`\n /\n function write(bytes memory _data) internal returns (address pointer) {\n // Append 00 to _data so contract can't be called\n // Build init code\n bytes memory code = Bytecode.creationCodeFor(\n abi.encodePacked(\n hex'00',\n _data\n )\n );\n\n // Deploy contract using create\n assembly { pointer := create(0, add(code, 32), mload(code)) }\n\n // Address MUST be non-zero\n if (pointer == address(0)) revert WriteError();\n }\n\n /*\n @notice Reads the contents of the `_pointer` code as data, skips the first byte \n @dev The function is intended for reading pointers generated by `write`\n @param _pointer to be read\n @return data read from `_pointer` contract\n /\n function read(address _pointer) internal view returns (bytes memory) {\n return Bytecode.codeAt(_pointer, 1, type(uint256).max);\n }\n\n /*\n @notice Reads the contents of the `_pointer` code as data, skips the first byte \n @dev The function is intended for reading pointers generated by `write`\n @param _pointer to be read\n @param _start number of bytes to skip\n @return data read from `_pointer` contract\n /\n function read(address _pointer, uint256 _start) internal view returns (bytes memory) {\n return Bytecode.codeAt(_pointer, _start + 1, type(uint256).max);\n }\n\n /*\n @notice Reads the contents of the `_pointer` code as data, skips the first byte \n @dev The function is intended for reading pointers generated by `write`\n @param _pointer to be read\n @param _start number of bytes to skip\n @param _end index before which to end extraction\n @return data read from `_pointer` contract\n /\n function read(address _pointer, uint256 _start, uint256 _end) internal view returns (bytes memory) {\n return Bytecode.codeAt(_pointer, _start + 1, _end + 1);\n }\n}\n"
	},
	"lib/sstore2/contracts/utils/Bytecode.sol": {
	"content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n\nlibrary Bytecode {\n error InvalidCodeAtRange(uint256 _size, uint256 _start, uint256 _end);\n\n /*\n @notice Generate a creation code that results on a contract with `_code` as bytecode\n @param _code The returning value of the resulting `creationCode`\n @return creationCode (constructor) for new contract\n /\n function creationCodeFor(bytes memory _code) internal pure returns (bytes memory) {\n /\n 0x00 0x63 0x63XXXXXX PUSH4 _code.length size\n 0x01 0x80 0x80 DUP1 size size\n 0x02 0x60 0x600e PUSH1 14 14 size size\n 0x03 0x60 0x6000 PUSH1 00 0 14 size size\n 0x04 0x39 0x39 CODECOPY size\n 0x05 0x60 0x6000 PUSH1 00 0 size\n 0x06 0xf3 0xf3 RETURN\n <CODE>\n /\n\n return abi.encodePacked(\n hex\"63\",\n uint32(_code.length),\n hex\"80_60_0E_60_00_39_60_00_F3\",\n _code\n );\n }\n\n /*\n @notice Returns the size of the code on a given address\n @param _addr Address that may or may not contain code\n @return size of the code on the given `_addr`\n /\n function codeSize(address _addr) internal view returns (uint256 size) {\n assembly { size := extcodesize(_addr) }\n }\n\n /*\n @notice Returns the code of a given address\n @dev It will fail if `_end < _start`\n @param _addr Address that may or may not contain code\n @param _start number of bytes of code to skip on read\n @param _end index before which to end extraction\n @return oCode read from `_addr` deployed bytecode\n\n Forked from: https://gist.github.com/KardanovIR/fe98661df9338c842b4a30306d507fbd\n /\n function codeAt(address _addr, uint256 _start, uint256 _end) internal view returns (bytes memory oCode) {\n uint256 csize = codeSize(_addr);\n if (csize == 0) return bytes(\"\");\n\n if (_start > csize) return bytes(\"\");\n if (_end < _start) revert InvalidCodeAtRange(csize, _start, _end); \n\n unchecked {\n uint256 reqSize = _end - _start;\n uint256 maxSize = csize - _start;\n\n uint256 size = maxSize < reqSize ? maxSize : reqSize;\n\n assembly {\n // allocate output byte array - this could also be done without assembly\n // by using o_code = new bytes(size)\n oCode := mload(0x40)\n // new \"memory end\" including padding\n mstore(0x40, add(oCode, and(add(add(size, 0x20), 0x1f), not(0x1f))))\n // store length in memory\n mstore(oCode, size)\n // actually retrieve the code, this needs assembly\n extcodecopy(_addr, add(oCode, 0x20), _start, size)\n }\n }\n }\n}\n"
	},
	"src/TokenBase.sol": {
	"content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.13;\n\nimport {ERC721Upgradeable} from \"@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol\";\nimport {Ownable2StepUpgradeable} from \"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol\";\nimport {CountersUpgradeable} from \"@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol\";\nimport {ReentrancyGuardUpgradeable} from \"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\";\nimport {IToken} from \"./tokens/interfaces/IToken.sol\";\nimport {IObservability} from \"./observability/Observability.sol\";\nimport {UUPS} from \"./lib/proxy/UUPS.sol\";\nimport {ITokenFactory} from \"./interfaces/ITokenFactory.sol\";\nimport {VersionedContract} from \"./VersionedContract.sol\";\n\nabstract contract TokenBase is\n IToken,\n ERC721Upgradeable,\n ReentrancyGuardUpgradeable,\n Ownable2StepUpgradeable,\n VersionedContract,\n UUPS\n{\n using CountersUpgradeable for CountersUpgradeable.Counter;\n\n CountersUpgradeable.Counter private _tokenIdCounter;\n\n mapping(uint256 => bytes32) public tokenIdToPreviousBlockHash;\n mapping(address => bool) public allowedMinters;\n\n address public immutable factory;\n address public immutable o11y;\n uint256 internal immutable FUNDS_SEND_GAS_LIMIT = 210_000;\n\n TokenInfo public tokenInfo;\n\n //[[[[MODIFIERS]]]]\n /// @notice restricts to only users with minter role\n modifier onlyAllowedMinter() {\n if (!allowedMinters[msg.sender]) revert SenderNotMinter();\n _;\n }\n\n //[[[[SETUP FUNCTIONS]]]]\n\n constructor(address _factory, address _o11y) {\n factory = _factory;\n o11y = _o11y;\n }\n\n //[[[[VIEW FUNCTIONS]]]]\n\n /// @notice gets the total supply of tokens\n function totalSupply() public view returns (uint256) {\n return _tokenIdCounter.current();\n }\n\n //[[[[WITHDRAW FUNCTIONS]]]]\n\n /// @notice withdraws the funds from the contract\n function withdraw() external nonReentrant returns (bool) {\n uint256 amount = address(this).balance;\n\n (bool successFunds, ) = tokenInfo.fundsRecipent.call{\n value: amount,\n gas: FUNDS_SEND_GAS_LIMIT\n }(\"\");\n\n if (!successFunds) revert FundsSendFailure();\n\n IObservability(o11y).emitFundsWithdrawn(\n msg.sender,\n tokenInfo.fundsRecipent,\n amount\n );\n return successFunds;\n }\n\n /// @notice sets the funds recipent for token funds\n function setFundsRecipent(address fundsRecipent) external onlyOwner {\n tokenInfo.fundsRecipent = fundsRecipent;\n }\n\n //[[[[MINT FUNCTIONS]]]]\n\n /// @notice sets the minter role for the given user\n function setMinter(address user, bool isAllowed) public onlyOwner {\n allowedMinters[user] = isAllowed;\n }\n\n /// @notice mint a token for the given address\n function safeMint(address to) public onlyAllowedMinter {\n if (totalSupply() >= tokenInfo.maxSupply) revert MaxSupplyReached();\n _seedAndMint(to);\n }\n\n //[[[[PRIVATE FUNCTIONS]]]]\n\n /// @notice seeds the token id and mints the token\n function _seedAndMint(address to) internal {\n uint256 tokenId = _tokenIdCounter.current();\n\n tokenIdToPreviousBlockHash[tokenId] = blockhash(block.number - 1);\n\n _tokenIdCounter.increment();\n _safeMint(to, tokenId);\n }\n\n /// @notice checks if an upgrade is valid\n function _authorizeUpgrade(address newImpl) internal override onlyOwner {\n if (\n !ITokenFactory(factory).isValidUpgrade(\n _getImplementation(),\n newImpl\n )\n ) {\n revert ITokenFactory.InvalidUpgrade(newImpl);\n }\n }\n}\n"
	},
	"src/VersionedContract.sol": {
	"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nabstract contract VersionedContract {\n function contractVersion() external pure returns (string memory) {\n return \"1.0.0\";\n }\n}\n"
	},
	"src/interfaces/ITokenFactory.sol": {
	"content": "//SPDX-License-Identifier: MIT\npragma solidity ^0.8.13;\n\ninterface ITokenFactory {\n error InvalidUpgrade(address impl);\n error NotDeployed(address impl);\n\n /// @notice Creates a new token contract with the given implementation and data\n function create(\n address tokenImpl,\n bytes calldata data\n ) external returns (address clone);\n\n /// @notice checks if an implementation is valid\n function isValidDeployment(address impl) external view returns (bool);\n\n /// @notice registers a new implementation\n function registerDeployment(address impl) external;\n\n /// @notice unregisters an implementation\n function unregisterDeployment(address impl) external;\n\n /// @notice checks if an upgrade is valid\n function isValidUpgrade(\n address prevImpl,\n address newImpl\n ) external returns (bool);\n\n /// @notice registers a new upgrade\n function registerUpgrade(address prevImpl, address newImpl) external;\n\n /// @notice unregisters an upgrade\n function unregisterUpgrade(address prevImpl, address newImpl) external;\n}\n"
	},
	"src/lib/interfaces/IERC1967Upgrade.sol": {
	"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\n/// @title IERC1967Upgrade\n/// @author Rohan Kulkarni\n/// @notice The external ERC1967Upgrade events and errors\ninterface IERC1967Upgrade {\n /// ///\n /// EVENTS ///\n /// ///\n\n /// @notice Emitted when the implementation is upgraded\n /// @param impl The address of the implementation\n event Upgraded(address impl);\n\n /// ///\n /// ERRORS ///\n /// ///\n\n /// @dev Reverts if an implementation is an invalid upgrade\n /// @param impl The address of the invalid implementation\n error INVALID_UPGRADE(address impl);\n\n /// @dev Reverts if an implementation upgrade is not stored at the storage slot of the original\n error UNSUPPORTED_UUID();\n\n /// @dev Reverts if an implementation does not support ERC1822 proxiableUUID()\n error ONLY_UUPS();\n}\n"
	},
	"src/lib/interfaces/IUUPS.sol": {
	"content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.16;\n\nimport {IERC1822Proxiable} from \"@openzeppelin/contracts/interfaces/draft-IERC1822.sol\";\nimport {IERC1967Upgrade} from \"./IERC1967Upgrade.sol\";\n\n/// @title IUUPS\n/// @author Rohan Kulkarni\n/// @notice The external UUPS errors and functions\ninterface IUUPS is IERC1967Upgrade, IERC1822Proxiable {\n /// ///\n /// ERRORS ///\n /// ///\n\n /// @dev Reverts if not called directly\n error ONLY_CALL();\n\n /// @dev Reverts if not called via delegatecall\n error ONLY_DELEGATECALL();\n\n /// @dev Reverts if not called via proxy\n error ONLY_PROXY();\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @notice Upgrades to an implementation\n /// @param newImpl The new implementation address\n function upgradeTo(address newImpl) external;\n\n /// @notice Upgrades to an implementation with an additional function call\n /// @param newImpl The new implementation address\n /// @param data The encoded function call\n function upgradeToAndCall(\n address newImpl,\n bytes memory data\n ) external payable;\n}\n"
	},
	"src/lib/proxy/ERC1967Proxy.sol": {
	"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport {Proxy} from \"@openzeppelin/contracts/proxy/Proxy.sol\";\n\nimport {IERC1967Upgrade} from \"../interfaces/IERC1967Upgrade.sol\";\nimport {ERC1967Upgrade} from \"./ERC1967Upgrade.sol\";\n\n/// @title ERC1967Proxy\n/// @author Rohan Kulkarni\n/// @notice Modified from OpenZeppelin Contracts v4.7.3 (proxy/ERC1967/ERC1967Proxy.sol)\n/// - Inherits a modern, minimal ERC1967Upgrade\ncontract ERC1967Proxy is IERC1967Upgrade, Proxy, ERC1967Upgrade {\n /// ///\n /// CONSTRUCTOR ///\n /// ///\n\n /// @dev Initializes the proxy with an implementation contract and encoded function call\n /// @param _logic The implementation address\n /// @param _data The encoded function call\n constructor(address _logic, bytes memory _data) payable {\n _upgradeToAndCall(_logic, _data, false);\n }\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @dev The address of the current implementation\n function _implementation()\n internal\n view\n virtual\n override\n returns (address)\n {\n return ERC1967Upgrade._getImplementation();\n }\n}\n"
	},
	"src/lib/proxy/ERC1967Upgrade.sol": {
	"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport {IERC1822Proxiable} from \"@openzeppelin/contracts/interfaces/draft-IERC1822.sol\";\nimport {StorageSlot} from \"@openzeppelin/contracts/utils/StorageSlot.sol\";\n\nimport {IERC1967Upgrade} from \"../interfaces/IERC1967Upgrade.sol\";\nimport {Address} from \"../utils/Address.sol\";\n\n/// @title ERC1967Upgrade\n/// @author Rohan Kulkarni\n/// @notice Modified from OpenZeppelin Contracts v4.7.3 (proxy/ERC1967/ERC1967Upgrade.sol)\n/// - Uses custom errors declared in IERC1967Upgrade\n/// - Removes ERC1967 admin and beacon support\nabstract contract ERC1967Upgrade is IERC1967Upgrade {\n /// ///\n /// CONSTANTS ///\n /// ///\n\n /// @dev bytes32(uint256(keccak256('eip1967.proxy.rollback')) - 1)\n bytes32 private constant _ROLLBACK_SLOT =\n 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\n\n /// @dev bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)\n bytes32 internal constant _IMPLEMENTATION_SLOT =\n 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @dev Upgrades to an implementation with security checks for UUPS proxies and an additional function call\n /// @param _newImpl The new implementation address\n /// @param _data The encoded function call\n function _upgradeToAndCallUUPS(\n address _newImpl,\n bytes memory _data,\n bool _forceCall\n ) internal {\n if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {\n _setImplementation(_newImpl);\n } else {\n try IERC1822Proxiable(_newImpl).proxiableUUID() returns (\n bytes32 slot\n ) {\n if (slot != _IMPLEMENTATION_SLOT) revert UNSUPPORTED_UUID();\n } catch {\n revert ONLY_UUPS();\n }\n\n _upgradeToAndCall(_newImpl, _data, _forceCall);\n }\n }\n\n /// @dev Upgrades to an implementation with an additional function call\n /// @param _newImpl The new implementation address\n /// @param _data The encoded function call\n function _upgradeToAndCall(\n address _newImpl,\n bytes memory _data,\n bool _forceCall\n ) internal {\n _upgradeTo(_newImpl);\n\n if (_data.length > 0 \|\| _forceCall) {\n Address.functionDelegateCall(_newImpl, _data);\n }\n }\n\n /// @dev Performs an implementation upgrade\n /// @param _newImpl The new implementation address\n function _upgradeTo(address _newImpl) internal {\n _setImplementation(_newImpl);\n\n emit Upgraded(_newImpl);\n }\n\n /// @dev Stores the address of an implementation\n /// @param _impl The implementation address\n function _setImplementation(address _impl) private {\n if (!Address.isContract(_impl)) revert INVALID_UPGRADE(_impl);\n\n StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = _impl;\n }\n\n /// @dev The address of the current implementation\n function _getImplementation() internal view returns (address) {\n return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n }\n}\n"
	},
	"src/lib/proxy/UUPS.sol": {
	"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport {IUUPS} from \"../interfaces/IUUPS.sol\";\nimport {ERC1967Upgrade} from \"./ERC1967Upgrade.sol\";\n\n/// @title UUPS\n/// @author Rohan Kulkarni\n/// @notice Modified from OpenZeppelin Contracts v4.7.3 (proxy/utils/UUPSUpgradeable.sol)\n/// - Uses custom errors declared in IUUPS\n/// - Inherits a modern, minimal ERC1967Upgrade\nabstract contract UUPS is IUUPS, ERC1967Upgrade {\n /// ///\n /// IMMUTABLES ///\n /// ///\n\n /// @dev The address of the implementation\n address private immutable __self = address(this);\n\n /// ///\n /// MODIFIERS ///\n /// ///\n\n /// @dev Ensures that execution is via proxy delegatecall with the correct implementation\n modifier onlyProxy() {\n if (address(this) == __self) revert ONLY_DELEGATECALL();\n if (_getImplementation() != __self) revert ONLY_PROXY();\n _;\n }\n\n /// @dev Ensures that execution is via direct call\n modifier notDelegated() {\n if (address(this) != __self) revert ONLY_CALL();\n _;\n }\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @dev Hook to authorize an implementation upgrade\n /// @param _newImpl The new implementation address\n function _authorizeUpgrade(address _newImpl) internal virtual;\n\n /// @notice Upgrades to an implementation\n /// @param _newImpl The new implementation address\n function upgradeTo(address _newImpl) external onlyProxy {\n _authorizeUpgrade(_newImpl);\n _upgradeToAndCallUUPS(_newImpl, \"\", false);\n }\n\n /// @notice Upgrades to an implementation with an additional function call\n /// @param _newImpl The new implementation address\n /// @param _data The encoded function call\n function upgradeToAndCall(\n address _newImpl,\n bytes memory _data\n ) external payable onlyProxy {\n _authorizeUpgrade(_newImpl);\n _upgradeToAndCallUUPS(_newImpl, _data, true);\n }\n\n /// @notice The storage slot of the implementation address\n function proxiableUUID() external view notDelegated returns (bytes32) {\n return _IMPLEMENTATION_SLOT;\n }\n}\n"
	},
	"src/lib/utils/Address.sol": {
	"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\n/// @title EIP712\n/// @author Rohan Kulkarni\n/// @notice Modified from OpenZeppelin Contracts v4.7.3 (utils/Address.sol)\n/// - Uses custom errors `INVALID_TARGET()` & `DELEGATE_CALL_FAILED()`\n/// - Adds util converting address to bytes32\nlibrary Address {\n /// ///\n /// ERRORS ///\n /// ///\n\n /// @dev Reverts if the target of a delegatecall is not a contract\n error INVALID_TARGET();\n\n /// @dev Reverts if a delegatecall has failed\n error DELEGATE_CALL_FAILED();\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @dev Utility to convert an address to bytes32\n function toBytes32(address _account) internal pure returns (bytes32) {\n return bytes32(uint256(uint160(_account)) << 96);\n }\n\n /// @dev If an address is a contract\n function isContract(address _account) internal view returns (bool rv) {\n assembly {\n rv := gt(extcodesize(_account), 0)\n }\n }\n\n /// @dev Performs a delegatecall on an address\n function functionDelegateCall(\n address _target,\n bytes memory _data\n ) internal returns (bytes memory) {\n if (!isContract(_target)) revert INVALID_TARGET();\n\n (bool success, bytes memory returndata) = _target.delegatecall(_data);\n\n return verifyCallResult(success, returndata);\n }\n\n /// @dev Verifies a delegatecall was successful\n function verifyCallResult(\n bool _success,\n bytes memory _returndata\n ) internal pure returns (bytes memory) {\n if (_success) {\n return _returndata;\n } else {\n if (_returndata.length > 0) {\n assembly {\n let returndata_size := mload(_returndata)\n\n revert(add(32, _returndata), returndata_size)\n }\n } else {\n revert DELEGATE_CALL_FAILED();\n }\n }\n }\n}\n"
	},
	"src/observability/Observability.sol": {
	"content": "// SPDX-License-Identifier: GPL-3.0-or-later\npragma solidity ^0.8.13;\n\nimport {IObservability, IObservabilityEvents} from \"./interface/IObservability.sol\";\n\ncontract Observability is IObservability, IObservabilityEvents {\n /// @notice Emitted when a new clone is deployed\n function emitCloneDeployed(address owner, address clone) external override {\n emit CloneDeployed(msg.sender, owner, clone);\n }\n\n /// @notice Emitted when a sale has occured\n function emitSale(\n address to,\n uint256 pricePerToken,\n uint256 amount\n ) external override {\n emit Sale(msg.sender, to, pricePerToken, amount);\n }\n\n /// @notice Emitted when funds have been withdrawn\n function emitFundsWithdrawn(\n address withdrawnBy,\n address withdrawnTo,\n uint256 amount\n ) external override {\n emit FundsWithdrawn(msg.sender, withdrawnBy, withdrawnTo, amount);\n }\n\n /// @notice Emitted when a new implementation is registered\n function emitDeploymentTargetRegistererd(address impl) external override {\n emit DeploymentTargetRegistered(impl);\n }\n\n /// @notice Emitted when an implementation is unregistered\n function emitDeploymentTargetUnregistered(address impl) external override {\n emit DeploymentTargetUnregistered(impl);\n }\n\n /// @notice Emitted when a new upgrade is registered\n function emitUpgradeRegistered(\n address prevImpl,\n address impl\n ) external override {\n emit UpgradeRegistered(prevImpl, impl);\n }\n\n /// @notice Emitted when an upgrade is unregistered\n function emitUpgradeUnregistered(\n address prevImpl,\n address impl\n ) external override {\n emit UpgradeUnregistered(prevImpl, impl);\n }\n}\n"
	},
	"src/observability/interface/IObservability.sol": {
	"content": "// SPDX-License-Identifier: GPL-3.0-or-later\npragma solidity ^0.8.13;\n\ninterface IObservabilityEvents {\n /// @notice Emitted when a new clone is deployed\n event CloneDeployed(\n address indexed factory,\n address indexed owner,\n address clone\n );\n\n /// @notice Emitted when a sale has occured\n event Sale(\n address indexed clone,\n address indexed to,\n uint256 pricePerToken,\n uint256 amount\n );\n\n /// @notice Emitted when funds have been withdrawn\n event FundsWithdrawn(\n address indexed clone,\n address indexed withdrawnBy,\n address indexed withdrawnTo,\n uint256 amount\n );\n\n /// @notice Emitted when a new implementation is registered\n event DeploymentTargetRegistered(address indexed impl);\n\n /// @notice Emitted when an implementation is unregistered\n event DeploymentTargetUnregistered(address indexed impl);\n\n /// @notice Emitted when an upgrade is registered\n /// @param prevImpl The address of the previous implementation\n /// @param newImpl The address of the registered upgrade\n event UpgradeRegistered(address indexed prevImpl, address indexed newImpl);\n\n /// @notice Emitted when an upgrade is unregistered\n /// @param prevImpl The address of the previous implementation\n /// @param newImpl The address of the unregistered upgrade\n event UpgradeUnregistered(\n address indexed prevImpl,\n address indexed newImpl\n );\n}\n\ninterface IObservability {\n function emitCloneDeployed(address owner, address clone) external;\n\n function emitSale(\n address to,\n uint256 pricePerToken,\n uint256 amount\n ) external;\n\n function emitFundsWithdrawn(\n address withdrawnBy,\n address withdrawnTo,\n uint256 amount\n ) external;\n\n function emitDeploymentTargetRegistererd(address impl) external;\n\n function emitDeploymentTargetUnregistered(address imp) external;\n\n function emitUpgradeRegistered(address prevImpl, address impl) external;\n\n function emitUpgradeUnregistered(address prevImpl, address impl) external;\n}\n"
	},
	"src/renderer/HTMLRendererProxy.sol": {
	"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity ^0.8.13;\n\nimport {ERC1967Proxy} from \"../lib/proxy/ERC1967Proxy.sol\";\n\ncontract HTMLRendererProxy is ERC1967Proxy {\n constructor(address logic, bytes memory data) ERC1967Proxy(logic, data) {}\n}\n"
	},
	"src/renderer/interfaces/IHTMLRenderer.sol": {
	"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity ^0.8.13;\n\ninterface IHTMLRenderer {\n struct FileType {\n string name;\n address fileSystem;\n uint8 fileType;\n }\n\n function initilize(address owner) external;\n\n /// @notice Returns the HTML for the given script and imports\n function generateURI(\n FileType[] calldata imports,\n string calldata script\n ) external view returns (string memory);\n}\n"
	},
	"src/tokens/FixedPriceToken.sol": {
	"content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.13;\n\nimport {TokenBase} from \"../TokenBase.sol\";\nimport {IHTMLRenderer} from \"../renderer/interfaces/IHTMLRenderer.sol\";\nimport {IObservability} from \"../observability/Observability.sol\";\nimport {IFixedPriceToken} from \"./interfaces/IFixedPriceToken.sol\";\nimport {IHTMLRenderer} from \"../renderer/interfaces/IHTMLRenderer.sol\";\nimport {StringsUpgradeable} from \"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\";\nimport {FixedPriceTokenStorageV1} from \"./storage/FixedPriceTokenStorageV1.sol\";\nimport {ITokenFactory} from \"../interfaces/ITokenFactory.sol\";\nimport {HTMLRendererProxy} from \"../renderer/HTMLRendererProxy.sol\";\nimport {IHTMLRenderer} from \"../renderer/interfaces/IHTMLRenderer.sol\";\nimport {IFileStore} from \"ethfs/IFileStore.sol\";\nimport {SSTORE2} from \"@0xsequence/sstore2/contracts/SSTORE2.sol\";\nimport {Base64} from \"base64-sol/base64.sol\";\n\ncontract FixedPriceToken is\n IFixedPriceToken,\n TokenBase,\n FixedPriceTokenStorageV1\n{\n using StringsUpgradeable for uint256;\n\n //[[[[SETUP FUNCTIONS]]]]\n\n constructor(address _factory, address _o11y) TokenBase(_factory, _o11y) {}\n\n /// @notice Initializes the token\n function initialize(\n address owner,\n bytes calldata data\n ) external initializer {\n if (msg.sender != factory) revert FactoryMustInitilize();\n\n (\n string memory _script,\n string memory _previewBaseURI,\n address _rendererImpl,\n TokenInfo memory _tokenInfo,\n SaleInfo memory _saleInfo,\n IHTMLRenderer.FileType[] memory _imports\n ) = abi.decode(\n data,\n (\n string,\n string,\n address,\n TokenInfo,\n SaleInfo,\n IHTMLRenderer.FileType[]\n )\n );\n\n if (!(ITokenFactory(factory).isValidDeployment(_rendererImpl)))\n revert ITokenFactory.NotDeployed(_rendererImpl);\n\n htmlRenderer = address(new HTMLRendererProxy(_rendererImpl, \"\"));\n allowedMinters[owner] = true;\n tokenInfo = _tokenInfo;\n saleInfo = _saleInfo;\n\n IHTMLRenderer(htmlRenderer).initilize(owner);\n\n __ERC721_init(_tokenInfo.name, _tokenInfo.symbol);\n _transferOwnership(owner);\n _addManyImports(_imports);\n _setScript(_script);\n _setPreviewBaseURI(_previewBaseURI);\n _mintArtistProofs(_saleInfo.artistProofCount);\n }\n\n //[[[[VIEW FUNCTIONS]]]]\n\n /// @notice a helper function for generating inital contract props\n function constructInitalProps(\n string memory _script,\n string memory _previewBaseURI,\n address _rendererImpl,\n TokenInfo memory _tokenInfo,\n SaleInfo memory _saleInfo,\n IHTMLRenderer.FileType[] memory _imports\n ) public pure returns (bytes memory) {\n return\n abi.encode(\n _script,\n _previewBaseURI,\n _rendererImpl,\n _tokenInfo,\n _saleInfo,\n _imports\n );\n }\n\n /// @notice returns token metadata for a given token id\n function tokenURI(\n uint256 tokenId\n ) public view override returns (string memory) {\n string memory tokenIdString = tokenId.toString();\n string memory fullName = string(\n abi.encodePacked(name(), \" \", tokenIdString)\n );\n string memory animationURL = tokenHTML(tokenId);\n string memory image = generatePreviewURI(tokenIdString);\n return\n genericDataURI(\n fullName,\n tokenInfo.description,\n animationURL,\n image\n );\n }\n\n /// @notice contruct a generic data URI from token data\n function genericDataURI(\n string memory _name,\n string memory _description,\n string memory _animationURL,\n string memory _image\n ) public pure returns (string memory) {\n return\n string.concat(\n \"data:application/json;base64,\",\n Base64.encode(\n bytes(\n string.concat(\n '{\"name\":\"',\n _name,\n '\", \"description\":\"',\n _description,\n '\", \"animation_url\": \"',\n _animationURL,\n '\", \"image\": \"',\n _image,\n '\"}'\n )\n )\n )\n );\n }\n\n /// @notice generate a preview URI for the token\n function generatePreviewURI(\n string memory tokenId\n ) public view returns (string memory) {\n return\n string.concat(\n previewBaseURI,\n uint256(uint160(address(this))).toHexString(20),\n \"/\",\n tokenId\n );\n }\n\n /// @notice generate the html for the token\n function tokenHTML(uint256 tokenId) public view returns (string memory) {\n return\n IHTMLRenderer(htmlRenderer).generateURI(\n imports,\n generateFullScript(tokenId)\n );\n }\n\n /// @notice generate the full script for the token\n function generateFullScript(\n uint256 tokenId\n ) public view returns (string memory) {\n return\n string.concat(\n '<script>var blockHash=\"',\n uint256(tokenIdToPreviousBlockHash[tokenId]).toString(),\n '\";var tokenId=\"',\n tokenId.toString(),\n '\";var timestamp=\"',\n block.timestamp.toString(),\n '\";',\n getScript(),\n \"</script>\"\n );\n }\n\n /// @notice get the script for the contract\n function getScript() public view returns (string memory) {\n return string(SSTORE2.read(scriptPointer));\n }\n\n //[[[[SCRIPT FUNCTIONS]]]]\n\n /// @notice set the script for the contract\n function setScript(string memory script) public onlyOwner {\n _setScript(script);\n }\n\n //[[[[PREVIEW FUNCTIONS]]]]\n\n /// @notice get the preview base URI for the token\n function setPreviewBaseURL(string memory uri) public onlyOwner {\n _setPreviewBaseURI(uri);\n }\n\n //[[[[RENDERER FUNCTIONS]]]]\n\n /// @notice set the html renderer for the token\n function setHTMLRenderer(address _htmlRenderer) external onlyOwner {\n htmlRenderer = _htmlRenderer;\n }\n\n /// @notice add multiple imports to the token\n function addManyImports(\n IHTMLRenderer.FileType[] calldata _imports\n ) external onlyOwner {\n _addManyImports(_imports);\n }\n\n /// @notice set a single import to the token for a given index\n function setImport(\n uint256 index,\n IHTMLRenderer.FileType calldata _import\n ) external onlyOwner {\n _setImport(index, _import);\n }\n\n //[[[[PURCHASE FUNCTIONS]]]]\n\n /// @notice purchase a number of tokens\n function purchase(uint256 amount) external payable nonReentrant {\n if (\n block.timestamp < saleInfo.startTime \|\|\n block.timestamp >= saleInfo.endTime\n ) revert SaleNotActive();\n\n if (msg.value < (amount * saleInfo.price)) revert InvalidPrice();\n if (totalSupply() + amount > tokenInfo.maxSupply) revert SoldOut();\n\n IObservability(o11y).emitSale(msg.sender, saleInfo.price, amount);\n\n for (uint256 i = 0; i < amount; i++) {\n _seedAndMint(msg.sender);\n }\n }\n\n //[[[[PRIVATE FUNCTIONS]]]]\n /// @notice adds a single import\n function _addImport(IHTMLRenderer.FileType memory _import) private {\n imports.push(_import);\n }\n\n /// @notice adds many imports\n function _addManyImports(IHTMLRenderer.FileType[] memory _imports) private {\n uint256 numImports = _imports.length;\n for (uint256 i; i < numImports; i++) {\n _addImport(_imports[i]);\n }\n }\n\n /// @notice sets a single import for the given index\n function _setImport(\n uint256 index,\n IHTMLRenderer.FileType memory _import\n ) private {\n imports[index] = _import;\n }\n\n /// @notice store the script and ovverwrite the script pointer\n function _setScript(string memory script) private {\n scriptPointer = SSTORE2.write(bytes(script));\n }\n\n /// @notice set the preview base URI\n function _setPreviewBaseURI(string memory _previewBaseURI) private {\n previewBaseURI = _previewBaseURI;\n }\n\n /// @notice mint the artist proofs\n function _mintArtistProofs(uint16 amount) private {\n if (proofsMinted) revert ProofsMinted();\n\n for (uint256 i = 0; i < amount; i++) {\n _seedAndMint(owner());\n }\n\n proofsMinted = true;\n }\n}\n"
	},
	"src/tokens/interfaces/IFixedPriceToken.sol": {
	"content": "//SPDX-License-Identifier: MIT\npragma solidity ^0.8.13;\n\nimport {IHTMLRenderer} from \"../../renderer/interfaces/IHTMLRenderer.sol\";\n\ninterface IFixedPriceToken {\n struct SaleInfo {\n uint16 artistProofCount;\n uint64 startTime;\n uint64 endTime;\n uint112 price;\n }\n\n error SaleNotActive();\n error InvalidPrice();\n error SoldOut();\n error ProofsMinted();\n\n /// @notice initialize the token\n function initialize(address owner, bytes calldata data) external;\n\n /// @notice contruct a generic data URI from token data\n function genericDataURI(\n string memory _name,\n string memory _description,\n string memory _animationURL,\n string memory _image\n ) external pure returns (string memory);\n\n /// @notice generate a preview URI for the token\n function generatePreviewURI(\n string memory tokenId\n ) external view returns (string memory);\n\n /// @notice generate the html for the token\n function tokenHTML(uint256 tokenId) external view returns (string memory);\n\n /// @notice generate the full script for the token\n function generateFullScript(\n uint256 tokenId\n ) external view returns (string memory);\n\n /// @notice get the script for the contract\n function getScript() external view returns (string memory);\n\n /// @notice set the script for the contract\n function setScript(string memory script) external;\n\n /// @notice get the preview base URI for the token\n function setPreviewBaseURL(string memory uri) external;\n\n /// @notice set the html renderer for the token\n function setHTMLRenderer(address _htmlRenderer) external;\n\n /// @notice add multiple imports to the token\n function addManyImports(\n IHTMLRenderer.FileType[] calldata _imports\n ) external;\n\n /// @notice set a single import to the token for a given index\n function setImport(\n uint256 index,\n IHTMLRenderer.FileType calldata _import\n ) external;\n\n /// @notice purchase a number of tokens\n function purchase(uint256 amount) external payable;\n}\n"
	},
	"src/tokens/interfaces/IToken.sol": {
	"content": "//SPDX-License-Identifier: MIT\npragma solidity ^0.8.13;\n\ninterface IToken {\n struct TokenInfo {\n string name;\n string symbol;\n string description;\n address fundsRecipent;\n uint256 maxSupply;\n }\n\n error FactoryMustInitilize();\n error SenderNotMinter();\n error FundsSendFailure();\n error MaxSupplyReached();\n\n /// @notice returns the total supply of tokens\n function totalSupply() external returns (uint256);\n\n /// @notice withdraws the funds from the contract\n function withdraw() external returns (bool);\n\n /// @notice mint a token for the given address\n function safeMint(address to) external;\n\n /// @notice sets the funds recipent for token funds\n function setFundsRecipent(address fundsRecipent) external;\n\n /// @notice sets the minter status for the given user\n function setMinter(address user, bool isAllowed) external;\n}\n"
	},
	"src/tokens/storage/FixedPriceTokenStorageV1.sol": {
	"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity ^0.8.13;\nimport {IFixedPriceToken} from \"../interfaces/IFixedPriceToken.sol\";\nimport {IHTMLRenderer} from \"../../renderer/interfaces/IHTMLRenderer.sol\";\n\nabstract contract FixedPriceTokenStorageV1 {\n /// @notice Storage pointer for the generative script\n address scriptPointer;\n\n /// @notice Address of the HTML renderer\n address htmlRenderer;\n\n /// @notice Base URI for the preview URI\n string previewBaseURI;\n\n /// @notice Required imports for the renderer\n IHTMLRenderer.FileType[] public imports;\n\n /// @notice Sales info for token purchases\n IFixedPriceToken.SaleInfo public saleInfo;\n\n /// @notice Flag to indicate if the artist proofs have been minted\n bool proofsMinted;\n}\n"
	}
	},
	"settings": {
	"remappings": [
	"@0xsequence/sstore2/=lib/sstore2/",
	"@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
	"@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
	"ERC721A-Upgradeable/=lib/ERC721A-Upgradeable/contracts/",
	"base64-sol/=lib/base64/",
	"base64/=lib/base64/",
	"ds-test/=lib/forge-std/lib/ds-test/src/",
	"erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
	"ethfs/=lib/ethfs/packages/contracts/src/",
	"ethier/=lib/ethfs/packages/contracts/lib/ethier/",
	"forge-std/=lib/forge-std/src/",
	"openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
	"openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/",
	"openzeppelin/=lib/ethfs/packages/contracts/lib/openzeppelin-contracts/contracts/",
	"solady/=lib/ethfs/packages/contracts/lib/solady/src/",
	"solmate/=lib/ethfs/packages/contracts/lib/solady/lib/solmate/src/",
	"sstore2/=lib/sstore2/contracts/"
	],
	"optimizer": {
	"enabled": true,
	"runs": 200
	},
	"metadata": {
	"bytecodeHash": "ipfs"
	},
	"outputSelection": {
	"*": {
	"*": [
	"evm.bytecode",
	"evm.deployedBytecode",
	"devdoc",
	"userdoc",
	"metadata",
	"abi"
	]
	}
	},
	"evmVersion": "london",
	"libraries": {}
	}
	}