Token

Purrnelopes Exclusives (PE)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-721

NFT

Overview

Max Total Supply

3,462 PE

Holders

1,488

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x9e8a92f833c0ae4842574ce9cc0ef4c7300ddb12

Filtered by Token Holder

0xe6569213085bB4ffe1e2aAAe9E485d3082A6c4d9

seanmatthew13.eth

Balance

1 PE

0xe6569213085bB4ffe1e2aAAe9E485d3082A6c4d9

OVERVIEW

A collection of $TOKEN yielding NFTs with 5 different categories to mint between.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

PurrnelopesExclusives

Compiler Version

v0.8.13+commit.abaa5c0e

Optimization Enabled:

Yes with 1000 runs

Other Settings:

default evmVersion

Contract Source Code (Solidity Standard Json-Input format)

IDE

File 1 of 12 : PurrnelopesExclusives.sol

/*
                              ▓▓█
                            ▒██▒▒█ 
                           █▓▓▓░▒▓▓     
                         ▒█▓▒█░▒▒▒█     
                        ▒█▒▒▒█▒▒▒▒▓▒    
 ▓▓▒░                  ▓█▒▒▒▓██▓▒░▒█    
 █▓▓██▓░              ▓█▒▒▒▒████▒▒▒█    
 ▓█▓▒▒▓██▓░          ▒█▒▒▒▒▒██▓█▓░░▓▒   
 ▓▒▓▒▒▒▒▒▓█▓░  ░▒▒▓▓██▒▒▒▒▒▒█████▒▒▒▓   
 ▓░█▒▒▒▒▒▒▒▓▓█▓█▓▓▓▓▒▒▒▒▒▒▒▒██▓██▒░▒█   
 ▓░▓█▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓████▒▒▒█   
 ▓░▓██▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▓██░░░█   
 ▓░▓███▒▒▒▒▒▒▒▒▒▒▒▓█▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▒▓▓  
 ▒▒▒██▓▒▓█▓▒▒▒▒▒▒▒▓▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▓▒█  
  ▓▒█▓▒▒▒▒▓▒▒▒▒▒▒▒▒▒▒▒▓█▓▓▓▓█▓▒▒▒▒▒▒▒▓▒ 
  ▓▒█▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓      ▓█▓▒▒▒▒▒▓█ 
  ▒▒▓▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▓▓   ░▓▓   █▓▒▒▒▒▒█ 
   █▒▒▓▓▓▒▒▓▓▒▒▒▒▒▒▓▓   █████▓  █▓▒▒▒▒▓▒
   ▓▓█▒     ▒▓▒▒▒▒▒█   ░██████  ░█▒▒▒▒▓▓
   ▓█▒  ▒███ ▒▓▒▒▒▒█    ██████   ▓▒▒▒▒▒▓
   ██   █████ █▒▒▒▒█     ███▓    ▓▓▒▒▒▒▓
   █▓   █████ ▒▓▒▒▒█             █▓▓▓▒▒▓
   █▓   ░███  ░▓▒▒▒▓█          ░█▓▒▒▒▓▒▓
   ██         ▒▓▒▒▒▒▓▓      ░▒▓█▓    ░▓▓
   ▓█░        █▓██▓▒▒▓█▓▓▓▓██▓▓▒▓▒░░▒▓▒▓
   ▒██░      ▓▒███▓▒▒▒▒▓▓▓▓▒▒▒▒▒▒▓▓▓▓▒▓ 
    █▓█▓▓▒▒▓█▓▒░██▒▒▓▓█▓▒▒▒▒▒▒▒▒▒▒▒▒▓▓█▒
    ▓ ░▓▓▓▓▓▒▓▓▓▓▒▓▓▓▒▓▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓
    ▒▒▒▓▒▒▒▒▒▒▓█░ ░░░ ▓▓▒▒▒▒▒▒▒▒▒▒▒▓██▓▒
     █▓▒▒▒▒▒▒▒▒▓▓ ░░░ ▓▓▒▒▒▒▒▒▒▒▒▓▓▓▒▒▓▒
      ██▓▓▒▒▒▒▒▒█▒░░░░█▒▒▒▒▒▒▒▒▓█▓▓▒▒▒▒▒
       ▒██▓▓▒▒▒▒▒█▓▒▒▓▒▒▒▒▒▒▓███▓▒▒▒▒▒▓▓
          ░▒▓▓▓▓▒▒▓▓▓▓▓▓████▓▓█▒▒▒▒▒▓▓█░
████████████████████████████████████████████████████████████████████████
█▄─▄▄─█▄─██─▄█▄─▄▄▀█▄─▄▄▀█▄─▀█▄─▄█▄─▄▄─█▄─▄███─▄▄─█▄─▄▄─█▄─▄▄─█─▄▄▄▄████
██─▄▄▄██─██─███─▄─▄██─▄─▄██─█▄▀─███─▄█▀██─██▀█─██─██─▄▄▄██─▄█▀█▄▄▄▄─████
█▄▄▄████▄▄▄▄██▄▄█▄▄█▄▄█▄▄█▄▄▄██▄▄█▄▄▄▄▄█▄▄▄▄▄█▄▄▄▄█▄▄▄███▄▄▄▄▄█▄▄▄▄▄████
████████████████████████████████████████████████████████████████████████
█─▄▄▄─█─▄▄─█▄─██─▄█▄─▀█▄─▄█─▄─▄─█▄─▄▄▀█▄─█─▄███─▄▄▄─█▄─▄███▄─██─▄█▄─▄─▀█
█─███▀█─██─██─██─███─█▄▀─████─████─▄─▄██▄─▄████─███▀██─██▀██─██─███─▄─▀█
█▄▄▄▄▄█▄▄▄▄██▄▄▄▄██▄▄▄██▄▄██▄▄▄██▄▄█▄▄██▄▄▄████▄▄▄▄▄█▄▄▄▄▄██▄▄▄▄██▄▄▄▄██*/

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

import './ERC721A.sol';
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";


/*
# python - please copy/paste, change IPFS_HASH and run to prove provenenance

import requests
import hashlib

FP = 'https://ipfs.io/ipfs/IPFS_HASH/'
PH = 'b4a994a127f3cedd3c96c9bf0db5cd0167d6c6da2c580ceb969b2b103777eb01'
s = hashlib.sha3_256()

def h(path, index, total):
    found = False
    while not found:
        try:
            content = requests.get(path).content
            print(f'getting {index}/{total}')
            s.update(content)           
            time.sleep(1)
            found = "<head><title>" not in str(content)
            if found:
                return s.hexdigest()
            else:
                time.sleep(3)
        except:
            pass


s.update("".join([h(f'{FP}/{i}.png', i) for i in range(0, 10000)]).encode('utf-8'))
print(f'provenance hash is {s.hexdigest()}')
print(f'provenance matches - {s.hexdigest() == PH}')
*/

contract PurrnelopesExclusives is ERC721A, Ownable, VRFConsumerBase{
    using SafeMath for uint256;
    using Strings for uint256;

    string public constant PROVENANCE = 'b4a994a127f3cedd3c96c9bf0db5cd0167d6c6da2c580ceb969b2b103777eb01';
    uint256 public constant MaxSupply = 10000;

    string public BaseHash = '';
    string public PlaceholderHash = 'QmSawfWXzswsgWt3soD421NHeeS6aw9fa2NKCQBAtiiNZt'; // << pre-reveal hash
    bytes32[3] public MerkleRoot;


    bool public SaleOpen;
    

    uint256 public UnitPrice = 0.1 ether;

    
    uint256 public StartingIndex = MaxSupply;

    bytes32 internal vrfRequestId;
    bytes32 internal keyHash;
    uint256 internal fee;

    uint256 public CurrentPhase;
    uint256[3] MaxMintPerPhase;
    uint256 public constant MaxPublicMint = 3;

    mapping(address => mapping(uint256 => uint256)) public WhitelistMinted;

    constructor() ERC721A("Purrnelopes Exclusives", "PE") 
                  VRFConsumerBase(
           0xf0d54349aDdcf704F77AE15b96510dEA15cb7952, 
            0x514910771AF9Ca656af840dff83E8264EcF986CA  
            /* 0xb3dCcb4Cf7a26f6cf6B120Cf5A73875B7BBc655B,// VRF Coordinator
            0x01BE23585060835E02B77ef475b0Cc51aA1e0709// LINK Token */
    ) {
        keyHash = 0xAA77729D3466CA35AE8D28B3BBAC7CC36A5031EFDC430821C02BC31A238AF445; //0x2ed0feb3e7fd2022120aa84fab1945545a9f2ffc9076fd6156fa96eaff4c1311
        fee = 2 ether; // 2 LINK (Varies by network)
        MaxMintPerPhase = [3, 3, 3];



    }

    function devMint(uint256 _quantity, address _addr) public onlyOwner{
        require(_quantity.add(totalSupply()) <= MaxSupply, "sale closed");

        _mint(_addr, _quantity);
    }

    function setKey(bytes32 _key) public onlyOwner {
        keyHash = _key;
    }

    function setFee(uint256 _fee) public onlyOwner {
        fee = _fee;
    }

    function setBaseHash(string calldata _hash) public onlyOwner {
        BaseHash = _hash;
    }

    function setPlaceholderHash(string calldata _hash) public onlyOwner {
        PlaceholderHash = _hash;
    }

    function setMerkleRoot(bytes32 _root, uint256 _phase) public onlyOwner {
        MerkleRoot[_phase] = _root;
    }

    function PublicSaleOpen() public returns(bool){
        return CurrentPhase == 2 && SaleOpen;
    }

    function toggleSaleOpen() public onlyOwner {

        SaleOpen = !SaleOpen;
    }


    function setUnitPrice(uint256 _priceInWei) public onlyOwner{
        UnitPrice = _priceInWei;
    }

    function _baseURI() internal view override returns (string memory) {
        return string(abi.encodePacked('ipfs://', BaseHash, '/'));
    }

    function incrementPhase() external onlyOwner {
        CurrentPhase = CurrentPhase + 1;
    }

    function publicMint(bytes32[] calldata _merkleProof, uint256 _quantity) payable public {
        require(SaleOpen, "sale not open yet");
        require(msg.value == _quantity.mul(UnitPrice), "incorrect ether");
        require(_quantity.add(totalSupply()) <= MaxSupply, "sale closed");
        require(_quantity <= MaxPublicMint, "too many");
        
        if (CurrentPhase != 2) {
            require(MaxMintPerPhase[CurrentPhase] >= _quantity.add(WhitelistMinted[msg.sender][CurrentPhase]), "too many");
            bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
            require(MerkleProof.verify(_merkleProof, MerkleRoot[CurrentPhase], leaf), "not authorised");
            WhitelistMinted[msg.sender][CurrentPhase] += _quantity;
        }
        _mint(msg.sender, _quantity);
    }

    function revealCollection(string memory _hash) public {
        require(StartingIndex == MaxSupply, "StartingIndex already set");
        BaseHash = _hash;
        vrfRequestId = requestRandomness(keyHash, fee);
    }

    function tokenURI(uint256 tokenId) public view override returns(string memory) {
        require(_exists(tokenId), "token does not exist");
        string memory baseURI = _baseURI();

        if (StartingIndex == MaxSupply) {
            return string(abi.encodePacked('ipfs://', PlaceholderHash));
        } else {
            uint256 id = tokenId.add(StartingIndex) % MaxSupply;
            return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, id.toString())) : "";
        }
    }

    function remainingToMint(bytes32[] calldata _merkleProof, address _addr) public view returns(uint256) {
        bytes32 leaf = keccak256(abi.encodePacked(_addr));
        if (MerkleProof.verify(_merkleProof, MerkleRoot[CurrentPhase], leaf) && CurrentPhase != 2) {
            return MaxMintPerPhase[CurrentPhase] - WhitelistMinted[_addr][CurrentPhase];
        }
        else{
            return CurrentPhase == 2 ? MaxPublicMint : 0;
        }
    }

    function withdraw() public onlyOwner {
		uint256 balance = address(this).balance;
		payable(msg.sender).transfer(balance);

	}

    function withdrawTokens(IERC20 token) public onlyOwner {
		require(address(token) != address(0));
		uint256 balance = token.balanceOf(address(this));
		token.transfer(msg.sender, balance);
	}

    function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
        require(StartingIndex == MaxSupply, "StartingIndex already set");
        require(vrfRequestId == requestId, "Chainlink VRF Request Id must match");
        StartingIndex = (randomness % MaxSupply);
    }

    function backupRandomness() public onlyOwner {
        require(StartingIndex == MaxSupply || block.chainid == 4, "StartingIndex already set");

        uint256 random = uint(keccak256(abi.encodePacked(block.difficulty, block.timestamp, msg.sender, block.number)));

        StartingIndex = (random % MaxSupply);
    }


}

File 2 of 12 : ERC721A.sol

// SPDX-License-Identifier: MIT
// ERC721A Contracts v3.3.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;

import './interfaces/IERC721A.sol';

/**
 * @dev ERC721 token receiver interface.
 */
interface ERC721A__IERC721Receiver {
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).
 *
 * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 *
 * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is IERC721A {
    // Mask of an entry in packed address data.
    uint256 private constant BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;

    // The bit position of `numberMinted` in packed address data.
    uint256 private constant BITPOS_NUMBER_MINTED = 64;

    // The bit position of `numberBurned` in packed address data.
    uint256 private constant BITPOS_NUMBER_BURNED = 128;

    // The bit position of `aux` in packed address data.
    uint256 private constant BITPOS_AUX = 192;

    // Mask of all 256 bits in packed address data except the 64 bits for `aux`.
    uint256 private constant BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;

    // The bit position of `startTimestamp` in packed ownership.
    uint256 private constant BITPOS_START_TIMESTAMP = 160;

    // The bit mask of the `burned` bit in packed ownership.
    uint256 private constant BITMASK_BURNED = 1 << 224;
    
    // The bit position of the `nextInitialized` bit in packed ownership.
    uint256 private constant BITPOS_NEXT_INITIALIZED = 225;

    // The bit mask of the `nextInitialized` bit in packed ownership.
    uint256 private constant BITMASK_NEXT_INITIALIZED = 1 << 225;

    // The tokenId of the next token to be minted.
    uint256 private _currentIndex;

    // The number of tokens burned.
    uint256 private _burnCounter;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to ownership details
    // An empty struct value does not necessarily mean the token is unowned.
    // See `_packedOwnershipOf` implementation for details.
    //
    // Bits Layout:
    // - [0..159]   `addr`
    // - [160..223] `startTimestamp`
    // - [224]      `burned`
    // - [225]      `nextInitialized`
    mapping(uint256 => uint256) private _packedOwnerships;

    // Mapping owner address to address data.
    //
    // Bits Layout:
    // - [0..63]    `balance`
    // - [64..127]  `numberMinted`
    // - [128..191] `numberBurned`
    // - [192..255] `aux`
    mapping(address => uint256) private _packedAddressData;

    // Mapping from token ID to approved address.
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
        _currentIndex = _startTokenId();
    }

    /**
     * @dev Returns the starting token ID. 
     * To change the starting token ID, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 0;
    }

    /**
     * @dev Returns the next token ID to be minted.
     */
    function _nextTokenId() internal view returns (uint256) {
        return _currentIndex;
    }

    /**
     * @dev Returns the total number of tokens in existence.
     * Burned tokens will reduce the count. 
     * To get the total number of tokens minted, please see `_totalMinted`.
     */
    function totalSupply() public view override returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than `_currentIndex - _startTokenId()` times.
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

    /**
     * @dev Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view returns (uint256) {
        // Counter underflow is impossible as _currentIndex does not decrement,
        // and it is initialized to `_startTokenId()`
        unchecked {
            return _currentIndex - _startTokenId();
        }
    }

    /**
     * @dev Returns the total number of tokens burned.
     */
    function _totalBurned() internal view returns (uint256) {
        return _burnCounter;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        // The interface IDs are constants representing the first 4 bytes of the XOR of
        // all function selectors in the interface. See: https://eips.ethereum.org/EIPS/eip-165
        // e.g. `bytes4(i.functionA.selector ^ i.functionB.selector ^ ...)`
        return
            interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165.
            interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.
            interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return _packedAddressData[owner] & BITMASK_ADDRESS_DATA_ENTRY;
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return (_packedAddressData[owner] >> BITPOS_NUMBER_MINTED) & BITMASK_ADDRESS_DATA_ENTRY;
    }

    /**
     * Returns the number of tokens burned by or on behalf of `owner`.
     */
    function _numberBurned(address owner) internal view returns (uint256) {
        return (_packedAddressData[owner] >> BITPOS_NUMBER_BURNED) & BITMASK_ADDRESS_DATA_ENTRY;
    }

    /**
     * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     */
    function _getAux(address owner) internal view returns (uint64) {
        return uint64(_packedAddressData[owner] >> BITPOS_AUX);
    }

    /**
     * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal {
        uint256 packed = _packedAddressData[owner];
        uint256 auxCasted;
        assembly { // Cast aux without masking.
            auxCasted := aux
        }
        packed = (packed & BITMASK_AUX_COMPLEMENT) | (auxCasted << BITPOS_AUX);
        _packedAddressData[owner] = packed;
    }

    /**
     * Returns the packed ownership data of `tokenId`.
     */
    function _packedOwnershipOf(uint256 tokenId) private view returns (uint256) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr)
                if (curr < _currentIndex) {
                    uint256 packed = _packedOwnerships[curr];
                    // If not burned.
                    if (packed & BITMASK_BURNED == 0) {
                        // Invariant:
                        // There will always be an ownership that has an address and is not burned
                        // before an ownership that does not have an address and is not burned.
                        // Hence, curr will not underflow.
                        //
                        // We can directly compare the packed value.
                        // If the address is zero, packed is zero.
                        while (packed == 0) {
                            packed = _packedOwnerships[--curr];
                        }
                        return packed;
                    }
                }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * Returns the unpacked `TokenOwnership` struct from `packed`.
     */
    function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
        ownership.addr = address(uint160(packed));
        ownership.startTimestamp = uint64(packed >> BITPOS_START_TIMESTAMP);
        ownership.burned = packed & BITMASK_BURNED != 0;
    }

    /**
     * Returns the unpacked `TokenOwnership` struct at `index`.
     */
    function _ownershipAt(uint256 index) internal view returns (TokenOwnership memory) {
        return _unpackedOwnership(_packedOwnerships[index]);
    }

    /**
     * @dev Initializes the ownership slot minted at `index` for efficiency purposes.
     */
    function _initializeOwnershipAt(uint256 index) internal {
        if (_packedOwnerships[index] == 0) {
            _packedOwnerships[index] = _packedOwnershipOf(index);
        }
    }

    /**
     * Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around in the collection over time.
     */
    function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
        return _unpackedOwnership(_packedOwnershipOf(tokenId));
    }

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

    /**
     * @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) {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

        string memory baseURI = _baseURI();
        return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, _toString(tokenId))) : '';
    }

    /**
     * @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 Casts the address to uint256 without masking.
     */
    function _addressToUint256(address value) private pure returns (uint256 result) {
        assembly {
            result := value
        }
    }

    /**
     * @dev Casts the boolean to uint256 without branching.
     */
    function _boolToUint256(bool value) private pure returns (uint256 result) {
        assembly {
            result := value
        }
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public override {
        address owner = address(uint160(_packedOwnershipOf(tokenId)));
        if (to == owner) revert ApprovalToCurrentOwner();

        if (_msgSenderERC721A() != owner)
            if (!isApprovedForAll(owner, _msgSenderERC721A())) {
                revert ApprovalCallerNotOwnerNorApproved();
            }

        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        if (operator == _msgSenderERC721A()) revert ApproveToCaller();

        _operatorApprovals[_msgSenderERC721A()][operator] = approved;
        emit ApprovalForAll(_msgSenderERC721A(), 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 {
        _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 {
        _transfer(from, to, tokenId);
        if (to.code.length != 0)
            if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {
                revert TransferToNonERC721ReceiverImplementer();
            }
    }

    /**
     * @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 returns (bool) {
        return
            _startTokenId() <= tokenId &&
            tokenId < _currentIndex && // If within bounds,
            _packedOwnerships[tokenId] & BITMASK_BURNED == 0; // and not burned.
    }

    /**
     * @dev Equivalent to `_safeMint(to, quantity, '')`.
     */
    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, '');
    }

    /**
     * @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,
        bytes memory _data
    ) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the balance and number minted.
            _packedAddressData[to] += quantity * ((1 << BITPOS_NUMBER_MINTED) | 1);

            // Updates:
            // - `address` to the owner.
            // - `startTimestamp` to the timestamp of minting.
            // - `burned` to `false`.
            // - `nextInitialized` to `quantity == 1`.
            _packedOwnerships[startTokenId] =
                _addressToUint256(to) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                (_boolToUint256(quantity == 1) << BITPOS_NEXT_INITIALIZED);

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            if (to.code.length != 0) {
                do {
                    emit Transfer(address(0), to, updatedIndex);
                    if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (updatedIndex < end);
                // Reentrancy protection
                if (_currentIndex != startTokenId) revert();
            } else {
                do {
                    emit Transfer(address(0), to, updatedIndex++);
                } while (updatedIndex < end);
            }
            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 quantity) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the balance and number minted.
            _packedAddressData[to] += quantity * ((1 << BITPOS_NUMBER_MINTED) | 1);

            // Updates:
            // - `address` to the owner.
            // - `startTimestamp` to the timestamp of minting.
            // - `burned` to `false`.
            // - `nextInitialized` to `quantity == 1`.
            _packedOwnerships[startTokenId] =
                _addressToUint256(to) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                (_boolToUint256(quantity == 1) << BITPOS_NEXT_INITIALIZED);

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            do {
                emit Transfer(address(0), to, updatedIndex++);
            } while (updatedIndex < end);

            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * 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
    ) private {
        uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

        if (address(uint160(prevOwnershipPacked)) != from) revert TransferFromIncorrectOwner();

        bool isApprovedOrOwner = (_msgSenderERC721A() == from ||
            isApprovedForAll(from, _msgSenderERC721A()) ||
            getApproved(tokenId) == _msgSenderERC721A());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

        // Clear approvals from the previous owner.
        delete _tokenApprovals[tokenId];

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            // We can directly increment and decrement the balances.
            --_packedAddressData[from]; // Updates: `balance -= 1`.
            ++_packedAddressData[to]; // Updates: `balance += 1`.

            // Updates:
            // - `address` to the next owner.
            // - `startTimestamp` to the timestamp of transfering.
            // - `burned` to `false`.
            // - `nextInitialized` to `true`.
            _packedOwnerships[tokenId] =
                _addressToUint256(to) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                BITMASK_NEXT_INITIALIZED;

            // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
            if (prevOwnershipPacked & BITMASK_NEXT_INITIALIZED == 0) {
                uint256 nextTokenId = tokenId + 1;
                // If the next slot's address is zero and not burned (i.e. packed value is zero).
                if (_packedOwnerships[nextTokenId] == 0) {
                    // If the next slot is within bounds.
                    if (nextTokenId != _currentIndex) {
                        // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                        _packedOwnerships[nextTokenId] = prevOwnershipPacked;
                    }
                }
            }
        }

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

    /**
     * @dev Equivalent to `_burn(tokenId, false)`.
     */
    function _burn(uint256 tokenId) internal virtual {
        _burn(tokenId, false);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
        uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

        address from = address(uint160(prevOwnershipPacked));

        if (approvalCheck) {
            bool isApprovedOrOwner = (_msgSenderERC721A() == from ||
                isApprovedForAll(from, _msgSenderERC721A()) ||
                getApproved(tokenId) == _msgSenderERC721A());

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

        _beforeTokenTransfers(from, address(0), tokenId, 1);

        // Clear approvals from the previous owner.
        delete _tokenApprovals[tokenId];

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            // Updates:
            // - `balance -= 1`.
            // - `numberBurned += 1`.
            //
            // We can directly decrement the balance, and increment the number burned.
            // This is equivalent to `packed -= 1; packed += 1 << BITPOS_NUMBER_BURNED;`.
            _packedAddressData[from] += (1 << BITPOS_NUMBER_BURNED) - 1;

            // Updates:
            // - `address` to the last owner.
            // - `startTimestamp` to the timestamp of burning.
            // - `burned` to `true`.
            // - `nextInitialized` to `true`.
            _packedOwnerships[tokenId] =
                _addressToUint256(from) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                BITMASK_BURNED | 
                BITMASK_NEXT_INITIALIZED;

            // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
            if (prevOwnershipPacked & BITMASK_NEXT_INITIALIZED == 0) {
                uint256 nextTokenId = tokenId + 1;
                // If the next slot's address is zero and not burned (i.e. packed value is zero).
                if (_packedOwnerships[nextTokenId] == 0) {
                    // If the next slot is within bounds.
                    if (nextTokenId != _currentIndex) {
                        // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                        _packedOwnerships[nextTokenId] = prevOwnershipPacked;
                    }
                }
            }
        }

        emit Transfer(from, address(0), tokenId);
        _afterTokenTransfers(from, address(0), tokenId, 1);

        // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
        unchecked {
            _burnCounter++;
        }
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        try ERC721A__IERC721Receiver(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data) returns (
            bytes4 retval
        ) {
            return retval == ERC721A__IERC721Receiver(to).onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == 0) {
                revert TransferToNonERC721ReceiverImplementer();
            } else {
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     * And also called before burning one token.
     *
     * 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`.
     * - When `to` is zero, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    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.
     * And also called after one token has been burned.
     *
     * 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` has been
     * transferred to `to`.
     * - When `from` is zero, `tokenId` has been minted for `to`.
     * - When `to` is zero, `tokenId` has been burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Returns the message sender (defaults to `msg.sender`).
     *
     * If you are writing GSN compatible contracts, you need to override this function.
     */
    function _msgSenderERC721A() internal view virtual returns (address) {
        return msg.sender;
    }

    /**
     * @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
        unchecked {
            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;
                buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
                value /= 10;
            }
            return string(buffer);
        }
    }
}

File 3 of 12 : IERC20.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

File 4 of 12 : Ownable.sol

// SPDX-License-Identifier: MIT

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() {
        _setOwner(_msgSender());
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        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 {
        _setOwner(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");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

File 5 of 12 : MerkleProof.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        bytes32 computedHash = leaf;

        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];

            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }

        // Check if the computed hash (root) is equal to the provided root
        return computedHash == root;
    }
}

File 6 of 12 : SafeMath.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

File 7 of 12 : Strings.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

File 8 of 12 : VRFConsumerBase.sol

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

import "./interfaces/LinkTokenInterface.sol";

import "./VRFRequestIDBase.sol";

/** ****************************************************************************
 * @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.
 * *****************************************************************************
 * @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     constuctor(<other arguments>, address _vrfCoordinator, address _link)
 * @dev       VRFConsumerBase(_vrfCoordinator, _link) 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), and have told you the minimum LINK
 * @dev price for VRF service. Make sure your contract has sufficient LINK, and
 * @dev call requestRandomness(keyHash, fee, seed), where seed is the input you
 * @dev want to generate randomness from.
 *
 * @dev Once the VRFCoordinator has received and validated the oracle's response
 * @dev to your request, it will call your contract's fulfillRandomness method.
 *
 * @dev The randomness argument to fulfillRandomness is the actual random value
 * @dev generated from your seed.
 *
 * @dev The requestId argument is generated from the keyHash and the seed by
 * @dev makeRequestId(keyHash, seed). If your contract could have concurrent
 * @dev requests open, you can use the requestId to track which seed is
 * @dev associated with which randomness. See VRFRequestIDBase.sol for more
 * @dev details. (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. (Which is critical to making unpredictable randomness! See the
 * @dev next section.)
 *
 * *****************************************************************************
 * @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 ultimate input to the VRF is mixed with the block hash of the
 * @dev block in which the request is made, user-provided seeds have no impact
 * @dev on its economic security properties. They are only included for API
 * @dev compatability with previous versions of this contract.
 *
 * @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.
 */
abstract contract VRFConsumerBase is VRFRequestIDBase {

  /**
   * @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 VRFConsumerBase 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 randomness the VRF output
   */
  function fulfillRandomness(
    bytes32 requestId,
    uint256 randomness
  )
    internal
    virtual;

  /**
   * @dev In order to keep backwards compatibility we have kept the user
   * seed field around. We remove the use of it because given that the blockhash
   * enters later, it overrides whatever randomness the used seed provides.
   * Given that it adds no security, and can easily lead to misunderstandings,
   * we have removed it from usage and can now provide a simpler API.
   */
  uint256 constant private USER_SEED_PLACEHOLDER = 0;

  /**
   * @notice requestRandomness initiates a request for VRF output given _seed
   *
   * @dev The fulfillRandomness method receives the output, once it's provided
   * @dev by the Oracle, and verified by the vrfCoordinator.
   *
   * @dev The _keyHash must already be registered with the VRFCoordinator, and
   * @dev the _fee must exceed the fee specified during registration of the
   * @dev _keyHash.
   *
   * @dev The _seed parameter is vestigial, and is kept only for API
   * @dev compatibility with older versions. It can't *hurt* to mix in some of
   * @dev your own randomness, here, but it's not necessary because the VRF
   * @dev oracle will mix the hash of the block containing your request into the
   * @dev VRF seed it ultimately uses.
   *
   * @param _keyHash ID of public key against which randomness is generated
   * @param _fee The amount of LINK to send with the request
   *
   * @return requestId unique ID for this request
   *
   * @dev The returned requestId can be used to distinguish responses to
   * @dev concurrent requests. It is passed as the first argument to
   * @dev fulfillRandomness.
   */
  function requestRandomness(
    bytes32 _keyHash,
    uint256 _fee
  )
    internal
    returns (
      bytes32 requestId
    )
  {
    LINK.transferAndCall(vrfCoordinator, _fee, abi.encode(_keyHash, USER_SEED_PLACEHOLDER));
    // This is the seed passed to VRFCoordinator. The oracle will mix this with
    // the hash of the block containing this request to obtain the seed/input
    // which is finally passed to the VRF cryptographic machinery.
    uint256 vRFSeed  = makeVRFInputSeed(_keyHash, USER_SEED_PLACEHOLDER, address(this), nonces[_keyHash]);
    // nonces[_keyHash] must stay in sync with
    // VRFCoordinator.nonces[_keyHash][this], which was incremented by the above
    // successful LINK.transferAndCall (in VRFCoordinator.randomnessRequest).
    // This provides protection against the user repeating their input seed,
    // which would result in a predictable/duplicate output, if multiple such
    // requests appeared in the same block.
    nonces[_keyHash] = nonces[_keyHash] + 1;
    return makeRequestId(_keyHash, vRFSeed);
  }

  LinkTokenInterface immutable internal LINK;
  address immutable private vrfCoordinator;

  // Nonces for each VRF key from which randomness has been requested.
  //
  // Must stay in sync with VRFCoordinator[_keyHash][this]
  mapping(bytes32 /* keyHash */ => uint256 /* nonce */) private nonces;

  /**
   * @param _vrfCoordinator address of VRFCoordinator contract
   * @param _link address of LINK token contract
   *
   * @dev https://docs.chain.link/docs/link-token-contracts
   */
  constructor(
    address _vrfCoordinator,
    address _link
  ) {
    vrfCoordinator = _vrfCoordinator;
    LINK = LinkTokenInterface(_link);
  }

  // rawFulfillRandomness is called by VRFCoordinator when it receives a valid VRF
  // proof. rawFulfillRandomness then calls fulfillRandomness, after validating
  // the origin of the call
  function rawFulfillRandomness(
    bytes32 requestId,
    uint256 randomness
  )
    external
  {
    require(msg.sender == vrfCoordinator, "Only VRFCoordinator can fulfill");
    fulfillRandomness(requestId, randomness);
  }
}

File 9 of 12 : IERC721A.sol

// SPDX-License-Identifier: MIT
// ERC721A Contracts v3.3.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;

/**
 * @dev Interface of an ERC721A compliant contract.
 */
interface IERC721A {
    /**
     * The caller must own the token or be an approved operator.
     */
    error ApprovalCallerNotOwnerNorApproved();

    /**
     * The token does not exist.
     */
    error ApprovalQueryForNonexistentToken();

    /**
     * The caller cannot approve to their own address.
     */
    error ApproveToCaller();

    /**
     * The caller cannot approve to the current owner.
     */
    error ApprovalToCurrentOwner();

    /**
     * Cannot query the balance for the zero address.
     */
    error BalanceQueryForZeroAddress();

    /**
     * Cannot mint to the zero address.
     */
    error MintToZeroAddress();

    /**
     * The quantity of tokens minted must be more than zero.
     */
    error MintZeroQuantity();

    /**
     * The token does not exist.
     */
    error OwnerQueryForNonexistentToken();

    /**
     * The caller must own the token or be an approved operator.
     */
    error TransferCallerNotOwnerNorApproved();

    /**
     * The token must be owned by `from`.
     */
    error TransferFromIncorrectOwner();

    /**
     * Cannot safely transfer to a contract that does not implement the ERC721Receiver interface.
     */
    error TransferToNonERC721ReceiverImplementer();

    /**
     * Cannot transfer to the zero address.
     */
    error TransferToZeroAddress();

    /**
     * The token does not exist.
     */
    error URIQueryForNonexistentToken();

    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Keeps track of the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
    }

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     *
     * Burned tokens are calculated here, use `_totalMinted()` if you want to count just minted tokens.
     */
    function totalSupply() external view returns (uint256);

    // ==============================
    //            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);

    // ==============================
    //            IERC721
    // ==============================

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

    // ==============================
    //        IERC721Metadata
    // ==============================

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

File 10 of 12 : Context.sol

// SPDX-License-Identifier: MIT

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;
    }
}

File 11 of 12 : LinkTokenInterface.sol

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

interface LinkTokenInterface {

  function allowance(
    address owner,
    address spender
  )
    external
    view
    returns (
      uint256 remaining
    );

  function approve(
    address spender,
    uint256 value
  )
    external
    returns (
      bool success
    );

  function balanceOf(
    address owner
  )
    external
    view
    returns (
      uint256 balance
    );

  function decimals()
    external
    view
    returns (
      uint8 decimalPlaces
    );

  function decreaseApproval(
    address spender,
    uint256 addedValue
  )
    external
    returns (
      bool success
    );

  function increaseApproval(
    address spender,
    uint256 subtractedValue
  ) external;

  function name()
    external
    view
    returns (
      string memory tokenName
    );

  function symbol()
    external
    view
    returns (
      string memory tokenSymbol
    );

  function totalSupply()
    external
    view
    returns (
      uint256 totalTokensIssued
    );

  function transfer(
    address to,
    uint256 value
  )
    external
    returns (
      bool success
    );

  function transferAndCall(
    address to,
    uint256 value,
    bytes calldata data
  )
    external
    returns (
      bool success
    );

  function transferFrom(
    address from,
    address to,
    uint256 value
  )
    external
    returns (
      bool success
    );

}

File 12 of 12 : VRFRequestIDBase.sol

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

contract VRFRequestIDBase {

  /**
   * @notice returns the seed which is actually input to the VRF coordinator
   *
   * @dev To prevent repetition of VRF output due to repetition of the
   * @dev user-supplied seed, that seed is combined in a hash with the
   * @dev user-specific nonce, and the address of the consuming contract. The
   * @dev risk of repetition is mostly mitigated by inclusion of a blockhash in
   * @dev the final seed, but the nonce does protect against repetition in
   * @dev requests which are included in a single block.
   *
   * @param _userSeed VRF seed input provided by user
   * @param _requester Address of the requesting contract
   * @param _nonce User-specific nonce at the time of the request
   */
  function makeVRFInputSeed(
    bytes32 _keyHash,
    uint256 _userSeed,
    address _requester,
    uint256 _nonce
  )
    internal
    pure
    returns (
      uint256
    )
  {
    return uint256(keccak256(abi.encode(_keyHash, _userSeed, _requester, _nonce)));
  }

  /**
   * @notice Returns the id for this request
   * @param _keyHash The serviceAgreement ID to be used for this request
   * @param _vRFInputSeed The seed to be passed directly to the VRF
   * @return The id for this request
   *
   * @dev Note that _vRFInputSeed is not the seed passed by the consuming
   * @dev contract, but the one generated by makeVRFInputSeed
   */
  function makeRequestId(
    bytes32 _keyHash,
    uint256 _vRFInputSeed
  )
    internal
    pure
    returns (
      bytes32
    )
  {
    return keccak256(abi.encodePacked(_keyHash, _vRFInputSeed));
  }
}

Settings

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

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"BaseHash","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CurrentPhase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MaxPublicMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MaxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"MerkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PROVENANCE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PlaceholderHash","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PublicSaleOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"SaleOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"StartingIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UnitPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"WhitelistMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"backupRandomness","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":"_quantity","type":"uint256"},{"internalType":"address","name":"_addr","type":"address"}],"name":"devMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"incrementPhase","outputs":[],"stateMutability":"nonpayable","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":"bytes32[]","name":"_merkleProof","type":"bytes32[]"},{"internalType":"uint256","name":"_quantity","type":"uint256"}],"name":"publicMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"requestId","type":"bytes32"},{"internalType":"uint256","name":"randomness","type":"uint256"}],"name":"rawFulfillRandomness","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"},{"internalType":"address","name":"_addr","type":"address"}],"name":"remainingToMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_hash","type":"string"}],"name":"revealCollection","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":"string","name":"_hash","type":"string"}],"name":"setBaseHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_fee","type":"uint256"}],"name":"setFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_key","type":"bytes32"}],"name":"setKey","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_root","type":"bytes32"},{"internalType":"uint256","name":"_phase","type":"uint256"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_hash","type":"string"}],"name":"setPlaceholderHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_priceInWei","type":"uint256"}],"name":"setUnitPrice","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":[],"name":"toggleSaleOpen","outputs":[],"stateMutability":"nonpayable","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":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services