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.17;

import "erc721psi/contracts/extension/ERC721PsiBurnable.sol";
import "./ArchOfPeaceEntropy.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";

import "fpe-map/contracts/FPEMap.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

                                /*░└╬┘░*\
             ░      ░█░┘────════════╩════════────└╩┘──
                ▒  ▒█ ████████████████████████████████
              ▒█  ═════════════╗░░▒▒▒▒▒░░╔═════════════
            ▒   ▒ █▒▒▒░░░░▒▒▒░░╚═════════╝░░▒▒▒░░░░░░▒
             ░ █▒  █ ███████████░░░▒▒▒░░░█████████████
                █  ░╦░     ╦╦╦ ╚█████████╝ ╦╦╦     ╦╦╦
                   │▒│░░▒▒▒│█│░▒▒▒░░ ░░▒▒▒░│█│▒▒▒░░│█│
                 ▒ │█│─────│█│─═▒░╔═╩═╗░▒══│█│═════│█│═
                   │█│░▒▒░░│█│▒░┌┘'   '╚╗░▒│█│░░▒▒░│█│
                   │▒│▒▒░ ░│█│░┌┘ \┌┴┐/ ╚╗░│█│░ ░▒▒│█│
                     │▒░┌┴░│█│░│  ┘   └┐ ║░│█│╔╩╗░▒│█│
                   │▒│▒┌┘\ │█│░│       └┐║░│█│╝/╚╗▒│█│
                 █ │█│▒│┌┘ │█│ │        │║▒│█│ └┐║▒│█│
              █ ▒  ╩╩╩▒││  ╩╩╩░│    ░   │║▒╩╩╩  │║▒╩╩╩
             ░  █ ▒███▒││ ████▒│   ░░░  │║▒████ │║▒████
           ░  ▒█ ▒██▒█▒││ ████▒│  ░░░░░ │║▒████ │║▒████
     __  __  ___ ▒█▒▒█▒││ ██▒░▒│ ░░░▒░░░│║▒████_│║▒████_____________________
    |  \/  |/ _ \█ \░▒ |│ ▒█ |\ \░░▒▒▒░░/ /__  ____/__  __ \_  ___/__  ____/
    | |\/| | | | |  \▒ |│ ░▒ | \ ░▒▒▒▒▒░ /__  __/  __  /_/ /____ \__  __/
    | |  | | |_| | |\  | \_░ |  \ ▒▒█▒▒ /__  /___  _  _, _/____/ /_  /___
    |_|  |_|\___/|_| \_|\___/    \ ███ /  /_____/  /_/ |_| /____/ /_____/
                                  \ █ /
                      ▒██ ████╗ ███████╗██████╗ 
                        ██╔══██╗██╔════╝██╔══██╗
                      ░█ █████╔╝█████╗  ██████╔╝
                         █╔═══╝ ██╔══╝  ██╔═══╝ 
                        ██║     ██║     ██║     
                        ╚*╝     ╚═/     ╚*/

/**
 * @title Monuverse PFP – Airdrop
 * @author Maxim Gaina
 *
 * @notice PFP Monuverse Airdrop Contract with
 * @notice O(1) fully decentralized and unpredictable reveal.
 */
contract MonuversePFP is ArchOfPeaceEntropy, ERC721PsiBurnable, DefaultOperatorFilterer {
    using FPEMap for uint256;
    using Strings for uint256;

    uint256 private _maxSupply;

    string private _pfpVeilURI;
    string private _pfpBaseURI;

    uint256 private constant _deterministicTokens = 4;

    constructor(
        uint256 maxSupply_,
        string memory name_,
        string memory symbol_,
        string memory archVeilURI_,
        string memory archBaseURI_,
        address vrfCoordinator_,
        bytes32 vrfGasLane_,
        uint64 vrfSubscriptionId_
    )
        ArchOfPeaceEntropy(vrfCoordinator_, vrfGasLane_, vrfSubscriptionId_)
        ERC721Psi(name_, symbol_)
    {
        _maxSupply = maxSupply_;
        _pfpVeilURI = archVeilURI_;
        _pfpBaseURI = archBaseURI_;
    }

    function airdrop(address receiver, uint256 quantity) external onlyOwner {
        require(entropy() == 0, "MonuversePFP: already revealed");
        require(_minted + quantity <= _maxSupply, "MonuversePFP: exceeding supply");

        _mint(receiver, quantity);
    }

    /**
     * @notice Reveals the entire collection when call effects are successful.
     *
     * @dev Requests a random seed that will be fulfilled in the future;
     * @dev seed will be used to randomly map token ids to metadata ids;
     * @dev callable only once in the entire Episode (i.e. collection lifecycle),
     * @dev that is, if seed is still default value and not waiting for any request;
     * @dev callable by anyone at any moment only during Reveal Chapter.
     */
    function reveal() public {
        require(entropy() == 0, "MonuversePFP: already revealed");
        require(!fulfilling(), "MonuversePFP: currently fulfilling");

        _requestRandomWord();
    }

    function burn(uint256 tokenId) public {
        require(_exists(tokenId), "MonuversePFP: non existent token");
        require(
            _msgSender() == ownerOf(tokenId) || _msgSender() == owner(),
            "MonuversePFP: sender not token owner"
        );

        super._burn(tokenId);
    }

    /**
     * @notice Obtains mapped URI for an existing token.
     * @param tokenId existing token ID.
     *
     * @dev Pre-reveal all tokens are mapped to the same `_VeilURI`;
     * @dev post-reveal each token is unpredictably mapped to its own URI;
     * @dev post-reveal is when VRFCoordinatorV2 has successfully fulfilled random word request;
     * @dev exception are the last `_deterministicTokens` which URI are indeed, pre-decided.
     *
     * @return metadataURI token URI string
     */
    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        require(_exists(tokenId), "MonuversePFP: non existent token");

        if (entropy() == 0) {
            return _pfpVeilURI;
        } else if (tokenId > (_maxSupply - _deterministicTokens - 1)) {
            return string(abi.encodePacked(_pfpBaseURI, "/", tokenId.toString()));
        } else {
            return
                string(
                    abi.encodePacked(
                        _pfpBaseURI,
                        "/",
                        tokenId
                            .fpeMappingFeistelAuto(entropy(), _maxSupply - _deterministicTokens)
                            .toString()
                    )
                );
        }
    }

    function setApprovalForAll(
        address operator,
        bool approved
    ) public override onlyAllowedOperatorApproval(operator) {
        super.setApprovalForAll(operator, approved);
    }

    function approve(
        address operator,
        uint256 tokenId
    ) public override onlyAllowedOperatorApproval(operator) {
        super.approve(operator, tokenId);
    }

    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public override onlyAllowedOperator(from) {
        super.transferFrom(from, to, tokenId);
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public override onlyAllowedOperator(from) {
        super.safeTransferFrom(from, to, tokenId);
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) public override onlyAllowedOperator(from) {
        super.safeTransferFrom(from, to, tokenId, data);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

import "@openzeppelin/contracts/access/Ownable.sol";

import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";

contract ArchOfPeaceEntropy is VRFConsumerBaseV2, Ownable {
    VRFCoordinatorV2Interface private immutable _coordinator;

    struct VRFRequestParams {
        bytes32 gasLane;
        uint64 subscriptionId;
        uint16 requestConfirmations;
        uint32 callbackGasLimit;
    }

    VRFRequestParams private _vrfRequestParams;

    bool private _fulfilling;

    uint256 private _entropy;

    event RandomnessRequested(uint256 requestId);

    constructor(
        address coordinator_,
        bytes32 gasLane_,
        uint64 subscriptionId_
    ) VRFConsumerBaseV2(coordinator_) {
        _coordinator = VRFCoordinatorV2Interface(coordinator_);
        _vrfRequestParams = VRFRequestParams(gasLane_, subscriptionId_, 5, 300000);
    }

    /// @notice Assumes the subscription is set sufficiently funded
    function _requestRandomWord() internal {
        uint256 requestId = _coordinator.requestRandomWords(
            _vrfRequestParams.gasLane,
            _vrfRequestParams.subscriptionId,
            _vrfRequestParams.requestConfirmations,
            _vrfRequestParams.callbackGasLimit,
            1
        );

        _fulfilling = true;

        emit RandomnessRequested(requestId);
    }

    function fulfillRandomWords(
        uint256, /* requestId */
        uint256[] memory randomWords
    ) internal override {
        _entropy = randomWords[0];

        _fulfilling = false;
    }

    // TODO: cover
    function updateVRFParams(VRFRequestParams calldata newParams) public onlyOwner {
        _vrfRequestParams = newParams;
    }

    function fulfilling() public view returns (bool) {
        return _fulfilling;
    }

    function entropy() public view returns (uint256) {
        return _entropy;
    }
}

//SPDX-License-Identifier: MIT
/**

███████╗██████╗ ███████╗    ███╗   ███╗ █████╗ ██████╗ 
██╔════╝██╔══██╗██╔════╝    ████╗ ████║██╔══██╗██╔══██╗
█████╗  ██████╔╝█████╗█████╗██╔████╔██║███████║██████╔╝
██╔══╝  ██╔═══╝ ██╔══╝╚════╝██║╚██╔╝██║██╔══██║██╔═══╝ 
██║     ██║     ███████╗    ██║ ╚═╝ ██║██║  ██║██║     
╚═╝     ╚═╝     ╚══════╝    ╚═╝     ╚═╝╚═╝  ╚═╝╚═╝     
                                                       
github: https://github.com/estarriolvetch/fpe-mapping

 */

pragma solidity ^0.8.0;

import "solidity-bits/contracts/BitScan.sol";
import "./Feistel.sol";

library FPEMap {
    using Feistel for uint256;

    string constant DOMAIN_ERROR_MSG = "The FPE domain should be within the domain of the Fiestel network (domain <= 2 ** size)";
    string constant INPUT_OUTSIDE_DOMAIN_ERROR_MSG = "input is not within the domain";

    uint256 constant DEFAULT_ROUND = 3;

    function fpeMappingFeistel(uint256 input, uint256 key, uint256 round, uint256 size, uint256 domain) internal pure returns (uint256 output) {
        require(input < domain, INPUT_OUTSIDE_DOMAIN_ERROR_MSG);
        require(2 ** size >= domain, DOMAIN_ERROR_MSG);
        while(true) {
            output = input.feistel(key, round, size);
            if(output < domain) {
                break;
            } else {
                input = output;
            }
        }
    }

    function fpeMappingFeistelUnbalanced(uint256 input, uint256 key, uint256 round, uint256 size, uint256 domain) internal pure returns (uint256 output) {
        require(input < domain, INPUT_OUTSIDE_DOMAIN_ERROR_MSG);
        require(2 ** size >= domain, DOMAIN_ERROR_MSG);
        while(true) {
            output = input.feistelUnbalanced(key, round, size);
            if(output < domain) {
                break;
            } else {
                input = output;
            }
        }
    }

    function fpeMappingFeistelAuto(uint256 input, uint256 key, uint256 domain) internal pure returns (uint256 output) {
        require(input < domain, INPUT_OUTSIDE_DOMAIN_ERROR_MSG);
        uint256 size;

        // Calculate the smallest required block size of the unbalanced Feistel network
        unchecked {
            size = BitScan.log2(domain) + 1;    
        }
        
        while(true) {
            output = input.feistelUnbalanced(key, DEFAULT_ROUND, size);
            if(output < domain) {
                break;
            } else {
                input = output;
            }
        }
    }
}

// SPDX-License-Identifier: MIT
/**
  ______ _____   _____ ______ ___  __ _  _  _ 
 |  ____|  __ \ / ____|____  |__ \/_ | || || |
 | |__  | |__) | |        / /   ) || | \| |/ |
 |  __| |  _  /| |       / /   / / | |\_   _/ 
 | |____| | \ \| |____  / /   / /_ | |  | |   
 |______|_|  \_\\_____|/_/   |____||_|  |_|   
                                              
                                            
 */
pragma solidity ^0.8.0;

import "solidity-bits/contracts/BitMaps.sol";
import "../ERC721Psi.sol";


abstract contract ERC721PsiBurnable is ERC721Psi {
    using BitMaps for BitMaps.BitMap;
    BitMaps.BitMap private _burnedToken;

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address from = ownerOf(tokenId);
        _beforeTokenTransfers(from, address(0), tokenId, 1);
        _burnedToken.set(tokenId);
        
        emit Transfer(from, address(0), tokenId);

        _afterTokenTransfers(from, address(0), tokenId, 1);
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view override virtual returns (bool){
        if(_burnedToken.get(tokenId)) {
            return false;
        } 
        return super._exists(tokenId);
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _minted - _burned();
    }

    /**
     * @dev Returns number of token burned.
     */
    function _burned() internal view returns (uint256 burned){
        uint256 totalBucket = (_minted >> 8) + 1;

        for(uint256 i=0; i < totalBucket; i++) {
            uint256 bucket = _burnedToken.getBucket(i);
            burned += _popcount(bucket);
        }
    }

    /**
     * @dev Returns number of set bits.
     */
    function _popcount(uint256 x) private pure returns (uint256 count) {
        unchecked{
            for (count=0; x!=0; count++)
                x &= x - 1;
        }
    }
}

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

import {OperatorFilterer} from "./OperatorFilterer.sol";
import {CANONICAL_CORI_SUBSCRIPTION} from "./lib/Constants.sol";
/**
 * @title  DefaultOperatorFilterer
 * @notice Inherits from OperatorFilterer and automatically subscribes to the default OpenSea subscription.
 * @dev    Please note that if your token contract does not provide an owner with EIP-173, it must provide
 *         administration methods on the contract itself to interact with the registry otherwise the subscription
 *         will be locked to the options set during construction.
 */

abstract contract DefaultOperatorFilterer is OperatorFilterer {
    /// @dev The constructor that is called when the contract is being deployed.
    constructor() OperatorFilterer(CANONICAL_CORI_SUBSCRIPTION, true) {}
}

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

pragma solidity ^0.8.0;

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        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_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        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);
    }
}

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

pragma solidity ^0.8.0;

import "../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.
 *
 * By default, the owner account will be the one that deploys the contract. 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;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @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 {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing 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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _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
pragma solidity ^0.8.0;

interface VRFCoordinatorV2Interface {
  /**
   * @notice Get configuration relevant for making requests
   * @return minimumRequestConfirmations global min for request confirmations
   * @return maxGasLimit global max for request gas limit
   * @return s_provingKeyHashes list of registered key hashes
   */
  function getRequestConfig()
    external
    view
    returns (
      uint16,
      uint32,
      bytes32[] memory
    );

  /**
   * @notice Request a set of random words.
   * @param keyHash - Corresponds to a particular oracle job which uses
   * that key for generating the VRF proof. Different keyHash's have different gas price
   * ceilings, so you can select a specific one to bound your maximum per request cost.
   * @param subId  - The ID of the VRF subscription. Must be funded
   * with the minimum subscription balance required for the selected keyHash.
   * @param minimumRequestConfirmations - How many blocks you'd like the
   * oracle to wait before responding to the request. See SECURITY CONSIDERATIONS
   * for why you may want to request more. The acceptable range is
   * [minimumRequestBlockConfirmations, 200].
   * @param callbackGasLimit - How much gas you'd like to receive in your
   * fulfillRandomWords callback. Note that gasleft() inside fulfillRandomWords
   * may be slightly less than this amount because of gas used calling the function
   * (argument decoding etc.), so you may need to request slightly more than you expect
   * to have inside fulfillRandomWords. The acceptable range is
   * [0, maxGasLimit]
   * @param numWords - The number of uint256 random values you'd like to receive
   * in your fulfillRandomWords callback. Note these numbers are expanded in a
   * secure way by the VRFCoordinator from a single random value supplied by the oracle.
   * @return requestId - A unique identifier of the request. Can be used to match
   * a request to a response in fulfillRandomWords.
   */
  function requestRandomWords(
    bytes32 keyHash,
    uint64 subId,
    uint16 minimumRequestConfirmations,
    uint32 callbackGasLimit,
    uint32 numWords
  ) external returns (uint256 requestId);

  /**
   * @notice Create a VRF subscription.
   * @return subId - A unique subscription id.
   * @dev You can manage the consumer set dynamically with addConsumer/removeConsumer.
   * @dev Note to fund the subscription, use transferAndCall. For example
   * @dev  LINKTOKEN.transferAndCall(
   * @dev    address(COORDINATOR),
   * @dev    amount,
   * @dev    abi.encode(subId));
   */
  function createSubscription() external returns (uint64 subId);

  /**
   * @notice Get a VRF subscription.
   * @param subId - ID of the subscription
   * @return balance - LINK balance of the subscription in juels.
   * @return reqCount - number of requests for this subscription, determines fee tier.
   * @return owner - owner of the subscription.
   * @return consumers - list of consumer address which are able to use this subscription.
   */
  function getSubscription(uint64 subId)
    external
    view
    returns (
      uint96 balance,
      uint64 reqCount,
      address owner,
      address[] memory consumers
    );

  /**
   * @notice Request subscription owner transfer.
   * @param subId - ID of the subscription
   * @param newOwner - proposed new owner of the subscription
   */
  function requestSubscriptionOwnerTransfer(uint64 subId, address newOwner) external;

  /**
   * @notice Request subscription owner transfer.
   * @param subId - ID of the subscription
   * @dev will revert if original owner of subId has
   * not requested that msg.sender become the new owner.
   */
  function acceptSubscriptionOwnerTransfer(uint64 subId) external;

  /**
   * @notice Add a consumer to a VRF subscription.
   * @param subId - ID of the subscription
   * @param consumer - New consumer which can use the subscription
   */
  function addConsumer(uint64 subId, address consumer) external;

  /**
   * @notice Remove a consumer from a VRF subscription.
   * @param subId - ID of the subscription
   * @param consumer - Consumer to remove from the subscription
   */
  function removeConsumer(uint64 subId, address consumer) external;

  /**
   * @notice Cancel a subscription
   * @param subId - ID of the subscription
   * @param to - Where to send the remaining LINK to
   */
  function cancelSubscription(uint64 subId, address to) external;

  /*
   * @notice Check to see if there exists a request commitment consumers
   * for all consumers and keyhashes for a given sub.
   * @param subId - ID of the subscription
   * @return true if there exists at least one unfulfilled request for the subscription, false
   * otherwise.
   */
  function pendingRequestExists(uint64 subId) external view returns (bool);
}

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

/** ****************************************************************************
 * @notice Interface for contracts using VRF randomness
 * *****************************************************************************
 * @dev PURPOSE
 *
 * @dev Reggie the Random Oracle (not his real job) wants to provide randomness
 * @dev to Vera the verifier in such a way that Vera can be sure he's not
 * @dev making his output up to suit himself. Reggie provides Vera a public key
 * @dev to which he knows the secret key. Each time Vera provides a seed to
 * @dev Reggie, he gives back a value which is computed completely
 * @dev deterministically from the seed and the secret key.
 *
 * @dev Reggie provides a proof by which Vera can verify that the output was
 * @dev correctly computed once Reggie tells it to her, but without that proof,
 * @dev the output is indistinguishable to her from a uniform random sample
 * @dev from the output space.
 *
 * @dev The purpose of this contract is to make it easy for unrelated contracts
 * @dev to talk to Vera the verifier about the work Reggie is doing, to provide
 * @dev simple access to a verifiable source of randomness. It ensures 2 things:
 * @dev 1. The fulfillment came from the VRFCoordinator
 * @dev 2. The consumer contract implements fulfillRandomWords.
 * *****************************************************************************
 * @dev USAGE
 *
 * @dev Calling contracts must inherit from VRFConsumerBase, and can
 * @dev initialize VRFConsumerBase's attributes in their constructor as
 * @dev shown:
 *
 * @dev   contract VRFConsumer {
 * @dev     constructor(<other arguments>, address _vrfCoordinator, address _link)
 * @dev       VRFConsumerBase(_vrfCoordinator) public {
 * @dev         <initialization with other arguments goes here>
 * @dev       }
 * @dev   }
 *
 * @dev The oracle will have given you an ID for the VRF keypair they have
 * @dev committed to (let's call it keyHash). Create subscription, fund it
 * @dev and your consumer contract as a consumer of it (see VRFCoordinatorInterface
 * @dev subscription management functions).
 * @dev Call requestRandomWords(keyHash, subId, minimumRequestConfirmations,
 * @dev callbackGasLimit, numWords),
 * @dev see (VRFCoordinatorInterface for a description of the arguments).
 *
 * @dev Once the VRFCoordinator has received and validated the oracle's response
 * @dev to your request, it will call your contract's fulfillRandomWords method.
 *
 * @dev The randomness argument to fulfillRandomWords is a set of random words
 * @dev generated from your requestId and the blockHash of the request.
 *
 * @dev If your contract could have concurrent requests open, you can use the
 * @dev requestId returned from requestRandomWords to track which response is associated
 * @dev with which randomness request.
 * @dev See "SECURITY CONSIDERATIONS" for principles to keep in mind,
 * @dev if your contract could have multiple requests in flight simultaneously.
 *
 * @dev Colliding `requestId`s are cryptographically impossible as long as seeds
 * @dev differ.
 *
 * *****************************************************************************
 * @dev SECURITY CONSIDERATIONS
 *
 * @dev A method with the ability to call your fulfillRandomness method directly
 * @dev could spoof a VRF response with any random value, so it's critical that
 * @dev it cannot be directly called by anything other than this base contract
 * @dev (specifically, by the VRFConsumerBase.rawFulfillRandomness method).
 *
 * @dev For your users to trust that your contract's random behavior is free
 * @dev from malicious interference, it's best if you can write it so that all
 * @dev behaviors implied by a VRF response are executed *during* your
 * @dev fulfillRandomness method. If your contract must store the response (or
 * @dev anything derived from it) and use it later, you must ensure that any
 * @dev user-significant behavior which depends on that stored value cannot be
 * @dev manipulated by a subsequent VRF request.
 *
 * @dev Similarly, both miners and the VRF oracle itself have some influence
 * @dev over the order in which VRF responses appear on the blockchain, so if
 * @dev your contract could have multiple VRF requests in flight simultaneously,
 * @dev you must ensure that the order in which the VRF responses arrive cannot
 * @dev be used to manipulate your contract's user-significant behavior.
 *
 * @dev Since the block hash of the block which contains the requestRandomness
 * @dev call is mixed into the input to the VRF *last*, a sufficiently powerful
 * @dev miner could, in principle, fork the blockchain to evict the block
 * @dev containing the request, forcing the request to be included in a
 * @dev different block with a different hash, and therefore a different input
 * @dev to the VRF. However, such an attack would incur a substantial economic
 * @dev cost. This cost scales with the number of blocks the VRF oracle waits
 * @dev until it calls responds to a request. It is for this reason that
 * @dev that you can signal to an oracle you'd like them to wait longer before
 * @dev responding to the request (however this is not enforced in the contract
 * @dev and so remains effective only in the case of unmodified oracle software).
 */
abstract contract VRFConsumerBaseV2 {
  error OnlyCoordinatorCanFulfill(address have, address want);
  address private immutable vrfCoordinator;

  /**
   * @param _vrfCoordinator address of VRFCoordinator contract
   */
  constructor(address _vrfCoordinator) {
    vrfCoordinator = _vrfCoordinator;
  }

  /**
   * @notice fulfillRandomness handles the VRF response. Your contract must
   * @notice implement it. See "SECURITY CONSIDERATIONS" above for important
   * @notice principles to keep in mind when implementing your fulfillRandomness
   * @notice method.
   *
   * @dev VRFConsumerBaseV2 expects its subcontracts to have a method with this
   * @dev signature, and will call it once it has verified the proof
   * @dev associated with the randomness. (It is triggered via a call to
   * @dev rawFulfillRandomness, below.)
   *
   * @param requestId The Id initially returned by requestRandomness
   * @param randomWords the VRF output expanded to the requested number of words
   */
  function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) internal virtual;

  // rawFulfillRandomness is called by VRFCoordinator when it receives a valid VRF
  // proof. rawFulfillRandomness then calls fulfillRandomness, after validating
  // the origin of the call
  function rawFulfillRandomWords(uint256 requestId, uint256[] memory randomWords) external {
    if (msg.sender != vrfCoordinator) {
      revert OnlyCoordinatorCanFulfill(msg.sender, vrfCoordinator);
    }
    fulfillRandomWords(requestId, randomWords);
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @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;
    }
}

// SPDX-License-Identifier: MIT
/**
   _____       ___     ___ __           ____  _ __      
  / ___/____  / (_)___/ (_) /___  __   / __ )(_) /______
  \__ \/ __ \/ / / __  / / __/ / / /  / __  / / __/ ___/
 ___/ / /_/ / / / /_/ / / /_/ /_/ /  / /_/ / / /_(__  ) 
/____/\____/_/_/\__,_/_/\__/\__, /  /_____/_/\__/____/  
                           /____/                        

- npm: https://www.npmjs.com/package/solidity-bits
- github: https://github.com/estarriolvetch/solidity-bits

 */

pragma solidity ^0.8.0;


library BitScan {
    uint256 constant private DEBRUIJN_256 = 0x818283848586878898a8b8c8d8e8f929395969799a9b9d9e9faaeb6bedeeff;
    bytes constant private LOOKUP_TABLE_256 = hex"0001020903110a19042112290b311a3905412245134d2a550c5d32651b6d3a7506264262237d468514804e8d2b95569d0d495ea533a966b11c886eb93bc176c9071727374353637324837e9b47af86c7155181ad4fd18ed32c9096db57d59ee30e2e4a6a5f92a6be3498aae067ddb2eb1d5989b56fd7baf33ca0c2ee77e5caf7ff0810182028303840444c545c646c7425617c847f8c949c48a4a8b087b8c0c816365272829aaec650acd0d28fdad4e22d6991bd97dfdcea58b4d6f29fede4f6fe0f1f2f3f4b5b6b607b8b93a3a7b7bf357199c5abcfd9e168bcdee9b3f1ecf5fd1e3e5a7a8aa2b670c4ced8bbe8f0f4fc3d79a1c3cde7effb78cce6facbf9f8";

    /**
        @dev Isolate the least significant set bit.
     */ 
    function isolateLS1B256(uint256 bb) pure internal returns (uint256) {
        require(bb > 0);
        unchecked {
            return bb & (0 - bb);
        }
    } 

    /**
        @dev Isolate the most significant set bit.
     */ 
    function isolateMS1B256(uint256 bb) pure internal returns (uint256) {
        require(bb > 0);
        unchecked {
            bb |= bb >> 128;
            bb |= bb >> 64;
            bb |= bb >> 32;
            bb |= bb >> 16;
            bb |= bb >> 8;
            bb |= bb >> 4;
            bb |= bb >> 2;
            bb |= bb >> 1;
            
            return (bb >> 1) + 1;
        }
    } 

    /**
        @dev Find the index of the lest significant set bit. (trailing zero count)
     */ 
    function bitScanForward256(uint256 bb) pure internal returns (uint8) {
        unchecked {
            return uint8(LOOKUP_TABLE_256[(isolateLS1B256(bb) * DEBRUIJN_256) >> 248]);
        }   
    }

    /**
        @dev Find the index of the most significant set bit.
     */ 
    function bitScanReverse256(uint256 bb) pure internal returns (uint8) {
        unchecked {
            return 255 - uint8(LOOKUP_TABLE_256[((isolateMS1B256(bb) * DEBRUIJN_256) >> 248)]);
        }   
    }

    function log2(uint256 bb) pure internal returns (uint8) {
        unchecked {
            return uint8(LOOKUP_TABLE_256[(isolateMS1B256(bb) * DEBRUIJN_256) >> 248]);
        } 
    }
}

//SPDX-License-Identifier: MIT
/**

███████╗██████╗ ███████╗    ███╗   ███╗ █████╗ ██████╗ 
██╔════╝██╔══██╗██╔════╝    ████╗ ████║██╔══██╗██╔══██╗
█████╗  ██████╔╝█████╗█████╗██╔████╔██║███████║██████╔╝
██╔══╝  ██╔═══╝ ██╔══╝╚════╝██║╚██╔╝██║██╔══██║██╔═══╝ 
██║     ██║     ███████╗    ██║ ╚═╝ ██║██║  ██║██║     
╚═╝     ╚═╝     ╚══════╝    ╚═╝     ╚═╝╚═╝  ╚═╝╚═╝     
                                                       
github: https://github.com/estarriolvetch/fpe-mapping

 */
pragma solidity ^0.8.0;

library Feistel {
    /// Balanced Feistel network
    function feistel(uint256 input, uint256 key, uint256 round, uint256 size) internal pure returns (uint256) {
        unchecked {
            uint256 halfSize = size / 2;
            uint256 halfMap = (2 ** halfSize) - 1;
                
            uint256 left = (input >> halfSize) & halfMap;
            uint256 right = (input & halfMap);
            
            for(uint256 i=0; i < round; i++) {
                uint256 roundKey = uint256(keccak256(abi.encode(key, i)));
                uint256 left_new = right;
                uint256 right_new = left ^ (halfMap & uint256(keccak256(abi.encode(right, roundKey))));

                left = left_new;
                right = right_new;
            }
            return (left << halfSize) | right;
        }
    }

    /// Unbalanced Feistel network
    function feistelUnbalanced(uint256 input, uint256 key, uint256 round, uint256 size) internal pure returns (uint256) {
        unchecked {
            uint256 shortSize = size / 2;
            uint256 longSize = size - shortSize;
            
            uint256 longMap = (1 << longSize) - 1;
            uint256 shortMap = (1 << shortSize) - 1;
            
            uint256 left = (input >> shortSize) & longMap;
            uint256 right = (input & shortMap);
            
            for(uint256 i=0; i < round; i++) {
                uint256 roundKey = uint256(keccak256(abi.encode(key, i)));
                uint256 left_new = right;
                uint256 right_new;
                if(i % 2 == 0){
                    right_new = left ^ (longMap & uint256(keccak256(abi.encode(right, roundKey))));
                } else {
                    right_new = left ^ (shortMap & uint256(keccak256(abi.encode(right, roundKey))));
                }
                
                left = left_new;
                right = right_new;
            }

            if (round % 2 == 0) {
                return (left << shortSize) | right;
            } else {
                return (left << longSize) | right;
            }
        }
    }
}

// SPDX-License-Identifier: MIT
/**
   _____       ___     ___ __           ____  _ __      
  / ___/____  / (_)___/ (_) /___  __   / __ )(_) /______
  \__ \/ __ \/ / / __  / / __/ / / /  / __  / / __/ ___/
 ___/ / /_/ / / / /_/ / / /_/ /_/ /  / /_/ / / /_(__  ) 
/____/\____/_/_/\__,_/_/\__/\__, /  /_____/_/\__/____/  
                           /____/                        

- npm: https://www.npmjs.com/package/solidity-bits
- github: https://github.com/estarriolvetch/solidity-bits

 */
pragma solidity ^0.8.0;

import "./BitScan.sol";

/**
 * @dev This Library is a modified version of Openzeppelin's BitMaps library.
 * Functions of finding the index of the closest set bit from a given index are added.
 * The indexing of each bucket is modifed to count from the MSB to the LSB instead of from the LSB to the MSB.
 * The modification of indexing makes finding the closest previous set bit more efficient in gas usage.
*/

/**
 * @dev Library for managing uint256 to bool mapping in a compact and efficient way, providing the keys are sequential.
 * Largelly inspired by Uniswap's https://github.com/Uniswap/merkle-distributor/blob/master/contracts/MerkleDistributor.sol[merkle-distributor].
 */

library BitMaps {
    using BitScan for uint256;
    uint256 private constant MASK_INDEX_ZERO = (1 << 255);
    uint256 private constant MASK_FULL = type(uint256).max;

    struct BitMap {
        mapping(uint256 => uint256) _data;
    }

    /**
     * @dev Returns whether the bit at `index` is set.
     */
    function get(BitMap storage bitmap, uint256 index) internal view returns (bool) {
        uint256 bucket = index >> 8;
        uint256 mask = MASK_INDEX_ZERO >> (index & 0xff);
        return bitmap._data[bucket] & mask != 0;
    }

    /**
     * @dev Sets the bit at `index` to the boolean `value`.
     */
    function setTo(
        BitMap storage bitmap,
        uint256 index,
        bool value
    ) internal {
        if (value) {
            set(bitmap, index);
        } else {
            unset(bitmap, index);
        }
    }

    /**
     * @dev Sets the bit at `index`.
     */
    function set(BitMap storage bitmap, uint256 index) internal {
        uint256 bucket = index >> 8;
        uint256 mask = MASK_INDEX_ZERO >> (index & 0xff);
        bitmap._data[bucket] |= mask;
    }

    /**
     * @dev Unsets the bit at `index`.
     */
    function unset(BitMap storage bitmap, uint256 index) internal {
        uint256 bucket = index >> 8;
        uint256 mask = MASK_INDEX_ZERO >> (index & 0xff);
        bitmap._data[bucket] &= ~mask;
    }


    /**
     * @dev Consecutively sets `amount` of bits starting from the bit at `startIndex`.
     */    
    function setBatch(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal {
        uint256 bucket = startIndex >> 8;

        uint256 bucketStartIndex = (startIndex & 0xff);

        unchecked {
            if(bucketStartIndex + amount < 256) {
                bitmap._data[bucket] |= MASK_FULL << (256 - amount) >> bucketStartIndex;
            } else {
                bitmap._data[bucket] |= MASK_FULL >> bucketStartIndex;
                amount -= (256 - bucketStartIndex);
                bucket++;

                while(amount > 256) {
                    bitmap._data[bucket] = MASK_FULL;
                    amount -= 256;
                    bucket++;
                }

                bitmap._data[bucket] |= MASK_FULL << (256 - amount);
            }
        }
    }


    /**
     * @dev Consecutively unsets `amount` of bits starting from the bit at `startIndex`.
     */    
    function unsetBatch(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal {
        uint256 bucket = startIndex >> 8;

        uint256 bucketStartIndex = (startIndex & 0xff);

        unchecked {
            if(bucketStartIndex + amount < 256) {
                bitmap._data[bucket] &= ~(MASK_FULL << (256 - amount) >> bucketStartIndex);
            } else {
                bitmap._data[bucket] &= ~(MASK_FULL >> bucketStartIndex);
                amount -= (256 - bucketStartIndex);
                bucket++;

                while(amount > 256) {
                    bitmap._data[bucket] = 0;
                    amount -= 256;
                    bucket++;
                }

                bitmap._data[bucket] &= ~(MASK_FULL << (256 - amount));
            }
        }
    }


    /**
     * @dev Find the closest index of the set bit before `index`.
     */
    function scanForward(BitMap storage bitmap, uint256 index) internal view returns (uint256 setBitIndex) {
        uint256 bucket = index >> 8;

        // index within the bucket
        uint256 bucketIndex = (index & 0xff);

        // load a bitboard from the bitmap.
        uint256 bb = bitmap._data[bucket];

        // offset the bitboard to scan from `bucketIndex`.
        bb = bb >> (0xff ^ bucketIndex); // bb >> (255 - bucketIndex)
        
        if(bb > 0) {
            unchecked {
                setBitIndex = (bucket << 8) | (bucketIndex -  bb.bitScanForward256());    
            }
        } else {
            while(true) {
                require(bucket > 0, "BitMaps: The set bit before the index doesn't exist.");
                unchecked {
                    bucket--;
                }
                // No offset. Always scan from the least significiant bit now.
                bb = bitmap._data[bucket];
                
                if(bb > 0) {
                    unchecked {
                        setBitIndex = (bucket << 8) | (255 -  bb.bitScanForward256());
                        break;
                    }
                } 
            }
        }
    }

    function getBucket(BitMap storage bitmap, uint256 bucket) internal view returns (uint256) {
        return bitmap._data[bucket];
    }
}

// SPDX-License-Identifier: MIT
/**
  ______ _____   _____ ______ ___  __ _  _  _ 
 |  ____|  __ \ / ____|____  |__ \/_ | || || |
 | |__  | |__) | |        / /   ) || | \| |/ |
 |  __| |  _  /| |       / /   / / | |\_   _/ 
 | |____| | \ \| |____  / /   / /_ | |  | |   
 |______|_|  \_\\_____|/_/   |____||_|  |_|   
                                              
                                            
 */

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/StorageSlot.sol";
import "solidity-bits/contracts/BitMaps.sol";


contract ERC721Psi is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
    using Address for address;
    using Strings for uint256;
    using BitMaps for BitMaps.BitMap;

    BitMaps.BitMap private _batchHead;

    string private _name;
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) internal _owners;
    uint256 internal _minted;

    mapping(uint256 => address) private _tokenApprovals;
    mapping(address => mapping(address => 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 ||
            interfaceId == type(IERC721Enumerable).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) 
        public 
        view 
        virtual 
        override 
        returns (uint) 
    {
        require(owner != address(0), "ERC721Psi: balance query for the zero address");

        uint count;
        for( uint i; i < _minted; ++i ){
            if(_exists(i)){
                if( owner == ownerOf(i)){
                    ++count;
                }
            }
        }
        return count;
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId)
        public
        view
        virtual
        override
        returns (address)
    {
        (address owner, ) = _ownerAndBatchHeadOf(tokenId);
        return owner;
    }

    function _ownerAndBatchHeadOf(uint256 tokenId) internal view returns (address owner, uint256 tokenIdBatchHead){
        require(_exists(tokenId), "ERC721Psi: owner query for nonexistent token");
        tokenIdBatchHead = _getBatchHead(tokenId);
        owner = _owners[tokenIdBatchHead];
    }

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Psi: URI query for nonexistent token");

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(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 overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }


    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ownerOf(tokenId);
        require(to != owner, "ERC721Psi: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721Psi: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId)
        public
        view
        virtual
        override
        returns (address)
    {
        require(
            _exists(tokenId),
            "ERC721Psi: approved query for nonexistent token"
        );

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved)
        public
        virtual
        override
    {
        require(operator != _msgSender(), "ERC721Psi: approve to caller");

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(
            _isApprovedOrOwner(_msgSender(), tokenId),
            "ERC721Psi: transfer caller is not owner nor approved"
        );

        _transfer(from, to, tokenId);
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        require(
            _isApprovedOrOwner(_msgSender(), tokenId),
            "ERC721Psi: transfer caller is not owner nor approved"
        );
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @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.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - 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,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(
            _checkOnERC721Received(from, to, tokenId, 1,_data),
            "ERC721Psi: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return tokenId < _minted;
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId)
        internal
        view
        virtual
        returns (bool)
    {
        require(
            _exists(tokenId),
            "ERC721Psi: operator query for nonexistent token"
        );
        address owner = ownerOf(tokenId);
        return (spender == owner ||
            getApproved(tokenId) == spender ||
            isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 quantity) internal virtual {
        _safeMint(to, quantity, "");
    }

    
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal virtual {
        uint256 startTokenId = _minted;
        _mint(to, quantity);
        require(
            _checkOnERC721Received(address(0), to, startTokenId, quantity, _data),
            "ERC721Psi: transfer to non ERC721Receiver implementer"
        );
    }


    function _mint(
        address to,
        uint256 quantity
    ) internal virtual {
        uint256 tokenIdBatchHead = _minted;
        
        require(quantity > 0, "ERC721Psi: quantity must be greater 0");
        require(to != address(0), "ERC721Psi: mint to the zero address");
        
        _beforeTokenTransfers(address(0), to, tokenIdBatchHead, quantity);
        _minted += quantity;
        _owners[tokenIdBatchHead] = to;
        _batchHead.set(tokenIdBatchHead);
        _afterTokenTransfers(address(0), to, tokenIdBatchHead, quantity);
        
        // Emit events
        for(uint256 tokenId=tokenIdBatchHead;tokenId < tokenIdBatchHead + quantity; tokenId++){
            emit Transfer(address(0), to, 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 virtual {
        (address owner, uint256 tokenIdBatchHead) = _ownerAndBatchHeadOf(tokenId);

        require(
            owner == from,
            "ERC721Psi: transfer of token that is not own"
        );
        require(to != address(0), "ERC721Psi: transfer to the zero address");

        _beforeTokenTransfers(from, to, tokenId, 1);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);   

        uint256 nextTokenId = tokenId + 1;

        if(!_batchHead.get(nextTokenId) &&  
            nextTokenId < _minted
        ) {
            _owners[nextTokenId] = from;
            _batchHead.set(nextTokenId);
        }

        _owners[tokenId] = to;
        if(tokenId != tokenIdBatchHead) {
            _batchHead.set(tokenId);
        }

        emit Transfer(from, to, tokenId);

        _afterTokenTransfers(from, to, tokenId, 1);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * 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 startTokenId uint256 the first ID of the tokens to be transferred
     * @param quantity uint256 amount of the tokens to be transfered.
     * @param _data bytes optional data to send along with the call
     * @return r bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity,
        bytes memory _data
    ) private returns (bool r) {
        if (to.isContract()) {
            r = true;
            for(uint256 tokenId = startTokenId; tokenId < startTokenId + quantity; tokenId++){
                try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                    r = r && retval == IERC721Receiver.onERC721Received.selector;
                } catch (bytes memory reason) {
                    if (reason.length == 0) {
                        revert("ERC721Psi: transfer to non ERC721Receiver implementer");
                    } else {
                        assembly {
                            revert(add(32, reason), mload(reason))
                        }
                    }
                }
            }
            return r;
        } else {
            return true;
        }
    }

    function _getBatchHead(uint256 tokenId) internal view returns (uint256 tokenIdBatchHead) {
        tokenIdBatchHead = _batchHead.scanForward(tokenId); 
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _minted;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256 tokenId) {
        require(index < totalSupply(), "ERC721Psi: global index out of bounds");
        
        uint count;
        for(uint i; i < _minted; i++){
            if(_exists(i)){
                if(count == index) return i;
                else count++;
            }
        }
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256 tokenId) {
        uint count;
        for(uint i; i < _minted; i++){
            if(_exists(i) && owner == ownerOf(i)){
                if(count == index) return i;
                else count++;
            }
        }

        revert("ERC721Psi: owner index out of bounds");
    }


    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     */
    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
     * minting.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}

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

pragma solidity ^0.8.0;

import "../../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: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * 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 caller.
     *
     * 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 v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @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 v4.7.0) (utils/StorageSlot.sol)

pragma solidity ^0.8.0;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly
                /// @solidity memory-safe-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

import "./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);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;

import "../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 v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;

import "../IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @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
pragma solidity ^0.8.13;

import {IOperatorFilterRegistry} from "./IOperatorFilterRegistry.sol";
import {CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS} from "./lib/Constants.sol";
/**
 * @title  OperatorFilterer
 * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
 *         registrant's entries in the OperatorFilterRegistry.
 * @dev    This smart contract is meant to be inherited by token contracts so they can use the following:
 *         - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
 *         - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
 *         Please note that if your token contract does not provide an owner with EIP-173, it must provide
 *         administration methods on the contract itself to interact with the registry otherwise the subscription
 *         will be locked to the options set during construction.
 */

abstract contract OperatorFilterer {
    /// @dev Emitted when an operator is not allowed.
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY =
        IOperatorFilterRegistry(CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS);

    /// @dev The constructor that is called when the contract is being deployed.
    constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
        // will not revert, but the contract will need to be registered with the registry once it is deployed in
        // order for the modifier to filter addresses.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (subscribe) {
                OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
                } else {
                    OPERATOR_FILTER_REGISTRY.register(address(this));
                }
            }
        }
    }

    /**
     * @dev A helper function to check if an operator is allowed.
     */
    modifier onlyAllowedOperator(address from) virtual {
        // Allow spending tokens from addresses with balance
        // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
        // from an EOA.
        if (from != msg.sender) {
            _checkFilterOperator(msg.sender);
        }
        _;
    }

    /**
     * @dev A helper function to check if an operator approval is allowed.
     */
    modifier onlyAllowedOperatorApproval(address operator) virtual {
        _checkFilterOperator(operator);
        _;
    }

    /**
     * @dev A helper function to check if an operator is allowed.
     */
    function _checkFilterOperator(address operator) internal view virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            // under normal circumstances, this function will revert rather than return false, but inheriting contracts
            // may specify their own OperatorFilterRegistry implementations, which may behave differently
            if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
                revert OperatorNotAllowed(operator);
            }
        }
    }
}

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

address constant CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS = 0x000000000000AAeB6D7670E522A718067333cd4E;
address constant CANONICAL_CORI_SUBSCRIPTION = 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6;

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

interface IOperatorFilterRegistry {
    /**
     * @notice Returns true if operator is not filtered for a given token, either by address or codeHash. Also returns
     *         true if supplied registrant address is not registered.
     */
    function isOperatorAllowed(address registrant, address operator) external view returns (bool);

    /**
     * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner.
     */
    function register(address registrant) external;

    /**
     * @notice Registers an address with the registry and "subscribes" to another address's filtered operators and codeHashes.
     */
    function registerAndSubscribe(address registrant, address subscription) external;

    /**
     * @notice Registers an address with the registry and copies the filtered operators and codeHashes from another
     *         address without subscribing.
     */
    function registerAndCopyEntries(address registrant, address registrantToCopy) external;

    /**
     * @notice Unregisters an address with the registry and removes its subscription. May be called by address itself or by EIP-173 owner.
     *         Note that this does not remove any filtered addresses or codeHashes.
     *         Also note that any subscriptions to this registrant will still be active and follow the existing filtered addresses and codehashes.
     */
    function unregister(address addr) external;

    /**
     * @notice Update an operator address for a registered address - when filtered is true, the operator is filtered.
     */
    function updateOperator(address registrant, address operator, bool filtered) external;

    /**
     * @notice Update multiple operators for a registered address - when filtered is true, the operators will be filtered. Reverts on duplicates.
     */
    function updateOperators(address registrant, address[] calldata operators, bool filtered) external;

    /**
     * @notice Update a codeHash for a registered address - when filtered is true, the codeHash is filtered.
     */
    function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;

    /**
     * @notice Update multiple codeHashes for a registered address - when filtered is true, the codeHashes will be filtered. Reverts on duplicates.
     */
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;

    /**
     * @notice Subscribe an address to another registrant's filtered operators and codeHashes. Will remove previous
     *         subscription if present.
     *         Note that accounts with subscriptions may go on to subscribe to other accounts - in this case,
     *         subscriptions will not be forwarded. Instead the former subscription's existing entries will still be
     *         used.
     */
    function subscribe(address registrant, address registrantToSubscribe) external;

    /**
     * @notice Unsubscribe an address from its current subscribed registrant, and optionally copy its filtered operators and codeHashes.
     */
    function unsubscribe(address registrant, bool copyExistingEntries) external;

    /**
     * @notice Get the subscription address of a given registrant, if any.
     */
    function subscriptionOf(address addr) external returns (address registrant);

    /**
     * @notice Get the set of addresses subscribed to a given registrant.
     *         Note that order is not guaranteed as updates are made.
     */
    function subscribers(address registrant) external returns (address[] memory);

    /**
     * @notice Get the subscriber at a given index in the set of addresses subscribed to a given registrant.
     *         Note that order is not guaranteed as updates are made.
     */
    function subscriberAt(address registrant, uint256 index) external returns (address);

    /**
     * @notice Copy filtered operators and codeHashes from a different registrantToCopy to addr.
     */
    function copyEntriesOf(address registrant, address registrantToCopy) external;

    /**
     * @notice Returns true if operator is filtered by a given address or its subscription.
     */
    function isOperatorFiltered(address registrant, address operator) external returns (bool);

    /**
     * @notice Returns true if the hash of an address's code is filtered by a given address or its subscription.
     */
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);

    /**
     * @notice Returns true if a codeHash is filtered by a given address or its subscription.
     */
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);

    /**
     * @notice Returns a list of filtered operators for a given address or its subscription.
     */
    function filteredOperators(address addr) external returns (address[] memory);

    /**
     * @notice Returns the set of filtered codeHashes for a given address or its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredCodeHashes(address addr) external returns (bytes32[] memory);

    /**
     * @notice Returns the filtered operator at the given index of the set of filtered operators for a given address or
     *         its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredOperatorAt(address registrant, uint256 index) external returns (address);

    /**
     * @notice Returns the filtered codeHash at the given index of the list of filtered codeHashes for a given address or
     *         its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);

    /**
     * @notice Returns true if an address has registered
     */
    function isRegistered(address addr) external returns (bool);

    /**
     * @dev Convenience method to compute the code hash of an arbitrary contract
     */
    function codeHashOf(address addr) external returns (bytes32);
}

{
  "optimizer": {
    "enabled": true,
    "runs": 1000
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"maxSupply_","type":"uint256"},{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"string","name":"archVeilURI_","type":"string"},{"internalType":"string","name":"archBaseURI_","type":"string"},{"internalType":"address","name":"vrfCoordinator_","type":"address"},{"internalType":"bytes32","name":"vrfGasLane_","type":"bytes32"},{"internalType":"uint64","name":"vrfSubscriptionId_","type":"uint64"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"have","type":"address"},{"internalType":"address","name":"want","type":"address"}],"name":"OnlyCoordinatorCanFulfill","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","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":false,"internalType":"uint256","name":"requestId","type":"uint256"}],"name":"RandomnessRequested","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":[],"name":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"airdrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","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":"entropy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fulfilling","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"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":[{"internalType":"uint256","name":"requestId","type":"uint256"},{"internalType":"uint256[]","name":"randomWords","type":"uint256[]"}],"name":"rawFulfillRandomWords","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reveal","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":"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":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"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"},{"inputs":[{"components":[{"internalType":"bytes32","name":"gasLane","type":"bytes32"},{"internalType":"uint64","name":"subscriptionId","type":"uint64"},{"internalType":"uint16","name":"requestConfirmations","type":"uint16"},{"internalType":"uint32","name":"callbackGasLimit","type":"uint32"}],"internalType":"struct ArchOfPeaceEntropy.VRFRequestParams","name":"newParams","type":"tuple"}],"name":"updateVRFParams","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000000000000000000000000000000000000000045700000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000001e0000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e699099fe0eebf5e446e3c998ec9bb19951541aee00bb90ea201ae456421a2ded8680500000000000000000000000000000000000000000000000000000000000001fd000000000000000000000000000000000000000000000000000000000000001854726176656c6572733a20416e6369656e742045677970740000000000000000000000000000000000000000000000000000000000000000000000000000000454525645000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035697066733a2f2f516d5a6b327536737559764c37516f7478596e43514d667056705976577863355577637070626b6171533457663700000000000000000000000000000000000000000000000000000000000000000000000000000000000035697066733a2f2f516d6151544333624337776845575266704a6e316954686558414632435a5238714243325138613464395a506e420000000000000000000000

-----Decoded View---------------
Arg [0] : maxSupply_ (uint256): 1111
Arg [1] : name_ (string): Travelers: Ancient Egypt
Arg [2] : symbol_ (string): TRVE
Arg [3] : archVeilURI_ (string): ipfs://QmZk2u6suYvL7QotxYnCQMfpVpYvWxc5UwcppbkaqS4Wf7
Arg [4] : archBaseURI_ (string): ipfs://QmaQTC3bC7whEWRfpJn1iTheXAF2CZR8qBC2Q8a4d9ZPnB
Arg [5] : vrfCoordinator_ (address): 0x271682DEB8C4E0901D1a1550aD2e64D568E69909
Arg [6] : vrfGasLane_ (bytes32): 0x9fe0eebf5e446e3c998ec9bb19951541aee00bb90ea201ae456421a2ded86805
Arg [7] : vrfSubscriptionId_ (uint64): 509

-----Encoded View---------------
18 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000457
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000140
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000180
Arg [4] : 00000000000000000000000000000000000000000000000000000000000001e0
Arg [5] : 000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909
Arg [6] : 9fe0eebf5e446e3c998ec9bb19951541aee00bb90ea201ae456421a2ded86805
Arg [7] : 00000000000000000000000000000000000000000000000000000000000001fd
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000018
Arg [9] : 54726176656c6572733a20416e6369656e742045677970740000000000000000
Arg [10] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [11] : 5452564500000000000000000000000000000000000000000000000000000000
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000035
Arg [13] : 697066733a2f2f516d5a6b327536737559764c37516f7478596e43514d667056
Arg [14] : 705976577863355577637070626b617153345766370000000000000000000000
Arg [15] : 0000000000000000000000000000000000000000000000000000000000000035
Arg [16] : 697066733a2f2f516d6151544333624337776845575266704a6e316954686558
Arg [17] : 414632435a5238714243325138613464395a506e420000000000000000000000