Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";

/**
 * @title ERC721Whitelisted
 * @dev ERC721 contract with multiple sale rounds and whitelists.
 */
contract ERC721Whitelisted is ERC721, ERC721Burnable, Ownable {
    error InvalidArrayLength();
    error OnlyAdminMinter();
    error AlreadyMintedForAddress();
    error InvalidMerkleProof();
    error MintLimitReached();
    error WrongTimeForGuaranteedRound();
    error WrongTimeForFCFSRound();
    error WrongTimeForPublicRound();

    /**
     * @dev Time parameters for the sale rounds.
     * @param startTime Start time of the round.
     * @param endTime End time of the round.
     */
    struct TimeParams {
        uint128 startTime;
        uint128 endTime;
    }

    /// Time parameters for the guaranteed round.
    TimeParams public guaranteedRound;
    /// Time parameters for the FCFS round.
    TimeParams public fcfsRound;

    /// Start time of the public round.
    uint256 public publicRoundStartTime;
    /// Total general minted tokens.
    uint256 public generalUsedMints;
    /// Maximum number of tokens that can be minted by general users (non-admins).
    uint256 public immutable mintLimitGeneral;

    /// Merkle root for the whitelist.
    bytes32 public merkleRootGuaranteed;
    /// Merkle root for the whitelist.
    bytes32 public merkleRootFCFS;

    /// Next token id to be minted
    uint256 private _nextTokenId;
    /// Base URI for the token metadata
    string private _baseTokenURI;

    /// Mapping of addresses to minted status
    mapping(address => bool) private _guaranteedMinted;
    /// Mapping of addresses to minted status
    mapping(address => bool) private _fcfsMinted;
    /// Mapping of addresses to mint amounts
    mapping(address => uint256) private _adminMintAmounts;
    /// Mapping of addresses to used mint amounts
    mapping(address => uint256) private _adminUsedMints;

    constructor(
        string memory name,
        string memory symbol,
        string memory baseTokenURI,
        TimeParams memory guaranteedTimeParams,
        TimeParams memory fcfsTimeParams,
        uint256 _publicRoundStartTime,
        uint256 _mintLimit,
        address[] memory adminAddresses,
        uint256[] memory adminMintAmounts
    ) ERC721(name, symbol) Ownable(msg.sender) {
        if (adminAddresses.length != adminMintAmounts.length) revert InvalidArrayLength();

        _baseTokenURI = baseTokenURI;
        guaranteedRound = guaranteedTimeParams;
        fcfsRound = fcfsTimeParams;
        publicRoundStartTime = _publicRoundStartTime;
        mintLimitGeneral = _mintLimit;

        for (uint256 i = 0; i < adminAddresses.length; i++) {
            _adminMintAmounts[adminAddresses[i]] = adminMintAmounts[i];
        }
    }

    /**
     * @dev Sets the time parameters for the guaranteed round.
     * @param startTime Start time of the round.
     * @param endTime End time of the round.
     */
    function setGuaranteedRoundTimeParams(uint128 startTime, uint128 endTime) external onlyOwner {
        guaranteedRound.startTime = startTime;
        guaranteedRound.endTime = endTime;
    }

    /**
     * @dev Sets the time parameters for the FCFS round.
     * @param startTime Start time of the round.
     * @param endTime End time of the round.
     */
    function setFCFSRoundTimeParams(uint128 startTime, uint128 endTime) external onlyOwner {
        fcfsRound.startTime = startTime;
        fcfsRound.endTime = endTime;
    }

    /**
     * @dev Sets the public round start time.
     * @param _publicRoundStartTime Start time of the round.
     */
    function setPublicRoundStartTime(uint256 _publicRoundStartTime) external onlyOwner {
        publicRoundStartTime = _publicRoundStartTime;
    }

    /**
     * @dev Set the merkle root for the guaranteed round whitelist.
     * @param _merkleRoot Merkle root to set.
     */
    function setMerkleRootForGuaranteedRound(bytes32 _merkleRoot) external onlyOwner {
        merkleRootGuaranteed = _merkleRoot;
    }

    /**
     * @dev Set the merkle root for the FCFS round whitelist.
     * @param _merkleRoot Merkle root to set.
     */
    function setMerkleRootForFCFSRound(bytes32 _merkleRoot) external onlyOwner {
        merkleRootFCFS = _merkleRoot;
    }

    /**
     * @dev Mint a token for the admin.
     * @param addressList List of addresses to mint to.
     */
    function safeMintAdmin(address[] calldata addressList) external {
        if (_adminMintAmounts[msg.sender] == 0) revert OnlyAdminMinter();
        uint256 listLength = addressList.length;
        if (_adminUsedMints[msg.sender] + listLength > _adminMintAmounts[msg.sender]) revert MintLimitReached();
        _adminUsedMints[msg.sender] += listLength;

        uint256 tokenId = _nextTokenId;
        _nextTokenId += listLength;
        for (uint256 i = 0; i < listLength; i++) {
            _safeMint(addressList[i], tokenId + i);
        }
    }

    /**
     * @dev Mint a token for the function caller on the guaranteed round.
     * @param proof Merkle proof to verify.
     */
    function safeMintGuaranteedRound(bytes32[] calldata proof) external {
        if (!_verifyMerkleProof(proof, merkleRootGuaranteed, msg.sender)) revert InvalidMerkleProof();
        if (block.timestamp < guaranteedRound.startTime || block.timestamp > guaranteedRound.endTime)
            revert WrongTimeForGuaranteedRound();
        if (_guaranteedMinted[msg.sender]) revert AlreadyMintedForAddress();

        _guaranteedMinted[msg.sender] = true;

        _safeMintGeneral(msg.sender);
    }

    /**
     * @dev Mint a token for the function caller on the FCFS round.
     * @param proof Merkle proof to verify.
     */
    function safeMintFCFSRound(bytes32[] calldata proof) external {
        if (!_verifyMerkleProof(proof, merkleRootFCFS, msg.sender)) revert InvalidMerkleProof();
        if (block.timestamp < fcfsRound.startTime || block.timestamp > fcfsRound.endTime)
            revert WrongTimeForFCFSRound();
        if (_fcfsMinted[msg.sender]) revert AlreadyMintedForAddress();

        _fcfsMinted[msg.sender] = true;

        _safeMintGeneral(msg.sender);
    }

    /**
     * @dev Mint a token for the function caller on the public round.
     */
    function safeMintPublicRound() external {
        if (block.timestamp < publicRoundStartTime) revert WrongTimeForPublicRound();

        _safeMintGeneral(msg.sender);
    }

    /**
     * @dev Mint a token to the given address.
     * @param to Address to mint the token to.
     */
    function _safeMintGeneral(address to) private {
        if (generalUsedMints >= mintLimitGeneral) revert MintLimitReached();
        generalUsedMints++;
        uint256 tokenId = _nextTokenId++;

        _safeMint(to, tokenId);
    }

    /**
     * @dev See {IERC721-_baseURI}.
     */
    function _baseURI() internal view override returns (string memory) {
        return _baseTokenURI;
    }

    /**
     * @dev Verify the merkle proof for the given address.
     * @param proof Merkle proof to verify.
     * @param addressToVerify Address to verify.
     */
    function _verifyMerkleProof(
        bytes32[] calldata proof,
        bytes32 merkleRoot,
        address addressToVerify
    ) private pure returns (bool) {
        bytes32 leaf = keccak256(abi.encodePacked(addressToVerify));

        return MerkleProof.verifyCalldata(proof, merkleRoot, leaf);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.20;

import {IERC721} from "./IERC721.sol";
import {IERC721Receiver} from "./IERC721Receiver.sol";
import {IERC721Metadata} from "./extensions/IERC721Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {Strings} from "../../utils/Strings.sol";
import {IERC165, ERC165} from "../../utils/introspection/ERC165.sol";
import {IERC721Errors} from "../../interfaces/draft-IERC6093.sol";

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    mapping(uint256 tokenId => address) private _owners;

    mapping(address owner => uint256) private _balances;

    mapping(uint256 tokenId => address) private _tokenApprovals;

    mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual returns (uint256) {
        if (owner == address(0)) {
            revert ERC721InvalidOwner(address(0));
        }
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual returns (address) {
        return _requireOwned(tokenId);
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
        _requireOwned(tokenId);

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual {
        _approve(to, tokenId, _msgSender());
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual returns (address) {
        _requireOwned(tokenId);

        return _getApproved(tokenId);
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
        address previousOwner = _update(to, tokenId, _msgSender());
        if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {
        transferFrom(from, to, tokenId);
        _checkOnERC721Received(from, to, tokenId, data);
    }

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     *
     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the
     * core ERC721 logic MUST be matched with the use of {_increaseBalance} to keep balances
     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by
     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.
     */
    function _getApproved(uint256 tokenId) internal view virtual returns (address) {
        return _tokenApprovals[tokenId];
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in
     * particular (ignoring whether it is owned by `owner`).
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {
        return
            spender != address(0) &&
            (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);
    }

    /**
     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.
     * Reverts if `spender` does not have approval from the provided `owner` for the given token or for all its assets
     * the `spender` for the specific `tokenId`.
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {
        if (!_isAuthorized(owner, spender, tokenId)) {
            if (owner == address(0)) {
                revert ERC721NonexistentToken(tokenId);
            } else {
                revert ERC721InsufficientApproval(spender, tokenId);
            }
        }
    }

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that
     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.
     *
     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the
     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership
     * remain consistent with one another.
     */
    function _increaseBalance(address account, uint128 value) internal virtual {
        unchecked {
            _balances[account] += value;
        }
    }

    /**
     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner
     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that
     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).
     *
     * Emits a {Transfer} event.
     *
     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.
     */
    function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {
        address from = _ownerOf(tokenId);

        // Perform (optional) operator check
        if (auth != address(0)) {
            _checkAuthorized(from, auth, tokenId);
        }

        // Execute the update
        if (from != address(0)) {
            // Clear approval. No need to re-authorize or emit the Approval event
            _approve(address(0), tokenId, address(0), false);

            unchecked {
                _balances[from] -= 1;
            }
        }

        if (to != address(0)) {
            unchecked {
                _balances[to] += 1;
            }
        }

        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        return from;
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner != address(0)) {
            revert ERC721InvalidSender(address(0));
        }
    }

    /**
     * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
        _mint(to, tokenId);
        _checkOnERC721Received(address(0), to, tokenId, data);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal {
        address previousOwner = _update(address(0), tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) internal {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        } else if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients
     * are aware of the ERC721 standard to prevent tokens from being forever locked.
     *
     * `data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is like {safeTransferFrom} in the sense that it invokes
     * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `tokenId` token must exist and be owned by `from`.
     * - `to` cannot be the zero address.
     * - `from` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(address from, address to, uint256 tokenId) internal {
        _safeTransfer(from, to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
        _transfer(from, to, tokenId);
        _checkOnERC721Received(from, to, tokenId, data);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is
     * either the owner of the token, or approved to operate on all tokens held by this owner.
     *
     * Emits an {Approval} event.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address to, uint256 tokenId, address auth) internal {
        _approve(to, tokenId, auth, true);
    }

    /**
     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not
     * emitted in the context of transfers.
     */
    function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {
        // Avoid reading the owner unless necessary
        if (emitEvent || auth != address(0)) {
            address owner = _requireOwned(tokenId);

            // We do not use _isAuthorized because single-token approvals should not be able to call approve
            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {
                revert ERC721InvalidApprover(auth);
            }

            if (emitEvent) {
                emit Approval(owner, to, tokenId);
            }
        }

        _tokenApprovals[tokenId] = to;
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Requirements:
     * - operator can't be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        if (operator == address(0)) {
            revert ERC721InvalidOperator(operator);
        }
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).
     * Returns the owner.
     *
     * Overrides to ownership logic should be done to {_ownerOf}.
     */
    function _requireOwned(uint256 tokenId) internal view returns (address) {
        address owner = _ownerOf(tokenId);
        if (owner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
        return owner;
    }

    /**
     * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target address. This will revert if the
     * recipient doesn't accept the token transfer. The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param data bytes optional data to send along with the call
     */
    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private {
        if (to.code.length > 0) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
                if (retval != IERC721Receiver.onERC721Received.selector) {
                    revert ERC721InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert ERC721InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/ERC721Burnable.sol)

pragma solidity ^0.8.20;

import {ERC721} from "../ERC721.sol";
import {Context} from "../../../utils/Context.sol";

/**
 * @title ERC721 Burnable Token
 * @dev ERC721 Token that can be burned (destroyed).
 */
abstract contract ERC721Burnable is Context, ERC721 {
    /**
     * @dev Burns `tokenId`. See {ERC721-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) public virtual {
        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
        _update(address(0), tokenId, _msgSender());
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.20;

import {IERC721} from "../IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or
     *   {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.20;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be
     * reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.20;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the Merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates Merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     *@dev The multiproof provided is not valid.
     */
    error MerkleProofInvalidMultiproof();

    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     */
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Sorts the pair (a, b) and hashes the result.
     */
    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    /**
     * @dev Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory.
     */
    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

import {IERC165} from "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)

pragma solidity ^0.8.20;

import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant HEX_DIGITS = "0123456789abcdef";
    uint8 private constant ADDRESS_LENGTH = 20;

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
     * representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

{
  "metadata": {
    "bytecodeHash": "none",
    "useLiteralContent": true
  },
  "optimizer": {
    "enabled": false,
    "runs": 800
  },
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"string","name":"baseTokenURI","type":"string"},{"components":[{"internalType":"uint128","name":"startTime","type":"uint128"},{"internalType":"uint128","name":"endTime","type":"uint128"}],"internalType":"struct ERC721Whitelisted.TimeParams","name":"guaranteedTimeParams","type":"tuple"},{"components":[{"internalType":"uint128","name":"startTime","type":"uint128"},{"internalType":"uint128","name":"endTime","type":"uint128"}],"internalType":"struct ERC721Whitelisted.TimeParams","name":"fcfsTimeParams","type":"tuple"},{"internalType":"uint256","name":"_publicRoundStartTime","type":"uint256"},{"internalType":"uint256","name":"_mintLimit","type":"uint256"},{"internalType":"address[]","name":"adminAddresses","type":"address[]"},{"internalType":"uint256[]","name":"adminMintAmounts","type":"uint256[]"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyMintedForAddress","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721IncorrectOwner","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721InsufficientApproval","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC721InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC721InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721InvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC721InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC721InvalidSender","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721NonexistentToken","type":"error"},{"inputs":[],"name":"InvalidArrayLength","type":"error"},{"inputs":[],"name":"InvalidMerkleProof","type":"error"},{"inputs":[],"name":"MintLimitReached","type":"error"},{"inputs":[],"name":"OnlyAdminMinter","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"WrongTimeForFCFSRound","type":"error"},{"inputs":[],"name":"WrongTimeForGuaranteedRound","type":"error"},{"inputs":[],"name":"WrongTimeForPublicRound","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"fcfsRound","outputs":[{"internalType":"uint128","name":"startTime","type":"uint128"},{"internalType":"uint128","name":"endTime","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"generalUsedMints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"guaranteedRound","outputs":[{"internalType":"uint128","name":"startTime","type":"uint128"},{"internalType":"uint128","name":"endTime","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRootFCFS","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRootGuaranteed","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintLimitGeneral","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicRoundStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"addressList","type":"address[]"}],"name":"safeMintAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"safeMintFCFSRound","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"safeMintGuaranteedRound","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"safeMintPublicRound","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"startTime","type":"uint128"},{"internalType":"uint128","name":"endTime","type":"uint128"}],"name":"setFCFSRoundTimeParams","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"startTime","type":"uint128"},{"internalType":"uint128","name":"endTime","type":"uint128"}],"name":"setGuaranteedRoundTimeParams","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setMerkleRootForFCFSRound","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setMerkleRootForGuaranteedRound","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_publicRoundStartTime","type":"uint256"}],"name":"setPublicRoundStartTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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