{ "language": "Solidity", "sources": { "contracts/KitsERC721Drop.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.10;\n\n/**\n\n██╗ ██╗██╗████████╗███████╗\n██║ ██╔╝██║╚══██╔══╝██╔════╝\n█████╔╝ ██║ ██║ ███████╗\n██╔═██╗ ██║ ██║ ╚════██║\n██║ ██╗██║ ██║ ███████║\n╚═╝ ╚═╝╚═╝ ╚═╝ ╚══════╝\n\nForked from Zora Drop by iain@zora.co\n\n */\n\nimport {ERC721AUpgradeable} from \"erc721a-upgradeable/contracts/ERC721AUpgradeable.sol\";\nimport {IERC721AUpgradeable} from \"erc721a-upgradeable/contracts/IERC721AUpgradeable.sol\";\nimport {IERC2981Upgradeable, IERC165Upgradeable} from \"@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol\";\nimport {AccessControlUpgradeable} from \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\nimport {ReentrancyGuardUpgradeable} from \"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\";\nimport {MerkleProofUpgradeable} from \"@openzeppelin/contracts-upgradeable/utils/cryptography/MerkleProofUpgradeable.sol\";\nimport {UUPSUpgradeable} from \"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\";\nimport {Strings} from \"@openzeppelin/contracts/utils/Strings.sol\";\n\nimport {IKitsFeeManager} from \"../interfaces/IKitsFeeManager.sol\";\nimport {IMetadataRenderer} from \"../interfaces/IMetadataRenderer.sol\";\nimport {IOperatorFilterRegistry} from \"../interfaces/IOperatorFilterRegistry.sol\";\nimport {IKitsERC721Drop} from \"../interfaces/IKitsERC721Drop.sol\";\nimport {IOwnable} from \"../interfaces/IOwnable.sol\";\nimport {IFactoryUpgradeGate} from \"../interfaces/IFactoryUpgradeGate.sol\";\n\nimport {OwnableSkeleton} from \"./utils/OwnableSkeleton.sol\";\nimport {FundsReceiver} from \"./utils/FundsReceiver.sol\";\nimport {Version} from \"./utils/Version.sol\";\nimport {ERC721DropStorageV1} from \"./storage/ERC721DropStorageV1.sol\";\n\n/**\n * @notice Kits NFT Base contract for Drops and Editions. Forked from Zora's ERC721Drop contract by iain@zora.co.\n *\n * Ownership of tokens in this contract entitles the owner to commercial use rights of sounds as specified in the\n * following Terms:\n * ar://Pxi9M882YT8P68p6e2Lzl_McvgbdzfO5brVRgZlLaEc.\n *\n * Terms are also available at:\n * https://h4ml2m6pgzqt6d7lzj5hwyxts7zrzpqg3xg7holowviydgklnbdq.arweave.net/Pxi9M882YT8P68p6e2Lzl_McvgbdzfO5brVRgZlLaEc\n *\n * @author alec@arpeggi.io, kyle@arpeggi.io\n *\n */\ncontract KitsERC721Drop is\n ERC721AUpgradeable,\n UUPSUpgradeable,\n IERC2981Upgradeable,\n ReentrancyGuardUpgradeable,\n AccessControlUpgradeable,\n IKitsERC721Drop,\n OwnableSkeleton,\n FundsReceiver,\n Version(9001),\n ERC721DropStorageV1\n{\n /// @dev This is the max mint batch size for the optimized ERC721A mint contract\n uint256 internal immutable MAX_MINT_BATCH_SIZE = 8;\n\n /// @dev This is the magic number that means this is an open edition. formerly type(uint64).max\n uint64 internal immutable OPEN_EDITION_VOLUME_MAGIC_NUMBER = 99999999;\n\n /// @dev Gas limit to send funds\n uint256 internal immutable FUNDS_SEND_GAS_LIMIT = 210_000;\n\n /// @notice Access control roles\n bytes32 public immutable MINTER_ROLE = keccak256(\"MINTER\");\n bytes32 public immutable SALES_MANAGER_ROLE = keccak256(\"SALES_MANAGER\");\n\n /// @dev KITS V3 transfer helper address for auto-approval\n address internal immutable kitsERC721TransferHelper;\n\n /// @dev Factory upgrade gate\n IFactoryUpgradeGate internal immutable factoryUpgradeGate;\n\n /// @dev Kits Fee Manager address\n IKitsFeeManager public immutable kitsFeeManager;\n\n /// @notice Max royalty BPS\n uint16 constant MAX_ROYALTY_BPS = 50_00;\n\n address immutable marketFilterDAOAddress;\n\n IOperatorFilterRegistry immutable operatorFilterRegistry =\n IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);\n\n /// @notice Only allow for users with admin access\n modifier onlyAdmin() {\n if (!hasRole(DEFAULT_ADMIN_ROLE, _msgSender())) {\n revert Access_OnlyAdmin();\n }\n\n _;\n }\n\n /// @notice Only a given role has access or admin\n /// @param role role to check for alongside the admin role\n modifier onlyRoleOrAdmin(bytes32 role) {\n if (\n !hasRole(DEFAULT_ADMIN_ROLE, _msgSender()) &&\n !hasRole(role, _msgSender())\n ) {\n revert Access_MissingRoleOrAdmin(role);\n }\n\n _;\n }\n\n /// @notice Allows user to mint tokens at a quantity\n modifier canMintPublicSaleTokens(uint256 quantity) {\n if (quantity + (_totalMinted()) > config.totalEditionSize) {\n revert Mint_SoldOut();\n }\n\n _;\n }\n\n /// @notice Allows user to mint presale tokens at a quantity\n modifier canMintPresaleTokens(uint256 quantity) {\n if (quantity + presaleMints > config.presaleEditionSize) {\n revert Mint_Presale_SoldOut();\n }\n\n _;\n }\n\n modifier recipientHoldsTokenGateToken(address recipient) {\n bool hasToken = false;\n for (uint i = 0; i < salesConfig.tokenGateContracts.length; i++) {\n address tokenGateContract = salesConfig.tokenGateContracts[i];\n uint balance = IERC721AUpgradeable(tokenGateContract).balanceOf(\n recipient\n );\n if (balance > 0) {\n hasToken = true;\n break;\n }\n }\n if (!hasToken) {\n revert Presale_UserNotAllowlist();\n }\n\n _;\n }\n\n function _presaleActive() internal view returns (bool) {\n return\n salesConfig.presaleStart <= block.timestamp &&\n salesConfig.presaleEnd > block.timestamp;\n }\n\n function _publicSaleActive() internal view returns (bool) {\n return\n salesConfig.publicSaleStart <= block.timestamp &&\n salesConfig.publicSaleEnd > block.timestamp;\n }\n\n /// @notice Presale active\n modifier onlyPresaleActive() {\n if (!_presaleActive()) {\n revert Presale_Inactive();\n }\n\n _;\n }\n\n /// @notice Public sale active\n modifier onlyPublicSaleActive() {\n if (!_publicSaleActive()) {\n revert Sale_Inactive();\n }\n\n _;\n }\n\n /// @notice Getter for last minted token ID (gets next token id and subtracts 1)\n function _lastMintedTokenId() internal view returns (uint256) {\n return _currentIndex - 1;\n }\n\n /// @notice Start token ID for minting (1-100 vs 0-99)\n function _startTokenId() internal pure override returns (uint256) {\n return 1;\n }\n\n /// @notice Global constructor – these variables will not change with further proxy deploys\n /// @dev Marked as an initializer to prevent storage being used of base implementation. Can only be init'd by a proxy.\n /// @param _kitsFeeManager Kits Fee Manager\n /// @param _kitsERC721TransferHelper Transfer helper\n constructor(\n IKitsFeeManager _kitsFeeManager,\n address _kitsERC721TransferHelper,\n IFactoryUpgradeGate _factoryUpgradeGate,\n address _marketFilterDAOAddress\n ) initializer {\n kitsFeeManager = _kitsFeeManager;\n kitsERC721TransferHelper = _kitsERC721TransferHelper;\n factoryUpgradeGate = _factoryUpgradeGate;\n marketFilterDAOAddress = _marketFilterDAOAddress;\n }\n\n /// @dev Create a new drop contract\n /// @param _contractName Contract name\n /// @param _contractSymbol Contract symbol\n /// @param _initialOwner User that owns and can mint the edition, gets royalty and sales payouts and can update the base url if needed.\n /// @param _fundsRecipient Wallet/user that receives funds from sale\n /// @param _totalEditionSize Number of editions that can be minted during public and presale. If OPEN_EDITION_VOLUME_MAGIC_NUMBER, unlimited editions can be minted as an open edition.\n /// @param _presaleEditionSize Number of editions that can be minted during presale. If OPEN_EDITION_VOLUME_MAGIC_NUMBER, unlimited editions can be minted during presale.\n /// @param _royaltyBPS BPS of the royalty set on the contract. Can be 0 for no royalty.\n /// @param _salesConfig New sales config to set upon init\n /// @param _metadataRenderer Renderer contract to use\n /// @param _baseURI HTTP URI, up to but not including, the contract address. eg: https://arpeggi.io/api/v2/kits-metadata\n function initialize(\n string memory _contractName,\n string memory _contractSymbol,\n address _initialOwner,\n address payable _fundsRecipient,\n uint64 _totalEditionSize,\n uint64 _presaleEditionSize,\n uint16 _royaltyBPS,\n SalesConfiguration memory _salesConfig,\n IMetadataRenderer _metadataRenderer,\n string memory _baseURI\n ) public initializer {\n // Setup ERC721A\n __ERC721A_init(_contractName, _contractSymbol);\n // Setup access control\n __AccessControl_init();\n // Setup re-entracy guard\n __ReentrancyGuard_init();\n // Setup the owner role\n _setupRole(DEFAULT_ADMIN_ROLE, _initialOwner);\n // Set ownership to original sender of contract call\n _setOwner(_initialOwner);\n\n if (config.royaltyBPS > MAX_ROYALTY_BPS) {\n revert Setup_RoyaltyPercentageTooHigh(MAX_ROYALTY_BPS);\n }\n\n // Update salesConfig\n salesConfig = _salesConfig;\n\n // Setup config variables\n config.totalEditionSize = _totalEditionSize;\n config.presaleEditionSize = _presaleEditionSize;\n config.metadataRenderer = _metadataRenderer;\n config.royaltyBPS = _royaltyBPS;\n config.fundsRecipient = _fundsRecipient;\n\n baseURI = _baseURI;\n }\n\n /// @dev Getter for admin role associated with the contract to handle metadata\n /// @return boolean if address is admin\n function isAdmin(address user) external view returns (bool) {\n return hasRole(DEFAULT_ADMIN_ROLE, user);\n }\n\n /// @dev Update the baseURI used by tokenURI\n function setBaseUri(string calldata baseUri_) public onlyAdmin {\n baseURI = baseUri_;\n emit UpdateBaseUri(msg.sender, baseUri_);\n }\n\n /// @notice Connects this contract to the factory upgrade gate\n /// @param newImplementation proposed new upgrade implementation\n /// @dev Only can be called by admin\n function _authorizeUpgrade(\n address newImplementation\n ) internal override onlyAdmin {\n if (\n !factoryUpgradeGate.isValidUpgradePath({\n _newImpl: newImplementation,\n _currentImpl: _getImplementation()\n })\n ) {\n revert Admin_InvalidUpgradeAddress(newImplementation);\n }\n }\n\n // ,-.\n // `-'\n // /|\\\n // | ,----------.\n // / \\ |KitsERC721Drop|\n // Caller `----+-----'\n // | burn() |\n // | ------------------>\n // | |\n // | |----.\n // | | | burn token\n // | |<---'\n // Caller ,----+-----.\n // ,-. |KitsERC721Drop|\n // `-' `----------'\n // /|\\\n // |\n // / \\\n /// @param tokenId Token ID to burn\n /// @notice User burn function for token id\n function burn(uint256 tokenId) public {\n _burn(tokenId, true);\n }\n\n /// @dev Get royalty information for token\n /// @param _salePrice Sale price for the token\n function royaltyInfo(\n uint256,\n uint256 _salePrice\n ) external view override returns (address receiver, uint256 royaltyAmount) {\n if (config.fundsRecipient == address(0)) {\n return (config.fundsRecipient, 0);\n }\n return (\n config.fundsRecipient,\n (_salePrice * config.royaltyBPS) / 10_000\n );\n }\n\n /// @notice Sale details\n /// @return IKitsERC721Drop.SaleDetails sale information details\n function saleDetails()\n external\n view\n returns (IKitsERC721Drop.SaleDetails memory)\n {\n return\n IKitsERC721Drop.SaleDetails({\n publicSaleActive: _publicSaleActive(),\n presaleActive: _presaleActive(),\n publicSalePrice: salesConfig.publicSalePrice,\n publicSaleStart: salesConfig.publicSaleStart,\n publicSaleEnd: salesConfig.publicSaleEnd,\n presaleStart: salesConfig.presaleStart,\n presaleEnd: salesConfig.presaleEnd,\n presaleMerkleRoot: salesConfig.presaleMerkleRoot,\n totalMinted: _totalMinted(),\n totalPreSaleMinted: presaleMints,\n maxSupply: config.totalEditionSize,\n maxSalePurchasePerAddress: salesConfig.maxSalePurchasePerAddress\n });\n }\n\n /// @dev Number of NFTs the user has minted per address\n /// @param minter to get counts for\n function mintedPerAddress(\n address minter\n )\n external\n view\n override\n returns (IKitsERC721Drop.AddressMintDetails memory)\n {\n return\n IKitsERC721Drop.AddressMintDetails({\n presaleMints: presaleMintsByAddress[minter],\n publicMints: _numberMinted(minter) -\n presaleMintsByAddress[minter],\n totalMints: _numberMinted(minter)\n });\n }\n\n /// @dev Setup auto-approval for Kits v3 access to sell NFT\n /// Still requires approval for module\n /// @param nftOwner owner of the nft\n /// @param operator operator wishing to transfer/burn/etc the NFTs\n function isApprovedForAll(\n address nftOwner,\n address operator\n ) public view override(ERC721AUpgradeable) returns (bool) {\n if (operator == kitsERC721TransferHelper) {\n return true;\n }\n return super.isApprovedForAll(nftOwner, operator);\n }\n\n /**\n *** ---------------------------------- ***\n *** ***\n *** PUBLIC MINTING FUNCTIONS ***\n *** ***\n *** ---------------------------------- ***\n ***/\n\n // ,-.\n // `-'\n // /|\\\n // | ,----------.\n // / \\ |KitsERC721Drop|\n // Caller `----+-----'\n // | purchase() |\n // | ---------------------------->\n // | |\n // | |\n // ___________________________________________________________\n // ! ALT / drop has no tokens left for caller to mint? !\n // !_____/ | | !\n // ! | revert Mint_SoldOut() | !\n // ! | <---------------------------- !\n // !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | |\n // ___________________________________________________________\n // ! ALT / public sale isn't active? | !\n // !_____/ | | !\n // ! | revert Sale_Inactive() | !\n // ! | <---------------------------- !\n // !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | |\n // ___________________________________________________________\n // ! ALT / inadequate funds sent? | !\n // !_____/ | | !\n // ! | revert Purchase_WrongPrice()| !\n // ! | <---------------------------- !\n // !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | |----.\n // | | | mint tokens\n // | |<---'\n // | |\n // | |----.\n // | | | emit IKitsERC721Drop.Sale()\n // | |<---'\n // | |\n // | return first minted token ID|\n // | <----------------------------\n // Caller ,----+-----.\n // ,-. |KitsERC721Drop|\n // `-' `----------'\n // /|\\\n // |\n // / \\\n /**\n @dev This allows the user to purchase a edition edition\n at the given price in the contract.\n */\n function purchase(\n address recipient,\n uint256 quantity\n )\n external\n payable\n nonReentrant\n canMintPublicSaleTokens(quantity)\n onlyPublicSaleActive\n returns (uint256)\n {\n uint256 salePrice = salesConfig.publicSalePrice;\n\n if (msg.value != salePrice * quantity) {\n revert Purchase_WrongPrice(salePrice * quantity);\n }\n\n // If max purchase per address == 0 there is no limit.\n // Any other number, the per address mint limit is that.\n if (\n salesConfig.maxSalePurchasePerAddress != 0 &&\n _numberMinted(recipient) +\n quantity -\n presaleMintsByAddress[recipient] >\n salesConfig.maxSalePurchasePerAddress\n ) {\n revert Purchase_TooManyForAddress();\n }\n\n _mintNFTs(recipient, quantity);\n uint256 firstMintedTokenId = _lastMintedTokenId() - quantity;\n\n emit IKitsERC721Drop.Sale({\n to: recipient,\n quantity: quantity,\n pricePerToken: salePrice,\n firstPurchasedTokenId: firstMintedTokenId\n });\n return firstMintedTokenId;\n }\n\n /// @notice Function to mint NFTs\n /// @dev (important: Does not enforce max supply limit, enforce that limit earlier)\n /// @dev This batches in size of 8 as per recommended by ERC721A creators\n /// @param to address to mint NFTs to\n /// @param quantity number of NFTs to mint\n function _mintNFTs(address to, uint256 quantity) internal {\n do {\n uint256 toMint = quantity > MAX_MINT_BATCH_SIZE\n ? MAX_MINT_BATCH_SIZE\n : quantity;\n _mint({to: to, quantity: toMint});\n quantity -= toMint;\n } while (quantity > 0);\n }\n\n // ,-.\n // `-'\n // /|\\\n // | ,----------.\n // / \\ |KitsERC721Drop|\n // Caller `----+-----'\n // | purchasePresale() |\n // | ---------------------------------->\n // | |\n // | |\n // _________________________________________________________________\n // ! ALT / drop has no tokens left for caller to mint? !\n // !_____/ | | !\n // ! | revert Mint_SoldOut() | !\n // ! | <---------------------------------- !\n // !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | |\n // _________________________________________________________________\n // ! ALT / presale sale isn't active? | !\n // !_____/ | | !\n // ! | revert Presale_Inactive() | !\n // ! | <---------------------------------- !\n // !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | |\n // _________________________________________________________________\n // ! ALT / merkle proof unapproved for caller? | !\n // !_____/ | | !\n // ! | revert Presale_MerkleNotApproved()| !\n // ! | <---------------------------------- !\n // !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | |\n // _________________________________________________________________\n // ! ALT / inadequate funds sent? | !\n // !_____/ | | !\n // ! | revert Purchase_WrongPrice() | !\n // ! | <---------------------------------- !\n // !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | |----.\n // | | | mint tokens\n // | |<---'\n // | |\n // | |----.\n // | | | emit IKitsERC721Drop.Sale()\n // | |<---'\n // | |\n // | return first minted token ID |\n // | <----------------------------------\n // Caller ,----+-----.\n // ,-. |KitsERC721Drop|\n // `-' `----------'\n // /|\\\n // |\n // / \\\n /// @notice Merkle-tree based presale purchase function\n /// @param recipient address for owner of newly minted token(s)\n /// @param quantity quantity to purchase\n /// @param maxQuantity max quantity that can be purchased via merkle proof #\n /// @param pricePerToken price that each token is purchased at\n /// @param merkleProof proof for presale mint\n function purchasePresale(\n address recipient,\n uint256 quantity,\n uint256 maxQuantity,\n uint256 pricePerToken,\n bytes32[] calldata merkleProof\n )\n external\n payable\n nonReentrant\n canMintPresaleTokens(quantity)\n onlyPresaleActive\n returns (uint256)\n {\n if (\n !MerkleProofUpgradeable.verify(\n merkleProof,\n salesConfig.presaleMerkleRoot,\n keccak256(\n // address, uint256, uint256\n abi.encode(recipient, maxQuantity, pricePerToken)\n )\n )\n ) {\n revert Presale_MerkleNotApproved();\n }\n\n if (msg.value != pricePerToken * quantity) {\n revert Purchase_WrongPrice(pricePerToken * quantity);\n }\n\n presaleMintsByAddress[recipient] += quantity;\n if (presaleMintsByAddress[recipient] > maxQuantity) {\n revert Presale_TooManyForAddress();\n }\n\n // canMintPresaleTokens modifier checks that we can\n // mint `quantity` and remain under `config.presaleEditionSize`\n unchecked {\n presaleMints += quantity;\n }\n\n _mintNFTs(recipient, quantity);\n uint256 firstMintedTokenId = _lastMintedTokenId() - quantity;\n\n emit IKitsERC721Drop.Sale({\n to: recipient,\n quantity: quantity,\n pricePerToken: pricePerToken,\n firstPurchasedTokenId: firstMintedTokenId\n });\n\n return firstMintedTokenId;\n }\n\n // ,-.\n // `-'\n // /|\\\n // | ,----------.\n // / \\ |KitsERC721Drop|\n // Caller `----+-----'\n // | purchaseAllowlist() |\n // | ---------------------------------->\n // | |\n // | |\n // _________________________________________________________________\n // ! ALT / drop has no tokens left for caller to mint? !\n // !_____/ | | !\n // ! | revert Mint_SoldOut() | !\n // ! | <---------------------------------- !\n // !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | |\n // _________________________________________________________________\n // ! ALT / presale sale isn't active? | !\n // !_____/ | | !\n // ! | revert Presale_Inactive() | !\n // ! | <---------------------------------- !\n // !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | |\n // _________________________________________________________________\n // ! ALT / caller does not own allowlist token? | !\n // !_____/ | | !\n // ! | revert Presale_UserNotAllowlist() | !\n // ! | <---------------------------------- !\n // !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | |\n // _________________________________________________________________\n // ! ALT / inadequate funds sent? | !\n // !_____/ | | !\n // ! | revert Purchase_WrongPrice() | !\n // ! | <---------------------------------- !\n // !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | |----.\n // | | | mint tokens\n // | |<---'\n // | |\n // | |----.\n // | | | emit IKitsERC721Drop.Sale()\n // | |<---'\n // | |\n // | return first minted token ID |\n // | <----------------------------------\n // Caller ,----+-----.\n // ,-. |KitsERC721Drop|\n // `-' `----------'\n // /|\\\n // |\n // / \\\n /// @notice External contract token holder-based presale purchase function\n /// @param recipient address for owner of newly minted token(s)\n /// @param quantity quantity to purchase\n function purchaseTokenGatePresale(\n address recipient,\n uint256 quantity\n )\n external\n payable\n nonReentrant\n canMintPresaleTokens(quantity)\n onlyPresaleActive\n recipientHoldsTokenGateToken(recipient)\n returns (uint256)\n {\n uint256 salePrice = salesConfig.allowlistSalePrice;\n if (msg.value != salePrice * quantity) {\n revert Purchase_WrongPrice(salePrice);\n }\n\n // If max purchase per address == 0 there is no limit.\n // Any other number, the per address mint limit is that.\n if (\n salesConfig.maxSalePurchasePerAddress != 0 &&\n _numberMinted(recipient) +\n quantity -\n presaleMintsByAddress[recipient] >\n salesConfig.maxSalePurchasePerAddress\n ) {\n revert Purchase_TooManyForAddress();\n }\n\n // canMintPresaleTokens modifier checks that we can\n // mint `quantity` and remain under `config.presaleEditionSize`\n unchecked {\n presaleMints += quantity;\n }\n\n _mintNFTs(recipient, quantity);\n uint256 firstMintedTokenId = _lastMintedTokenId() - quantity;\n\n emit IKitsERC721Drop.Sale({\n to: recipient,\n quantity: quantity,\n pricePerToken: salePrice,\n firstPurchasedTokenId: firstMintedTokenId\n });\n\n return firstMintedTokenId;\n }\n\n /**\n *** ---------------------------------- ***\n *** ***\n *** ADMIN OPERATOR FILTERING ***\n *** ***\n *** ---------------------------------- ***\n ***/\n\n /// @notice Proxy to update market filter settings in the main registry contracts\n /// @notice Requires admin permissions\n /// @param args Calldata args to pass to the registry\n function updateMarketFilterSettings(\n bytes calldata args\n ) external onlyAdmin returns (bytes memory) {\n (bool success, bytes memory ret) = address(operatorFilterRegistry).call(\n args\n );\n if (!success) {\n revert RemoteOperatorFilterRegistryCallFailed();\n }\n return ret;\n }\n\n /// @notice Manage subscription to the DAO for marketplace filtering based off royalty payouts.\n /// @param enable Enable filtering to non-royalty payout marketplaces\n function manageMarketFilterDAOSubscription(bool enable) external onlyAdmin {\n address self = address(this);\n if (marketFilterDAOAddress == address(0x0)) {\n revert MarketFilterDAOAddressNotSupportedForChain();\n }\n if (!operatorFilterRegistry.isRegistered(self) && enable) {\n operatorFilterRegistry.registerAndSubscribe(\n self,\n marketFilterDAOAddress\n );\n } else if (enable) {\n operatorFilterRegistry.subscribe(self, marketFilterDAOAddress);\n } else {\n operatorFilterRegistry.unsubscribe(self, false);\n operatorFilterRegistry.unregister(self);\n }\n }\n\n /// @notice Hook to filter operators (no-op if no filters are registered)\n /// @dev Part of ERC721A token hooks\n /// @param from Transfer from user\n /// @param to Transfer to user\n /// @param startTokenId Token ID to start with\n /// @param quantity Quantity of token being transferred\n function _beforeTokenTransfers(\n address from,\n address to,\n uint256 startTokenId,\n uint256 quantity\n ) internal virtual override {\n if (\n from != msg.sender &&\n address(operatorFilterRegistry).code.length > 0\n ) {\n if (\n !operatorFilterRegistry.isOperatorAllowed(\n address(this),\n msg.sender\n )\n ) {\n revert OperatorNotAllowed(msg.sender);\n }\n }\n }\n\n /**\n *** ---------------------------------- ***\n *** ***\n *** ADMIN MINTING FUNCTIONS ***\n *** ***\n *** ---------------------------------- ***\n ***/\n\n // ,-.\n // `-'\n // /|\\\n // | ,----------.\n // / \\ |KitsERC721Drop|\n // Caller `----+-----'\n // | adminMint() |\n // | ---------------------------------->\n // | |\n // | |\n // _________________________________________________________________\n // ! ALT / caller is not admin or minter role? | !\n // !_____/ | | !\n // ! | revert Access_MissingRoleOrAdmin()| !\n // ! | <---------------------------------- !\n // !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | |\n // _________________________________________________________________\n // ! ALT / drop has no tokens left for caller to mint? !\n // !_____/ | | !\n // ! | revert Mint_SoldOut() | !\n // ! | <---------------------------------- !\n // !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | |----.\n // | | | mint tokens\n // | |<---'\n // | |\n // | return last minted token ID |\n // | <----------------------------------\n // Caller ,----+-----.\n // ,-. |KitsERC721Drop|\n // `-' `----------'\n // /|\\\n // |\n // / \\\n /// @notice Mint admin\n /// @param recipient recipient to mint to\n /// @param quantity quantity to mint\n function adminMint(\n address recipient,\n uint256 quantity\n )\n external\n onlyRoleOrAdmin(MINTER_ROLE)\n canMintPublicSaleTokens(quantity)\n returns (uint256)\n {\n _mintNFTs(recipient, quantity);\n\n return _lastMintedTokenId();\n }\n\n // ,-.\n // `-'\n // /|\\\n // | ,----------.\n // / \\ |KitsERC721Drop|\n // Caller `----+-----'\n // | adminMintAirdrop() |\n // | ---------------------------------->\n // | |\n // | |\n // _________________________________________________________________\n // ! ALT / caller is not admin or minter role? | !\n // !_____/ | | !\n // ! | revert Access_MissingRoleOrAdmin()| !\n // ! | <---------------------------------- !\n // !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | |\n // _________________________________________________________________\n // ! ALT / drop has no tokens left for recipients to mint? !\n // !_____/ | | !\n // ! | revert Mint_SoldOut() | !\n // ! | <---------------------------------- !\n // !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | |\n // | _____________________________________\n // | ! LOOP / for all recipients !\n // | !______/ | !\n // | ! |----. !\n // | ! | | mint tokens !\n // | ! |<---' !\n // | !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | return last minted token ID |\n // | <----------------------------------\n // Caller ,----+-----.\n // ,-. |KitsERC721Drop|\n // `-' `----------'\n // /|\\\n // |\n // / \\\n /// @dev This mints multiple editions to the given list of addresses.\n /// @param recipients list of addresses to send the newly minted editions to\n function adminMintAirdrop(\n address[] calldata recipients\n )\n external\n override\n onlyRoleOrAdmin(MINTER_ROLE)\n canMintPublicSaleTokens(recipients.length)\n returns (uint256)\n {\n uint256 atId = _currentIndex;\n uint256 startAt = atId;\n\n unchecked {\n for (\n uint256 endAt = atId + recipients.length;\n atId < endAt;\n atId++\n ) {\n _mintNFTs(recipients[atId - startAt], 1);\n }\n }\n return _lastMintedTokenId();\n }\n\n /**\n *** ---------------------------------- ***\n *** ***\n *** ADMIN CONFIGURATION FUNCTIONS ***\n *** ***\n *** ---------------------------------- ***\n ***/\n\n // ,-.\n // `-'\n // /|\\\n // | ,----------.\n // / \\ |KitsERC721Drop|\n // Caller `----+-----'\n // | setOwner() |\n // | ------------------------->\n // | |\n // | |\n // ________________________________________________________\n // ! ALT / caller is not admin? | !\n // !_____/ | | !\n // ! | revert Access_OnlyAdmin()| !\n // ! | <------------------------- !\n // !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | |----.\n // | | | set owner\n // | |<---'\n // Caller ,----+-----.\n // ,-. |KitsERC721Drop|\n // `-' `----------'\n // /|\\\n // |\n // / \\\n /// @dev Set new owner for royalties / opensea\n /// @param newOwner new owner to set\n function setOwner(address newOwner) public onlyAdmin {\n _setOwner(newOwner);\n }\n\n /// @notice Set a new metadata renderer\n /// @param newRenderer new renderer address to use\n /// @param setupRenderer data to setup new renderer with\n function setMetadataRenderer(\n IMetadataRenderer newRenderer,\n bytes memory setupRenderer\n ) external onlyAdmin {\n config.metadataRenderer = newRenderer;\n\n if (setupRenderer.length > 0) {\n newRenderer.initializeWithData(setupRenderer);\n }\n\n emit UpdatedMetadataRenderer({\n sender: _msgSender(),\n renderer: newRenderer\n });\n }\n\n // ,-.\n // `-'\n // /|\\\n // | ,----------.\n // / \\ |KitsERC721Drop|\n // Caller `----+-----'\n // | setSalesConfiguration() |\n // | ---------------------------------->\n // | |\n // | |\n // _________________________________________________________________\n // ! ALT / caller is not admin? | !\n // !_____/ | | !\n // ! | revert Access_MissingRoleOrAdmin()| !\n // ! | <---------------------------------- !\n // !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | |----.\n // | | | set funds recipient\n // | |<---'\n // | |\n // | |----.\n // | | | emit FundsRecipientChanged()\n // | |<---'\n // Caller ,----+-----.\n // ,-. |KitsERC721Drop|\n // `-' `----------'\n // /|\\\n // |\n // / \\\n /// @dev This sets the sales configuration\n // / @param publicSalePrice New public sale price\n function setSaleConfiguration(\n uint104 publicSalePrice,\n uint32 maxSalePurchasePerAddress,\n uint64 publicSaleStart,\n uint64 publicSaleEnd,\n uint64 presaleStart,\n uint64 presaleEnd,\n uint104 allowlistSalePrice,\n address[] memory tokenGateContracts,\n bytes32 presaleMerkleRoot\n ) external onlyRoleOrAdmin(SALES_MANAGER_ROLE) {\n // SalesConfiguration storage newConfig = SalesConfiguration({\n // publicSaleStart: publicSaleStart,\n // publicSaleEnd: publicSaleEnd,\n // presaleStart: presaleStart,\n // presaleEnd: presaleEnd,\n // publicSalePrice: publicSalePrice,\n // maxSalePurchasePerAddress: maxSalePurchasePerAddress,\n // presaleMerkleRoot: presaleMerkleRoot\n // });\n salesConfig.publicSalePrice = publicSalePrice;\n salesConfig.maxSalePurchasePerAddress = maxSalePurchasePerAddress;\n salesConfig.publicSaleStart = publicSaleStart;\n salesConfig.publicSaleEnd = publicSaleEnd;\n salesConfig.presaleStart = presaleStart;\n salesConfig.presaleEnd = presaleEnd;\n salesConfig.presaleMerkleRoot = presaleMerkleRoot;\n salesConfig.allowlistSalePrice = allowlistSalePrice;\n salesConfig.tokenGateContracts = tokenGateContracts;\n\n emit SalesConfigChanged(_msgSender());\n }\n\n // ,-.\n // `-'\n // /|\\\n // | ,----------.\n // / \\ |KitsERC721Drop|\n // Caller `----+-----'\n // | setOwner() |\n // | ------------------------->\n // | |\n // | |\n // ________________________________________________________\n // ! ALT / caller is not admin or SALES_MANAGER_ROLE? !\n // !_____/ | | !\n // ! | revert Access_OnlyAdmin()| !\n // ! | <------------------------- !\n // !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | |\n // | |----.\n // | | | set sales configuration\n // | |<---'\n // | |\n // | |----.\n // | | | emit SalesConfigChanged()\n // | |<---'\n // Caller ,----+-----.\n // ,-. |KitsERC721Drop|\n // `-' `----------'\n // /|\\\n // |\n // / \\\n /// @notice Set a different funds recipient\n /// @param newRecipientAddress new funds recipient address\n function setFundsRecipient(\n address payable newRecipientAddress\n ) external onlyRoleOrAdmin(SALES_MANAGER_ROLE) {\n // TODO(iain): funds recipient cannot be 0?\n config.fundsRecipient = newRecipientAddress;\n emit FundsRecipientChanged(newRecipientAddress, _msgSender());\n }\n\n // ,-. ,-. ,-.\n // `-' `-' `-'\n // /|\\ /|\\ /|\\\n // | | | ,----------.\n // / \\ / \\ / \\ |KitsERC721Drop|\n // Caller FeeRecipient FundsRecipient `----+-----'\n // | | withdraw() | |\n // | ------------------------------------------------------------------------->\n // | | | |\n // | | | |\n // | | | |\n // | | | |\n // | | | |\n // | | | ____________________________________________________________\n // | | | ! ALT / send unsuccesful? !\n // | | | !_____/ | !\n // | | | ! |----. !\n // | | | ! | | revert Withdraw_FundsSendFailure() !\n // | | | ! |<---' !\n // | | | !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | | | !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | | | |\n // | | | send remaining funds amount|\n // | | | <---------------------------\n // | | | |\n // | | | |\n // | | | ____________________________________________________________\n // | | | ! ALT / send unsuccesful? !\n // | | | !_____/ | !\n // | | | ! |----. !\n // | | | ! | | revert Withdraw_FundsSendFailure() !\n // | | | ! |<---' !\n // | | | !~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // | | | !~[noop]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!\n // Caller FeeRecipient FundsRecipient ,----+-----.\n // ,-. ,-. ,-. |KitsERC721Drop|\n // `-' `-' `-' `----------'\n // /|\\ /|\\ /|\\\n // | | |\n // / \\ / \\ / \\\n /// @notice This withdraws ETH from the contract to the contract owner. Anyone can call this.\n function withdraw() external nonReentrant {\n // Get fee amount\n uint256 funds = address(this).balance;\n\n // Payout recipient\n (bool successFunds, ) = config.fundsRecipient.call{\n value: funds,\n gas: FUNDS_SEND_GAS_LIMIT\n }(\"\");\n if (!successFunds) {\n revert Withdraw_FundsSendFailure();\n }\n\n // Emit event for indexing\n emit FundsWithdrawn(\n _msgSender(),\n config.fundsRecipient,\n funds,\n address(0x0), // formerly feeRecipient. we are not collecting a fee\n 0 // formerly kitsFee. we are not collecting a fee\n );\n }\n\n /**\n *** ---------------------------------- ***\n *** ***\n *** GENERAL GETTER FUNCTIONS ***\n *** ***\n *** ---------------------------------- ***\n ***/\n\n /// @notice Simple override for owner interface.\n /// @return user owner address\n function owner()\n public\n view\n override(OwnableSkeleton, IKitsERC721Drop)\n returns (address)\n {\n return super.owner();\n }\n\n /// @notice Contract URI Getter, proxies to metadataRenderer\n /// @return Contract URI\n function contractURI() external view returns (string memory) {\n return config.metadataRenderer.contractURI();\n }\n\n /// @notice Getter for metadataRenderer contract\n function metadataRenderer() external view returns (IMetadataRenderer) {\n return IMetadataRenderer(config.metadataRenderer);\n }\n\n /// @notice Token URI Getter, proxies to metadataRenderer\n /// @param tokenId id of token to get URI for\n /// @return Token URI\n function tokenURI(\n uint256 tokenId\n ) public view override returns (string memory) {\n if (!_exists(tokenId)) {\n revert IERC721AUpgradeable.URIQueryForNonexistentToken();\n }\n\n return\n string.concat(\n baseURI,\n \"/\",\n Strings.toHexString(uint256(uint160(address(this))), 20),\n \"/\",\n Strings.toString(tokenId)\n );\n }\n\n /// @notice ERC165 supports interface\n /// @param interfaceId interface id to check if supported\n function supportsInterface(\n bytes4 interfaceId\n )\n public\n view\n override(\n IERC165Upgradeable,\n ERC721AUpgradeable,\n AccessControlUpgradeable\n )\n returns (bool)\n {\n return\n super.supportsInterface(interfaceId) ||\n type(IOwnable).interfaceId == interfaceId ||\n type(IERC2981Upgradeable).interfaceId == interfaceId ||\n type(IKitsERC721Drop).interfaceId == interfaceId;\n }\n}\n" }, "contracts/storage/ERC721DropStorageV1.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.10;\n\nimport {IKitsERC721Drop} from \"../../interfaces/IKitsERC721Drop.sol\";\n\ncontract ERC721DropStorageV1 {\n /// @notice Configuration for NFT minting contract storage\n IKitsERC721Drop.Configuration public config;\n\n /// @notice Sales configuration\n IKitsERC721Drop.SalesConfiguration public salesConfig;\n\n /// @dev Number of total presale mints. Includes merkle root mints plus allowlist mints\n uint256 public presaleMints;\n\n /// @dev Mapping for presale mint counts by address\n mapping(address => uint256) public presaleMintsByAddress;\n\n /// @dev HTTP URI, up to but not including, the contract address. eg: https://arpeggi.io/api/v2/kits-metadata\n string baseURI;\n}\n" }, "contracts/utils/FundsReceiver.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.10;\n\n/**\n * @notice This allows this contract to receive native currency funds from other contracts\n * Uses event logging for UI reasons.\n */\ncontract FundsReceiver {\n event FundsReceived(address indexed source, uint256 amount);\n\n receive() external payable {\n emit FundsReceived(msg.sender, msg.value);\n }\n}\n" }, "contracts/utils/OwnableSkeleton.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.10;\n\nimport {IOwnable} from \"../../interfaces/IOwnable.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 * This ownership interface matches OZ's ownable interface.\n */\ncontract OwnableSkeleton is IOwnable {\n address private _owner;\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 function _setOwner(address newAddress) internal {\n emit OwnershipTransferred(_owner, newAddress);\n _owner = newAddress;\n }\n}\n" }, "contracts/utils/Version.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.10;\n\ncontract Version {\n uint32 private immutable __version;\n\n /// @notice The version of the contract\n /// @return The version ID of this contract implementation\n function contractVersion() external view returns (uint32) {\n return __version;\n }\n\n constructor(uint32 version) {\n __version = version;\n }\n}\n" }, "interfaces/IFactoryUpgradeGate.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.10;\n\ninterface IFactoryUpgradeGate {\n function isValidUpgradePath(\n address _newImpl,\n address _currentImpl\n ) external returns (bool);\n\n function registerNewUpgradePath(\n address _newImpl,\n address[] calldata _supportedPrevImpls\n ) external;\n\n function unregisterUpgradePath(\n address _newImpl,\n address _prevImpl\n ) external;\n}\n" }, "interfaces/IKitsERC721Drop.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.10;\n\nimport {IMetadataRenderer} from \"./IMetadataRenderer.sol\";\n\n/**\n\n██╗ ██╗██╗████████╗███████╗\n██║ ██╔╝██║╚══██╔══╝██╔════╝\n█████╔╝ ██║ ██║ ███████╗\n██╔═██╗ ██║ ██║ ╚════██║\n██║ ██╗██║ ██║ ███████║\n╚═╝ ╚═╝╚═╝ ╚═╝ ╚══════╝\n\nForked from Zora Drop by iain@zora.co\n\n */\n\n/// @notice Interface for KITS Drops contract\ninterface IKitsERC721Drop {\n // Access errors\n\n /// @notice Only admin can access this function\n error Access_OnlyAdmin();\n /// @notice Missing the given role or admin access\n error Access_MissingRoleOrAdmin(bytes32 role);\n /// @notice Withdraw is not allowed by this user\n error Access_WithdrawNotAllowed();\n /// @notice Cannot withdraw funds due to ETH send failure.\n error Withdraw_FundsSendFailure();\n\n /// @notice Thrown when the operator for the contract is not allowed\n /// @dev Used when strict enforcement of marketplaces for creator royalties is desired.\n error OperatorNotAllowed(address operator);\n\n /// @notice Thrown when there is no active market filter DAO address supported for the current chain\n /// @dev Used for enabling and disabling filter for the given chain.\n error MarketFilterDAOAddressNotSupportedForChain();\n\n /// @notice Used when the operator filter registry external call fails\n /// @dev Used for bubbling error up to clients.\n error RemoteOperatorFilterRegistryCallFailed();\n\n // Sale/Purchase errors\n /// @notice Sale is inactive\n error Sale_Inactive();\n /// @notice Presale is inactive\n error Presale_Inactive();\n /// @notice Presale merkle root is invalid\n error Presale_MerkleNotApproved();\n /// @notice User does not own a token on the presale contract\n error Presale_UserNotAllowlist();\n /// @notice Wrong price for purchase\n error Purchase_WrongPrice(uint256 correctPrice);\n /// @notice NFT sold out, public sale\n error Mint_SoldOut();\n /// @notice NFT sold out, pre sale\n error Mint_Presale_SoldOut();\n /// @notice Too many purchase for address\n error Purchase_TooManyForAddress();\n /// @notice Too many presale for address\n error Presale_TooManyForAddress();\n\n // Admin errors\n /// @notice Royalty percentage too high\n error Setup_RoyaltyPercentageTooHigh(uint16 maxRoyaltyBPS);\n /// @notice Invalid admin upgrade address\n error Admin_InvalidUpgradeAddress(address proposedAddress);\n /// @notice Unable to finalize an edition not marked as open (size set to uint64_max_value)\n error Admin_UnableToFinalizeNotOpenEdition();\n\n /// @notice Event emitted for each sale\n /// @param to address sale was made to\n /// @param quantity quantity of the minted nfts\n /// @param pricePerToken price for each token\n /// @param firstPurchasedTokenId first purchased token ID (to get range add to quantity for max)\n event Sale(\n address indexed to,\n uint256 indexed quantity,\n uint256 indexed pricePerToken,\n uint256 firstPurchasedTokenId\n );\n\n /// @notice Sales configuration has been changed\n /// @dev To access new sales configuration, use getter function.\n /// @param changedBy Changed by user\n event SalesConfigChanged(address indexed changedBy);\n\n /// @notice Event emitted when the funds recipient is changed\n /// @param newAddress new address for the funds recipient\n /// @param changedBy address that the recipient is changed by\n event FundsRecipientChanged(\n address indexed newAddress,\n address indexed changedBy\n );\n\n /// @notice Event emitted when the funds are withdrawn from the minting contract\n /// @param withdrawnBy address that issued the withdraw\n /// @param withdrawnTo address that the funds were withdrawn to\n /// @param amount amount that was withdrawn\n /// @param feeRecipient user getting withdraw fee (if any)\n /// @param feeAmount amount of the fee getting sent (if any)\n event FundsWithdrawn(\n address indexed withdrawnBy,\n address indexed withdrawnTo,\n uint256 amount,\n address feeRecipient,\n uint256 feeAmount\n );\n\n /// @notice Event emitted when an open mint is finalized and further minting is closed forever on the contract.\n /// @param sender address sending close mint\n /// @param numberOfMints number of mints the contract is finalized at\n event OpenMintFinalized(address indexed sender, uint256 numberOfMints);\n\n /// @notice Event emitted when metadata renderer is updated.\n /// @param sender address of the updater\n /// @param renderer new metadata renderer address\n event UpdatedMetadataRenderer(address sender, IMetadataRenderer renderer);\n\n /// @notice Event emitted when rarities are updated.\n /// @param sender address updating rarities\n /// @param rarityConfigs new rarity configs used\n event UpdatedRarities(\n address indexed sender,\n RarityConfiguration[10] rarityConfigs\n );\n\n event UpdateBaseUri(address indexed sender, string baseURI);\n\n struct AvailableTiers {\n uint256 rarityId;\n uint256 tierMintsRemaining;\n }\n\n /// @notice General configuration for NFT Minting and bookkeeping\n struct Configuration {\n /// @dev Metadata renderer (uint160)\n IMetadataRenderer metadataRenderer;\n /// @dev Total size of edition that can be minted (including public and presale) (uint160+64 = 224)\n uint64 totalEditionSize;\n /// @dev Royalty amount in bps (uint224+16 = 240)\n uint16 royaltyBPS;\n /// @dev Funds recipient for sale (new slot, uint160)\n address payable fundsRecipient;\n /// @dev Total size of edition available during presale\n uint64 presaleEditionSize;\n }\n\n /// @notice General configuration for rarity tiers\n struct RarityConfiguration {\n /// @dev Total number of tokens that belong to this tier\n uint256 tierVolume;\n /// @dev Name of the tier\n string name;\n /// @dev URI of the cover image for this tier\n string coverImageURI;\n /// @dev The description for this rarity. Used as the description of the token.\n string rarityDescription;\n /// @dev The number of tokens that have been minted at this rarity\n uint256 volumeMinted;\n }\n\n /// @notice Sales states and configuration\n /// @dev Uses 3 storage slots\n struct SalesConfiguration {\n /// @dev Public sale price (max ether value > 1000 ether with this value)\n uint104 publicSalePrice;\n /// @notice Purchase mint limit per address (if set to 0 === unlimited mints)\n /// @dev Max purchase number per txn (90+32 = 122)\n uint32 maxSalePurchasePerAddress;\n /// @dev uint64 type allows for dates into 292 billion years\n /// @notice Public sale start timestamp (136+64 = 186)\n uint64 publicSaleStart;\n /// @notice Public sale end timestamp (186+64 = 250)\n uint64 publicSaleEnd;\n /// @notice Presale start timestamp\n /// @dev new storage slot\n uint64 presaleStart;\n /// @notice Presale end timestamp\n uint64 presaleEnd;\n /// @notice Allowlist sale price. Different from presale price\n uint104 allowlistSalePrice;\n /// @notice Token-gate contract addresses\n address[] tokenGateContracts;\n /// @notice Presale merkle root\n bytes32 presaleMerkleRoot;\n }\n\n /// @notice Return value for sales details to use with front-ends\n struct SaleDetails {\n // Synthesized status variables for sale and presale\n bool publicSaleActive;\n bool presaleActive;\n // Price for public sale\n uint256 publicSalePrice;\n // Timed sale actions for public sale\n uint64 publicSaleStart;\n uint64 publicSaleEnd;\n // Timed sale actions for presale\n uint64 presaleStart;\n uint64 presaleEnd;\n // Merkle root (includes address, quantity, and price data for each entry)\n bytes32 presaleMerkleRoot;\n // Limit public sale to a specific number of mints per wallet\n uint256 maxSalePurchasePerAddress;\n // Information about the rest of the supply\n // Total that have been minted\n uint256 totalMinted;\n // Total presale that have been minted\n uint256 totalPreSaleMinted;\n // The total supply available\n uint256 maxSupply;\n }\n\n /// @notice Return type of specific mint counts and details per address\n struct AddressMintDetails {\n /// Number of total mints from the given address\n uint256 totalMints;\n /// Number of presale mints from the given address\n uint256 presaleMints;\n /// Number of public mints from the given address\n uint256 publicMints;\n }\n\n /// @notice External purchase function (payable in eth)\n /// @param quantity to purchase\n /// @return first minted token ID\n function purchase(\n address recipient,\n uint256 quantity\n ) external payable returns (uint256);\n\n /// @notice External purchase presale function (takes a merkle proof and matches to root) (payable in eth)\n /// @param quantity to purchase\n /// @param maxQuantity can purchase (verified by merkle root)\n /// @param pricePerToken price per token allowed (verified by merkle root)\n /// @param merkleProof input for merkle proof leaf verified by merkle root\n /// @return first minted token ID\n function purchasePresale(\n address recipient,\n uint256 quantity,\n uint256 maxQuantity,\n uint256 pricePerToken,\n bytes32[] memory merkleProof\n ) external payable returns (uint256);\n\n /// @notice Function to return the global sales details for the given drop\n function saleDetails() external view returns (SaleDetails memory);\n\n /// @notice Function to get rarity mapping id for a given token id\n //\n\n /// @notice Function to return the specific sales details for a given address\n /// @param minter address for minter to return mint information for\n function mintedPerAddress(\n address minter\n ) external view returns (AddressMintDetails memory);\n\n /// @notice This is the opensea/public owner setting that can be set by the contract admin\n function owner() external view returns (address);\n\n /// @notice Update the metadata renderer\n /// @param newRenderer new address for renderer\n /// @param setupRenderer data to call to bootstrap data for the new renderer (optional)\n function setMetadataRenderer(\n IMetadataRenderer newRenderer,\n bytes memory setupRenderer\n ) external;\n\n /// @notice This is an admin mint function to mint a quantity to a specific address\n /// @param to address to mint to\n /// @param quantity quantity to mint\n /// @return the id of the first minted NFT\n function adminMint(address to, uint256 quantity) external returns (uint256);\n\n /// @notice This is an admin mint function to mint a single nft each to a list of addresses\n /// @param to list of addresses to mint an NFT each to\n /// @return the id of the first minted NFT\n function adminMintAirdrop(address[] memory to) external returns (uint256);\n\n /// @dev Getter for admin role associated with the contract to handle metadata\n /// @return boolean if address is admin\n function isAdmin(address user) external view returns (bool);\n\n /// @notice This sets the _baseURI variable on the contract\n /// @param baseUri HTTP URI, up to but not including, the contract address. eg: https://arpeggi.io/api/v2/kits-metadata\n function setBaseUri(string memory baseUri) external;\n}\n" }, "interfaces/IKitsFeeManager.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.10;\n\ninterface IKitsFeeManager {\n function getKITSWithdrawFeesBPS(\n address sender\n ) external returns (address payable, uint256);\n}\n" }, "interfaces/IMetadataRenderer.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.10;\n\ninterface IMetadataRenderer {\n function contractURI() external view returns (string memory);\n\n function initializeWithData(bytes memory initData) external;\n}\n" }, "interfaces/IOperatorFilterRegistry.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.10;\n\ninterface IOperatorFilterRegistry {\n function isOperatorAllowed(\n address registrant,\n address operator\n ) external view returns (bool);\n\n function register(address registrant) external;\n\n function registerAndSubscribe(\n address registrant,\n address subscription\n ) external;\n\n function registerAndCopyEntries(\n address registrant,\n address registrantToCopy\n ) external;\n\n function updateOperator(\n address registrant,\n address operator,\n bool filtered\n ) external;\n\n function updateOperators(\n address registrant,\n address[] calldata operators,\n bool filtered\n ) external;\n\n function updateCodeHash(\n address registrant,\n bytes32 codehash,\n bool filtered\n ) external;\n\n function updateCodeHashes(\n address registrant,\n bytes32[] calldata codeHashes,\n bool filtered\n ) external;\n\n function subscribe(\n address registrant,\n address registrantToSubscribe\n ) external;\n\n function unsubscribe(address registrant, bool copyExistingEntries) external;\n\n function subscriptionOf(address addr) external returns (address registrant);\n\n function subscribers(\n address registrant\n ) external returns (address[] memory);\n\n function subscriberAt(\n address registrant,\n uint256 index\n ) external returns (address);\n\n function copyEntriesOf(\n address registrant,\n address registrantToCopy\n ) external;\n\n function isOperatorFiltered(\n address registrant,\n address operator\n ) external returns (bool);\n\n function isCodeHashOfFiltered(\n address registrant,\n address operatorWithCode\n ) external returns (bool);\n\n function isCodeHashFiltered(\n address registrant,\n bytes32 codeHash\n ) external returns (bool);\n\n function filteredOperators(\n address addr\n ) external returns (address[] memory);\n\n function filteredCodeHashes(\n address addr\n ) external returns (bytes32[] memory);\n\n function filteredOperatorAt(\n address registrant,\n uint256 index\n ) external returns (address);\n\n function filteredCodeHashAt(\n address registrant,\n uint256 index\n ) external returns (bytes32);\n\n function isRegistered(address addr) external returns (bool);\n\n function codeHashOf(address addr) external returns (bytes32);\n\n function unregister(address registrant) external;\n}\n" }, "interfaces/IOwnable.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.10;\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 * This ownership interface matches OZ's ownable interface.\n *\n */\ninterface IOwnable {\n error ONLY_OWNER();\n error ONLY_PENDING_OWNER();\n\n event OwnershipTransferred(\n address indexed previousOwner,\n address indexed newOwner\n );\n\n event OwnerPending(\n address indexed previousOwner,\n address indexed potentialNewOwner\n );\n\n event OwnerCanceled(\n address indexed previousOwner,\n address indexed potentialNewOwner\n );\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() external view returns (address);\n}\n" }, "node_modules/@openzeppelin/contracts/utils/Strings.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./math/Math.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n bytes16 private constant _SYMBOLS = \"0123456789abcdef\";\n uint8 private constant _ADDRESS_LENGTH = 20;\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n */\n function toString(uint256 value) internal pure returns (string memory) {\n unchecked {\n uint256 length = Math.log10(value) + 1;\n string memory buffer = new string(length);\n uint256 ptr;\n /// @solidity memory-safe-assembly\n assembly {\n ptr := add(buffer, add(32, length))\n }\n while (true) {\n ptr--;\n /// @solidity memory-safe-assembly\n assembly {\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\n }\n value /= 10;\n if (value == 0) break;\n }\n return buffer;\n }\n }\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n */\n function toHexString(uint256 value) internal pure returns (string memory) {\n unchecked {\n return toHexString(value, Math.log256(value) + 1);\n }\n }\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n */\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n bytes memory buffer = new bytes(2 * length + 2);\n buffer[0] = \"0\";\n buffer[1] = \"x\";\n for (uint256 i = 2 * length + 1; i > 1; --i) {\n buffer[i] = _SYMBOLS[value & 0xf];\n value >>= 4;\n }\n require(value == 0, \"Strings: hex length insufficient\");\n return string(buffer);\n }\n\n /**\n * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\n */\n function toHexString(address addr) internal pure returns (string memory) {\n return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\n }\n}\n" }, "node_modules/@openzeppelin/contracts/utils/math/Math.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n enum Rounding {\n Down, // Toward negative infinity\n Up, // Toward infinity\n Zero // Toward zero\n }\n\n /**\n * @dev Returns the largest of two numbers.\n */\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\n return a > b ? a : b;\n }\n\n /**\n * @dev Returns the smallest of two numbers.\n */\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\n return a < b ? a : b;\n }\n\n /**\n * @dev Returns the average of two numbers. The result is rounded towards\n * zero.\n */\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\n // (a + b) / 2 can overflow.\n return (a & b) + (a ^ b) / 2;\n }\n\n /**\n * @dev Returns the ceiling of the division of two numbers.\n *\n * This differs from standard division with `/` in that it rounds up instead\n * of rounding down.\n */\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n // (a + b - 1) / b can overflow on addition, so we distribute.\n return a == 0 ? 0 : (a - 1) / b + 1;\n }\n\n /**\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\n * with further edits by Uniswap Labs also under MIT license.\n */\n function mulDiv(\n uint256 x,\n uint256 y,\n uint256 denominator\n ) internal pure returns (uint256 result) {\n unchecked {\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n // variables such that product = prod1 * 2^256 + prod0.\n uint256 prod0; // Least significant 256 bits of the product\n uint256 prod1; // Most significant 256 bits of the product\n assembly {\n let mm := mulmod(x, y, not(0))\n prod0 := mul(x, y)\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n }\n\n // Handle non-overflow cases, 256 by 256 division.\n if (prod1 == 0) {\n return prod0 / denominator;\n }\n\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\n require(denominator > prod1);\n\n ///////////////////////////////////////////////\n // 512 by 256 division.\n ///////////////////////////////////////////////\n\n // Make division exact by subtracting the remainder from [prod1 prod0].\n uint256 remainder;\n assembly {\n // Compute remainder using mulmod.\n remainder := mulmod(x, y, denominator)\n\n // Subtract 256 bit number from 512 bit number.\n prod1 := sub(prod1, gt(remainder, prod0))\n prod0 := sub(prod0, remainder)\n }\n\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\n // See https://cs.stackexchange.com/q/138556/92363.\n\n // Does not overflow because the denominator cannot be zero at this stage in the function.\n uint256 twos = denominator & (~denominator + 1);\n assembly {\n // Divide denominator by twos.\n denominator := div(denominator, twos)\n\n // Divide [prod1 prod0] by twos.\n prod0 := div(prod0, twos)\n\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n twos := add(div(sub(0, twos), twos), 1)\n }\n\n // Shift in bits from prod1 into prod0.\n prod0 |= prod1 * twos;\n\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n // four bits. That is, denominator * inv = 1 mod 2^4.\n uint256 inverse = (3 * denominator) ^ 2;\n\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\n // in modular arithmetic, doubling the correct bits in each step.\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\n\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n // is no longer required.\n result = prod0 * inverse;\n return result;\n }\n }\n\n /**\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n */\n function mulDiv(\n uint256 x,\n uint256 y,\n uint256 denominator,\n Rounding rounding\n ) internal pure returns (uint256) {\n uint256 result = mulDiv(x, y, denominator);\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\n result += 1;\n }\n return result;\n }\n\n /**\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\n *\n * Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n */\n function sqrt(uint256 a) internal pure returns (uint256) {\n if (a == 0) {\n return 0;\n }\n\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n //\n // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n //\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n //\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n uint256 result = 1 << (log2(a) >> 1);\n\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n // into the expected uint128 result.\n unchecked {\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n return min(result, a / result);\n }\n }\n\n /**\n * @notice Calculates sqrt(a), following the selected rounding direction.\n */\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = sqrt(a);\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\n }\n }\n\n /**\n * @dev Return the log in base 2, rounded down, of a positive value.\n * Returns 0 if given 0.\n */\n function log2(uint256 value) internal pure returns (uint256) {\n uint256 result = 0;\n unchecked {\n if (value >> 128 > 0) {\n value >>= 128;\n result += 128;\n }\n if (value >> 64 > 0) {\n value >>= 64;\n result += 64;\n }\n if (value >> 32 > 0) {\n value >>= 32;\n result += 32;\n }\n if (value >> 16 > 0) {\n value >>= 16;\n result += 16;\n }\n if (value >> 8 > 0) {\n value >>= 8;\n result += 8;\n }\n if (value >> 4 > 0) {\n value >>= 4;\n result += 4;\n }\n if (value >> 2 > 0) {\n value >>= 2;\n result += 2;\n }\n if (value >> 1 > 0) {\n result += 1;\n }\n }\n return result;\n }\n\n /**\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n * Returns 0 if given 0.\n */\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = log2(value);\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\n }\n }\n\n /**\n * @dev Return the log in base 10, rounded down, of a positive value.\n * Returns 0 if given 0.\n */\n function log10(uint256 value) internal pure returns (uint256) {\n uint256 result = 0;\n unchecked {\n if (value >= 10**64) {\n value /= 10**64;\n result += 64;\n }\n if (value >= 10**32) {\n value /= 10**32;\n result += 32;\n }\n if (value >= 10**16) {\n value /= 10**16;\n result += 16;\n }\n if (value >= 10**8) {\n value /= 10**8;\n result += 8;\n }\n if (value >= 10**4) {\n value /= 10**4;\n result += 4;\n }\n if (value >= 10**2) {\n value /= 10**2;\n result += 2;\n }\n if (value >= 10**1) {\n result += 1;\n }\n }\n return result;\n }\n\n /**\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n * Returns 0 if given 0.\n */\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = log10(value);\n return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\n }\n }\n\n /**\n * @dev Return the log in base 256, rounded down, of a positive value.\n * Returns 0 if given 0.\n *\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n */\n function log256(uint256 value) internal pure returns (uint256) {\n uint256 result = 0;\n unchecked {\n if (value >> 128 > 0) {\n value >>= 128;\n result += 16;\n }\n if (value >> 64 > 0) {\n value >>= 64;\n result += 8;\n }\n if (value >> 32 > 0) {\n value >>= 32;\n result += 4;\n }\n if (value >> 16 > 0) {\n value >>= 16;\n result += 2;\n }\n if (value >> 8 > 0) {\n result += 1;\n }\n }\n return result;\n }\n\n /**\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n * Returns 0 if given 0.\n */\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = log256(value);\n return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);\n }\n }\n}\n" }, "node_modules/@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (access/AccessControl.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IAccessControlUpgradeable.sol\";\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../utils/StringsUpgradeable.sol\";\nimport \"../utils/introspection/ERC165Upgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```\n * function foo() public {\n * require(hasRole(MY_ROLE, msg.sender));\n * ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it.\n */\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\n function __AccessControl_init() internal onlyInitializing {\n }\n\n function __AccessControl_init_unchained() internal onlyInitializing {\n }\n struct RoleData {\n mapping(address => bool) members;\n bytes32 adminRole;\n }\n\n mapping(bytes32 => RoleData) private _roles;\n\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n /**\n * @dev Modifier that checks that an account has a specific role. Reverts\n * with a standardized message including the required role.\n *\n * The format of the revert reason is given by the following regular expression:\n *\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n *\n * _Available since v4.1._\n */\n modifier onlyRole(bytes32 role) {\n _checkRole(role);\n _;\n }\n\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IAccessControlUpgradeable).interfaceId || super.supportsInterface(interfaceId);\n }\n\n /**\n * @dev Returns `true` if `account` has been granted `role`.\n */\n function hasRole(bytes32 role, address account) public view virtual override returns (bool) {\n return _roles[role].members[account];\n }\n\n /**\n * @dev Revert with a standard message if `_msgSender()` is missing `role`.\n * Overriding this function changes the behavior of the {onlyRole} modifier.\n *\n * Format of the revert message is described in {_checkRole}.\n *\n * _Available since v4.6._\n */\n function _checkRole(bytes32 role) internal view virtual {\n _checkRole(role, _msgSender());\n }\n\n /**\n * @dev Revert with a standard message if `account` is missing `role`.\n *\n * The format of the revert reason is given by the following regular expression:\n *\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n */\n function _checkRole(bytes32 role, address account) internal view virtual {\n if (!hasRole(role, account)) {\n revert(\n string(\n abi.encodePacked(\n \"AccessControl: account \",\n StringsUpgradeable.toHexString(account),\n \" is missing role \",\n StringsUpgradeable.toHexString(uint256(role), 32)\n )\n )\n );\n }\n }\n\n /**\n * @dev Returns the admin role that controls `role`. See {grantRole} and\n * {revokeRole}.\n *\n * To change a role's admin, use {_setRoleAdmin}.\n */\n function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {\n return _roles[role].adminRole;\n }\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n *\n * May emit a {RoleGranted} event.\n */\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n _grantRole(role, account);\n }\n\n /**\n * @dev Revokes `role` from `account`.\n *\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n *\n * May emit a {RoleRevoked} event.\n */\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n _revokeRole(role, account);\n }\n\n /**\n * @dev Revokes `role` from the calling account.\n *\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\n * purpose is to provide a mechanism for accounts to lose their privileges\n * if they are compromised (such as when a trusted device is misplaced).\n *\n * If the calling account had been revoked `role`, emits a {RoleRevoked}\n * event.\n *\n * Requirements:\n *\n * - the caller must be `account`.\n *\n * May emit a {RoleRevoked} event.\n */\n function renounceRole(bytes32 role, address account) public virtual override {\n require(account == _msgSender(), \"AccessControl: can only renounce roles for self\");\n\n _revokeRole(role, account);\n }\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event. Note that unlike {grantRole}, this function doesn't perform any\n * checks on the calling account.\n *\n * May emit a {RoleGranted} event.\n *\n * [WARNING]\n * ====\n * This function should only be called from the constructor when setting\n * up the initial roles for the system.\n *\n * Using this function in any other way is effectively circumventing the admin\n * system imposed by {AccessControl}.\n * ====\n *\n * NOTE: This function is deprecated in favor of {_grantRole}.\n */\n function _setupRole(bytes32 role, address account) internal virtual {\n _grantRole(role, account);\n }\n\n /**\n * @dev Sets `adminRole` as ``role``'s admin role.\n *\n * Emits a {RoleAdminChanged} event.\n */\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n bytes32 previousAdminRole = getRoleAdmin(role);\n _roles[role].adminRole = adminRole;\n emit RoleAdminChanged(role, previousAdminRole, adminRole);\n }\n\n /**\n * @dev Grants `role` to `account`.\n *\n * Internal function without access restriction.\n *\n * May emit a {RoleGranted} event.\n */\n function _grantRole(bytes32 role, address account) internal virtual {\n if (!hasRole(role, account)) {\n _roles[role].members[account] = true;\n emit RoleGranted(role, account, _msgSender());\n }\n }\n\n /**\n * @dev Revokes `role` from `account`.\n *\n * Internal function without access restriction.\n *\n * May emit a {RoleRevoked} event.\n */\n function _revokeRole(bytes32 role, address account) internal virtual {\n if (hasRole(role, account)) {\n _roles[role].members[account] = false;\n emit RoleRevoked(role, account, _msgSender());\n }\n }\n\n /**\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" }, "node_modules/@openzeppelin/contracts-upgradeable/access/IAccessControlUpgradeable.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControlUpgradeable {\n /**\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n *\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n * {RoleAdminChanged} not being emitted signaling this.\n *\n * _Available since v3.1._\n */\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n /**\n * @dev Emitted when `account` is granted `role`.\n *\n * `sender` is the account that originated the contract call, an admin role\n * bearer except when using {AccessControl-_setupRole}.\n */\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Emitted when `account` is revoked `role`.\n *\n * `sender` is the account that originated the contract call:\n * - if using `revokeRole`, it is the admin role bearer\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\n */\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Returns `true` if `account` has been granted `role`.\n */\n function hasRole(bytes32 role, address account) external view returns (bool);\n\n /**\n * @dev Returns the admin role that controls `role`. See {grantRole} and\n * {revokeRole}.\n *\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n */\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function grantRole(bytes32 role, address account) external;\n\n /**\n * @dev Revokes `role` from `account`.\n *\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function revokeRole(bytes32 role, address account) external;\n\n /**\n * @dev Revokes `role` from the calling account.\n *\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\n * purpose is to provide a mechanism for accounts to lose their privileges\n * if they are compromised (such as when a trusted device is misplaced).\n *\n * If the calling account had been granted `role`, emits a {RoleRevoked}\n * event.\n *\n * Requirements:\n *\n * - the caller must be `account`.\n */\n function renounceRole(bytes32 role, address account) external;\n}\n" }, "node_modules/@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/introspection/IERC165Upgradeable.sol\";\n\n/**\n * @dev Interface for the NFT Royalty Standard.\n *\n * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal\n * support for royalty payments across all NFT marketplaces and ecosystem participants.\n *\n * _Available since v4.5._\n */\ninterface IERC2981Upgradeable is IERC165Upgradeable {\n /**\n * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of\n * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.\n */\n function royaltyInfo(uint256 tokenId, uint256 salePrice)\n external\n view\n returns (address receiver, uint256 royaltyAmount);\n}\n" }, "node_modules/@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.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 IERC1822ProxiableUpgradeable {\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" }, "node_modules/@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../beacon/IBeaconUpgradeable.sol\";\nimport \"../../interfaces/draft-IERC1822Upgradeable.sol\";\nimport \"../../utils/AddressUpgradeable.sol\";\nimport \"../../utils/StorageSlotUpgradeable.sol\";\nimport \"../utils/Initializable.sol\";\n\n/**\n * @dev This abstract contract provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\n *\n * _Available since v4.1._\n *\n * @custom:oz-upgrades-unsafe-allow delegatecall\n */\nabstract contract ERC1967UpgradeUpgradeable is Initializable {\n function __ERC1967Upgrade_init() internal onlyInitializing {\n }\n\n function __ERC1967Upgrade_init_unchained() internal onlyInitializing {\n }\n // This is the keccak-256 hash of \"eip1967.proxy.rollback\" subtracted by 1\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\n\n /**\n * @dev Storage slot with the address of the current implementation.\n * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n /**\n * @dev Emitted when the implementation is upgraded.\n */\n event Upgraded(address indexed implementation);\n\n /**\n * @dev Returns the current implementation address.\n */\n function _getImplementation() internal view returns (address) {\n return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 implementation slot.\n */\n function _setImplementation(address newImplementation) private {\n require(AddressUpgradeable.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n }\n\n /**\n * @dev Perform implementation upgrade\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeTo(address newImplementation) internal {\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n }\n\n /**\n * @dev Perform implementation upgrade with additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCall(\n address newImplementation,\n bytes memory data,\n bool forceCall\n ) internal {\n _upgradeTo(newImplementation);\n if (data.length > 0 || forceCall) {\n _functionDelegateCall(newImplementation, data);\n }\n }\n\n /**\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCallUUPS(\n address newImplementation,\n bytes memory data,\n bool forceCall\n ) internal {\n // Upgrades from old implementations will perform a rollback test. This test requires the new\n // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing\n // this special case will break upgrade paths from old UUPS implementation to new ones.\n if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {\n _setImplementation(newImplementation);\n } else {\n try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {\n require(slot == _IMPLEMENTATION_SLOT, \"ERC1967Upgrade: unsupported proxiableUUID\");\n } catch {\n revert(\"ERC1967Upgrade: new implementation is not UUPS\");\n }\n _upgradeToAndCall(newImplementation, data, forceCall);\n }\n }\n\n /**\n * @dev Storage slot with the admin of the contract.\n * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n /**\n * @dev Emitted when the admin account has changed.\n */\n event AdminChanged(address previousAdmin, address newAdmin);\n\n /**\n * @dev Returns the current admin.\n */\n function _getAdmin() internal view returns (address) {\n return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 admin slot.\n */\n function _setAdmin(address newAdmin) private {\n require(newAdmin != address(0), \"ERC1967: new admin is the zero address\");\n StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\n }\n\n /**\n * @dev Changes the admin of the proxy.\n *\n * Emits an {AdminChanged} event.\n */\n function _changeAdmin(address newAdmin) internal {\n emit AdminChanged(_getAdmin(), newAdmin);\n _setAdmin(newAdmin);\n }\n\n /**\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\n */\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n /**\n * @dev Emitted when the beacon is upgraded.\n */\n event BeaconUpgraded(address indexed beacon);\n\n /**\n * @dev Returns the current beacon.\n */\n function _getBeacon() internal view returns (address) {\n return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;\n }\n\n /**\n * @dev Stores a new beacon in the EIP1967 beacon slot.\n */\n function _setBeacon(address newBeacon) private {\n require(AddressUpgradeable.isContract(newBeacon), \"ERC1967: new beacon is not a contract\");\n require(\n AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),\n \"ERC1967: beacon implementation is not a contract\"\n );\n StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;\n }\n\n /**\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\n *\n * Emits a {BeaconUpgraded} event.\n */\n function _upgradeBeaconToAndCall(\n address newBeacon,\n bytes memory data,\n bool forceCall\n ) internal {\n _setBeacon(newBeacon);\n emit BeaconUpgraded(newBeacon);\n if (data.length > 0 || forceCall) {\n _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);\n }\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function _functionDelegateCall(address target, bytes memory data) private returns (bytes memory) {\n require(AddressUpgradeable.isContract(target), \"Address: delegate call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return AddressUpgradeable.verifyCallResult(success, returndata, \"Address: low-level delegate call failed\");\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" }, "node_modules/@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeaconUpgradeable {\n /**\n * @dev Must return an address that can be used as a delegate call target.\n *\n * {BeaconProxy} will check that this address is a contract.\n */\n function implementation() external view returns (address);\n}\n" }, "node_modules/@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.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" }, "node_modules/@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (proxy/utils/UUPSUpgradeable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../../interfaces/draft-IERC1822Upgradeable.sol\";\nimport \"../ERC1967/ERC1967UpgradeUpgradeable.sol\";\nimport \"./Initializable.sol\";\n\n/**\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\n *\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\n * `UUPSUpgradeable` with a custom implementation of upgrades.\n *\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\n *\n * _Available since v4.1._\n */\nabstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {\n function __UUPSUpgradeable_init() internal onlyInitializing {\n }\n\n function __UUPSUpgradeable_init_unchained() internal onlyInitializing {\n }\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment\n address private immutable __self = address(this);\n\n /**\n * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\n * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case\n * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\n * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\n * fail.\n */\n modifier onlyProxy() {\n require(address(this) != __self, \"Function must be called through delegatecall\");\n require(_getImplementation() == __self, \"Function must be called through active proxy\");\n _;\n }\n\n /**\n * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\n * callable on the implementing contract but not through proxies.\n */\n modifier notDelegated() {\n require(address(this) == __self, \"UUPSUpgradeable: must not be called through delegatecall\");\n _;\n }\n\n /**\n * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the\n * implementation. It is used to validate the implementation's compatibility when performing an upgrade.\n *\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\n */\n function proxiableUUID() external view virtual override notDelegated returns (bytes32) {\n return _IMPLEMENTATION_SLOT;\n }\n\n /**\n * @dev Upgrade the implementation of the proxy to `newImplementation`.\n *\n * Calls {_authorizeUpgrade}.\n *\n * Emits an {Upgraded} event.\n */\n function upgradeTo(address newImplementation) external virtual onlyProxy {\n _authorizeUpgrade(newImplementation);\n _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);\n }\n\n /**\n * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\n * encoded in `data`.\n *\n * Calls {_authorizeUpgrade}.\n *\n * Emits an {Upgraded} event.\n */\n function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {\n _authorizeUpgrade(newImplementation);\n _upgradeToAndCallUUPS(newImplementation, data, true);\n }\n\n /**\n * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\n * {upgradeTo} and {upgradeToAndCall}.\n *\n * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\n *\n * ```solidity\n * function _authorizeUpgrade(address) internal override onlyOwner {}\n * ```\n */\n function _authorizeUpgrade(address newImplementation) 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[50] private __gap;\n}\n" }, "node_modules/@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (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 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" }, "node_modules/@openzeppelin/contracts-upgradeable/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" }, "node_modules/@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.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" }, "node_modules/@openzeppelin/contracts-upgradeable/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" }, "node_modules/@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary 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://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev 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" }, "node_modules/@openzeppelin/contracts-upgradeable/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" }, "node_modules/@openzeppelin/contracts-upgradeable/utils/StorageSlotUpgradeable.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 StorageSlotUpgradeable {\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" }, "node_modules/@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.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" }, "node_modules/@openzeppelin/contracts-upgradeable/utils/cryptography/MerkleProofUpgradeable.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev These functions deal with verification of Merkle Tree proofs.\n *\n * The tree and the proofs can be generated using our\n * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].\n * You will find a quickstart guide in the readme.\n *\n * WARNING: You should avoid using leaf values that are 64 bytes long prior to\n * hashing, or use a hash function other than keccak256 for hashing leaves.\n * This is because the concatenation of a sorted pair of internal nodes in\n * the merkle tree could be reinterpreted as a leaf value.\n * OpenZeppelin's JavaScript library generates merkle trees that are safe\n * against this attack out of the box.\n */\nlibrary MerkleProofUpgradeable {\n /**\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\n * defined by `root`. For this, a `proof` must be provided, containing\n * sibling hashes on the branch from the leaf to the root of the tree. Each\n * pair of leaves and each pair of pre-images are assumed to be sorted.\n */\n function verify(\n bytes32[] memory proof,\n bytes32 root,\n bytes32 leaf\n ) internal pure returns (bool) {\n return processProof(proof, leaf) == root;\n }\n\n /**\n * @dev Calldata version of {verify}\n *\n * _Available since v4.7._\n */\n function verifyCalldata(\n bytes32[] calldata proof,\n bytes32 root,\n bytes32 leaf\n ) internal pure returns (bool) {\n return processProofCalldata(proof, leaf) == root;\n }\n\n /**\n * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up\n * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt\n * hash matches the root of the tree. When processing the proof, the pairs\n * of leafs & pre-images are assumed to be sorted.\n *\n * _Available since v4.4._\n */\n function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {\n bytes32 computedHash = leaf;\n for (uint256 i = 0; i < proof.length; i++) {\n computedHash = _hashPair(computedHash, proof[i]);\n }\n return computedHash;\n }\n\n /**\n * @dev Calldata version of {processProof}\n *\n * _Available since v4.7._\n */\n function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {\n bytes32 computedHash = leaf;\n for (uint256 i = 0; i < proof.length; i++) {\n computedHash = _hashPair(computedHash, proof[i]);\n }\n return computedHash;\n }\n\n /**\n * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by\n * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.\n *\n * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.\n *\n * _Available since v4.7._\n */\n function multiProofVerify(\n bytes32[] memory proof,\n bool[] memory proofFlags,\n bytes32 root,\n bytes32[] memory leaves\n ) internal pure returns (bool) {\n return processMultiProof(proof, proofFlags, leaves) == root;\n }\n\n /**\n * @dev Calldata version of {multiProofVerify}\n *\n * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.\n *\n * _Available since v4.7._\n */\n function multiProofVerifyCalldata(\n bytes32[] calldata proof,\n bool[] calldata proofFlags,\n bytes32 root,\n bytes32[] memory leaves\n ) internal pure returns (bool) {\n return processMultiProofCalldata(proof, proofFlags, leaves) == root;\n }\n\n /**\n * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction\n * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another\n * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false\n * respectively.\n *\n * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree\n * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the\n * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).\n *\n * _Available since v4.7._\n */\n function processMultiProof(\n bytes32[] memory proof,\n bool[] memory proofFlags,\n bytes32[] memory leaves\n ) internal pure returns (bytes32 merkleRoot) {\n // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by\n // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the\n // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of\n // the merkle tree.\n uint256 leavesLen = leaves.length;\n uint256 totalHashes = proofFlags.length;\n\n // Check proof validity.\n require(leavesLen + proof.length - 1 == totalHashes, \"MerkleProof: invalid multiproof\");\n\n // The xxxPos values are \"pointers\" to the next value to consume in each array. All accesses are done using\n // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \"pop\".\n bytes32[] memory hashes = new bytes32[](totalHashes);\n uint256 leafPos = 0;\n uint256 hashPos = 0;\n uint256 proofPos = 0;\n // At each step, we compute the next hash using two values:\n // - a value from the \"main queue\". If not all leaves have been consumed, we get the next leaf, otherwise we\n // get the next hash.\n // - depending on the flag, either another value for the \"main queue\" (merging branches) or an element from the\n // `proof` array.\n for (uint256 i = 0; i < totalHashes; i++) {\n bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\n bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];\n hashes[i] = _hashPair(a, b);\n }\n\n if (totalHashes > 0) {\n return hashes[totalHashes - 1];\n } else if (leavesLen > 0) {\n return leaves[0];\n } else {\n return proof[0];\n }\n }\n\n /**\n * @dev Calldata version of {processMultiProof}.\n *\n * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.\n *\n * _Available since v4.7._\n */\n function processMultiProofCalldata(\n bytes32[] calldata proof,\n bool[] calldata proofFlags,\n bytes32[] memory leaves\n ) internal pure returns (bytes32 merkleRoot) {\n // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by\n // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the\n // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of\n // the merkle tree.\n uint256 leavesLen = leaves.length;\n uint256 totalHashes = proofFlags.length;\n\n // Check proof validity.\n require(leavesLen + proof.length - 1 == totalHashes, \"MerkleProof: invalid multiproof\");\n\n // The xxxPos values are \"pointers\" to the next value to consume in each array. All accesses are done using\n // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \"pop\".\n bytes32[] memory hashes = new bytes32[](totalHashes);\n uint256 leafPos = 0;\n uint256 hashPos = 0;\n uint256 proofPos = 0;\n // At each step, we compute the next hash using two values:\n // - a value from the \"main queue\". If not all leaves have been consumed, we get the next leaf, otherwise we\n // get the next hash.\n // - depending on the flag, either another value for the \"main queue\" (merging branches) or an element from the\n // `proof` array.\n for (uint256 i = 0; i < totalHashes; i++) {\n bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\n bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];\n hashes[i] = _hashPair(a, b);\n }\n\n if (totalHashes > 0) {\n return hashes[totalHashes - 1];\n } else if (leavesLen > 0) {\n return leaves[0];\n } else {\n return proof[0];\n }\n }\n\n function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {\n return a < b ? _efficientHash(a, b) : _efficientHash(b, a);\n }\n\n function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, a)\n mstore(0x20, b)\n value := keccak256(0x00, 0x40)\n }\n }\n}\n" }, "node_modules/@openzeppelin/contracts-upgradeable/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" }, "node_modules/@openzeppelin/contracts-upgradeable/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" }, "node_modules/@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary 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 < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n //\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n //\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n uint256 result = 1 << (log2(a) >> 1);\n\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n // into the expected uint128 result.\n unchecked {\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n return min(result, a / result);\n }\n }\n\n /**\n * @notice Calculates sqrt(a), following the selected rounding direction.\n */\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = sqrt(a);\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\n }\n }\n\n /**\n * @dev Return the log in base 2, rounded down, of a positive value.\n * Returns 0 if given 0.\n */\n function log2(uint256 value) internal pure returns (uint256) {\n uint256 result = 0;\n unchecked {\n if (value >> 128 > 0) {\n value >>= 128;\n result += 128;\n }\n if (value >> 64 > 0) {\n value >>= 64;\n result += 64;\n }\n if (value >> 32 > 0) {\n value >>= 32;\n result += 32;\n }\n if (value >> 16 > 0) {\n value >>= 16;\n result += 16;\n }\n if (value >> 8 > 0) {\n value >>= 8;\n result += 8;\n }\n if (value >> 4 > 0) {\n value >>= 4;\n result += 4;\n }\n if (value >> 2 > 0) {\n value >>= 2;\n result += 2;\n }\n if (value >> 1 > 0) {\n result += 1;\n }\n }\n return result;\n }\n\n /**\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n * Returns 0 if given 0.\n */\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = log2(value);\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\n }\n }\n\n /**\n * @dev Return the log in base 10, rounded down, of a positive value.\n * Returns 0 if given 0.\n */\n function log10(uint256 value) internal pure returns (uint256) {\n uint256 result = 0;\n unchecked {\n if (value >= 10**64) {\n value /= 10**64;\n result += 64;\n }\n if (value >= 10**32) {\n value /= 10**32;\n result += 32;\n }\n if (value >= 10**16) {\n value /= 10**16;\n result += 16;\n }\n if (value >= 10**8) {\n value /= 10**8;\n result += 8;\n }\n if (value >= 10**4) {\n value /= 10**4;\n result += 4;\n }\n if (value >= 10**2) {\n value /= 10**2;\n result += 2;\n }\n if (value >= 10**1) {\n result += 1;\n }\n }\n return result;\n }\n\n /**\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n * Returns 0 if given 0.\n */\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = log10(value);\n return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\n }\n }\n\n /**\n * @dev Return the log in base 256, rounded down, of a positive value.\n * Returns 0 if given 0.\n *\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n */\n function log256(uint256 value) internal pure returns (uint256) {\n uint256 result = 0;\n unchecked {\n if (value >> 128 > 0) {\n value >>= 128;\n result += 16;\n }\n if (value >> 64 > 0) {\n value >>= 64;\n result += 8;\n }\n if (value >> 32 > 0) {\n value >>= 32;\n result += 4;\n }\n if (value >> 16 > 0) {\n value >>= 16;\n result += 2;\n }\n if (value >> 8 > 0) {\n result += 1;\n }\n }\n return result;\n }\n\n /**\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n * Returns 0 if given 0.\n */\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = log256(value);\n return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);\n }\n }\n}\n" }, "node_modules/erc721a-upgradeable/contracts/ERC721AUpgradeable.sol": { "content": "// SPDX-License-Identifier: MIT\n// ERC721A Contracts v3.3.0\n// Creator: Chiru Labs\n\npragma solidity ^0.8.4;\n\nimport \"./IERC721AUpgradeable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/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. Built to optimize for lower gas during batch mints.\n *\n * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).\n *\n * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.\n *\n * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).\n */\ncontract ERC721AUpgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721AUpgradeable {\n using AddressUpgradeable for address;\n using StringsUpgradeable for uint256;\n\n // The tokenId of the next token to be minted.\n uint256 internal _currentIndex;\n\n // The number of tokens burned.\n uint256 internal _burnCounter;\n\n // Token name\n string private _name;\n\n // Token symbol\n string private _symbol;\n\n // Mapping from token ID to ownership details\n // An empty struct value does not necessarily mean the token is unowned. See _ownershipOf implementation for details.\n mapping(uint256 => TokenOwnership) internal _ownerships;\n\n // Mapping owner address to address data\n mapping(address => AddressData) private _addressData;\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 function __ERC721A_init(string memory name_, string memory symbol_) internal onlyInitializing {\n __ERC721A_init_unchained(name_, symbol_);\n }\n\n function __ERC721A_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {\n _name = name_;\n _symbol = symbol_;\n _currentIndex = _startTokenId();\n }\n\n /**\n * To change the starting tokenId, please override this function.\n */\n function _startTokenId() internal view virtual returns (uint256) {\n return 0;\n }\n\n /**\n * @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.\n */\n function totalSupply() public view override returns (uint256) {\n // Counter underflow is impossible as _burnCounter cannot be incremented\n // more than _currentIndex - _startTokenId() times\n unchecked {\n return _currentIndex - _burnCounter - _startTokenId();\n }\n }\n\n /**\n * Returns the total amount of tokens minted in the contract.\n */\n function _totalMinted() internal view returns (uint256) {\n // Counter underflow is impossible as _currentIndex does not decrement,\n // and it is initialized to _startTokenId()\n unchecked {\n return _currentIndex - _startTokenId();\n }\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 override returns (uint256) {\n if (owner == address(0)) revert BalanceQueryForZeroAddress();\n return uint256(_addressData[owner].balance);\n }\n\n /**\n * Returns the number of tokens minted by `owner`.\n */\n function _numberMinted(address owner) internal view returns (uint256) {\n return uint256(_addressData[owner].numberMinted);\n }\n\n /**\n * Returns the number of tokens burned by or on behalf of `owner`.\n */\n function _numberBurned(address owner) internal view returns (uint256) {\n return uint256(_addressData[owner].numberBurned);\n }\n\n /**\n * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).\n */\n function _getAux(address owner) internal view returns (uint64) {\n return _addressData[owner].aux;\n }\n\n /**\n * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).\n * If there are multiple variables, please pack them into a uint64.\n */\n function _setAux(address owner, uint64 aux) internal {\n _addressData[owner].aux = aux;\n }\n\n /**\n * Gas spent here starts off proportional to the maximum mint batch size.\n * It gradually moves to O(1) as tokens get transferred around in the collection over time.\n */\n function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {\n uint256 curr = tokenId;\n\n unchecked {\n if (_startTokenId() <= curr) if (curr < _currentIndex) {\n TokenOwnership memory ownership = _ownerships[curr];\n if (!ownership.burned) {\n if (ownership.addr != address(0)) {\n return ownership;\n }\n // Invariant:\n // There will always be an ownership that has an address and is not burned\n // before an ownership that does not have an address and is not burned.\n // Hence, curr will not underflow.\n while (true) {\n curr--;\n ownership = _ownerships[curr];\n if (ownership.addr != address(0)) {\n return ownership;\n }\n }\n }\n }\n }\n revert OwnerQueryForNonexistentToken();\n }\n\n /**\n * @dev See {IERC721-ownerOf}.\n */\n function ownerOf(uint256 tokenId) public view override returns (address) {\n return _ownershipOf(tokenId).addr;\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 if (!_exists(tokenId)) revert URIQueryForNonexistentToken();\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 overriden 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 override {\n address owner = ERC721AUpgradeable.ownerOf(tokenId);\n if (to == owner) revert ApprovalToCurrentOwner();\n\n if (_msgSender() != owner) if(!isApprovedForAll(owner, _msgSender())) {\n revert ApprovalCallerNotOwnerNorApproved();\n }\n\n _approve(to, tokenId, owner);\n }\n\n /**\n * @dev See {IERC721-getApproved}.\n */\n function getApproved(uint256 tokenId) public view override returns (address) {\n if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();\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 if (operator == _msgSender()) revert ApproveToCaller();\n\n _operatorApprovals[_msgSender()][operator] = approved;\n emit ApprovalForAll(_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 _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 _transfer(from, to, tokenId);\n if (to.isContract()) if(!_checkContractOnERC721Received(from, to, tokenId, _data)) {\n revert TransferToNonERC721ReceiverImplementer();\n }\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 */\n function _exists(uint256 tokenId) internal view returns (bool) {\n return _startTokenId() <= tokenId && tokenId < _currentIndex && !_ownerships[tokenId].burned;\n }\n\n /**\n * @dev Equivalent to `_safeMint(to, quantity, '')`.\n */\n function _safeMint(address to, uint256 quantity) internal {\n _safeMint(to, quantity, '');\n }\n\n /**\n * @dev Safely mints `quantity` tokens and transfers them to `to`.\n *\n * Requirements:\n *\n * - If `to` refers to a smart contract, it must implement\n * {IERC721Receiver-onERC721Received}, which is called for each safe transfer.\n * - `quantity` must be greater than 0.\n *\n * Emits a {Transfer} event.\n */\n function _safeMint(\n address to,\n uint256 quantity,\n bytes memory _data\n ) internal {\n uint256 startTokenId = _currentIndex;\n if (to == address(0)) revert MintToZeroAddress();\n if (quantity == 0) revert MintZeroQuantity();\n\n _beforeTokenTransfers(address(0), to, startTokenId, quantity);\n\n // Overflows are incredibly unrealistic.\n // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1\n // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1\n unchecked {\n _addressData[to].balance += uint64(quantity);\n _addressData[to].numberMinted += uint64(quantity);\n\n _ownerships[startTokenId].addr = to;\n _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);\n\n uint256 updatedIndex = startTokenId;\n uint256 end = updatedIndex + quantity;\n\n if (to.isContract()) {\n do {\n emit Transfer(address(0), to, updatedIndex);\n if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {\n revert TransferToNonERC721ReceiverImplementer();\n }\n } while (updatedIndex < end);\n // Reentrancy protection\n if (_currentIndex != startTokenId) revert();\n } else {\n do {\n emit Transfer(address(0), to, updatedIndex++);\n } while (updatedIndex < end);\n }\n _currentIndex = updatedIndex;\n }\n _afterTokenTransfers(address(0), to, startTokenId, quantity);\n }\n\n /**\n * @dev Mints `quantity` tokens and transfers them to `to`.\n *\n * Requirements:\n *\n * - `to` cannot be the zero address.\n * - `quantity` must be greater than 0.\n *\n * Emits a {Transfer} event.\n */\n function _mint(address to, uint256 quantity) internal {\n uint256 startTokenId = _currentIndex;\n if (to == address(0)) revert MintToZeroAddress();\n if (quantity == 0) revert MintZeroQuantity();\n\n _beforeTokenTransfers(address(0), to, startTokenId, quantity);\n\n // Overflows are incredibly unrealistic.\n // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1\n // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1\n unchecked {\n _addressData[to].balance += uint64(quantity);\n _addressData[to].numberMinted += uint64(quantity);\n\n _ownerships[startTokenId].addr = to;\n _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);\n\n uint256 updatedIndex = startTokenId;\n uint256 end = updatedIndex + quantity;\n\n do {\n emit Transfer(address(0), to, updatedIndex++);\n } while (updatedIndex < end);\n\n _currentIndex = updatedIndex;\n }\n _afterTokenTransfers(address(0), to, startTokenId, quantity);\n }\n\n /**\n * @dev Transfers `tokenId` from `from` to `to`.\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 ) private {\n TokenOwnership memory prevOwnership = _ownershipOf(tokenId);\n\n if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();\n\n bool isApprovedOrOwner = (_msgSender() == from ||\n isApprovedForAll(from, _msgSender()) ||\n getApproved(tokenId) == _msgSender());\n\n if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();\n if (to == address(0)) revert TransferToZeroAddress();\n\n _beforeTokenTransfers(from, to, tokenId, 1);\n\n // Clear approvals from the previous owner\n _approve(address(0), tokenId, from);\n\n // Underflow of the sender's balance is impossible because we check for\n // ownership above and the recipient's balance can't realistically overflow.\n // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.\n unchecked {\n _addressData[from].balance -= 1;\n _addressData[to].balance += 1;\n\n TokenOwnership storage currSlot = _ownerships[tokenId];\n currSlot.addr = to;\n currSlot.startTimestamp = uint64(block.timestamp);\n\n // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.\n // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.\n uint256 nextTokenId = tokenId + 1;\n TokenOwnership storage nextSlot = _ownerships[nextTokenId];\n if (nextSlot.addr == address(0)) {\n // This will suffice for checking _exists(nextTokenId),\n // as a burned slot cannot contain the zero address.\n if (nextTokenId != _currentIndex) {\n nextSlot.addr = from;\n nextSlot.startTimestamp = prevOwnership.startTimestamp;\n }\n }\n }\n\n emit Transfer(from, to, tokenId);\n _afterTokenTransfers(from, to, tokenId, 1);\n }\n\n /**\n * @dev Equivalent to `_burn(tokenId, false)`.\n */\n function _burn(uint256 tokenId) internal virtual {\n _burn(tokenId, false);\n }\n\n /**\n * @dev Destroys `tokenId`.\n * The approval is cleared when the token is burned.\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n *\n * Emits a {Transfer} event.\n */\n function _burn(uint256 tokenId, bool approvalCheck) internal virtual {\n TokenOwnership memory prevOwnership = _ownershipOf(tokenId);\n\n address from = prevOwnership.addr;\n\n if (approvalCheck) {\n bool isApprovedOrOwner = (_msgSender() == from ||\n isApprovedForAll(from, _msgSender()) ||\n getApproved(tokenId) == _msgSender());\n\n if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();\n }\n\n _beforeTokenTransfers(from, address(0), tokenId, 1);\n\n // Clear approvals from the previous owner\n _approve(address(0), tokenId, from);\n\n // Underflow of the sender's balance is impossible because we check for\n // ownership above and the recipient's balance can't realistically overflow.\n // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.\n unchecked {\n AddressData storage addressData = _addressData[from];\n addressData.balance -= 1;\n addressData.numberBurned += 1;\n\n // Keep track of who burned the token, and the timestamp of burning.\n TokenOwnership storage currSlot = _ownerships[tokenId];\n currSlot.addr = from;\n currSlot.startTimestamp = uint64(block.timestamp);\n currSlot.burned = true;\n\n // If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.\n // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.\n uint256 nextTokenId = tokenId + 1;\n TokenOwnership storage nextSlot = _ownerships[nextTokenId];\n if (nextSlot.addr == address(0)) {\n // This will suffice for checking _exists(nextTokenId),\n // as a burned slot cannot contain the zero address.\n if (nextTokenId != _currentIndex) {\n nextSlot.addr = from;\n nextSlot.startTimestamp = prevOwnership.startTimestamp;\n }\n }\n }\n\n emit Transfer(from, address(0), tokenId);\n _afterTokenTransfers(from, address(0), tokenId, 1);\n\n // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.\n unchecked {\n _burnCounter++;\n }\n }\n\n /**\n * @dev Approve `to` to operate on `tokenId`\n *\n * Emits a {Approval} event.\n */\n function _approve(\n address to,\n uint256 tokenId,\n address owner\n ) private {\n _tokenApprovals[tokenId] = to;\n emit Approval(owner, to, tokenId);\n }\n\n /**\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target 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 _checkContractOnERC721Received(\n address from,\n address to,\n uint256 tokenId,\n bytes memory _data\n ) private returns (bool) {\n try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {\n return retval == IERC721ReceiverUpgradeable(to).onERC721Received.selector;\n } catch (bytes memory reason) {\n if (reason.length == 0) {\n revert TransferToNonERC721ReceiverImplementer();\n } else {\n assembly {\n revert(add(32, reason), mload(reason))\n }\n }\n }\n }\n\n /**\n * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.\n * And also called before burning one token.\n *\n * startTokenId - the first token id to be transferred\n * quantity - the amount to be transferred\n *\n * Calling conditions:\n *\n * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be\n * transferred to `to`.\n * - When `from` is zero, `tokenId` will be minted for `to`.\n * - When `to` is zero, `tokenId` will be burned by `from`.\n * - `from` and `to` are never both zero.\n */\n function _beforeTokenTransfers(\n address from,\n address to,\n uint256 startTokenId,\n uint256 quantity\n ) internal virtual {}\n\n /**\n * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes\n * minting.\n * And also called after one token has been burned.\n *\n * startTokenId - the first token id to be transferred\n * quantity - the amount to be transferred\n *\n * Calling conditions:\n *\n * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been\n * transferred to `to`.\n * - When `from` is zero, `tokenId` has been minted for `to`.\n * - When `to` is zero, `tokenId` has been burned by `from`.\n * - `from` and `to` are never both zero.\n */\n function _afterTokenTransfers(\n address from,\n address to,\n uint256 startTokenId,\n uint256 quantity\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[42] private __gap;\n}\n" }, "node_modules/erc721a-upgradeable/contracts/IERC721AUpgradeable.sol": { "content": "// SPDX-License-Identifier: MIT\n// ERC721A Contracts v3.3.0\n// Creator: Chiru Labs\n\npragma solidity ^0.8.4;\n\nimport \"@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\";\n\n/**\n * @dev Interface of an ERC721A compliant contract.\n */\ninterface IERC721AUpgradeable is IERC721Upgradeable, IERC721MetadataUpgradeable {\n /**\n * The caller must own the token or be an approved operator.\n */\n error ApprovalCallerNotOwnerNorApproved();\n\n /**\n * The token does not exist.\n */\n error ApprovalQueryForNonexistentToken();\n\n /**\n * The caller cannot approve to their own address.\n */\n error ApproveToCaller();\n\n /**\n * The caller cannot approve to the current owner.\n */\n error ApprovalToCurrentOwner();\n\n /**\n * Cannot query the balance for the zero address.\n */\n error BalanceQueryForZeroAddress();\n\n /**\n * Cannot mint to the zero address.\n */\n error MintToZeroAddress();\n\n /**\n * The quantity of tokens minted must be more than zero.\n */\n error MintZeroQuantity();\n\n /**\n * The token does not exist.\n */\n error OwnerQueryForNonexistentToken();\n\n /**\n * The caller must own the token or be an approved operator.\n */\n error TransferCallerNotOwnerNorApproved();\n\n /**\n * The token must be owned by `from`.\n */\n error TransferFromIncorrectOwner();\n\n /**\n * Cannot safely transfer to a contract that does not implement the ERC721Receiver interface.\n */\n error TransferToNonERC721ReceiverImplementer();\n\n /**\n * Cannot transfer to the zero address.\n */\n error TransferToZeroAddress();\n\n /**\n * The token does not exist.\n */\n error URIQueryForNonexistentToken();\n\n // Compiler will pack this into a single 256bit word.\n struct TokenOwnership {\n // The address of the owner.\n address addr;\n // Keeps track of the start time of ownership with minimal overhead for tokenomics.\n uint64 startTimestamp;\n // Whether the token has been burned.\n bool burned;\n }\n\n // Compiler will pack this into a single 256bit word.\n struct AddressData {\n // Realistically, 2**64-1 is more than enough.\n uint64 balance;\n // Keeps track of mint count with minimal overhead for tokenomics.\n uint64 numberMinted;\n // Keeps track of burn count with minimal overhead for tokenomics.\n uint64 numberBurned;\n // For miscellaneous variable(s) pertaining to the address\n // (e.g. number of whitelist mint slots used).\n // If there are multiple variables, please pack them into a uint64.\n uint64 aux;\n }\n\n /**\n * @dev Returns the total amount of tokens stored by the contract.\n * \n * Burned tokens are calculated here, use `_totalMinted()` if you want to count just minted tokens.\n */\n function totalSupply() external view returns (uint256);\n}\n" } }, "settings": { "remappings": [ "@openzeppelin/=node_modules/@openzeppelin/", "ds-test/=lib/forge-std/lib/ds-test/src/", "erc721a-upgradeable/=node_modules/erc721a-upgradeable/", "eth-gas-reporter/=node_modules/eth-gas-reporter/", "forge-std/=lib/forge-std/src/", "hardhat/=node_modules/hardhat/" ], "optimizer": { "enabled": true, "runs": 200 }, "metadata": { "bytecodeHash": "ipfs" }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "london", "libraries": {} } }