Token

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: Apache-2.0

pragma solidity 0.8.9; // code below expects that integer overflows will revert
import "./AreaNFT.sol";
import "./RandomDropVending.sol";
import "./Utilities/PlusCodes.sol";
import "./Vendor/openzeppelin-contracts-3dadd40034961d5ca75fa209a4188b01d7129501/access/Ownable.sol";

/// @title  Area main contract, 🌐 the earth on the blockchain, 📌 geolocation NFTs
/// @notice This contract is responsible for initial allocation and non-fungible tokens.
///         ⚠️ Bad things will happen if the reveals do not happen a sufficient amount for more than ~60 minutes.
/// @author William Entriken
contract Area is Ownable, AreaNFT, RandomDropVending {
    /// @param inventorySize  inventory for code length 4 tokens for sale (normally 43,200)
    /// @param teamAllocation how many set aside for team
    /// @param pricePerPack   the cost in Wei for each pack
    /// @param packSize       how many drops can be purchased at a time
    /// @param name           ERC721 contract name
    /// @param symbol         ERC721 symbol name
    /// @param baseURI        prefix for all token URIs
    /// @param priceToSplit   value (in Wei) required to split Area tokens
    constructor(
        uint256 inventorySize,
        uint256 teamAllocation,
        uint256 pricePerPack,
        uint32 packSize,
        string memory name,
        string memory symbol,
        string memory baseURI,
        uint256 priceToSplit
    )
        RandomDropVending(inventorySize, teamAllocation, pricePerPack, packSize)
        AreaNFT(name, symbol, baseURI, priceToSplit)
    {
    }

    /// @notice Start the sale
    function beginSale() external onlyOwner {
        _beginSale();
    }

    /// @notice In case of emergency, the number of allocations set aside for the team can be adjusted
    /// @param  teamAllocation the new allocation amount
    function setTeamAllocation(uint256 teamAllocation) external onlyOwner {
        _setTeamAllocation(teamAllocation);
    }

    /// @notice A quantity of Area tokens that were committed by anybody and are now mature are revealed
    /// @param  revealsLeft up to how many reveals will occur
    function reveal(uint32 revealsLeft) external onlyOwner {
        RandomDropVending._reveal(revealsLeft);
    }

    /// @notice Takes some of the code length 4 codes that are not near the poles and assigns them. Team is unable to
    ///         take tokens until all other tokens are allocated from sale.
    /// @param  recipient the account that is assigned the tokens
    /// @param  quantity  how many to assign
    function mintTeamAllocation(address recipient, uint256 quantity) external onlyOwner {
        RandomDropVending._takeTeamAllocation(recipient, quantity);
    }

    /// @notice Takes some of the code length 2 codes that are near the poles and assigns them. Team is unable to take
    ///         tokens until all other tokens are allocated from sale.
    /// @param  recipient    the account that is assigned the tokens
    /// @param  indexFromOne a number in the closed range [1, 54]
    function mintWaterAndIceReserve(address recipient, uint256 indexFromOne) external onlyOwner {
        require(RandomDropVending._inventoryForSale() == 0, "Cannot take during sale");
        uint256 tokenId = PlusCodes.getNthCodeLength2CodeNearPoles(indexFromOne);
        AreaNFT._mint(recipient, tokenId);
    }

    /// @notice Pay the bills
    function withdrawBalance() external onlyOwner {
        payable(msg.sender).transfer(address(this).balance);
    }

    /// @dev Convert a Plus Code token ID to an ASCII (and UTF-8) string
    /// @param  plusCode  the Plus Code token ID to format
    /// @return the ASCII (and UTF-8) string showing the Plus Code token ID
    function tokenIdToString(uint256 plusCode) external pure returns(string memory) {
        return PlusCodes.toString(plusCode);
    }

    /// @dev Convert ASCII string to a Plus Code token ID
    /// @param  stringPlusCode the ASCII (UTF-8) Plus Code token ID
    /// @return plusCode       the Plus Code token ID representing the provided ASCII string
    function stringToTokenId(string memory stringPlusCode) external pure returns(uint256 plusCode) {
        return PlusCodes.fromString(stringPlusCode);
    }

    /// @inheritdoc RandomDropVending
    function _revealCallback(address recipient, uint256 allocation) internal override(RandomDropVending) {
        uint256 tokenId = PlusCodes.getNthCodeLength4CodeNotNearPoles(allocation);
        AreaNFT._mint(recipient, tokenId);
    }
}

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

// SPDX-License-Identifier: Apache-2.0

pragma solidity 0.8.9;

/* Quick reference of valid Plus Codes (full code) formats, where D is some Plus Codes digit
 *
 * Code length 2:  DD000000+
 * Code length 4:  DDDD0000+
 * Code length 6:  DDDDDD00+
 * Code length 8:  DDDDDDDD+
 * Code length 10: DDDDDDDD+DD
 * Code length 11: DDDDDDDD+DDD
 * Code length 12: DDDDDDDD+DDDD
 * Code length 13: DDDDDDDD+DDDDD
 * Code length 14: DDDDDDDD+DDDDDD
 * Code length 15: DDDDDDDD+DDDDDDD
 */

/// @title  Part of Area, 🌐 the earth on the blockchain, 📌 geolocation NFTs
/// @notice Utilities for working with a subset (upper case and no higher than code length 12) of Plus Codes
/// @dev    A Plus Code is a character string representing GPS coordinates. See complete specification at
///         https://github.com/google/open-location-code.
///         We encode this string using ASCII, little endian, into a 256-bit integer. Following is an example code
///         length 8 Plus Code:
/// String:                                                  2 2 2 2 0 0 0 0 +
/// Hex:    0x000000000000000000000000000000000000000000000032323232303030302B
/// @author William Entriken
library PlusCodes {
    struct ChildTemplate {
        uint256 setBits;       // Every child is guaranteed to set these bits
        uint32 childCount;     // How many children are there, either 20 or 400
        uint32 digitsLocation; // How many bits must the child's significant digit(s) be left-shifted before adding
                               // (oring) to `setBits`?
    }

    /// @dev Plus Codes digits use base-20, these are the constituent digits
    bytes20 private constant _PLUS_CODES_DIGITS = bytes20("23456789CFGHJMPQRVWX");

    /// @notice Get the Plus Code at a certain index from the list of all code level 4 Plus Codes which are not near the
    ///         north or south poles
    /// @dev    Code length 4 Plus Codes represent 1 degree latitude by 1 degree longitude. We consider 40 degrees from
    ///         the South Pole and 20 degrees from the North Pole as "near". Therefore 360 × 120 = 43,200 Plus Codes are
    ///         here.
    /// @param  indexFromOne a number in the closed range [1, 43,200]
    /// @return plusCode     the n-th (one-indexed) Plus Code from the alphabetized list of all code length 4 Plus Codes
    ///                      which are not "near" a pole
    function getNthCodeLength4CodeNotNearPoles(uint256 indexFromOne) internal pure returns (uint256 plusCode) {
        require((indexFromOne >= 1) && (indexFromOne <= 43200), "Out of range");
        uint256 indexFromZero = indexFromOne - 1; // In the half-open range [0, 43,200)

        plusCode = uint256(uint40(bytes5("0000+")));
        // 0x000000000000000000000000000000000000000000000000000000303030302B;

        // Least significant digit can take any of 20 values
        plusCode |= uint256(uint8(_PLUS_CODES_DIGITS[indexFromZero % 20])) << 8*5;
        // 0x0000000000000000000000000000000000000000000000000000__303030302B;
        indexFromZero /= 20;

        // Next digit can take any of 20 values
        plusCode |= uint256(uint8(_PLUS_CODES_DIGITS[indexFromZero % 20])) << 8*6;
        // 0x00000000000000000000000000000000000000000000000000____303030302B;
        indexFromZero /= 20;

        // Next digit can take any of 18 values (18 × 20 degrees = 360 degrees)
        plusCode |= uint256(uint8(_PLUS_CODES_DIGITS[indexFromZero % 18])) << 8*7;
        // 0x000000000000000000000000000000000000000000000000______303030302B;
        indexFromZero /= 18;

        // Most significant digit can be not the lowest 2 nor highest 1 (6 options)
        plusCode |= uint256(uint8(_PLUS_CODES_DIGITS[2 + indexFromZero])) << 8*8;
        // 0x0000000000000000000000000000000000000000000000________303030302B;
    }

    /// @notice Get the Plus Code at a certain index from the list of all code level 2 Plus Codes which are near the
    ///         north or south poles
    /// @dev    Code length 2 Plus Codes represent 20 degrees latitude by 20 degrees longitude. We consider 40 degrees
    ///         from the South Pole and 20 degrees from the North Pole as "near". Therefore 360 × 60 ÷ 20 ÷ 20 = 54 Plus
    ///         Codes are here.
    /// @param  indexFromOne a number in the closed range [1, 54]
    /// @return plusCode     the n-th (one-indexed) Plus Code from the alphabetized list of all code length 2 Plus Codes
    ///                      which are "near" a pole
    function getNthCodeLength2CodeNearPoles(uint256 indexFromOne) internal pure returns (uint256 plusCode) {
        require((indexFromOne >= 1) && (indexFromOne <= 54), "Out of range");
        uint256 indexFromZero = indexFromOne - 1; // In the half-open range [0, 54)

        plusCode = uint256(uint56(bytes7("000000+")));
        // 0x000000000000000000000000000000000000000000000000003030303030302B;

        // Least significant digit can take any of 18 values (18 × 20 degrees = 360 degrees)
        plusCode |= uint256(uint8(_PLUS_CODES_DIGITS[indexFromZero % 18])) << 8*7;
        // 0x000000000000000000000000000000000000000000000000__3030303030302B;
        indexFromZero /= 18;

        // Most significant digit determines latitude
        if (indexFromZero <= 1) {
            // indexFromZero ∈ {0, 1}, this is the 40 degrees near South Pole
            plusCode |= uint256(uint8(_PLUS_CODES_DIGITS[indexFromZero])) << 8*8;
            // 0x0000000000000000000000000000000000000000000000____3030303030302B;
        } else {
            // indexFromZero = 2, this is the 20 degrees near North Pole
            plusCode |= uint256(uint8(_PLUS_CODES_DIGITS[8])) << 8*8;
            // 0x000000000000000000000000000000000000000000000043__3030303030302B;
        }
    }

    /// @notice Find the Plus Code representing `childCode` plus some more area if input is a valid Plus Code; otherwise
    ///         revert
    /// @param  childCode  a Plus Code
    /// @return parentCode the Plus Code representing the smallest area which contains the `childCode` area plus some
    ///                    additional area
    function getParent(uint256 childCode) internal pure returns (uint256 parentCode) {
        uint8 childCodeLength = getCodeLength(childCode);
        if (childCodeLength == 2) {
            revert("Code length 2 Plus Codes do not have parents");
        }
        if (childCodeLength == 4) {
            return childCode & 0xFFFF00000000000000 | 0x3030303030302B;
        }
        if (childCodeLength == 6) {
            return childCode & 0xFFFFFFFF0000000000 | 0x303030302B;
        }
        if (childCodeLength == 8) {
            return childCode & 0xFFFFFFFFFFFF000000 | 0x30302B;
        }
        if (childCodeLength == 10) {
            return childCode >> 8*2;
        }
        // childCodeLength ∈ {11, 12}
        return childCode >> 8*1;
    }

    /// @notice Create a template for enumerating Plus Codes that are a portion of `parentCode` if input is a valid Plus
    ///         Code; otherwise revert
    /// @dev    A "child" is a Plus Code representing the largest area which contains some of the `parentCode` area
    ///         minus some area.
    /// @param  parentCode    a Plus Code to operate on
    /// @return childTemplate bit pattern and offsets every child will have
    function getChildTemplate(uint256 parentCode) internal pure returns (ChildTemplate memory) {
        uint8 parentCodeLength = getCodeLength(parentCode);
        if (parentCodeLength == 2) {
            return ChildTemplate(parentCode & 0xFFFF0000FFFFFFFFFF, 400, 8*5);
            // DD__0000+
        }
        if (parentCodeLength == 4) {
            return ChildTemplate(parentCode & 0xFFFFFFFF0000FFFFFF, 400, 8*3);
            // DDDD__00+
        }
        if (parentCodeLength == 6) {
            return ChildTemplate(parentCode & 0xFFFFFFFFFFFF0000FF, 400, 8*1);
            // DDDDDD__+
        }
        if (parentCodeLength == 8) {
            return ChildTemplate(parentCode << 8*2, 400, 0);
            // DDDDDDDD+__
        }
        if (parentCodeLength == 10) {
            return ChildTemplate(parentCode << 8*1, 20, 0);
            // DDDDDDDD+DD_
        }
        if (parentCodeLength == 11) {
            return ChildTemplate(parentCode << 8*1, 20, 0);
            // DDDDDDDD+DDD_
        }
        revert("Plus Codes with code length greater than 12 not supported");
    }

    /// @notice Find a child Plus Code based on a template
    /// @dev    A "child" is a Plus Code representing the largest area which contains some of a "parent" area minus some
    ///         area.
    /// @param  indexFromZero which child (zero-indexed) to generate, must be less than `template.childCount`
    /// @param  template      tit pattern and offsets to generate child
    function getNthChildFromTemplate(uint32 indexFromZero, ChildTemplate memory template)
        internal
        pure
        returns (uint256 childCode)
    {
        // This may run in a 400-wide loop (for Transfer events), keep it tight

        // These bits are guaranteed
        childCode = template.setBits;

        // Add rightmost digit
        uint8 rightmostDigit = uint8(_PLUS_CODES_DIGITS[indexFromZero % 20]);
        childCode |= uint256(rightmostDigit) << template.digitsLocation;
        // 0xTEMPLATETEMPLATETEMPLATETEMPLATETEMPLATETEMPLATETEMPLATETEML=ATE;

        // Do we need to add a second digit?
        if (template.childCount == 400) {
            uint8 secondDigit = uint8(_PLUS_CODES_DIGITS[indexFromZero / 20]);
            childCode |= uint256(secondDigit) << (template.digitsLocation + 8*1);
            // 0xTEMPLATETEMPLATETEMPLATETEMPLATETEMPLATETEMPLATETEMPLATETEM==ATE;
        }
    }

    /// @dev Returns 2, 4, 6, 8, 10, 11, or 12 for valid Plus Codes, otherwise reverts
    /// @param  plusCode the Plus Code to format
    /// @return the code length
    function getCodeLength(uint256 plusCode) internal pure returns(uint8) {
        if (bytes1(uint8(plusCode)) == "+") {
            // Code lengths 2, 4, 6 and 8 are the only ones that end with the format separator (+) and they have exactly
            // 9 characters.
            require((plusCode >> 8*9) == 0, "Too many characters in Plus Code");
            _requireValidDigit(plusCode, 8);
            _requireValidDigit(plusCode, 7);
            require(bytes1(uint8(plusCode >> 8*8)) <= "C", "Beyond North Pole");
            require(bytes1(uint8(plusCode >> 8*7)) <= "V", "Beyond antimeridian");
            if (bytes7(uint56(plusCode & 0xFFFFFFFFFFFFFF)) == "000000+") {
                return 2;
            }
            _requireValidDigit(plusCode, 6);
            _requireValidDigit(plusCode, 5);
            if (bytes5(uint40(plusCode & 0xFFFFFFFFFF)) == "0000+") {
                return 4;
            }
            _requireValidDigit(plusCode, 4);
            _requireValidDigit(plusCode, 3);
            if (bytes3(uint24(plusCode & 0xFFFFFF)) == "00+") {
                return 6;
            }
            _requireValidDigit(plusCode, 2);
            _requireValidDigit(plusCode, 1);
            return 8;
        }
        // Only code lengths 10, 11 and 12 (or more) don't end with a format separator.
        _requireValidDigit(plusCode, 0);
        _requireValidDigit(plusCode, 1);
        if (bytes1(uint8(plusCode >> 8*2)) == "+") {
            require(getCodeLength(plusCode >> 8*2) == 8, "Invalid before +");
            return 10;
        }
        _requireValidDigit(plusCode, 2);
        if (bytes1(uint8(plusCode >> 8*3)) == "+") {
            require(getCodeLength(plusCode >> 8*3) == 8, "Invalid before +");
            return 11;
        }
        _requireValidDigit(plusCode, 3);
        if (bytes1(uint8(plusCode >> 8*4)) == "+") {
            require(getCodeLength(plusCode >> 8*4) == 8, "Invalid before +");
            return 12;
        }
        revert("Code lengths greater than 12 are not supported");
    }

    /// @dev Convert a Plus Code to an ASCII (and UTF-8) string
    /// @param  plusCode the Plus Code to format
    /// @return the ASCII (and UTF-8) string showing the Plus Code
    function toString(uint256 plusCode) internal pure returns(string memory) {
        getCodeLength(plusCode);
        bytes memory retval = new bytes(0);
        while (plusCode > 0) {
            retval = abi.encodePacked(uint8(plusCode % 2**8), retval);
            plusCode >>= 8;
        }
        return string(retval);
    }

    /// @dev Convert ASCII string to a Plus Code
    /// @param  stringPlusCode the ASCII (UTF-8) Plus Code
    /// @return plusCode       the Plus Code representing the provided ASCII string
    function fromString(string memory stringPlusCode) internal pure returns(uint256 plusCode) {
        bytes memory bytesPlusCode = bytes(stringPlusCode);
        for (uint index=0; index<bytesPlusCode.length; index++) {
            plusCode = (plusCode << 8) + uint8(bytesPlusCode[index]);
        }
        PlusCodes.getCodeLength(plusCode);
    }

    /// @dev Reverts if the given byte is not a valid Plus Codes digit
    function _requireValidDigit(uint256 plusCode, uint8 offsetFromRightmostByte) private pure {
        uint8 digit = uint8(plusCode >> (8 * offsetFromRightmostByte));
        for (uint256 index = 0; index < 20; index++) {
            if (uint8(_PLUS_CODES_DIGITS[index]) == digit) {
                return;
            }
        }
        revert("Not a valid Plus Codes digit");
    }
}

// SPDX-License-Identifier: Apache-2.0

pragma solidity 0.8.9; // code below expects that integer overflows will revert
import "./Utilities/LazyArray.sol";
import "./Utilities/PlusCodes.sol";
import "./Utilities/CommitQueue.sol";

/// @title  Area commit-reveal drop contract, 🌐 the earth on the blockchain, 📌 geolocation NFTs
/// @notice This contract assigns all code length 4 Plus Codes to participants with randomness provided by a
///         commit-reveal mechanism. ⚠️ Bad things will happen if the reveals do not happen a sufficient amount for more
///         than ~60 minutes.
/// @dev    Each commit must be revealed (by the next committer or a benevolent revealer) to ensure that the intended
///         randomness for that, and subsequent, commits are used.
/// @author William Entriken
abstract contract RandomDropVending {
    using CommitQueue for CommitQueue.Self;
    CommitQueue.Self private _commitQueue;

    using LazyArray for LazyArray.Self;
    LazyArray.Self private _dropInventoryIntegers;

    uint256 private immutable _pricePerPack;
    uint32 private immutable _packSize;
    bool private _saleDidNotBeginYet;
    uint256 private _teamAllocation;

    /// @notice Some code length 4 Plus Codes were purchased, but not yet revealed
    /// @param  buyer    who purchased
    /// @param  quantity how many were purchased
    event Purchased(address buyer, uint32 quantity);

    /// @param inventorySize   integers [1, quantity] are available
    /// @param teamAllocation_ how many set aside for team
    /// @param pricePerPack_   the cost in Wei for each pack
    /// @param packSize_       how many drops can be purchased at a time
    constructor(uint256 inventorySize, uint256 teamAllocation_, uint256 pricePerPack_, uint32 packSize_) {
        require((inventorySize - teamAllocation_) % packSize_ == 0, "Pack size must evenly divide sale quantity");
        require(inventorySize > teamAllocation_, "None for sale, no fun");
        _dropInventoryIntegers.initialize(inventorySize);
        _teamAllocation = teamAllocation_;
        _pricePerPack = pricePerPack_;
        _packSize = packSize_;
        _saleDidNotBeginYet = true;
    }

    /// @notice A quantity of code length 4 Areas are committed for the benefit of the message sender, to be revealed
    ///         soon later. And a quantity of code length 4 Areas that were committed by anybody and are now mature are
    ///         revealed.
    /// @dev    ⚠️ If a commitment is made and is mature more than ~60 minutes without being revealed, then assignment
    ///         will use randomness from the then-current block hash, rather than the intended block hash.
    /// @param  benevolence how many reveals will be attempted in addition to the number of commits
    function purchaseTokensAndReveal(uint32 benevolence) external payable {
        require(msg.value == _pricePerPack, "Did not send correct Ether amount");
        require(_inventoryForSale() >= _packSize, "Sold out");
        require(msg.sender == tx.origin, "Only externally-owned accounts are eligible to purchase");
        require(_saleDidNotBeginYet == false, "The sale did not begin yet");
        _commit();
        _reveal(_packSize + benevolence); // overflow reverts
    }

    /// @notice Important numbers about the drop
    /// @return inventoryForSale how many more can be committed for sale
    /// @return queueCount       how many were committed but not yet revealed
    /// @return setAside         how many are remaining for team to claim
    function dropStatistics() external view returns (uint256 inventoryForSale, uint256 queueCount, uint256 setAside) {
        return (
            _inventoryForSale(),
            _commitQueue.count(),
            _teamAllocation <= _dropInventoryIntegers.count()
                ? _teamAllocation
                : _dropInventoryIntegers.count()
        );
    }

    /// @notice Start the sale
    function _beginSale() internal {
        _saleDidNotBeginYet = false;
    }

    /// @notice In case of emergency, the number of allocations set aside for the team can be adjusted
    /// @param  teamAllocation_ the new allocation amount
    function _setTeamAllocation(uint256 teamAllocation_) internal {
        _teamAllocation = teamAllocation_;
    }

    /// @notice A quantity of integers that were committed by anybody and are now mature are revealed
    /// @param  revealsLeft up to how many reveals will occur
    function _reveal(uint32 revealsLeft) internal {
        for (; revealsLeft > 0 && _commitQueue.isMature(); revealsLeft--) {
            // Get one from queue
            address recipient;
            uint64 maturityBlock;
            (recipient, maturityBlock) = _commitQueue.dequeue();

            // Allocate randomly
            uint256 randomNumber = _random(maturityBlock);
            uint256 randomIndex = randomNumber % _dropInventoryIntegers.count();
            uint allocatedNumber = _dropInventoryIntegers.popByIndex(randomIndex);
            _revealCallback(recipient, allocatedNumber);
        }
    }

    /// @dev   This callback triggers when some drop is revealed.
    /// @param recipient  the beneficiary of the drop
    /// @param allocation which number was dropped
    function _revealCallback(address recipient, uint256 allocation) internal virtual;

    /// @notice Takes some integers (not randomly) in inventory and assigns them. Team does not get tokens until all
    ///         other integers are allocated.
    /// @param  recipient the account that is assigned the integers
    /// @param  quantity  how many integers to assign
    function _takeTeamAllocation(address recipient, uint256 quantity) internal {
        require(_inventoryForSale() == 0, "Cannot take during sale");
        require(quantity <= _dropInventoryIntegers.count(), "Not enough to take");
        for (; quantity > 0; quantity--) {
            uint256 lastIndex = _dropInventoryIntegers.count() - 1;
            uint256 allocatedNumber = _dropInventoryIntegers.popByIndex(lastIndex);
            _revealCallback(recipient, allocatedNumber);
        }
    }

    /// @dev Get a random number based on the given block's hash; or some other hash if not available
    function _random(uint256 blockNumber) internal view returns (uint256) {
        // Blockhash produces non-zero values only for the input range [block.number - 256, block.number - 1]
        if (blockhash(blockNumber) != 0) {
            return uint256(blockhash(blockNumber));
        }
        return uint256(blockhash(((block.number - 1)>>8)<<8));
    }

    /// @notice How many more can be committed for sale
    function _inventoryForSale() internal view returns (uint256) {
        uint256 inventoryAvailable = _commitQueue.count() >= _dropInventoryIntegers.count()
            ? 0
            : _dropInventoryIntegers.count() - _commitQueue.count();
        return _teamAllocation >= inventoryAvailable
            ? 0
            : inventoryAvailable - _teamAllocation;
    }

    /// @notice A quantity of integers are committed for the benefit of the message sender, to be revealed soon later.
    /// @dev    ⚠️ If a commitment is made and is mature more than ~60 minutes without being revealed, then assignment
    ///         will use randomness from the then-current block hash, rather than the intended block hash.
    function _commit() private {
        _commitQueue.enqueue(msg.sender, _packSize);
        emit Purchased(msg.sender, _packSize);
    }
}

// SPDX-License-Identifier: Apache-2.0

pragma solidity 0.8.9; // code below expects that integer overflows will revert
import "./Vendor/openzeppelin-contracts-3dadd40034961d5ca75fa209a4188b01d7129501/token/ERC721/ERC721.sol";
import "./Vendor/openzeppelin-contracts-3dadd40034961d5ca75fa209a4188b01d7129501/access/Ownable.sol";
import "./Utilities/PlusCodes.sol";

/// @title  Area NFT contract, 🌐 the earth on the blockchain, 📌 geolocation NFTs
/// @notice This implementation adds features to the baseline ERC-721 standard:
///         - groups of tokens (siblings) are stored efficiently
///         - tokens can be split
/// @dev    This builds on the OpenZeppelin Contracts implementation
/// @author William Entriken
abstract contract AreaNFT is ERC721, Ownable {
    // The prefix for all token URIs
    string internal _baseTokenURI;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _explicitOwners;

    // Mapping from token ID to owner address, if a token is split
    mapping(uint256 => address) private _splitOwners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

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

    // Price to split an area in Wei
    uint256 private _priceToSplit;

    /// @dev Contract constructor
    /// @param name_         ERC721 contract name
    /// @param symbol_       ERC721 symbol name
    /// @param baseURI       prefix for all token URIs
    /// @param priceToSplit_ value (in Wei) required to split Area tokens
    constructor(string memory name_, string memory symbol_, string memory baseURI, uint256 priceToSplit_)
        ERC721(name_, symbol_)
    {
        _baseTokenURI = baseURI;
        _priceToSplit = priceToSplit_;
    }

    /// @notice The owner of an Area Token can irrevocably split it into Plus Codes at one greater level of precision.
    /// @dev    This is the only function with burn functionality. The newly minted tokens do not cause a call to
    ///         onERC721Received on the recipient.
    /// @param  tokenId the token that will be split
    function split(uint256 tokenId) external payable {
        require(msg.value == _priceToSplit, "Did not send correct Ether amount");
        require(_msgSender() == ownerOf(tokenId), "AreaNFT: split caller is not owner");
        _burn(tokenId);

        // Split. This causes our ownerOf(childTokenId) to return the owner
        _splitOwners[tokenId] = _msgSender();

        // Ghost mint the child tokens
        // Ghost mint (verb): create N tokens on-chain (i.e. ownerOf returns something) without using N storage slots
        PlusCodes.ChildTemplate memory template = PlusCodes.getChildTemplate(tokenId);
        _balances[_msgSender()] += template.childCount; // Solidity 0.8+
        for (uint32 index = 0; index < template.childCount; index++) {
            uint256 childTokenId = PlusCodes.getNthChildFromTemplate(index, template);
            emit Transfer(address(0), _msgSender(), childTokenId);
        }
    }

    /// @notice Update the price to split Area tokens
    /// @param  newPrice value (in Wei) required to split Area tokens
    function setPriceToSplit(uint256 newPrice) external onlyOwner {
        _priceToSplit = newPrice;
    }

    /// @notice Update the base URI for token metadata
    /// @dev    All data you need is on-chain via token ID, and metadata is real world data. This Base URI is completely
    ///         optional and is only here to facilitate serving to marketplaces.
    /// @param  baseURI the new URI to prepend to all token URIs
    function setBaseURI(string calldata baseURI) external onlyOwner {
        _baseTokenURI = baseURI;
    }

    /// @inheritdoc ERC721
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

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

        _approve(to, tokenId);
    }

    /// @inheritdoc ERC721
    function ownerOf(uint256 tokenId) public view override returns (address owner) {
        owner = _explicitOwners[tokenId];
        if (owner != address(0)) {
            return owner;
        }
        require(_splitOwners[tokenId] == address(0), "AreaNFT: owner query for invalid (split) token");
        uint256 parentTokenId = PlusCodes.getParent(tokenId);
        owner = _splitOwners[parentTokenId];
        if (owner != address(0)) {
            return owner;
        }
        revert("ERC721: owner query for nonexistent token");
    }

    /// @inheritdoc ERC721
    /// @dev We must override because we need to access the derived `_tokenApprovals` variable that is set by the
    ///      derived`_approved`.
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /// @inheritdoc ERC721
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _balances[owner];
    }

    /// @inheritdoc ERC721
    function _burn(uint256 tokenId) internal virtual override {
        address owner = ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _explicitOwners[tokenId];

        emit Transfer(owner, address(0), tokenId);
    }

    /// @inheritdoc ERC721
    function _transfer(address from, address to, uint256 tokenId) internal virtual override {
        require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

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

        _balances[from] -= 1;
        _balances[to] += 1;
        _explicitOwners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

    /// @inheritdoc ERC721
    /// @dev We must override because we need the derived `ownerOf` function.
    function _approve(address to, uint256 tokenId) internal virtual override {
        _tokenApprovals[tokenId] = to;
        emit Approval(ownerOf(tokenId), to, tokenId);
    }

    /// @inheritdoc ERC721
    function _mint(address to, uint256 tokenId) internal virtual override {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");
        require(_splitOwners[tokenId] == address(0), "AreaNFT: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _explicitOwners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);
    }

    /// @inheritdoc ERC721
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual override returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /// @inheritdoc ERC721
    function _exists(uint256 tokenId) internal view virtual override returns (bool) {
        address owner;
        owner = _explicitOwners[tokenId];
        if (owner != address(0)) {
            return true;
        }
        if (_splitOwners[tokenId] != address(0)) { // query for invalid (split) token
            return false;
        }
        if (PlusCodes.getCodeLength(tokenId) > 2) { // It has a parent; This throws if it's not a valid plus code.
            uint256 parentTokenId = PlusCodes.getParent(tokenId);
            owner = _splitOwners[parentTokenId];
            if (owner != address(0)) {
                return true;
            }
        }
        return false;
    }

    /// @inheritdoc ERC721
    function _baseURI() internal view virtual override returns (string memory) {
        return _baseTokenURI;
    }
}

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

// SPDX-License-Identifier: Apache-2.0

pragma solidity 0.8.9; // code below expects that integer overflows will revert

/// @title  Part of Area, 🌐 the earth on the blockchain, 📌 geolocation NFTs
/// @notice A multi-queue data structure for commits that are waiting to be revealed
/// @author William Entriken
library CommitQueue {
    struct Self {
        // Storage of all elements
        mapping(uint256 => Element) elements;

        // The position of the first element if queue is not empty
        uint32 startIndex;

        // The queue’s “past the end” position, i.e. one greater than the last valid subscript argument
        uint32 endIndex;

        // How many items (sum of Element.quantity) are in the queue
        uint256 length;
    }

    struct Element {
        // These sizes are chosen to fit in one EVM word
        address beneficiary;
        uint64 maturityBlock;
        uint32 quantity; // this must be greater than zero
    }

    /// @notice Adds a new entry to the end of the queue
    /// @param  self        the data structure
    /// @param  beneficiary an address associated with the commitment
    /// @param  quantity    how many to enqueue
    function enqueue(Self storage self, address beneficiary, uint32 quantity) internal {
        require(quantity > 0, "Quantity is missing");
        self.elements[self.endIndex] = Element(
            beneficiary,
            uint64(block.number), // maturityBlock, hash thereof not yet known
            quantity
        );
        self.endIndex += 1;
        self.length += quantity;
    }

    /// @notice Removes and returns the first element of the multi-queue; reverts if queue is empty
    /// @param  self          the data structure
    /// @return beneficiary   an address associated with the commitment
    /// @return maturityBlock when this commitment matured
    function dequeue(Self storage self) internal returns (address beneficiary, uint64 maturityBlock) {
        require(!_isEmpty(self), "Queue is empty");
        beneficiary = self.elements[self.startIndex].beneficiary;
        maturityBlock = self.elements[self.startIndex].maturityBlock;
        if (self.elements[self.startIndex].quantity == 1) {
            delete self.elements[self.startIndex];
            self.startIndex += 1;
        } else {
            self.elements[self.startIndex].quantity -= 1;
        }
        self.length -= 1;
    }

    /// @notice Checks whether the first element can be revealed
    /// @dev    Elements are added to the queue in order, so if the first element is not mature than neither are all
    ///         remaining elements.
    /// @param  self the data structure
    /// @return true if the first element exists and is mature; false otherwise
    function isMature(Self storage self) internal view returns (bool) {
        if (_isEmpty(self)) {
            return false;
        }
        return block.number > self.elements[self.startIndex].maturityBlock;
    }

    /// @notice Finds how many items are remaining to be dequeued
    /// @dev    This is the sum of Element.quantity.
    /// @param  self the data structure
    /// @return how many items are in the queue (i.e. how many dequeues can happen)
    function count(Self storage self) internal view returns (uint256) {
        return self.length;
    }

    /// @notice Whether or not the queue is empty
    /// @param  self the data structure
    /// @return true if the queue is empty; false otherwise
    function _isEmpty(Self storage self) private view returns (bool) {
        return self.startIndex == self.endIndex;
    }
}

// SPDX-License-Identifier: Apache-2.0

pragma solidity 0.8.9; // code below expects that integer overflows will revert

/// @title  Part of Area, 🌐 the earth on the blockchain, 📌 geolocation NFTs
/// @notice A data structure that supports random read and delete access and that efficiently initializes to a range of
///         [1, N]
/// @author William Entriken
library LazyArray {
    struct Self {
        // This stores element values and cannot represent an underlying value of zero.
        //
        // A zero value at index i represents an element of (i+1). Any other value stored in the array represents an
        // element of that value. We employ this technique because all storage in Solidity starts at zero.
        //
        // e.g. the array [0, 135, 243, 0, 500] represents the values [1, 135, 243, 5, 500]. Then if we remove the 135
        // that becomes [0, 500, 243, 0] which represents the values [1, 500, 243, 5].
        mapping(uint256 => uint256) elements;

        // Adding to this value logically appends a sequence to the array ending in `length`. E.g. changing from 0 to 2
        // makes [1, 2].
        uint256 length;
    }

    /// @notice Sets the logical contents to a range of [1, N]. Setting near 2**(256-DIFFICULTY) creates a security
    ///         vulnerability.
    /// @param  self          the data structure
    /// @param  initialLength how big to make the range
    function initialize(Self storage self, uint256 initialLength) internal {
        require(self.length == 0, "Cannot initialize non-empty structure");
        self.length = initialLength;
    }

    /// @notice Removes and returns the n-th logical element
    /// @param  self   the data structure
    /// @param  index  which element (zero indexed) to remove and return
    /// @return popped the specified element
    function popByIndex(Self storage self, uint256 index) internal returns (uint256 popped) {
        popped = getByIndex(self, index);
        uint256 lastIndex = self.length - 1; // will not underflow b/c prior get
        if (index < lastIndex) {
            uint256 lastElement = getByIndex(self, lastIndex);
            self.elements[index] = lastElement;
        }
        delete self.elements[lastIndex];
        self.length -= 1;
    }

    /// @notice Returns the n-th logical element
    /// @param  self    the data structure
    /// @param  index   which element (zero indexed) to get
    /// @return element the specified element
    function getByIndex(Self storage self, uint256 index) internal view returns (uint256 element) {
        require(index < self.length, "Out of bounds");
        return self.elements[index] == 0
            ? index + 1 // revert on overflow
            : self.elements[index];
    }

    /// @notice Finds how many items remain
    /// @param  self   the data structure
    /// @return the number of remaining items
    function count(Self storage self) internal view returns (uint256) {
        return self.length;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./extensions/IERC721Metadata.sol";
import "../../utils/Address.sol";
import "../../utils/Context.sol";
import "../../utils/Strings.sol";
import "../../utils/introspection/ERC165.sol";

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

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

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

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

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

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

    /**
     * @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), "ERC721Metadata: 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 = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: 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), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(operator != _msgSender(), "ERC721: 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), "ERC721: 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), "ERC721: 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, _data), "ERC721: 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`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @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), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

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

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

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);
    }

    /**
     * @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 owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), 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 {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

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

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.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 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 _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * 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, ``from``'s `tokenId` will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

// SPDX-License-Identifier: MIT

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @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
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT

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

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 `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT

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`, 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 Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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

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

// SPDX-License-Identifier: MIT

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

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"inventorySize","type":"uint256"},{"internalType":"uint256","name":"teamAllocation","type":"uint256"},{"internalType":"uint256","name":"pricePerPack","type":"uint256"},{"internalType":"uint32","name":"packSize","type":"uint32"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"string","name":"baseURI","type":"string"},{"internalType":"uint256","name":"priceToSplit","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"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":"address","name":"buyer","type":"address"},{"indexed":false,"internalType":"uint32","name":"quantity","type":"uint32"}],"name":"Purchased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"beginSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"dropStatistics","outputs":[{"internalType":"uint256","name":"inventoryForSale","type":"uint256"},{"internalType":"uint256","name":"queueCount","type":"uint256"},{"internalType":"uint256","name":"setAside","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"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":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"mintTeamAllocation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"indexFromOne","type":"uint256"}],"name":"mintWaterAndIceReserve","outputs":[],"stateMutability":"nonpayable","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":"owner","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"benevolence","type":"uint32"}],"name":"purchaseTokensAndReveal","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"revealsLeft","type":"uint32"}],"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":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"setPriceToSplit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"teamAllocation","type":"uint256"}],"name":"setTeamAllocation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"split","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"string","name":"stringPlusCode","type":"string"}],"name":"stringToTokenId","outputs":[{"internalType":"uint256","name":"plusCode","type":"uint256"}],"stateMutability":"pure","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":"plusCode","type":"uint256"}],"name":"tokenIdToString","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawBalance","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000000000000000000000000000000000000000a8c00000000000000000000000000000000000000000000000000000000000000c80000000000000000000000000000000000000000000000000016345785d8a0000000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000014000000000000000000000000000000000000000000000000000000000000001800000000000000000000000000000000000000000000000003782dace9d9000000000000000000000000000000000000000000000000000000000000000000004417265610000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044152454100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001268747470733a2f2f617265612e776f726c640000000000000000000000000000

-----Decoded View---------------
Arg [0] : inventorySize (uint256): 43200
Arg [1] : teamAllocation (uint256): 3200
Arg [2] : pricePerPack (uint256): 100000000000000000
Arg [3] : packSize (uint32): 10
Arg [4] : name (string): Area
Arg [5] : symbol (string): AREA
Arg [6] : baseURI (string): https://area.world
Arg [7] : priceToSplit (uint256): 4000000000000000000

-----Encoded View---------------
14 Constructor Arguments found :
Arg [0] : 000000000000000000000000000000000000000000000000000000000000a8c0
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000c80
Arg [2] : 000000000000000000000000000000000000000000000000016345785d8a0000
Arg [3] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000140
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000180
Arg [7] : 0000000000000000000000000000000000000000000000003782dace9d900000
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [9] : 4172656100000000000000000000000000000000000000000000000000000000
Arg [10] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [11] : 4152454100000000000000000000000000000000000000000000000000000000
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000012
Arg [13] : 68747470733a2f2f617265612e776f726c640000000000000000000000000000