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: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.0;

import "../utils/introspection/IERC165.sol";

/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        returns (address receiver, uint256 royaltyAmount);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

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

pragma solidity ^0.8.0;

import "../IERC721.sol";

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

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

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

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

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

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

pragma solidity ^0.8.0;

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

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

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

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

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

pragma solidity ^0.8.0;

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

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

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

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

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

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

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

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

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

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

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

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 *Glitch was here
 */

// SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.19;
/*
            ____ _ _ _       _     _          _
           / ___| (_) |_ ___| |__ ( )___     / \   _ __ _ __ ___  _   _
          | |  _| | | __/ __| '_ \|// __|   / _ \ | '__| '_ ` _ \| | | |
          | |_| | | | || (__| | | | \__ \  / ___ \| |  | | | | | | |_| |
           \____|_|_|\__\___|_| |_| |___/ /_/   \_\_|  |_| |_| |_|\__, |
                                                                  |___/

             ____             _      _____
            |  _ \  __ _ _ __| | __ | ____|_ __   ___ _ __ __ _ _   _
            | | | |/ _` | '__| |/ / |  _| | '_ \ / _ \ '__/ _` | | | |
            | |_| | (_| | |  |   <  | |___| | | |  __/ | | (_| | |_| |
            |____/ \__,_|_|  |_|\_\ |_____|_| |_|\___|_|  \__, |\__, |
                                                          |___/ |___/
*/


import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./GlitchGeneralMintSpots.sol";
import "../interfaces/ISeaDrop.sol";
import "../util/OwnableAndAdministrable.sol";
import "../libraries/UriEncode.sol";
import "../interfaces/IDarkEnergy.sol";
import "../libraries/DarkEnergyPackedStruct.sol";

/**
 * @title  DarkEnergy
 * @author mouradif.eth
 * @notice Optimized ERC721 base for use with LazyLion's missing 80 Open
 *         Edition: DarkEnergy
 */
contract DarkEnergy is
    OwnableAndAdministrable,
    ReentrancyGuard,
    IDarkEnergy
{
    string internal constant NAME = "Glitchs Army: Dark Energy";
    string internal constant SYMBOL = "DE";
    uint256 internal constant ENERGY_PER_MINT = 100;

    using DarkEnergyPackedStruct for bytes32;
    using DarkEnergyPackedStruct for DarkEnergyPackedStruct.GameRules;
    using Strings for uint256;
    using Strings for int256;
    using UriEncode for string;

    /// @notice Missing80 Ordinals Vouchers contract
    address public ordinalsVouchers;

    /// @notice Track the allowed SeaDrop addresses.
    mapping(address => bool) internal _allowedSeaDrop;

    /// @notice Track the enumerated allowed SeaDrop addresses.
    address[] internal _enumeratedAllowedSeaDrop;

    /// @notice Mapping from address to ownership details in binary format
    ///
    /// Bits Layout:
    /// - [0]        bool   isHolder
    /// - [1..40]    int40  energyAmount
    /// - [41..56]   uint16 gamePasses
    /// - [57..72]   uint16 mintCount
    /// - [73..88]   uint16 mergeCount
    /// - [89..104]  uint16 noRiskPlayCount
    /// - [105..120] uint16 noRiskWinCount
    /// - [121..136] uint16 highStakesPlayCount
    /// - [137..152] uint16 highStakesWinCount
    /// - [153..168] uint16 highStakesLossCount
    /// - [169..200] uint32 totalEarned
    /// - [201..232] uint32 totalRugged
    /// - [233..255] 23bits unused
    mapping(address => bytes32) internal _playerData;

    /// @notice Game configuration
    ///
    /// @dev for the Odds:
    ///              Each uint16 is a number that divided by 120_000
    ///              returns the probability of an event to occur
    /// Bits layout:
    /// - [0]        bool isActive (bool)
    /// - [1..16]    uint16 oddsNoRiskEarn100
    /// - [17..32]   uint16 oddsNoRiskEarn300
    /// - [33..48]   uint16 oddsNoRiskEarn500
    /// - [49..64]   uint16 oddsHighStakesWinOrdinal
    /// - [65..80]   uint16 oddsHighStakesLose100
    /// - [81..96]   uint16 oddsHighStakesLose300
    /// - [97..112]  uint16 oddsHighStakesLose500
    /// - [113..128] uint16 oddsHighStakesLose1000
    /// - [129..144] uint16 oddsHighStakesEarn100
    /// - [145..160] uint16 oddsHighStakesEarn300
    /// - [161..176] uint16 oddsHighStakesEarn500
    /// - [177..192] uint16 oddsHighStakesEarn1000
    /// - [193..208] uint16 oddsHighStakesDoubles
    /// - [209..224] uint16 oddsHighStakesHalves
    /// - [225..240] uint16 oddsGamePassOnMint
    /// - [241..248] uint8  remainingOrdinals
    /// - [249]      bool   flagA
    /// - [250]      bool   flagB
    /// - [251]      bool   flagC
    /// - [252]      bool   flagD
    /// - [253]      bool   flagE
    /// - [254]      bool   flagF
    /// - [255]      bool   flagG

    bytes32 internal _gameRules =
        0x0026ea60096009602ee03e805dc0bb802ee03e805dc0bb80003c096012c02ee1;

    /// @notice The maximum supply
    uint64 internal _maxSupply;

    /// @notice The current circulating supply
    uint64 internal _totalSupply;

    /// @notice The current circulating energy
    int256 internal _circulatingEnergy;

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

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

    /// @notice Track the royalty info: address to receive royalties, and
    ///         royalty basis points.
    RoyaltyInfo _royaltyInfo;

    /// @notice AllowList of marketplaces
    mapping(address => bool) internal _allowedOperators;

    /**
     * @notice Deploy the token contract with its name and symbol.
     */
    constructor(address admin, address[] memory allowedSeaDrop) {
        _setOwner(msg.sender);
        _setRole(admin, 0, true);
        // Put the length on the stack for more efficient access.
        uint256 allowedSeaDropLength = allowedSeaDrop.length;

        // Set the mapping for allowed SeaDrop contracts.
        for (uint256 i = 0; i < allowedSeaDropLength; ) {
            _allowedSeaDrop[allowedSeaDrop[i]] = true;
            unchecked {
                ++i;
            }
        }
        GlitchGeneralMintSpots _ordinalsVouchers = new GlitchGeneralMintSpots();
        ordinalsVouchers = address(_ordinalsVouchers);
        _royaltyInfo.royaltyBps = 500;
        _royaltyInfo.royaltyAddress = msg.sender;
        emit SeaDropTokenDeployed();
        emit OrdinalsVouchersDeployed(ordinalsVouchers);
    }

    /**
     * @dev Returns the total number of tokens in existence.
     * Burned tokens will reduce the count.
     */
    function totalSupply() external view override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev Returns the total number of energy in circulation
     */
    function circulatingEnergy() external view returns (int256) {
        return _circulatingEnergy;
    }

    /**
     * @notice Returns the token collection name.
     */
    function name() external pure override returns (string memory) {
        return NAME;
    }

    /**
     * @notice Returns the token collection symbol.
     */
    function symbol() external pure override returns (string memory) {
        return SYMBOL;
    }

    /**
     * @notice Checks wether a token exists or not
     */
    function exists(uint256 tokenId) external view returns(bool) {
        address potentialOwner = address(uint160(tokenId));
        return _playerData[potentialOwner].isHolder();
    }

    /**
     * @notice Returns the expected ball size in the SVG
     */
    function _getBallSize(uint32 x) internal pure returns (uint256) {
        if (x < 150) return x;
        if (x < 1000) return 150 + (x - 150) / 20;
        if (x < 4000) return 193 + (x - 1000) / 30;
        if (x < 10000) return 293 + (x - 4000) / 80;
        if (x < 300000) return 368 + (x - 10000) / 2200;
        return 500;
    }

    /**
     * @notice Returns the expected center of the ball in the SVG
     */
    function _getCenter(uint256 x) internal pure returns (uint256) {
        if (x < 150) return 1000 + x / 4;
        if (x < 1000) return 1070 - x / 5;
        if (x < 4000) return 870 - (x - 1000) / 20;
        if (x < 9500) return 720 - (x - 4000) / 25;
        return 500;
    }

    /**
     * @notice Special metadata for dead tokens
     */
    function _deadToken() internal pure returns (string memory) {
        string memory svgData = string(abi.encodePacked(
                "<svg viewBox='0 0 1e3 1e3' xmlns='http://www.w3.org/2000/svg'><style>svg{background:#000000}</style></svg>"
            ));
        return string(
            abi.encodePacked(
                'data:application/json,{"name":"Energy Waste","image_data":"',
                svgData,
                '","attributes":[{"trait_type":"energy","value":0},',
                '{"trait_type":"Game Passes","value":0},',
                '{"trait_type":"Burned","value":"yes"}',
                ']}'
            )
        ).uriEncode();
    }

    /**
     * @notice Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(
        uint256 tokenId
    ) public view virtual override returns (string memory) {
        address potentialOwner = address(uint160(tokenId));
        bytes32 data = _playerData[potentialOwner];
        if (!data.isHolder()) {
            return _deadToken();
        }
        int40 energy = data.getEnergy();
        uint16 gamePasses = data.getGamePasses();
        uint32 absEnergy = uint32(uint40(energy < 0 ? -energy : energy));
        uint256 size = _getBallSize(absEnergy);
        uint256 center = _getCenter(absEnergy);
        bytes6 color = energy < 0 ? bytes6(bytes("B46278")) : bytes6(bytes("5C6BBA"));
        bytes6 background = gamePasses == 0 ? bytes6(bytes("0B0B0B")) : bytes6(bytes("1B309F"));

        string memory svgData = string(abi.encodePacked(
            "<svg viewBox='0 0 1e3 1e3' xmlns='http://www.w3.org/2000/svg'><defs><radialGradient id='a' cx='500' cy='",
            center.toString(),
            "' r='",
            size.toString(),
            "' gradientUnits='userSpaceOnUse'><stop stop-color='#fff' stop-opacity='.6' offset='.17'/><stop stop-color='#fff' stop-opacity='0' offset='1'/></radialGradient></defs><circle cx='500' cy='",
            center.toString(),
            "' r='",
            size.toString(),
            "' fill='#",
            color,
            "'/><circle id='cg' cx='500' cy='",
            center.toString(),
            "' r='",
            size.toString(),
            "' fill='url(#a)' opacity='0'/><style>svg{background:#",
            background,
            "}#cg{-webkit-animation:1.5s ease-in-out infinite alternate p;animation:1.5s ease-in-out infinite alternate p}@-webkit-keyframes p{to{opacity:1}}@keyframes p{to{opacity:1}}</style></svg>"
        ));

        return string(
            abi.encodePacked(
                'data:application/json,{"name":"Dark Energy: ',
                int256(energy).toString(),
                '","image_data":"',
                svgData,
                '","attributes":[{"trait_type":"Energy","value":"',
                int256(energy).toString(),
                '"},{"trait_type":"Game Passes","value":"',
                uint256(gamePasses).toString(),
                '"}]}'
            )
        ).uriEncode();
    }

    /**
     * @notice Returns the contract URI for contract metadata.
     */
    function contractURI() external view override returns (string memory) {
        return string(
            abi.encodePacked(
                'data:application/json,{"name":"',
                NAME,
                '","totalSupply":',
                uint256(_totalSupply).toString(),
                '}'
            )
        ).uriEncode();
    }

    /**
     * @notice Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     */
    function approve(address to, uint256 tokenId) external virtual override {
        address _owner = ownerOf(tokenId);

        if (msg.sender != _owner) {
            if (!_operatorApprovals[_owner][msg.sender]) {
                revert CallerNotOwnerNorApproved();
            }
        }
        _tokenApprovals[tokenId] = to;

        emit Approval(_owner, to, tokenId);
    }

    /**
     * @notice Returns the account approved for `tokenId` token.
     */
    function getApproved(
        uint256 tokenId
    ) public view virtual override returns (address) {
        ownerOf(tokenId);
        return _tokenApprovals[tokenId];
    }

    /**
     * @notice Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom}, {safeTransferFrom} or {approve}
     * for any token owned by the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(
        address operator,
        bool approved
    ) public virtual override {
        if (!_allowedOperators[operator]) {
            revert OperatorNotAllowed();
        }
        _operatorApprovals[msg.sender][operator] = approved;
        emit ApprovalForAll(msg.sender, operator, approved);
    }

    /**
     * @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 virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    function _transferFrom(address from, address to, uint256 tokenId) internal {
        address potentialOwner = ownerOf(tokenId);

        if (potentialOwner != from) revert TransferFromIncorrectOwner();
        if (to == address(0)) revert QueryForZeroAddress();
        if (!_isApprovedOrOwner(msg.sender, tokenId))
            revert CallerNotOwnerNorApproved();
        if (from != msg.sender && !_allowedOperators[msg.sender])
            revert OperatorNotAllowed();

        bytes32 senderData = _playerData[from];
        bytes32 recipientData = _playerData[to];
        int40 senderEnergy = senderData.getEnergy();
        int40 recipientEnergy = recipientData.getEnergy();
        uint256 newTokenId = uint256(uint160(to));

        emit Transfer(from, to, tokenId);

        if (recipientData.isHolder()) {
            if (senderEnergy < 0 && recipientEnergy >= 0)
                revert NegativeEnergyToPositiveHolder();
            recipientEnergy += senderEnergy;
            uint256 realTotalGamePasses;
            unchecked {
                realTotalGamePasses = senderData.getGamePasses() +
                recipientData.getGamePasses();
            }
            uint16 gamePasses = realTotalGamePasses > 0xFFFF
            ? 0xFFFF
            : uint16(realTotalGamePasses);
            uint16 mergeCount = recipientData.getMergeCount();

            recipientData = recipientData.setHolder(true);
            recipientData = recipientData.setEnergy(recipientEnergy);
            recipientData = recipientData.setGamePasses(gamePasses);
            recipientData = recipientData.setMergeCount(mergeCount + 1);
            unchecked {
                _totalSupply--;
            }
        } else {
            recipientData = recipientData.setHoldingData(senderData);
            emit Transfer(address(0), to, newTokenId);
        }
        _playerData[from] = senderData.clearHoldingData();
        _playerData[to] = recipientData;
        _tokenApprovals[tokenId] = address(0);

        // Burn of the sent token
        emit Transfer(to, address(0), tokenId);
        emit MetadataUpdate(tokenId);
        emit MetadataUpdate(newTokenId);
    }

    function _safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal {
        _transferFrom(from, to, tokenId);
        if (to.code.length != 0)
            if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {
                revert TransferToNonERC721ReceiverImplementer();
            }
    }

    /**
     * @notice Transfers `tokenId` from `from` to `to`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external override {
        _transferFrom(from, to, tokenId);
    }

    /**
     * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        _safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @notice Safely transfers `tokenId` token from `from` to `to`.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        _safeTransferFrom(from, to, tokenId, _data);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     */
    function _mint(
        address to,
        uint16 quantity
    ) internal virtual returns (uint256) {
        uint256 tokenId = uint256(uint160(to));
        bytes32 data = _playerData[to];
        uint16 mintCount = data.getMintCount();
        int40 energy = data.getEnergy();
        unchecked {
            energy += int40(uint40(quantity * ENERGY_PER_MINT));
            mintCount += quantity;
        }
        uint16 gamePasses = 0;
        bool isHolder = data.isHolder();
        if (quantity >= 4) {
            unchecked { gamePasses = uint16(quantity / 4); }
        }
        uint8 remainder = uint8(quantity % 4);
        for (uint256 i = 0; i < remainder;) {
            uint256 base;
            unchecked {
                base = block.prevrandao - i;
                ++i;
            }

            uint256 n = uint256(keccak256(abi.encode(base))) % 120000;
            if (n < _gameRules.getUint16(225)) {
                unchecked { gamePasses++; }
            }
        }
        if (isHolder) {
            uint16 mergeCount = data.getMergeCount();
            data = data.setMergeCount(mergeCount + 1);
        } else {
            unchecked { _totalSupply++; }
            if (_totalSupply > _maxSupply) {
                revert MaxSupplyExceeded();
            }
            emit Transfer(address(0), to, tokenId);
        }

        data = data.setHolder(true);
        data = data.setEnergy(energy);
        data = data.setGamePasses(gamePasses + data.getGamePasses());
        data = data.setMintCount(mintCount);
        _playerData[to] = data;
        unchecked { _circulatingEnergy += int256(ENERGY_PER_MINT * quantity); }
        emit GlitchMint(to, quantity * ENERGY_PER_MINT, gamePasses);
        emit MetadataUpdate(tokenId);
        return isHolder ? 0 : tokenId;
    }

    function _noRiskEarn(int40 amount, bytes32 data) internal {
        _circulatingEnergy += amount;
        uint256 tokenId = uint256(uint160(msg.sender));
        int40 energy = data.getEnergy();
        uint16 winCount = data.getNoRiskWinCount();
        uint32 totalEarned = data.getTotalEarned();
        data = data.setEnergy(energy + amount);
        data = data.setNoRiskWinCount(winCount + 1);
        data = data.setTotalEarned(totalEarned + uint32(uint40(amount)));
        _playerData[msg.sender] = data;
        emit EnergyUpdate(msg.sender, int40(amount));
        emit MetadataUpdate(tokenId);
    }

    function _winOrdinal(address winner, bytes32 data) internal {
        uint256 tokenId = uint256(uint160(winner));
        int40 energy = data.getEnergy();
        _circulatingEnergy -= energy;
        data = data.setEnergy(int40(0));
        _playerData[winner] = data;

        GlitchGeneralMintSpots vouchers = GlitchGeneralMintSpots(ordinalsVouchers);
        uint256 voucherId = vouchers.nextId();
        if (energy < 0) {
            energy = -energy;
        }
        uint256 ballSize = _getBallSize(uint32(uint40(energy)));
        vouchers.adminMint(winner, voucherId, ballSize);

        emit MetadataUpdate(tokenId);
        emit OrdinalWon(winner);
    }

    function _highStakesResult(int40 result, bytes32 data) internal {
        _circulatingEnergy += result;
        uint256 tokenId = uint256(uint160(msg.sender));
        emit EnergyUpdate(msg.sender, result);
        data = data.setEnergy(data.getEnergy() + result);
        if (result < 0) {
            result = -result;
            data = data.setHighStakesLossCount(
                data.getHighStakesLossCount() + 1
            );
            data = data.setTotalRugged(
                data.getTotalRugged() + uint32(uint40(result))
            );
        } else {
            data = data.setHighStakesWinCount(
                data.getHighStakesWinCount() + 1
            );
            data = data.setTotalEarned(
                data.getTotalEarned() + uint32(uint40(result))
            );
        }
        _playerData[msg.sender] = data;
        emit MetadataUpdate(tokenId);
    }

    function playNoRisk() external {
        if (!_gameRules.getBool(0)) {
            revert GameNotActive();
        }
        emit PlayNoRisk(msg.sender);
        bytes32 data = _playerData[msg.sender];
        uint16 gamePasses = data.getGamePasses();
        if (gamePasses == 0) {
            revert NoGamePass();
        }
        data = data.setNoRiskPlayCount(data.getNoRiskPlayCount() + 1);
        data = data.setGamePasses(gamePasses - 1);
        bytes32 rules = _gameRules;

        uint256 randomNumber = uint256(
            keccak256(abi.encode(block.prevrandao))
        ) % 120000;
        uint32 treshold = rules.getUint16(1);
        if (randomNumber < treshold) {
            _noRiskEarn(100, data);
            return;
        }
        treshold += rules.getUint16(17);
        if (randomNumber < treshold) {
            _noRiskEarn(300, data);
            return;
        }
        treshold += rules.getUint16(33);
        if (randomNumber < treshold) {
            _noRiskEarn(500, data);
            return;
        }
        _playerData[msg.sender] = data;
        emit MetadataUpdate(uint256(uint160(msg.sender)));
    }

    function playHighStakes() external {
        if (!_gameRules.getBool(0)) {
            revert GameNotActive();
        }
        emit PlayHighStakes(msg.sender);
        bytes32 data = _playerData[msg.sender];
        uint16 gamePasses = data.getGamePasses();
        if (gamePasses == 0) {
            revert NoGamePass();
        }
        data = data.setHighStakesPlayCount(data.getHighStakesPlayCount() + 1);
        data = data.setGamePasses(gamePasses - 1);
        bytes32 rules = _gameRules;
        uint256 randomNumber = uint256(
            keccak256(abi.encode(block.prevrandao))
        ) % 120000;
        uint32 treshold = uint32(rules.getUint16(49)) * uint32(rules.getUint8(241));
        if (randomNumber < treshold) {
            _gameRules = _gameRules.setUint8(241, _gameRules.getUint8(241) - 1);
            return _winOrdinal(msg.sender, data);
        }
        treshold = rules.getUint16(65);
        if (randomNumber < treshold) {
            return _highStakesResult(-100, data);
        }
        treshold += rules.getUint16(81);
        if (randomNumber < treshold) {
            return _highStakesResult(-300, data);
        }
        treshold += rules.getUint16(97);
        if (randomNumber < treshold) {
            return _highStakesResult(-500, data);
        }
        treshold += rules.getUint16(113);
        if (randomNumber < treshold) {
            return _highStakesResult(-1000, data);
        }
        treshold += rules.getUint16(129);
        if (randomNumber < treshold) {
            return _highStakesResult(100, data);
        }
        treshold += rules.getUint16(145);
        if (randomNumber < treshold) {
            return _highStakesResult(300, data);
        }
        treshold += rules.getUint16(161);
        if (randomNumber < treshold) {
            return _highStakesResult(500, data);
        }
        treshold += rules.getUint16(177);
        if (randomNumber < treshold) {
            return _highStakesResult(1000, data);
        }
        int40 energy = data.getEnergy();
        uint256 tokenId = uint256(uint160(msg.sender));
        treshold += rules.getUint16(193);
        if (randomNumber < treshold && energy != 0) {
            emit EnergyDoubled(msg.sender, energy);
            return _highStakesResult(energy, data);
        }
        treshold += rules.getUint16(209);
        if (randomNumber < treshold && energy != 0) {
            emit EnergyHalved(msg.sender, energy);
            int40 diff = energy / 2;
            return _highStakesResult(-diff, data);
        }
        _playerData[msg.sender] = data;
        emit MetadataUpdate(tokenId);
    }

    /**
     * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target contract.
     *
     * `from` - Previous owner of the given token ID.
     * `to` - Target address that will receive the token.
     * `tokenId` - Token ID to be transferred.
     * `_data` - Optional data to send along with the call.
     *
     * Returns whether the call correctly returned the expected magic value.
     */
    function _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        try
        IERC721Receiver(to).onERC721Received(
            msg.sender,
            from,
            tokenId,
            _data
        )
        returns (bytes4 retval) {
            return retval == IERC721Receiver(to).onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == 0) {
                revert TransferToNonERC721ReceiverImplementer();
            }
            assembly {
                revert(add(32, reason), mload(reason))
            }
        }
    }

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal virtual {
        uint256 tokenId = _mint(to, uint16(quantity));
        if (tokenId == 0) {
            return;
        }

        unchecked {
            if (to.code.length != 0) {
                if (
                    !_checkContractOnERC721Received(
                    address(0),
                    to,
                    tokenId,
                    _data
                )
                ) {
                    revert TransferToNonERC721ReceiverImplementer();
                }
            }
        }
    }

    function _onlyAllowedSeaDrop(address seaDrop) internal view {
        if (!_allowedSeaDrop[seaDrop]) {
            revert OnlyAllowedSeaDrop();
        }
    }

    /**
     * @notice Mint tokens, restricted to the SeaDrop contract.
     */
    function mintSeaDrop(
        address minter,
        uint256 quantity
    ) external override nonReentrant {
        _onlyAllowedSeaDrop(msg.sender);
        _safeMint(minter, quantity, "");
    }

    /**
     * @notice Mint tokens, restricted to the SeaDrop contract.
     */
    function adminMint(
        address minter,
        int40 energy,
        uint16 gamePasses
    ) external nonReentrant {
        _checkRoleOrOwner(msg.sender, 1);
        _safeMint(minter, 0, "");
        bytes32 data = _playerData[minter];
        emit AdminMint(minter, energy - data.getEnergy(), gamePasses - data.getGamePasses());
        _circulatingEnergy += energy - data.getEnergy();
        data = data.setEnergy(energy);
        data = data.setGamePasses(gamePasses);
        _playerData[minter] = data;
    }

    /**
     * @notice Admin function to distribute rewards to the raffle winners
     */
    function raffleReward(address winner) external nonReentrant {
        _checkRoleOrOwner(msg.sender, 1);
        bytes32 data = _playerData[winner];
        if (!data.isHolder()) {
            revert AddressNotHolder();
        }
        _winOrdinal(winner, data);
    }

    /**
     * @notice Sets the address and basis points for royalties.
     *
     * @param newInfo The struct to configure royalties.
     */
    function setRoyaltyInfo(RoyaltyInfo calldata newInfo) external {
        // Ensure the sender is only the owner or contract itself.
        _checkRoleOrOwner(msg.sender, 1);

        // Revert if the new royalty address is the zero address.
        if (newInfo.royaltyAddress == address(0)) {
            revert RoyaltyAddressCannotBeZeroAddress();
        }

        // Revert if the new basis points is greater than 10_000.
        if (newInfo.royaltyBps > 10_000) {
            revert InvalidRoyaltyBasisPoints(newInfo.royaltyBps);
        }

        // Set the new royalty info.
        _royaltyInfo = newInfo;

        // Emit an event with the updated params.
        emit RoyaltyInfoUpdated(newInfo.royaltyAddress, newInfo.royaltyBps);
    }

    /**
     * @notice Returns the address that receives royalties.
     */
    function royaltyAddress() external view returns (address) {
        return _royaltyInfo.royaltyAddress;
    }

    /**
     * @notice Returns the royalty basis points out of 10_000.
     */
    function royaltyBasisPoints() external view returns (uint256) {
        return _royaltyInfo.royaltyBps;
    }

    /**
     * @notice Called with the sale price to determine how much royalty
     *         is owed and to whom.
     *
     * @return receiver      Address of who should be sent the royalty payment.
     * @return royaltyAmount The royalty payment amount for _salePrice.
     */
    function royaltyInfo(
        uint256,
        uint256 _salePrice
    ) external view returns (address receiver, uint256 royaltyAmount) {
        royaltyAmount = (_salePrice * _royaltyInfo.royaltyBps) / 10_000;
        receiver = _royaltyInfo.royaltyAddress;
    }

    /**
     * @dev Returns whether `tokenId` exists.
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        address potentialOwner = address(uint160(tokenId));
        return _playerData[potentialOwner].isHolder();
    }

    /**
     * @dev Returns whether `address` is approved for transfering `tokenId`
     */
    function _isApprovedOrOwner(
        address spender,
        uint256 tokenId
    ) internal view returns (bool) {
        address potentialOwner = ownerOf(tokenId);
        if (spender == potentialOwner) return true;
        return spender == _tokenApprovals[tokenId] ||
        _operatorApprovals[potentialOwner][spender];
    }

    /**
     * @notice Returns whether the interface is supported.
     *
     * @param interfaceId The interface id to check against.
     */
    function supportsInterface(
        bytes4 interfaceId
    ) public view virtual override(IDarkEnergy) returns (bool) {
        return
        interfaceId == 0x01ffc9a7 || // ER165
        interfaceId == 0x80ac58cd || // ERC721
        interfaceId == 0x5b5e139f || // ERC721-Metadata
        interfaceId == 0x2a55205a || // ERC2981
        interfaceId == 0x49064906 || // ERC4906
        interfaceId == type(INonFungibleSeaDropToken).interfaceId ||
        interfaceId == type(ISeaDropTokenContractMetadata).interfaceId;
    }

    // =============================================================
    //                      Game configuration
    // =============================================================

    function _checkNoRiskOdds(
        uint16 earn1,
        uint16 earn3,
        uint16 earn5
    ) internal pure {
        uint256 total = earn1 + earn3 + earn5;
        if (total > 120000) {
            revert InvalidGameRules();
        }
    }

    function _checkHighStakesOdds(
        uint16 lose1,
        uint16 lose3,
        uint16 lose5,
        uint16 lose10,
        uint16 earn1,
        uint16 earn3,
        uint16 earn5,
        uint16 earn10,
        uint16 double,
        uint16 halve
    ) internal pure {
        uint256 total = lose1 + lose3 + lose5;
        total = total + lose10 + earn1;
        total = total + earn3 + earn5;
        total = total + earn10 + double + halve;
        if (total > 120000) {
            revert InvalidGameRules();
        }
    }

    function _checkOrdinalsRules(
        uint16 odds,
        uint8 amount
    ) internal pure {
        uint256 total = uint256(odds) * uint256(amount);
        if (total > 120000) {
            revert InvalidGameRules();
        }
    }

    function setRules(
        DarkEnergyPackedStruct.GameRules calldata config
    ) external {
        _checkRoleOrOwner(msg.sender, 1);
        _checkNoRiskOdds(
            config.oddsNoRiskEarn100,
            config.oddsNoRiskEarn300,
            config.oddsNoRiskEarn500
        );
        _checkHighStakesOdds(
            config.oddsHighStakesLose100,
            config.oddsHighStakesLose300,
            config.oddsHighStakesLose500,
            config.oddsHighStakesLose1000,
            config.oddsHighStakesEarn100,
            config.oddsHighStakesEarn300,
            config.oddsHighStakesEarn500,
            config.oddsHighStakesEarn1000,
            config.oddsHighStakesDoubles,
            config.oddsHighStakesHalves
        );
        _checkOrdinalsRules(
            config.oddsHighStakesWinOrdinal,
            config.remainingOrdinals
        );
        bytes32 newRules = config.packGameRules();
        emit GameRulesUpdated(_gameRules, newRules);
        _gameRules = newRules;
    }

    function gameRules()
    external
    view
    returns (DarkEnergyPackedStruct.GameRules memory) {
        return _gameRules.gameRules();
    }

    // =============================================================
    //                  Administrative functions
    // =============================================================

    /**
     * @notice Sets the max token supply and emits an event.
     *
     * @param operator   The operator account or contract address
     * @param status        The status (true = approved, false = denied)
     */
    function setOperatorStatus(address operator, bool status) external {
        _checkRoleOrOwner(msg.sender, 1);
        _allowedOperators[operator] = status;
    }

    /**
     * @notice Sets the max token supply and emits an event.
     *
     * @param newMaxSupply The new max supply to set.
     */
    function setMaxSupply(uint256 newMaxSupply) external {
        _checkRoleOrOwner(msg.sender, 1);
        uint64 supply = uint64(newMaxSupply);
        if (supply < _totalSupply) {
            supply = _totalSupply;
        }
        _maxSupply = supply;
        emit MaxSupplyUpdated(supply);
    }

    /**
     * @notice Internal function to update the allowed SeaDrop contracts.
     *
     * @param allowedSeaDrop The allowed SeaDrop addresses.
     */
    function _updateAllowedSeaDrop(address[] calldata allowedSeaDrop) internal {
        // Put the length on the stack for more efficient access.
        uint256 enumeratedAllowedSeaDropLength = _enumeratedAllowedSeaDrop
        .length;
        uint256 allowedSeaDropLength = allowedSeaDrop.length;

        // Reset the old mapping.
        for (uint256 i = 0; i < enumeratedAllowedSeaDropLength; ) {
            _allowedSeaDrop[_enumeratedAllowedSeaDrop[i]] = false;
            unchecked {
                ++i;
            }
        }

        // Set the new mapping for allowed SeaDrop contracts.
        for (uint256 i = 0; i < allowedSeaDropLength; ) {
            _allowedSeaDrop[allowedSeaDrop[i]] = true;
            unchecked {
                ++i;
            }
        }

        // Set the enumeration.
        _enumeratedAllowedSeaDrop = allowedSeaDrop;

        // Emit an event for the update.
        emit AllowedSeaDropUpdated(allowedSeaDrop);
    }


    function updateAllowedSeaDrop(address[] calldata allowedSeaDrop) external {
        _checkRoleOrOwner(msg.sender, 0);

        _updateAllowedSeaDrop(allowedSeaDrop);
    }

    function updateCreatorPayoutAddress(
        address seaDrop,
        address creator
    ) external {
        _checkRoleOrOwner(msg.sender, 1);
        _onlyAllowedSeaDrop(seaDrop);
        ISeaDrop(seaDrop).updateCreatorPayoutAddress(creator);
    }

    function updatePublicDrop(
        address seaDrop,
        PublicDrop memory dropData
    ) external {
        _checkRoleOrOwner(msg.sender, 0);
        _onlyAllowedSeaDrop(seaDrop);
        PublicDrop memory r = ISeaDrop(seaDrop).getPublicDrop(address(this));
        if (!_hasRole(msg.sender, 0)) {
            if (r.maxTotalMintableByWallet == 0) {
                revert AdministratorMustInitializeWithFee();
            }
            dropData.feeBps = r.feeBps;
            dropData.restrictFeeRecipients = true;
        } else {
            uint256 maxTotalMintableByWallet = r.maxTotalMintableByWallet;
            r.maxTotalMintableByWallet = maxTotalMintableByWallet > 0 ?
                uint16(maxTotalMintableByWallet) :
                1;
            r.feeBps = dropData.feeBps;
            r.restrictFeeRecipients = true;
            dropData = r;
        }
        ISeaDrop(seaDrop).updatePublicDrop(dropData);
    }

    /**
     * @notice Update the drop URI for this nft contract on SeaDrop.
     *         Only the owner or administrator can use this function.
     *
     * @param seaDropImpl The allowed SeaDrop contract.
     * @param dropURI     The new drop URI.
     */
    function updateDropURI(address seaDropImpl, string calldata dropURI)
        external
        virtual
        override
    {
        _checkRoleOrOwner(msg.sender, 0);
        // Ensure the SeaDrop is allowed.
        _onlyAllowedSeaDrop(seaDropImpl);

        // Update the drop URI.
        ISeaDrop(seaDropImpl).updateDropURI(dropURI);
    }

    /**
     * @notice Update the allow list data for this nft contract on SeaDrop.
     *         Only the owner or administrator can use this function.
     *
     * @param seaDropImpl   The allowed SeaDrop contract.
     * @param allowListData The allow list data.
     */
    function updateAllowList(
        address seaDropImpl,
        AllowListData calldata allowListData
    ) external virtual override {
        _checkRoleOrOwner(msg.sender, 0);
        // Ensure the SeaDrop is allowed.
        _onlyAllowedSeaDrop(seaDropImpl);

        // Update the allow list on SeaDrop.
        ISeaDrop(seaDropImpl).updateAllowList(allowListData);
    }

    /**
     * @notice Update the allowed fee recipient for this nft contract
     *         on SeaDrop.
     *         Only the administrator can set the allowed fee recipient.
     *
     * @param seaDrop      The allowed SeaDrop contract.
     * @param feeRecipient The new fee recipient.
     * @param status       If the fee recipient is allowed.
     */
    function updateAllowedFeeRecipient(
        address seaDrop,
        address feeRecipient,
        bool status
    ) external {
        _checkRole(msg.sender, 0);
        _onlyAllowedSeaDrop(seaDrop);
        ISeaDrop(seaDrop).updateAllowedFeeRecipient(feeRecipient, status);
    }

    /**
     * @notice Update the allowed payers for this nft contract on SeaDrop.
     *         Only the owner or administrator can use this function.
     *
     * @param seaDropImpl The allowed SeaDrop contract.
     * @param payer       The payer to update.
     * @param allowed     Whether the payer is allowed.
     */
    function updatePayer(
        address seaDropImpl,
        address payer,
        bool allowed
    ) external virtual override {
        _checkRoleOrOwner(msg.sender, 0);
        // Ensure the SeaDrop is allowed.
        _onlyAllowedSeaDrop(seaDropImpl);

        // Update the payer.
        ISeaDrop(seaDropImpl).updatePayer(payer, allowed);
    }

    /**
     * @notice Configure multiple properties at a time.
     *
     *         Note: The individual configure methods should be used
     *         to unset or reset any properties to zero, as this method
     *         will ignore zero-value properties in the config struct.
     *
     * @param config The configuration struct.
     */
    function multiConfigure(MultiConfigureStruct calldata config)
    external
    {
        _checkRoleOrOwner(msg.sender, 1);
        if (config.maxSupply > 0) {
            this.setMaxSupply(config.maxSupply);
        }
        if (
            config.publicDrop.startTime != 0 ||
            config.publicDrop.endTime != 0
        ) {
            this.updatePublicDrop(config.seaDropImpl, config.publicDrop);
        }
        if (bytes(config.dropURI).length != 0) {
            this.updateDropURI(config.seaDropImpl, config.dropURI);
        }
        if (config.allowListData.merkleRoot != bytes32(0)) {
            this.updateAllowList(config.seaDropImpl, config.allowListData);
        }
        if (config.creatorPayoutAddress != address(0)) {
            this.updateCreatorPayoutAddress(
                config.seaDropImpl,
                config.creatorPayoutAddress
            );
        }
        if (config.allowedFeeRecipients.length > 0) {
            for (uint256 i = 0; i < config.allowedFeeRecipients.length; ) {
                this.updateAllowedFeeRecipient(
                    config.seaDropImpl,
                    config.allowedFeeRecipients[i],
                    true
                );
                unchecked {
                    ++i;
                }
            }
        }
        if (config.disallowedFeeRecipients.length > 0) {
            for (uint256 i = 0; i < config.disallowedFeeRecipients.length; ) {
                this.updateAllowedFeeRecipient(
                    config.seaDropImpl,
                    config.disallowedFeeRecipients[i],
                    false
                );
                unchecked {
                    ++i;
                }
            }
        }
        if (config.allowedPayers.length > 0) {
            for (uint256 i = 0; i < config.allowedPayers.length; ) {
                this.updatePayer(
                    config.seaDropImpl,
                    config.allowedPayers[i],
                    true
                );
                unchecked {
                    ++i;
                }
            }
        }
        if (config.disallowedPayers.length > 0) {
            for (uint256 i = 0; i < config.disallowedPayers.length; ) {
                this.updatePayer(
                    config.seaDropImpl,
                    config.disallowedPayers[i],
                    false
                );
                unchecked {
                    ++i;
                }
            }
        }
    }

    // =============================================================
    //   No-op or low-op functions to ensure compatibility
    // =============================================================

    function setBaseURI(string calldata) external override {}

    function setContractURI(string calldata) external override {}


    function setProvenanceHash(bytes32) external {}

    function updateSignedMintValidationParams(
        address,
        address,
        SignedMintValidationParams memory
    ) external {}

    function updateTokenGatedDrop(
        address,
        address,
        TokenGatedDropStage calldata
    ) external {}

    function baseURI() external pure override returns (string memory) {
        return "";
    }

    // =============================================================
    //        NFT and Game stats
    // =============================================================


    function maxSupply() external view returns (uint256) {
        return _maxSupply;
    }

    function provenanceHash() external pure override returns (bytes32) {
        return bytes32(0);
    }

    function getMintStats(
        address minter
    ) external view returns (uint256, uint256, uint256) {
        bytes32 data = _playerData[minter];
        return (
        uint256(data.getMintCount()),
        _totalSupply,
        _maxSupply
        );
    }

    /**
     * @notice Returns the address that owns the given token.
     *
     * @dev The tokenId is the numeric representation of the owner's address.
     *      If that address holds a token, its last bit will be 1 and we can
     *      return the address representation of the tokenId. If not, then
     *      the token doesn't exist.
     */
    function ownerOf(
        uint256 tokenId
    ) public view virtual override returns (address) {
        address potentialOwner = address(uint160(tokenId));
        if (!_playerData[potentialOwner].isHolder()) {
            revert QueryForNonExistentToken();
        }
        return potentialOwner;
    }

    /**
     * @notice Returns the number of tokens in `owner`'s account.
     *
     * @dev An address may have at most one token. If the data of an
            address has 1 as a last bit, then that address has a token.
     */
    function balanceOf(address _owner) public view override returns (uint256) {
        if (_owner == address(0)) {
            revert QueryForZeroAddress();
        }
        bool isHolder = _playerData[_owner].isHolder();
        if (isHolder) {
            return 1;
        }
        return 0;
    }

    /**
     * @notice Returns the amount of energy in a given tokenId
     */
    function playerData(
        address player
    ) external view returns (DarkEnergyPackedStruct.PlayerData memory) {
        return _playerData[player].playerData();
    }
}

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

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "../libraries/Strings.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, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string internal _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: address zero is not a valid owner");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _ownerOf(tokenId);
        require(owner != address(0), "ERC721: invalid token ID");
        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) {
        _requireMinted(tokenId);

        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 overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual 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 token owner or approved for all"
        );

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_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: caller is not token owner or 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: caller is not token owner or 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 the owner of the `tokenId`. Does NOT revert if token doesn't exist
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @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 _ownerOf(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) {
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == 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, 1);

        // Check that tokenId was not minted by `_beforeTokenTransfer` hook
        require(!_exists(tokenId), "ERC721: token already minted");

        unchecked {
            // Will not overflow unless all 2**256 token ids are minted to the same owner.
            // Given that tokens are minted one by one, it is impossible in practice that
            // this ever happens. Might change if we allow batch minting.
            // The ERC fails to describe this case.
            _balances[to] += 1;
        }

        _owners[tokenId] = to;

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

        _afterTokenTransfer(address(0), to, tokenId, 1);
    }

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

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

        // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
        owner = ERC721.ownerOf(tokenId);

        // Clear approvals
        delete _tokenApprovals[tokenId];

        unchecked {
            // Cannot overflow, as that would require more tokens to be burned/transferred
            // out than the owner initially received through minting and transferring in.
            _balances[owner] -= 1;
        }
        delete _owners[tokenId];

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

        _afterTokenTransfer(owner, address(0), tokenId, 1);
    }

    /**
     * @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 from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId, 1);

        // Check that tokenId was not transferred by `_beforeTokenTransfer` hook
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");

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

        unchecked {
            // `_balances[from]` cannot overflow for the same reason as described in `_burn`:
            // `from`'s balance is the number of token held, which is at least one before the current
            // transfer.
            // `_balances[to]` could overflow in the conditions described in `_mint`. That would require
            // all 2**256 token ids to be minted, which in practice is impossible.
            _balances[from] -= 1;
            _balances[to] += 1;
        }
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

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

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

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

    /**
     * @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 {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
     * - When `from` is zero, the tokens will be minted for `to`.
     * - When `to` is zero, ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual {}

    /**
     * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
     * - When `from` is zero, the tokens were minted for `to`.
     * - When `to` is zero, ``from``'s tokens were burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual {}

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * WARNING: Anyone calling this MUST ensure that the balances remain consistent with the ownership. The invariant
     * being that for any address `a` the value returned by `balanceOf(a)` must be equal to the number of tokens such
     * that `ownerOf(tokenId)` is `a`.
     */
    // solhint-disable-next-line func-name-mixedcase
    function __unsafe_increaseBalance(address account, uint256 amount) internal {
        _balances[account] += amount;
    }
}

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

import "./ERC721.sol";
import "../util/OwnableAndAdministrable.sol";
import "../libraries/UriEncode.sol";

contract GlitchGeneralMintSpots is ERC721, OwnableAndAdministrable {
  using Strings for uint256;
  using UriEncode for string;

  /**
   * @dev Revert if the royalty basis points is greater than 10_000.
     */
  error InvalidRoyaltyBasisPoints(uint256 basisPoints);

  /**
   * @dev Revert if the royalty address is being set to the zero address.
     */
  error RoyaltyAddressCannotBeZeroAddress();

  /**
   * @dev Emit an event when the royalties info is updated.
   */
  event RoyaltyInfoUpdated(address receiver, uint256 bps);

  /**
   * @notice A struct defining royalty info for the contract.
   */
  struct RoyaltyInfo {
    address royaltyAddress;
    uint96 royaltyBps;
  }

  /// @notice Track the royalty info: address to receive royalties, and
  ///         royalty basis points.
  RoyaltyInfo _royaltyInfo;

  uint256 private _tokenIdCounter = 1;
  mapping(uint256 => uint256) private _tokenSize;

  event MetadataUpdate(uint256 _tokenId);

  address public darkEnergyContract;

  constructor() ERC721("Glitchs Army: The Generals mint spot", "GMS") {
    _setOwner(tx.origin);
    _setRole(tx.origin, 0, true);
    _setRole(msg.sender, 0, true);
    _royaltyInfo.royaltyBps = 500;
    _royaltyInfo.royaltyAddress = tx.origin;
    darkEnergyContract = msg.sender;
  }

  /**
   * @notice Returns whether the interface is supported.
   *
   * @param interfaceId The interface id to check against.
   */
  function supportsInterface(
    bytes4 interfaceId
  ) public view virtual override(ERC721) returns (bool) {
    return
    interfaceId == 0x01ffc9a7 || // ER165
    interfaceId == 0x80ac58cd || // ERC721
    interfaceId == 0x5b5e139f || // ERC721-Metadata
    interfaceId == 0x2a55205a;   // ERC2981
  }

  /**
   * @notice Sets the address and basis points for royalties.
   *
   * @param newInfo The struct to configure royalties.
   */
  function setRoyaltyInfo(RoyaltyInfo calldata newInfo) external {
    // Ensure the sender is only the owner or contract itself.
    _checkRoleOrOwner(msg.sender, 1);

    // Revert if the new royalty address is the zero address.
    if (newInfo.royaltyAddress == address(0)) {
      revert RoyaltyAddressCannotBeZeroAddress();
    }

    // Revert if the new basis points is greater than 10_000.
    if (newInfo.royaltyBps > 10_000) {
      revert InvalidRoyaltyBasisPoints(newInfo.royaltyBps);
    }

    // Set the new royalty info.
    _royaltyInfo = newInfo;

    // Emit an event with the updated params.
    emit RoyaltyInfoUpdated(newInfo.royaltyAddress, newInfo.royaltyBps);
  }

  /**
   * @notice Returns the address that receives royalties.
   */
  function royaltyAddress() external view returns (address) {
    return _royaltyInfo.royaltyAddress;
  }

  /**
   * @notice Returns the royalty basis points out of 10_000.
   */
  function royaltyBasisPoints() external view returns (uint256) {
    return _royaltyInfo.royaltyBps;
  }

  /**
   * @notice Called with the sale price to determine how much royalty
   *         is owed and to whom.
   *
   * @return receiver      Address of who should be sent the royalty payment.
   * @return royaltyAmount The royalty payment amount for _salePrice.
   */
  function royaltyInfo(
    uint256,
    uint256 _salePrice
  ) external view returns (address receiver, uint256 royaltyAmount) {
    royaltyAmount = (_salePrice * _royaltyInfo.royaltyBps) / 10_000;
    receiver = _royaltyInfo.royaltyAddress;
  }

  function adminMint(address to, uint256 tokenId, uint256 size) external {
    _checkRoleOrOwner(msg.sender, 0);
    if(tokenId == _tokenIdCounter) {
      _tokenIdCounter++;
    }
    _tokenSize[tokenId] = size;
    _safeMint(to, tokenId);
  }

  function adminBurn(uint256 tokenId) external {
    _checkRoleOrOwner(msg.sender, 0);
    _burn(tokenId);
  }

  function adminSetTokenSize(uint256 tokenId, uint256 size) external {
    _checkRoleOrOwner(msg.sender, 0);
    _requireMinted(tokenId);
    _tokenSize[tokenId] = size;
    emit MetadataUpdate(tokenId);
  }

  function nextId() external view returns(uint256) {
    return _tokenIdCounter;
  }

  function tokenURI(uint256 tokenId) public view override returns(string memory) {
    _requireMinted(tokenId);
    uint256 size = _tokenSize[tokenId];
    uint256 center = 500;
    bytes6 color = bytes6(bytes("DDC159"));
    bytes6 background = bytes6(bytes("0B0B0B"));

    string memory svgData = string(abi.encodePacked(
        "<svg viewBox='0 0 1e3 1e3' xmlns='http://www.w3.org/2000/svg'><defs><radialGradient id='a' cx='500' cy='",
        center.toString(),
        "' r='",
        size.toString(),
        "' gradientUnits='userSpaceOnUse'><stop stop-color='#fff' stop-opacity='.6' offset='.17'/><stop stop-color='#fff' stop-opacity='0' offset='1'/></radialGradient></defs><circle cx='500' cy='",
        center.toString(),
        "' r='",
        size.toString(),
        "' fill='#",
        color,
        "'/><circle id='cg' cx='500' cy='",
        center.toString(),
        "' r='",
        size.toString(),
        "' fill='url(#a)' opacity='0'/><style>svg{background:#",
        background,
        "}#cg{-webkit-animation:1.5s ease-in-out infinite alternate p;animation:1.5s ease-in-out infinite alternate p}@-webkit-keyframes p{to{opacity:1}}@keyframes p{to{opacity:1}}</style></svg>"
      ));

    return string(
      abi.encodePacked(
        'data:application/json,{"name":"Glitch\'s Army: The Generals mint spot #',
        tokenId.toString(),
        '","image_data":"',
        svgData,
        '"}'
      )
    ).uriEncode();
  }

  function contractURI() external pure returns(string memory) {
    return string(abi.encodePacked(
      'data:application/json,{"name": "Glitch\'s Army: The Generals mint spot"}'
    )).uriEncode();
  }
}

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

import { PublicDrop, TokenGatedDropStage, SignedMintValidationParams } from "./SeaDropStructs.sol";

interface SeaDropErrorsAndEvents {
    /**
     * @dev Revert with an error if the drop stage is not active.
     */
    error NotActive(
        uint256 currentTimestamp,
        uint256 startTimestamp,
        uint256 endTimestamp
    );

    /**
     * @dev Revert with an error if the mint quantity is zero.
     */
    error MintQuantityCannotBeZero();

    /**
     * @dev Revert with an error if the mint quantity exceeds the max allowed
     *      to be minted per wallet.
     */
    error MintQuantityExceedsMaxMintedPerWallet(uint256 total, uint256 allowed);

    /**
     * @dev Revert with an error if the mint quantity exceeds the max token
     *      supply.
     */
    error MintQuantityExceedsMaxSupply(uint256 total, uint256 maxSupply);

    /**
     * @dev Revert with an error if the mint quantity exceeds the max token
     *      supply for the stage.
     *      Note: The `maxTokenSupplyForStage` for public mint is
     *      always `type(uint).max`.
     */
    error MintQuantityExceedsMaxTokenSupplyForStage(
        uint256 total,
        uint256 maxTokenSupplyForStage
    );

    /**
     * @dev Revert if the fee recipient is the zero address.
     */
    error FeeRecipientCannotBeZeroAddress();

    /**
     * @dev Revert if the fee recipient is not already included.
     */
    error FeeRecipientNotPresent();

    /**
     * @dev Revert if the fee basis points is greater than 10_000.
     */
    error InvalidFeeBps(uint256 feeBps);

    /**
     * @dev Revert if the fee recipient is already included.
     */
    error DuplicateFeeRecipient();

    /**
     * @dev Revert if the fee recipient is restricted and not allowed.
     */
    error FeeRecipientNotAllowed();

    /**
     * @dev Revert if the creator payout address is the zero address.
     */
    error CreatorPayoutAddressCannotBeZeroAddress();

    /**
     * @dev Revert with an error if the received payment is incorrect.
     */
    error IncorrectPayment(uint256 got, uint256 want);

    /**
     * @dev Revert with an error if the allow list proof is invalid.
     */
    error InvalidProof();

    /**
     * @dev Revert if a supplied signer address is the zero address.
     */
    error SignerCannotBeZeroAddress();

    /**
     * @dev Revert with an error if signer's signature is invalid.
     */
    error InvalidSignature(address recoveredSigner);

    /**
     * @dev Revert with an error if a signer is not included in
     *      the enumeration when removing.
     */
    error SignerNotPresent();

    /**
     * @dev Revert with an error if a payer is not included in
     *      the enumeration when removing.
     */
    error PayerNotPresent();

    /**
     * @dev Revert with an error if a payer is already included in mapping
     *      when adding.
     *      Note: only applies when adding a single payer, as duplicates in
     *      enumeration can be removed with updatePayer.
     */
    error DuplicatePayer();

    /**
     * @dev Revert with an error if the payer is not allowed. The minter must
     *      pay for their own mint.
     */
    error PayerNotAllowed();

    /**
     * @dev Revert if a supplied payer address is the zero address.
     */
    error PayerCannotBeZeroAddress();

    /**
     * @dev Revert with an error if the sender does not
     *      match the INonFungibleSeaDropToken interface.
     */
    error OnlyINonFungibleSeaDropToken(address sender);

    /**
     * @dev Revert with an error if the sender of a token gated supplied
     *      drop stage redeem is not the owner of the token.
     */
    error TokenGatedNotTokenOwner(
        address nftContract,
        address allowedNftToken,
        uint256 allowedNftTokenId
    );

    /**
     * @dev Revert with an error if the token id has already been used to
     *      redeem a token gated drop stage.
     */
    error TokenGatedTokenIdAlreadyRedeemed(
        address nftContract,
        address allowedNftToken,
        uint256 allowedNftTokenId
    );

    /**
     * @dev Revert with an error if an empty TokenGatedDropStage is provided
     *      for an already-empty TokenGatedDropStage.
     */
     error TokenGatedDropStageNotPresent();

    /**
     * @dev Revert with an error if an allowedNftToken is set to
     *      the zero address.
     */
     error TokenGatedDropAllowedNftTokenCannotBeZeroAddress();

    /**
     * @dev Revert with an error if an allowedNftToken is set to
     *      the drop token itself.
     */
     error TokenGatedDropAllowedNftTokenCannotBeDropToken();


    /**
     * @dev Revert with an error if supplied signed mint price is less than
     *      the minimum specified.
     */
    error InvalidSignedMintPrice(uint256 got, uint256 minimum);

    /**
     * @dev Revert with an error if supplied signed maxTotalMintableByWallet
     *      is greater than the maximum specified.
     */
    error InvalidSignedMaxTotalMintableByWallet(uint256 got, uint256 maximum);

    /**
     * @dev Revert with an error if supplied signed start time is less than
     *      the minimum specified.
     */
    error InvalidSignedStartTime(uint256 got, uint256 minimum);

    /**
     * @dev Revert with an error if supplied signed end time is greater than
     *      the maximum specified.
     */
    error InvalidSignedEndTime(uint256 got, uint256 maximum);

    /**
     * @dev Revert with an error if supplied signed maxTokenSupplyForStage
     *      is greater than the maximum specified.
     */
     error InvalidSignedMaxTokenSupplyForStage(uint256 got, uint256 maximum);

     /**
     * @dev Revert with an error if supplied signed feeBps is greater than
     *      the maximum specified, or less than the minimum.
     */
    error InvalidSignedFeeBps(uint256 got, uint256 minimumOrMaximum);

    /**
     * @dev Revert with an error if signed mint did not specify to restrict
     *      fee recipients.
     */
    error SignedMintsMustRestrictFeeRecipients();

    /**
     * @dev Revert with an error if a signature for a signed mint has already
     *      been used.
     */
    error SignatureAlreadyUsed();

    /**
     * @dev An event with details of a SeaDrop mint, for analytical purposes.
     *
     * @param nftContract    The nft contract.
     * @param minter         The mint recipient.
     * @param feeRecipient   The fee recipient.
     * @param payer          The address who payed for the tx.
     * @param quantityMinted The number of tokens minted.
     * @param unitMintPrice  The amount paid for each token.
     * @param feeBps         The fee out of 10_000 basis points collected.
     * @param dropStageIndex The drop stage index. Items minted
     *                       through mintPublic() have
     *                       dropStageIndex of 0.
     */
    event SeaDropMint(
        address indexed nftContract,
        address indexed minter,
        address indexed feeRecipient,
        address payer,
        uint256 quantityMinted,
        uint256 unitMintPrice,
        uint256 feeBps,
        uint256 dropStageIndex
    );

    /**
     * @dev An event with updated public drop data for an nft contract.
     */
    event PublicDropUpdated(
        address indexed nftContract,
        PublicDrop publicDrop
    );

    /**
     * @dev An event with updated token gated drop stage data
     *      for an nft contract.
     */
    event TokenGatedDropStageUpdated(
        address indexed nftContract,
        address indexed allowedNftToken,
        TokenGatedDropStage dropStage
    );

    /**
     * @dev An event with updated allow list data for an nft contract.
     *
     * @param nftContract        The nft contract.
     * @param previousMerkleRoot The previous allow list merkle root.
     * @param newMerkleRoot      The new allow list merkle root.
     * @param publicKeyURI       If the allow list is encrypted, the public key
     *                           URIs that can decrypt the list.
     *                           Empty if unencrypted.
     * @param allowListURI       The URI for the allow list.
     */
    event AllowListUpdated(
        address indexed nftContract,
        bytes32 indexed previousMerkleRoot,
        bytes32 indexed newMerkleRoot,
        string[] publicKeyURI,
        string allowListURI
    );

    /**
     * @dev An event with updated drop URI for an nft contract.
     */
    event DropURIUpdated(address indexed nftContract, string newDropURI);

    /**
     * @dev An event with the updated creator payout address for an nft
     *      contract.
     */
    event CreatorPayoutAddressUpdated(
        address indexed nftContract,
        address indexed newPayoutAddress
    );

    /**
     * @dev An event with the updated allowed fee recipient for an nft
     *      contract.
     */
    event AllowedFeeRecipientUpdated(
        address indexed nftContract,
        address indexed feeRecipient,
        bool indexed allowed
    );

    /**
     * @dev An event with the updated validation parameters for server-side
     *      signers.
     */
    event SignedMintValidationParamsUpdated(
        address indexed nftContract,
        address indexed signer,
        SignedMintValidationParams signedMintValidationParams
    );

    /**
     * @dev An event with the updated payer for an nft contract.
     */
    event PayerUpdated(
        address indexed nftContract,
        address indexed payer,
        bool indexed allowed
    );
}

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

/**
 * @notice A struct defining public drop data.
 *         Designed to fit efficiently in one storage slot.
 *
 * @param mintPrice                The mint price per token. (Up to 1.2m
 *                                 of native token, e.g. ETH, MATIC)
 * @param startTime                The start time, ensure this is not zero.
 * @param endTIme                  The end time, ensure this is not zero.
 * @param maxTotalMintableByWallet Maximum total number of mints a user is
 *                                 allowed. (The limit for this field is
 *                                 2^16 - 1)
 * @param feeBps                   Fee out of 10_000 basis points to be
 *                                 collected.
 * @param restrictFeeRecipients    If false, allow any fee recipient;
 *                                 if true, check fee recipient is allowed.
 */
struct PublicDrop {
    uint80 mintPrice; // 80/256 bits
    uint48 startTime; // 128/256 bits
    uint48 endTime; // 176/256 bits
    uint16 maxTotalMintableByWallet; // 224/256 bits
    uint16 feeBps; // 240/256 bits
    bool restrictFeeRecipients; // 248/256 bits
}

/**
 * @notice A struct defining token gated drop stage data.
 *         Designed to fit efficiently in one storage slot.
 *
 * @param mintPrice                The mint price per token. (Up to 1.2m
 *                                 of native token, e.g.: ETH, MATIC)
 * @param maxTotalMintableByWallet Maximum total number of mints a user is
 *                                 allowed. (The limit for this field is
 *                                 2^16 - 1)
 * @param startTime                The start time, ensure this is not zero.
 * @param endTime                  The end time, ensure this is not zero.
 * @param dropStageIndex           The drop stage index to emit with the event
 *                                 for analytical purposes. This should be
 *                                 non-zero since the public mint emits
 *                                 with index zero.
 * @param maxTokenSupplyForStage   The limit of token supply this stage can
 *                                 mint within. (The limit for this field is
 *                                 2^16 - 1)
 * @param feeBps                   Fee out of 10_000 basis points to be
 *                                 collected.
 * @param restrictFeeRecipients    If false, allow any fee recipient;
 *                                 if true, check fee recipient is allowed.
 */
struct TokenGatedDropStage {
    uint80 mintPrice; // 80/256 bits
    uint16 maxTotalMintableByWallet; // 96/256 bits
    uint48 startTime; // 144/256 bits
    uint48 endTime; // 192/256 bits
    uint8 dropStageIndex; // non-zero. 200/256 bits
    uint32 maxTokenSupplyForStage; // 232/256 bits
    uint16 feeBps; // 248/256 bits
    bool restrictFeeRecipients; // 256/256 bits
}

/**
 * @notice A struct defining mint params for an allow list.
 *         An allow list leaf will be composed of `msg.sender` and
 *         the following params.
 *
 *         Note: Since feeBps is encoded in the leaf, backend should ensure
 *         that feeBps is acceptable before generating a proof.
 *
 * @param mintPrice                The mint price per token.
 * @param maxTotalMintableByWallet Maximum total number of mints a user is
 *                                 allowed.
 * @param startTime                The start time, ensure this is not zero.
 * @param endTime                  The end time, ensure this is not zero.
 * @param dropStageIndex           The drop stage index to emit with the event
 *                                 for analytical purposes. This should be
 *                                 non-zero since the public mint emits with
 *                                 index zero.
 * @param maxTokenSupplyForStage   The limit of token supply this stage can
 *                                 mint within.
 * @param feeBps                   Fee out of 10_000 basis points to be
 *                                 collected.
 * @param restrictFeeRecipients    If false, allow any fee recipient;
 *                                 if true, check fee recipient is allowed.
 */
struct MintParams {
    uint256 mintPrice;
    uint256 maxTotalMintableByWallet;
    uint256 startTime;
    uint256 endTime;
    uint256 dropStageIndex; // non-zero
    uint256 maxTokenSupplyForStage;
    uint256 feeBps;
    bool restrictFeeRecipients;
}

/**
 * @notice A struct defining token gated mint params.
 *
 * @param allowedNftToken    The allowed nft token contract address.
 * @param allowedNftTokenIds The token ids to redeem.
 */
struct TokenGatedMintParams {
    address allowedNftToken;
    uint256[] allowedNftTokenIds;
}

/**
 * @notice A struct defining allow list data (for minting an allow list).
 *
 * @param merkleRoot    The merkle root for the allow list.
 * @param publicKeyURIs If the allowListURI is encrypted, a list of URIs
 *                      pointing to the public keys. Empty if unencrypted.
 * @param allowListURI  The URI for the allow list.
 */
struct AllowListData {
    bytes32 merkleRoot;
    string[] publicKeyURIs;
    string allowListURI;
}

/**
 * @notice A struct defining minimum and maximum parameters to validate for
 *         signed mints, to minimize negative effects of a compromised signer.
 *
 * @param minMintPrice                The minimum mint price allowed.
 * @param maxMaxTotalMintableByWallet The maximum total number of mints allowed
 *                                    by a wallet.
 * @param minStartTime                The minimum start time allowed.
 * @param maxEndTime                  The maximum end time allowed.
 * @param maxMaxTokenSupplyForStage   The maximum token supply allowed.
 * @param minFeeBps                   The minimum fee allowed.
 * @param maxFeeBps                   The maximum fee allowed.
 */
struct SignedMintValidationParams {
    uint80 minMintPrice; // 80/256 bits
    uint24 maxMaxTotalMintableByWallet; // 104/256 bits
    uint40 minStartTime; // 144/256 bits
    uint40 maxEndTime; // 184/256 bits
    uint40 maxMaxTokenSupplyForStage; // 224/256 bits
    uint16 minFeeBps; // 240/256 bits
    uint16 maxFeeBps; // 256/256 bits
}

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

import {
  AllowListData,
  PublicDrop,
  SignedMintValidationParams,
  TokenGatedDropStage
} from "../contracts/lib/SeaDropStructs.sol";

interface ERC721SeaDropStructsErrorsAndEvents {
  /**
   * @notice Revert with an error if mint exceeds the max supply.
   */
  error MintQuantityExceedsMaxSupply(uint256 total, uint256 maxSupply);

  /**
   * @notice Revert with an error if the number of token gated
   *         allowedNftTokens doesn't match the length of supplied
   *         drop stages.
   */
  error TokenGatedMismatch();

  /**
   *  @notice Revert with an error if the number of signers doesn't match
   *          the length of supplied signedMintValidationParams
   */
  error SignersMismatch();

  /**
   * @notice A struct to configure multiple contract options at a time.
   */
  struct MultiConfigureStruct {
    uint256 maxSupply;
    string baseURI;
    string contractURI;
    address seaDropImpl;
    PublicDrop publicDrop;
    string dropURI;
    AllowListData allowListData;
    address creatorPayoutAddress;
    bytes32 provenanceHash;

    address[] allowedFeeRecipients;
    address[] disallowedFeeRecipients;

    address[] allowedPayers;
    address[] disallowedPayers;

    // Token-gated
    address[] tokenGatedAllowedNftTokens;
    TokenGatedDropStage[] tokenGatedDropStages;
    address[] disallowedTokenGatedAllowedNftTokens;

    // Server-signed
    address[] signers;
    SignedMintValidationParams[] signedMintValidationParams;
    address[] disallowedSigners;
  }
}

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

import "./INonFungibleSeaDropToken.sol";
import "./ERC721SeaDropStructsErrorsAndEvents.sol";

/**
 * @dev Interface of ERC721A.
 */
interface IDarkEnergy is INonFungibleSeaDropToken, ERC721SeaDropStructsErrorsAndEvents {
    /**
     * The caller must own the token or be an approved operator.
     */
    error CallerNotOwnerNorApproved();

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

    /**
     * One cannot send a token holding negative energy to a holder of a token
     * holding positive energy
     */
    error NegativeEnergyToPositiveHolder();

    /**
     * The `quantity` minted with ERC2309 exceeds the safety limit.
     */
    error QuantityExceedsLimit();

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

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

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

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

    /**
     * Caller needs a gamePass to proceed
     */
    error NoGamePass();

    /**
     * The game rules aren't consistent
     */
    error InvalidGameRules();

    /**
     * To prevent Owner from overriding fees, Administrator must
     * first initialize with fee.
     */
    error AdministratorMustInitializeWithFee();

    /**
     * To be thrown in case the max supply was reached and the mint doesn't go
     * through SeaDrop
     */
    error MaxSupplyExceeded();

    /**
     * To be thrown in case the max supply was reached and the mint doesn't go
     * through SeaDrop
     */
    error OperatorNotAllowed();

    /**
     * To be thrown in case the max supply was reached and the mint doesn't go
     * through SeaDrop
     */
    error AddressNotHolder();

    /**
     * To be thrown in case the max supply was reached and the mint doesn't go
     * through SeaDrop
     */
    error GameNotActive();

    // =============================================================
    //                            STRUCTS
    // =============================================================

    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Stores the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
        // Arbitrary data similar to `startTimestamp` that can be set via {_extraData}.
        uint24 extraData;
    }

    // =============================================================
    //                         TOKEN COUNTERS
    // =============================================================

    /**
     * @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() external view returns (uint256);

    // =============================================================
    //                            IERC165
    // =============================================================

    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30000 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`,
     * 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,
        bytes calldata data
    ) external;

    /**
     * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` 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);

    // =============================================================
    //                           IERC2309
    // =============================================================

    /**
     * @dev Emitted when tokens in `fromTokenId` to `toTokenId`
     * (inclusive) is transferred from `from` to `to`, as defined in the
     * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309) standard.
     *
     * See {_mintERC2309} for more details.
     */
    event ConsecutiveTransfer(
        uint256 indexed fromTokenId,
        uint256 toTokenId,
        address indexed from,
        address indexed to
    );

    // =============================================================
    //                      Marketplace Related
    // =============================================================
    /**
     * @dev Signal to marketplaces that the token has been updated
     */
    event MetadataUpdate(uint256 _tokenId);

    /**
     * @dev Allowed a SeaDrop
     */
    event AllowedSeaDrop(address indexed seaDrop);

    /**
     * @dev Denied a SeaDrop
     */
    event DeniedSeaDrop(address indexed seaDrop);

    // =============================================================
    //                      DarkEnergy-specific
    // =============================================================

    /**
     * @dev GamePass earned through minting
     */
    event GamePassesGained(uint256 indexed tokenId, uint16 indexed amount);

    /**
     * @dev Energy updated
     */
    event EnergyUpdate(address indexed player, int40 indexed energyDiff);

    /**
     * @dev Energy doubled
     */
    event EnergyDoubled(address indexed player, int40 indexed energy);

    /**
     * @dev Energy halved
     */
    event EnergyHalved(address indexed player, int40 indexed energy);

    /**
     * @dev No risk game played
     */
    event PlayNoRisk(address indexed player);

    /**
     * @dev High stakes game played
     */
    event PlayHighStakes(address indexed player);

    /**
     * @dev Ordinal won
     */
    event OrdinalWon(address indexed player);

    /**
     * @dev Game rules updated
     */
    event GameRulesUpdated(bytes32 indexed oldRules, bytes32 indexed newRules);

    /**
     * @dev Game rules updated
     */
    event OrdinalsVouchersDeployed(address indexed contractAddress);

    /**
     * @dev Dark Energy minted
     */
    event GlitchMint(address indexed to, uint256 indexed energy, uint256 indexed gamePasses);

    /**
     * @dev Dark Energy minted
     */
    event AdminMint(address indexed to, int40 indexed energyDiff, uint16 indexed gamePassesDiff);
}

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

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

import {
    AllowListData,
    PublicDrop,
    TokenGatedDropStage,
    SignedMintValidationParams
} from "../contracts/lib/SeaDropStructs.sol";

interface INonFungibleSeaDropToken is ISeaDropTokenContractMetadata {
    /**
     * @dev Revert with an error if a contract is not an allowed
     *      SeaDrop address.
     */
    error OnlyAllowedSeaDrop();

    /**
     * @dev Emit an event when allowed SeaDrop contracts are updated.
     */
    event AllowedSeaDropUpdated(address[] allowedSeaDrop);

    /**
     * @notice An event to signify that a SeaDrop token contract was deployed.
     */
    event SeaDropTokenDeployed();

    /**
     * @notice Update the allowed SeaDrop contracts.
     *         Only the owner or administrator can use this function.
     *
     * @param allowedSeaDrop The allowed SeaDrop addresses.
     */
    function updateAllowedSeaDrop(address[] calldata allowedSeaDrop) external;

    /**
     * @notice Mint tokens, restricted to the SeaDrop contract.
     *
     * @dev    NOTE: If a token registers itself with multiple SeaDrop
     *         contracts, the implementation of this function should guard
     *         against reentrancy. If the implementing token uses
     *         _safeMint(), or a feeRecipient with a malicious receive() hook
     *         is specified, the token or fee recipients may be able to execute
     *         another mint in the same transaction via a separate SeaDrop
     *         contract.
     *         This is dangerous if an implementing token does not correctly
     *         update the minterNumMinted and currentTotalSupply values before
     *         transferring minted tokens, as SeaDrop references these values
     *         to enforce token limits on a per-wallet and per-stage basis.
     *
     * @param minter   The address to mint to.
     * @param quantity The number of tokens to mint.
     */
    function mintSeaDrop(address minter, uint256 quantity) external;

    /**
     * @notice Returns a set of mint stats for the address.
     *         This assists SeaDrop in enforcing maxSupply,
     *         maxTotalMintableByWallet, and maxTokenSupplyForStage checks.
     *
     * @dev    NOTE: Implementing contracts should always update these numbers
     *         before transferring any tokens with _safeMint() to mitigate
     *         consequences of malicious onERC721Received() hooks.
     *
     * @param minter The minter address.
     */
    function getMintStats(address minter)
        external
        view
        returns (
            uint256 minterNumMinted,
            uint256 currentTotalSupply,
            uint256 maxSupply
        );

    /**
     * @notice Update the public drop data for this nft contract on SeaDrop.
     *         Only the owner or administrator can use this function.
     *
     *         The administrator can only update `feeBps`.
     *
     * @param seaDropImpl The allowed SeaDrop contract.
     * @param publicDrop  The public drop data.
     */
    function updatePublicDrop(
        address seaDropImpl,
        PublicDrop calldata publicDrop
    ) external;

    /**
     * @notice Update the allow list data for this nft contract on SeaDrop.
     *         Only the owner or administrator can use this function.
     *
     * @param seaDropImpl   The allowed SeaDrop contract.
     * @param allowListData The allow list data.
     */
    function updateAllowList(
        address seaDropImpl,
        AllowListData calldata allowListData
    ) external;

    /**
     * @notice Update the token gated drop stage data for this nft contract
     *         on SeaDrop.
     *         Only the owner or administrator can use this function.
     *
     *         The administrator, when present, must first set `feeBps`.
     *
     *         Note: If two INonFungibleSeaDropToken tokens are doing
     *         simultaneous token gated drop promotions for each other,
     *         they can be minted by the same actor until
     *         `maxTokenSupplyForStage` is reached. Please ensure the
     *         `allowedNftToken` is not running an active drop during the
     *         `dropStage` time period.
     *
     *
     * @param seaDropImpl     The allowed SeaDrop contract.
     * @param allowedNftToken The allowed nft token.
     * @param dropStage       The token gated drop stage data.
     */
    function updateTokenGatedDrop(
        address seaDropImpl,
        address allowedNftToken,
        TokenGatedDropStage calldata dropStage
    ) external;

    /**
     * @notice Update the drop URI for this nft contract on SeaDrop.
     *         Only the owner or administrator can use this function.
     *
     * @param seaDropImpl The allowed SeaDrop contract.
     * @param dropURI     The new drop URI.
     */
    function updateDropURI(address seaDropImpl, string calldata dropURI)
        external;

    /**
     * @notice Update the creator payout address for this nft contract on
     *         SeaDrop.
     *         Only the owner can set the creator payout address.
     *
     * @param seaDropImpl   The allowed SeaDrop contract.
     * @param payoutAddress The new payout address.
     */
    function updateCreatorPayoutAddress(
        address seaDropImpl,
        address payoutAddress
    ) external;

    /**
     * @notice Update the allowed fee recipient for this nft contract
     *         on SeaDrop.
     *         Only the administrator can set the allowed fee recipient.
     *
     * @param seaDropImpl  The allowed SeaDrop contract.
     * @param feeRecipient The new fee recipient.
     */
    function updateAllowedFeeRecipient(
        address seaDropImpl,
        address feeRecipient,
        bool allowed
    ) external;

    /**
     * @notice Update the server-side signers for this nft contract
     *         on SeaDrop.
     *         Only the owner or administrator can use this function.
     *
     * @param seaDropImpl                The allowed SeaDrop contract.
     * @param signer                     The signer to update.
     * @param signedMintValidationParams Minimum and maximum parameters
     *                                   to enforce for signed mints.
     */
    function updateSignedMintValidationParams(
        address seaDropImpl,
        address signer,
        SignedMintValidationParams memory signedMintValidationParams
    ) external;

    /**
     * @notice Update the allowed payers for this nft contract on SeaDrop.
     *         Only the owner or administrator can use this function.
     *
     * @param seaDropImpl The allowed SeaDrop contract.
     * @param payer       The payer to update.
     * @param allowed     Whether the payer is allowed.
     */
    function updatePayer(
        address seaDropImpl,
        address payer,
        bool allowed
    ) external;
}

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

import {
    AllowListData,
    MintParams,
    PublicDrop,
    TokenGatedDropStage,
    TokenGatedMintParams,
    SignedMintValidationParams
} from "../contracts/lib/SeaDropStructs.sol";

import { SeaDropErrorsAndEvents } from "../contracts/lib/SeaDropErrorsAndEvents.sol";

interface ISeaDrop is SeaDropErrorsAndEvents {
    /**
     * @notice Mint a public drop.
     *
     * @param nftContract      The nft contract to mint.
     * @param feeRecipient     The fee recipient.
     * @param minterIfNotPayer The mint recipient if different than the payer.
     * @param quantity         The number of tokens to mint.
     */
    function mintPublic(
        address nftContract,
        address feeRecipient,
        address minterIfNotPayer,
        uint256 quantity
    ) external payable;

    /**
     * @notice Mint from an allow list.
     *
     * @param nftContract      The nft contract to mint.
     * @param feeRecipient     The fee recipient.
     * @param minterIfNotPayer The mint recipient if different than the payer.
     * @param quantity         The number of tokens to mint.
     * @param mintParams       The mint parameters.
     * @param proof            The proof for the leaf of the allow list.
     */
    function mintAllowList(
        address nftContract,
        address feeRecipient,
        address minterIfNotPayer,
        uint256 quantity,
        MintParams calldata mintParams,
        bytes32[] calldata proof
    ) external payable;

    /**
     * @notice Mint with a server-side signature.
     *         Note that a signature can only be used once.
     *
     * @param nftContract      The nft contract to mint.
     * @param feeRecipient     The fee recipient.
     * @param minterIfNotPayer The mint recipient if different than the payer.
     * @param quantity         The number of tokens to mint.
     * @param mintParams       The mint parameters.
     * @param salt             The sale for the signed mint.
     * @param signature        The server-side signature, must be an allowed
     *                         signer.
     */
    function mintSigned(
        address nftContract,
        address feeRecipient,
        address minterIfNotPayer,
        uint256 quantity,
        MintParams calldata mintParams,
        uint256 salt,
        bytes calldata signature
    ) external payable;

    /**
     * @notice Mint as an allowed token holder.
     *         This will mark the token id as redeemed and will revert if the
     *         same token id is attempted to be redeemed twice.
     *
     * @param nftContract      The nft contract to mint.
     * @param feeRecipient     The fee recipient.
     * @param minterIfNotPayer The mint recipient if different than the payer.
     * @param mintParams       The token gated mint params.
     */
    function mintAllowedTokenHolder(
        address nftContract,
        address feeRecipient,
        address minterIfNotPayer,
        TokenGatedMintParams calldata mintParams
    ) external payable;

    /**
     * @notice Emits an event to notify update of the drop URI.
     *
     *         This method assume msg.sender is an nft contract and its
     *         ERC165 interface id matches INonFungibleSeaDropToken.
     *
     *         Note: Be sure only authorized users can call this from
     *         token contracts that implement INonFungibleSeaDropToken.
     *
     * @param dropURI The new drop URI.
     */
    function updateDropURI(string calldata dropURI) external;

    /**
     * @notice Updates the public drop data for the nft contract
     *         and emits an event.
     *
     *         This method assume msg.sender is an nft contract and its
     *         ERC165 interface id matches INonFungibleSeaDropToken.
     *
     *         Note: Be sure only authorized users can call this from
     *         token contracts that implement INonFungibleSeaDropToken.
     *
     * @param publicDrop The public drop data.
     */
    function updatePublicDrop(PublicDrop calldata publicDrop) external;

    /**
     * @notice Updates the allow list merkle root for the nft contract
     *         and emits an event.
     *
     *         This method assume msg.sender is an nft contract and its
     *         ERC165 interface id matches INonFungibleSeaDropToken.
     *
     *         Note: Be sure only authorized users can call this from
     *         token contracts that implement INonFungibleSeaDropToken.
     *
     * @param allowListData The allow list data.
     */
    function updateAllowList(AllowListData calldata allowListData) external;

    /**
     * @notice Updates the token gated drop stage for the nft contract
     *         and emits an event.
     *
     *         This method assume msg.sender is an nft contract and its
     *         ERC165 interface id matches INonFungibleSeaDropToken.
     *
     *         Note: Be sure only authorized users can call this from
     *         token contracts that implement INonFungibleSeaDropToken.
     *
     *         Note: If two INonFungibleSeaDropToken tokens are doing
     *         simultaneous token gated drop promotions for each other,
     *         they can be minted by the same actor until
     *         `maxTokenSupplyForStage` is reached. Please ensure the
     *         `allowedNftToken` is not running an active drop during
     *         the `dropStage` time period.
     *
     * @param allowedNftToken The token gated nft token.
     * @param dropStage       The token gated drop stage data.
     */
    function updateTokenGatedDrop(
        address allowedNftToken,
        TokenGatedDropStage calldata dropStage
    ) external;

    /**
     * @notice Updates the creator payout address and emits an event.
     *
     *         This method assume msg.sender is an nft contract and its
     *         ERC165 interface id matches INonFungibleSeaDropToken.
     *
     *         Note: Be sure only authorized users can call this from
     *         token contracts that implement INonFungibleSeaDropToken.
     *
     * @param payoutAddress The creator payout address.
     */
    function updateCreatorPayoutAddress(address payoutAddress) external;

    /**
     * @notice Updates the allowed fee recipient and emits an event.
     *
     *         This method assume msg.sender is an nft contract and its
     *         ERC165 interface id matches INonFungibleSeaDropToken.
     *
     *         Note: Be sure only authorized users can call this from
     *         token contracts that implement INonFungibleSeaDropToken.
     *
     * @param feeRecipient The fee recipient.
     * @param allowed      If the fee recipient is allowed.
     */
    function updateAllowedFeeRecipient(address feeRecipient, bool allowed)
        external;

    /**
     * @notice Updates the allowed server-side signers and emits an event.
     *
     *         This method assume msg.sender is an nft contract and its
     *         ERC165 interface id matches INonFungibleSeaDropToken.
     *
     *         Note: Be sure only authorized users can call this from
     *         token contracts that implement INonFungibleSeaDropToken.
     *
     * @param signer                     The signer to update.
     * @param signedMintValidationParams Minimum and maximum parameters
     *                                   to enforce for signed mints.
     */
    function updateSignedMintValidationParams(
        address signer,
        SignedMintValidationParams calldata signedMintValidationParams
    ) external;

    /**
     * @notice Updates the allowed payer and emits an event.
     *
     *         This method assume msg.sender is an nft contract and its
     *         ERC165 interface id matches INonFungibleSeaDropToken.
     *
     *         Note: Be sure only authorized users can call this from
     *         token contracts that implement INonFungibleSeaDropToken.
     *
     * @param payer   The payer to add or remove.
     * @param allowed Whether to add or remove the payer.
     */
    function updatePayer(address payer, bool allowed) external;

    /**
     * @notice Returns the public drop data for the nft contract.
     *
     * @param nftContract The nft contract.
     */
    function getPublicDrop(address nftContract)
        external
        view
        returns (PublicDrop memory);

    /**
     * @notice Returns the creator payout address for the nft contract.
     *
     * @param nftContract The nft contract.
     */
    function getCreatorPayoutAddress(address nftContract)
        external
        view
        returns (address);

    /**
     * @notice Returns the allow list merkle root for the nft contract.
     *
     * @param nftContract The nft contract.
     */
    function getAllowListMerkleRoot(address nftContract)
        external
        view
        returns (bytes32);

    /**
     * @notice Returns if the specified fee recipient is allowed
     *         for the nft contract.
     *
     * @param nftContract  The nft contract.
     * @param feeRecipient The fee recipient.
     */
    function getFeeRecipientIsAllowed(address nftContract, address feeRecipient)
        external
        view
        returns (bool);

    /**
     * @notice Returns an enumeration of allowed fee recipients for an
     *         nft contract when fee recipients are enforced
     *
     * @param nftContract The nft contract.
     */
    function getAllowedFeeRecipients(address nftContract)
        external
        view
        returns (address[] memory);

    /**
     * @notice Returns the server-side signers for the nft contract.
     *
     * @param nftContract The nft contract.
     */
    function getSigners(address nftContract)
        external
        view
        returns (address[] memory);

    /**
     * @notice Returns the struct of SignedMintValidationParams for a signer.
     *
     * @param nftContract The nft contract.
     * @param signer      The signer.
     */
    function getSignedMintValidationParams(address nftContract, address signer)
        external
        view
        returns (SignedMintValidationParams memory);

    /**
     * @notice Returns the payers for the nft contract.
     *
     * @param nftContract The nft contract.
     */
    function getPayers(address nftContract)
        external
        view
        returns (address[] memory);

    /**
     * @notice Returns if the specified payer is allowed
     *         for the nft contract.
     *
     * @param nftContract The nft contract.
     * @param payer       The payer.
     */
    function getPayerIsAllowed(address nftContract, address payer)
        external
        view
        returns (bool);

    /**
     * @notice Returns the allowed token gated drop tokens for the nft contract.
     *
     * @param nftContract The nft contract.
     */
    function getTokenGatedAllowedTokens(address nftContract)
        external
        view
        returns (address[] memory);

    /**
     * @notice Returns the token gated drop data for the nft contract
     *         and token gated nft.
     *
     * @param nftContract     The nft contract.
     * @param allowedNftToken The token gated nft token.
     */
    function getTokenGatedDrop(address nftContract, address allowedNftToken)
        external
        view
        returns (TokenGatedDropStage memory);

    /**
     * @notice Returns whether the token id for a token gated drop has been
     *         redeemed.
     *
     * @param nftContract       The nft contract.
     * @param allowedNftToken   The token gated nft token.
     * @param allowedNftTokenId The token gated nft token id to check.
     */
    function getAllowedNftTokenIdIsRedeemed(
        address nftContract,
        address allowedNftToken,
        uint256 allowedNftTokenId
    ) external view returns (bool);
}

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

import { IERC2981 } from "@openzeppelin/contracts/interfaces/IERC2981.sol";

interface ISeaDropTokenContractMetadata is IERC2981 {
    /**
     * @notice Throw if the max supply exceeds uint64, a limit
     *         due to the storage of bit-packed variables in ERC721A.
     */
    error CannotExceedMaxSupplyOfUint64(uint256 newMaxSupply);

    /**
     * @dev Revert with an error when attempting to set the provenance
     *      hash after the mint has started.
     */
    error ProvenanceHashCannotBeSetAfterMintStarted();

    /**
     * @dev Revert if the royalty basis points is greater than 10_000.
     */
    error InvalidRoyaltyBasisPoints(uint256 basisPoints);

    /**
     * @dev Revert if the royalty address is being set to the zero address.
     */
    error RoyaltyAddressCannotBeZeroAddress();

    /**
     * @dev Emit an event for token metadata reveals/updates,
     *      according to EIP-4906.
     *
     * @param _fromTokenId The start token id.
     * @param _toTokenId   The end token id.
     */
    event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);

    /**
     * @dev Emit an event when the URI for the collection-level metadata
     *      is updated.
     */
    event ContractURIUpdated(string newContractURI);

    /**
     * @dev Emit an event when the max token supply is updated.
     */
    event MaxSupplyUpdated(uint256 newMaxSupply);

    /**
     * @dev Emit an event with the previous and new provenance hash after
     *      being updated.
     */
    event ProvenanceHashUpdated(bytes32 previousHash, bytes32 newHash);

    /**
     * @dev Emit an event when the royalties info is updated.
     */
    event RoyaltyInfoUpdated(address receiver, uint256 bps);

    /**
     * @notice A struct defining royalty info for the contract.
     */
    struct RoyaltyInfo {
        address royaltyAddress;
        uint96 royaltyBps;
    }

    /**
     * @notice Sets the base URI for the token metadata and emits an event.
     *
     * @param tokenURI The new base URI to set.
     */
    function setBaseURI(string calldata tokenURI) external;

    /**
     * @notice Sets the contract URI for contract metadata.
     *
     * @param newContractURI The new contract URI.
     */
    function setContractURI(string calldata newContractURI) external;

    /**
     * @notice Sets the max supply and emits an event.
     *
     * @param newMaxSupply The new max supply to set.
     */
    function setMaxSupply(uint256 newMaxSupply) external;

    /**
     * @notice Sets the provenance hash and emits an event.
     *
     *         The provenance hash is used for random reveals, which
     *         is a hash of the ordered metadata to show it has not been
     *         modified after mint started.
     *
     *         This function will revert after the first item has been minted.
     *
     * @param newProvenanceHash The new provenance hash to set.
     */
    function setProvenanceHash(bytes32 newProvenanceHash) external;

    /**
     * @notice Sets the address and basis points for royalties.
     *
     * @param newInfo The struct to configure royalties.
     */
    function setRoyaltyInfo(RoyaltyInfo calldata newInfo) external;

    /**
     * @notice Returns the base URI for token metadata.
     */
    function baseURI() external view returns (string memory);

    /**
     * @notice Returns the contract URI.
     */
    function contractURI() external view returns (string memory);

    /**
     * @notice Returns the max token supply.
     */
    function maxSupply() external view returns (uint256);

    /**
     * @notice Returns the provenance hash.
     *         The provenance hash is used for random reveals, which
     *         is a hash of the ordered metadata to show it is unmodified
     *         after mint has started.
     */
    function provenanceHash() external view returns (bytes32);

    /**
     * @notice Returns the address that receives royalties.
     */
    function royaltyAddress() external view returns (address);

    /**
     * @notice Returns the royalty basis points out of 10_000.
     */
    function royaltyBasisPoints() external view returns (uint256);
}

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

library DarkEnergyPackedStruct {
    // =============================================================
    //                            Structs
    // =============================================================

    /// @dev All 256 bits from a PlayerData (from right to left)
    struct PlayerData {
        bool isHolder;
        int40 energyAmount;
        uint16 gamePasses;
        uint16 mintCount;
        uint16 mergeCount;
        uint16 noRiskPlayCount;
        uint16 noRiskWinCount;
        uint16 highStakesPlayCount;
        uint16 highStakesWinCount;
        uint16 highStakesLossCount;
        uint32 totalEarned;
        uint32 totalRugged;
        uint16 unused;
        bool flagA;
        bool flagB;
        bool flagC;
        bool flagD;
        bool flagE;
        bool flagF;
        bool flagG;
    }

    /// @dev All 256 bits from a GameRules (from right to left)
    struct GameRules {
        bool isActive;
        uint16 oddsNoRiskEarn100;
        uint16 oddsNoRiskEarn300;
        uint16 oddsNoRiskEarn500;
        uint16 oddsHighStakesWinOrdinal;
        uint16 oddsHighStakesLose100;
        uint16 oddsHighStakesLose300;
        uint16 oddsHighStakesLose500;
        uint16 oddsHighStakesLose1000;
        uint16 oddsHighStakesEarn100;
        uint16 oddsHighStakesEarn300;
        uint16 oddsHighStakesEarn500;
        uint16 oddsHighStakesEarn1000;
        uint16 oddsHighStakesDoubles;
        uint16 oddsHighStakesHalves;
        uint16 oddsGamePassOnMint;
        uint8 remainingOrdinals;
        bool flagA;
        bool flagB;
        bool flagC;
        bool flagD;
        bool flagE;
        bool flagF;
        bool flagG;
    }

    // =============================================================
    //                 Unpacking by type and offset
    // =============================================================

    /**
     * @dev unpack bit [offset] (bool)
     */
    function getBool(bytes32 p, uint8 offset) internal pure returns (bool r) {
        assembly {
            r := and(shr(offset, p), 1)
        }
    }

    /**
     * @dev unpack bits [offset..offset + 8]
     */
    function getUint8(bytes32 p, uint8 offset) internal pure returns (uint8 r) {
        assembly {
            r := and(shr(offset, p), 0xFF)
        }
    }

    /**
     * @dev unpack bits [offset..offset + 16]
     */
    function getUint16(
        bytes32 p,
        uint8 offset
    ) internal pure returns (uint16 r) {
        assembly {
            r := and(shr(offset, p), 0xFFFF)
        }
    }

    /**
     * @dev unpack bits [offset..offset + 32]
     */
    function getUint32(
        bytes32 p,
        uint8 offset
    ) internal pure returns (uint32 r) {
        assembly {
            r := and(shr(offset, p), 0xFFFFFFFF)
        }
    }

    /**
     * @dev unpack bits[offset..offset + 40]
     */
    function getInt40(bytes32 p, uint8 offset) internal pure returns (int40 r) {
        assembly {
            r := and(shr(offset, p), 0xFFFFFFFFFF)
        }
    }

    // =============================================================
    //                    Unpacking whole structs
    // =============================================================

    function playerData(bytes32 p) internal pure returns (PlayerData memory r) {
        return
            PlayerData({
                isHolder: getBool(p, 0),
                energyAmount: getInt40(p, 1),
                gamePasses: getUint16(p, 41),
                mintCount: getUint16(p, 57),
                mergeCount: getUint16(p, 73),
                noRiskPlayCount: getUint16(p, 89),
                noRiskWinCount: getUint16(p, 105),
                highStakesPlayCount: getUint16(p, 121),
                highStakesWinCount: getUint16(p, 137),
                highStakesLossCount: getUint16(p, 153),
                totalEarned: getUint32(p, 169),
                totalRugged: getUint32(p, 201),
                unused: getUint16(p, 169),
                flagA: getBool(p, 249),
                flagB: getBool(p, 250),
                flagC: getBool(p, 251),
                flagD: getBool(p, 252),
                flagE: getBool(p, 253),
                flagF: getBool(p, 254),
                flagG: getBool(p, 255)
        });
    }

    function gameRules(bytes32 p) internal pure returns (GameRules memory r) {
        return
            GameRules({
                isActive: getBool(p, 0),
                oddsNoRiskEarn100: getUint16(p, 1),
                oddsNoRiskEarn300: getUint16(p, 17),
                oddsNoRiskEarn500: getUint16(p, 33),
                oddsHighStakesWinOrdinal: getUint16(p, 49),
                oddsHighStakesLose100: getUint16(p, 65),
                oddsHighStakesLose300: getUint16(p, 81),
                oddsHighStakesLose500: getUint16(p, 97),
                oddsHighStakesLose1000: getUint16(p, 113),
                oddsHighStakesEarn100: getUint16(p, 129),
                oddsHighStakesEarn300: getUint16(p, 145),
                oddsHighStakesEarn500: getUint16(p, 161),
                oddsHighStakesEarn1000: getUint16(p, 177),
                oddsHighStakesDoubles: getUint16(p, 193),
                oddsHighStakesHalves: getUint16(p, 209),
                oddsGamePassOnMint: getUint16(p, 225),
                remainingOrdinals: getUint8(p, 241),
                flagA: getBool(p, 249),
                flagB: getBool(p, 250),
                flagC: getBool(p, 251),
                flagD: getBool(p, 252),
                flagE: getBool(p, 253),
                flagF: getBool(p, 254),
                flagG: getBool(p, 255)
            });
    }

    // =============================================================
    //                         Setting Bits
    // =============================================================

    /**
     * @dev set bit [{offset}] to {value}
     */
    function setBit(
        bytes32 p,
        uint8 offset,
        bool value
    ) internal pure returns (bytes32 np) {
        assembly {
            np := or(
                and(
                    p,
                    xor(
                        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,
                        shl(offset, 1)
                    )
                ),
                shl(offset, value)
            )
        }
    }

    /**
     * @dev set 8 bits to {value} at [{offset}]
     */
    function setUint8(
        bytes32 p,
        uint8 offset,
        uint8 value
    ) internal pure returns (bytes32 np) {
        assembly {
            np := or(
                and(
                    p,
                    xor(
                        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,
                        shl(offset, 0xFF)
                    )
                ),
                shl(offset, and(value, 0xFF))
            )
        }
    }

    /**
     * @dev set 16 bits to {value} at [{offset}]
     */
    function setUint16(
        bytes32 p,
        uint8 offset,
        uint16 value
    ) internal pure returns (bytes32 np) {
        assembly {
            np := or(
                and(
                    p,
                    xor(
                        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,
                        shl(offset, 0xFFFF)
                    )
                ),
                shl(offset, and(value, 0xFFFF))
            )
        }
    }

    /**
     * @dev set 32 bits to {value} at [{offset}]
     */
    function setUint32(
        bytes32 p,
        uint8 offset,
        uint32 value
    ) internal pure returns (bytes32 np) {
        assembly {
            np := or(
                and(
                    p,
                    xor(
                        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,
                        shl(offset, 0xFFFFFFFF)
                    )
                ),
                shl(offset, and(value, 0xFFFFFFFF))
            )
        }
    }

    /**
     * @dev set 40 bits to {value} at [{offset}]
     */
    function setInt40(
        bytes32 p,
        uint8 offset,
        int40 value
    ) internal pure returns (bytes32 np) {
        assembly {
            np := or(
                and(
                    p,
                    xor(
                        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,
                        shl(offset, 0xFFFFFFFFFF)
                    )
                ),
                shl(offset, and(value, 0xFFFFFFFFFF))
            )
        }
    }

    // =============================================================
    //                         DarkEnergy-specific
    // =============================================================

    /**
     * @dev get _playerData.isHolder
     */
    function isHolder(bytes32 p) internal pure returns (bool) {
        return getBool(p, 0);
    }

    /**
     * @dev get _playerData.energyAmount
     */
    function getEnergy(bytes32 p) internal pure returns (int40) {
        return getInt40(p, 1);
    }

    /**
     * @dev get _playerData.gamePasses
     */
    function getGamePasses(bytes32 p) internal pure returns (uint16) {
        return getUint16(p, 41);
    }

    /**
     * @dev get _playerData.mintCount
     */
    function getMintCount(bytes32 p) internal pure returns (uint16) {
        return getUint16(p, 57);
    }

    /**
     * @dev get _playerData.mergeCount
     */
    function getMergeCount(bytes32 p) internal pure returns (uint16) {
        return getUint16(p, 73);
    }

    /**
     * @dev get _playerData.noRiskPlayCount
     */
    function getNoRiskPlayCount(bytes32 p) internal pure returns (uint16) {
        return getUint16(p, 89);
    }

    /**
     * @dev get _playerData.noRiskWinCount
     */
    function getNoRiskWinCount(bytes32 p) internal pure returns (uint16) {
        return getUint16(p, 105);
    }

    /**
     * @dev get _playerData.highStakesPlayCount
     */
    function getHighStakesPlayCount(bytes32 p) internal pure returns (uint16) {
        return getUint16(p, 121);
    }

    /**
     * @dev get _playerData.highStakesWinCount
     */
    function getHighStakesWinCount(bytes32 p) internal pure returns (uint16) {
        return getUint16(p, 137);
    }

    /**
     * @dev get _playerData.highStakesLossCount
     */
    function getHighStakesLossCount(bytes32 p) internal pure returns (uint16) {
        return getUint16(p, 153);
    }

    /**
     * @dev get _playerData.totalEarned
     */
    function getTotalEarned(bytes32 p) internal pure returns (uint32) {
        return getUint32(p, 169);
    }

    /**
     * @dev get _playerData.totalRugged
     */
    function getTotalRugged(bytes32 p) internal pure returns (uint32) {
        return getUint32(p, 201);
    }

    /**
     * @dev sets _playerData.isHolder
     */
    function setHolder(bytes32 p, bool status) internal pure returns (bytes32 np) {
        return setBit(p, 0, status);
    }

    /**
     * @dev sets _playerData.energyAmount
     */
    function setEnergy(bytes32 p, int40 value) internal pure returns (bytes32 np) {
        return setInt40(p, 1, value);
    }

    /**
     * @dev sets _playerData.gamePasses
     */
    function setGamePasses(bytes32 p, uint16 value) internal pure returns (bytes32 np) {
        return setUint16(p, 41, value);
    }

    /**
     * @dev sets _playerData.mintCount
     */
    function setMintCount(bytes32 p, uint16 value) internal pure returns (bytes32 np) {
        return setUint16(p, 57, value);
    }

    /**
     * @dev sets _playerData.mergeCount
     */
    function setMergeCount(bytes32 p, uint16 value) internal pure returns (bytes32 np) {
        return setUint16(p, 73, value);
    }

    /**
     * @dev sets _playerData.noRiskPlayCount
     */
    function setNoRiskPlayCount(bytes32 p, uint16 value) internal pure returns (bytes32 np) {
        return setUint16(p, 89, value);
    }

    /**
     * @dev sets _playerData.noRiskWinCount
     */
    function setNoRiskWinCount(bytes32 p, uint16 value) internal pure returns (bytes32 np) {
        return setUint16(p, 105, value);
    }

    /**
     * @dev sets _playerData.highStakesPlayCount
     */
    function setHighStakesPlayCount(bytes32 p, uint16 value) internal pure returns (bytes32 np) {
        return setUint16(p, 121, value);
    }

    /**
     * @dev sets _playerData.highStakesWinCount
     */
    function setHighStakesWinCount(bytes32 p, uint16 value) internal pure returns (bytes32 np) {
        return setUint16(p, 137, value);
    }

    /**
     * @dev sets _playerData.highStakesLossCount
     */
    function setHighStakesLossCount(bytes32 p, uint16 value) internal pure returns (bytes32 np) {
        return setUint16(p, 153, value);
    }

    /**
     * @dev sets _playerData.totalEarned
     */
    function setTotalEarned(bytes32 p, uint32 value) internal pure returns (bytes32 np) {
        return setUint32(p, 169, value);
    }

    /**
     * @dev sets _playerData.totalRugged
     */
    function setTotalRugged(bytes32 p, uint32 value) internal pure returns (bytes32 np) {
        return setUint32(p, 201, value);
    }

    /**
     * @dev Clears the last 57 bits (isHolder, energyAmount, gamePasses)
     */
    function clearHoldingData(bytes32 p) internal pure returns (bytes32 np) {
        assembly {
            np := and(
                p,
                0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE00000000000000
            )
        }
    }

    /**
     * @dev Replace the last 57 bits (isHolder, energyAmount, gamePasses) from
     *      another packed bytes variable (to be used for transfers)
     */
    function setHoldingData(
        bytes32 p,
        bytes32 q
    ) internal pure returns (bytes32 np) {
        assembly {
            np := or(
                and(
                    p,
                    0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE00000000000000
                ),
                and(q, 0x1FFFFFFFFFFFFFF)
            )
        }
    }

    /**
     * @dev tight-pack a GameRules struct into a uint256
     */
    function packGameRules(
        GameRules calldata
    ) internal pure returns (bytes32 result) {
        assembly {
            result := calldataload(4)
            result := or(result, shl(1, calldataload(36)))
            result := or(result, shl(17, calldataload(68)))
            result := or(result, shl(33, calldataload(100)))
            result := or(result, shl(49, calldataload(132)))
            result := or(result, shl(65, calldataload(164)))
            result := or(result, shl(81, calldataload(196)))
            result := or(result, shl(97, calldataload(228)))
            result := or(result, shl(113, calldataload(260)))
            result := or(result, shl(129, calldataload(292)))
            result := or(result, shl(145, calldataload(324)))
            result := or(result, shl(161, calldataload(356)))
            result := or(result, shl(177, calldataload(388)))
            result := or(result, shl(193, calldataload(420)))
            result := or(result, shl(209, calldataload(452)))
            result := or(result, shl(225, calldataload(484)))
            result := or(result, shl(241, calldataload(516)))
            result := or(result, shl(249, calldataload(548)))
            result := or(result, shl(250, calldataload(580)))
            result := or(result, shl(251, calldataload(612)))
            result := or(result, shl(252, calldataload(644)))
            result := or(result, shl(253, calldataload(676)))
            result := or(result, shl(254, calldataload(708)))
            result := or(result, shl(255, calldataload(740)))
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)
// Added support for int256

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/utils/math/Math.sol";

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

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

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        if (value >= 0) {
            return toString(uint256(value));
        }
        return
            string(
                abi.encodePacked(
                    "-",
                    toString(uint256(-value))
                )
            );
    }

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

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

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

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

library UriEncode {
    string internal constant _TABLE = "0123456789abcdef";

    function uriEncode(
        string memory uri
    ) internal pure returns (string memory) {
        bytes memory bytesUri = bytes(uri);

        string memory table = _TABLE;

        // Max size is worse case all chars need to be encoded
        bytes memory result = new bytes(3 * bytesUri.length);

        /// @solidity memory-safe-assembly
        assembly {
            // Get the lookup table
            let tablePtr := add(table, 1)

            // Prepare result pointer, jump over length
            let resultPtr := add(result, 32)

            // Keep track of the final result size string length
            let resultSize := 0

            for {
                let dataPtr := bytesUri
                let endPtr := add(bytesUri, mload(bytesUri))
            } lt(dataPtr, endPtr) {

            } {
                // advance 1 byte
                dataPtr := add(dataPtr, 1)
                // bytemask out a char
                let char := and(mload(dataPtr), 255)

                // Check if is valid URI character
                let isInvalidUriChar := or(
                    or(
                        lt(char, 33), // lower than "!"
                        gt(char, 122) // higher than "z"
                    ),
                    or(
                        or(
                            eq(char, 37), // "%"
                            or(
                                eq(char, 60), // "<"
                                eq(char, 62) // ">"
                            )
                        ),
                        or(
                            and(gt(char, 90), lt(char, 95)), // "[\]^"
                            eq(char, 96) // "`"
                        )
                    )
                )
                if eq(char, 35) { isInvalidUriChar := 1 }

                switch isInvalidUriChar
                // If is valid uri character copy character over and increment the result
                case 0 {
                    mstore8(resultPtr, char)
                    resultPtr := add(resultPtr, 1)
                    resultSize := add(resultSize, 1)
                }
                // If the char is not a valid uri character, uriencode the character
                case 1 {
                    mstore8(resultPtr, 37)
                    resultPtr := add(resultPtr, 1)
                    // table[character >> 4] (take the last 4 bits)
                    mstore8(resultPtr, mload(add(tablePtr, shr(4, char))))
                    resultPtr := add(resultPtr, 1)
                    // table & 15 (take the first 4 bits)
                    mstore8(resultPtr, mload(add(tablePtr, and(char, 15))))
                    resultPtr := add(resultPtr, 1)
                    resultSize := add(resultSize, 3)
                }
            }

            // Set size of result string in memory
            mstore(result, resultSize)
        }

        return string(result);
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.19;

import "../libraries/DarkEnergyPackedStruct.sol";

contract OwnableAndAdministrable {
    using DarkEnergyPackedStruct for bytes32;

    error MissingRole(address user, uint256 role);
    error NotOwner(address user);

    event OwnershipTransferred(address indexed user, address indexed newOwner);
    event RoleUpdated(address indexed user, uint256 indexed role, bool indexed status);

    /**
     * @dev There is a maximum of 256 roles: each bit says if the role is on or off
     */
    mapping(address => bytes32) private _addressRoles;

    /**
     * @dev There is one owner
     */
    address internal _owner;

    function _isOwner(address sender) internal view returns(bool) {
        return (sender == _owner || sender == address(this));
    }

    function _hasRole(address sender, uint8 role) internal view returns(bool) {
        bytes32 roles = _addressRoles[sender];
        return roles.getBool(role);
    }

    function _checkOwner(address sender) internal virtual view {
        if (!_isOwner(sender)) {
            revert NotOwner(sender);
        }
    }

    function _checkRoleOrOwner(address sender, uint8 role) internal virtual view {
        if (_isOwner(sender)) return;
        _checkRole(sender, role);
    }

    function _checkRole(address sender, uint8 role) internal virtual view {
        if (sender == address(this)) return;
        bytes32 roles = _addressRoles[sender];
        bool allowed = roles.getBool(role);
        if (!allowed) {
            revert MissingRole(sender, role);
        }
    }

    function _setOwner(address newOwner) internal virtual {
        _owner = newOwner;
        emit OwnershipTransferred(_owner, newOwner);
    }

    function _setRole(address user, uint8 role, bool status) internal virtual {
        _addressRoles[user] = _addressRoles[user].setBit(role, status);
        emit RoleUpdated(user, role, status);
    }

    function setRole(address user, uint8 role, bool status) external virtual {
        _checkOwner(msg.sender);
        _setRole(user, role, status);
    }

    function transferOwnership(address newOwner) external virtual {
        _checkOwner(msg.sender);
        _setOwner(newOwner);
    }

    function owner() external virtual view returns(address) {
        return _owner;
    }
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"admin","type":"address"},{"internalType":"address[]","name":"allowedSeaDrop","type":"address[]"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AddressNotHolder","type":"error"},{"inputs":[],"name":"AdministratorMustInitializeWithFee","type":"error"},{"inputs":[],"name":"CallerNotOwnerNorApproved","type":"error"},{"inputs":[{"internalType":"uint256","name":"newMaxSupply","type":"uint256"}],"name":"CannotExceedMaxSupplyOfUint64","type":"error"},{"inputs":[],"name":"GameNotActive","type":"error"},{"inputs":[],"name":"InvalidGameRules","type":"error"},{"inputs":[{"internalType":"uint256","name":"basisPoints","type":"uint256"}],"name":"InvalidRoyaltyBasisPoints","type":"error"},{"inputs":[],"name":"MaxSupplyExceeded","type":"error"},{"inputs":[{"internalType":"uint256","name":"total","type":"uint256"},{"internalType":"uint256","name":"maxSupply","type":"uint256"}],"name":"MintQuantityExceedsMaxSupply","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"role","type":"uint256"}],"name":"MissingRole","type":"error"},{"inputs":[],"name":"NegativeEnergyToPositiveHolder","type":"error"},{"inputs":[],"name":"NoGamePass","type":"error"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"NotOwner","type":"error"},{"inputs":[],"name":"OnlyAllowedSeaDrop","type":"error"},{"inputs":[],"name":"OperatorNotAllowed","type":"error"},{"inputs":[],"name":"ProvenanceHashCannotBeSetAfterMintStarted","type":"error"},{"inputs":[],"name":"QuantityExceedsLimit","type":"error"},{"inputs":[],"name":"QueryForNonExistentToken","type":"error"},{"inputs":[],"name":"QueryForZeroAddress","type":"error"},{"inputs":[],"name":"RoyaltyAddressCannotBeZeroAddress","type":"error"},{"inputs":[],"name":"SignersMismatch","type":"error"},{"inputs":[],"name":"TokenGatedMismatch","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"int40","name":"energyDiff","type":"int40"},{"indexed":true,"internalType":"uint16","name":"gamePassesDiff","type":"uint16"}],"name":"AdminMint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"seaDrop","type":"address"}],"name":"AllowedSeaDrop","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address[]","name":"allowedSeaDrop","type":"address[]"}],"name":"AllowedSeaDropUpdated","type":"event"},{"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":false,"internalType":"uint256","name":"_fromTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_toTokenId","type":"uint256"}],"name":"BatchMetadataUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"fromTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"toTokenId","type":"uint256"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"ConsecutiveTransfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"newContractURI","type":"string"}],"name":"ContractURIUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"seaDrop","type":"address"}],"name":"DeniedSeaDrop","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"player","type":"address"},{"indexed":true,"internalType":"int40","name":"energy","type":"int40"}],"name":"EnergyDoubled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"player","type":"address"},{"indexed":true,"internalType":"int40","name":"energy","type":"int40"}],"name":"EnergyHalved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"player","type":"address"},{"indexed":true,"internalType":"int40","name":"energyDiff","type":"int40"}],"name":"EnergyUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":true,"internalType":"uint16","name":"amount","type":"uint16"}],"name":"GamePassesGained","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"oldRules","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newRules","type":"bytes32"}],"name":"GameRulesUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"energy","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"gamePasses","type":"uint256"}],"name":"GlitchMint","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newMaxSupply","type":"uint256"}],"name":"MaxSupplyUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"MetadataUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"player","type":"address"}],"name":"OrdinalWon","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"contractAddress","type":"address"}],"name":"OrdinalsVouchersDeployed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"player","type":"address"}],"name":"PlayHighStakes","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"player","type":"address"}],"name":"PlayNoRisk","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"previousHash","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"newHash","type":"bytes32"}],"name":"ProvenanceHashUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"role","type":"uint256"},{"indexed":true,"internalType":"bool","name":"status","type":"bool"}],"name":"RoleUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"bps","type":"uint256"}],"name":"RoyaltyInfoUpdated","type":"event"},{"anonymous":false,"inputs":[],"name":"SeaDropTokenDeployed","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":"minter","type":"address"},{"internalType":"int40","name":"energy","type":"int40"},{"internalType":"uint16","name":"gamePasses","type":"uint16"}],"name":"adminMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"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":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"circulatingEnergy","outputs":[{"internalType":"int256","name":"","type":"int256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gameRules","outputs":[{"components":[{"internalType":"bool","name":"isActive","type":"bool"},{"internalType":"uint16","name":"oddsNoRiskEarn100","type":"uint16"},{"internalType":"uint16","name":"oddsNoRiskEarn300","type":"uint16"},{"internalType":"uint16","name":"oddsNoRiskEarn500","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesWinOrdinal","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesLose100","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesLose300","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesLose500","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesLose1000","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesEarn100","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesEarn300","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesEarn500","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesEarn1000","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesDoubles","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesHalves","type":"uint16"},{"internalType":"uint16","name":"oddsGamePassOnMint","type":"uint16"},{"internalType":"uint8","name":"remainingOrdinals","type":"uint8"},{"internalType":"bool","name":"flagA","type":"bool"},{"internalType":"bool","name":"flagB","type":"bool"},{"internalType":"bool","name":"flagC","type":"bool"},{"internalType":"bool","name":"flagD","type":"bool"},{"internalType":"bool","name":"flagE","type":"bool"},{"internalType":"bool","name":"flagF","type":"bool"},{"internalType":"bool","name":"flagG","type":"bool"}],"internalType":"struct DarkEnergyPackedStruct.GameRules","name":"","type":"tuple"}],"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":"minter","type":"address"}],"name":"getMintStats","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"minter","type":"address"},{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"mintSeaDrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"maxSupply","type":"uint256"},{"internalType":"string","name":"baseURI","type":"string"},{"internalType":"string","name":"contractURI","type":"string"},{"internalType":"address","name":"seaDropImpl","type":"address"},{"components":[{"internalType":"uint80","name":"mintPrice","type":"uint80"},{"internalType":"uint48","name":"startTime","type":"uint48"},{"internalType":"uint48","name":"endTime","type":"uint48"},{"internalType":"uint16","name":"maxTotalMintableByWallet","type":"uint16"},{"internalType":"uint16","name":"feeBps","type":"uint16"},{"internalType":"bool","name":"restrictFeeRecipients","type":"bool"}],"internalType":"struct PublicDrop","name":"publicDrop","type":"tuple"},{"internalType":"string","name":"dropURI","type":"string"},{"components":[{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"internalType":"string[]","name":"publicKeyURIs","type":"string[]"},{"internalType":"string","name":"allowListURI","type":"string"}],"internalType":"struct AllowListData","name":"allowListData","type":"tuple"},{"internalType":"address","name":"creatorPayoutAddress","type":"address"},{"internalType":"bytes32","name":"provenanceHash","type":"bytes32"},{"internalType":"address[]","name":"allowedFeeRecipients","type":"address[]"},{"internalType":"address[]","name":"disallowedFeeRecipients","type":"address[]"},{"internalType":"address[]","name":"allowedPayers","type":"address[]"},{"internalType":"address[]","name":"disallowedPayers","type":"address[]"},{"internalType":"address[]","name":"tokenGatedAllowedNftTokens","type":"address[]"},{"components":[{"internalType":"uint80","name":"mintPrice","type":"uint80"},{"internalType":"uint16","name":"maxTotalMintableByWallet","type":"uint16"},{"internalType":"uint48","name":"startTime","type":"uint48"},{"internalType":"uint48","name":"endTime","type":"uint48"},{"internalType":"uint8","name":"dropStageIndex","type":"uint8"},{"internalType":"uint32","name":"maxTokenSupplyForStage","type":"uint32"},{"internalType":"uint16","name":"feeBps","type":"uint16"},{"internalType":"bool","name":"restrictFeeRecipients","type":"bool"}],"internalType":"struct TokenGatedDropStage[]","name":"tokenGatedDropStages","type":"tuple[]"},{"internalType":"address[]","name":"disallowedTokenGatedAllowedNftTokens","type":"address[]"},{"internalType":"address[]","name":"signers","type":"address[]"},{"components":[{"internalType":"uint80","name":"minMintPrice","type":"uint80"},{"internalType":"uint24","name":"maxMaxTotalMintableByWallet","type":"uint24"},{"internalType":"uint40","name":"minStartTime","type":"uint40"},{"internalType":"uint40","name":"maxEndTime","type":"uint40"},{"internalType":"uint40","name":"maxMaxTokenSupplyForStage","type":"uint40"},{"internalType":"uint16","name":"minFeeBps","type":"uint16"},{"internalType":"uint16","name":"maxFeeBps","type":"uint16"}],"internalType":"struct SignedMintValidationParams[]","name":"signedMintValidationParams","type":"tuple[]"},{"internalType":"address[]","name":"disallowedSigners","type":"address[]"}],"internalType":"struct ERC721SeaDropStructsErrorsAndEvents.MultiConfigureStruct","name":"config","type":"tuple"}],"name":"multiConfigure","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"ordinalsVouchers","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"playHighStakes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"playNoRisk","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"player","type":"address"}],"name":"playerData","outputs":[{"components":[{"internalType":"bool","name":"isHolder","type":"bool"},{"internalType":"int40","name":"energyAmount","type":"int40"},{"internalType":"uint16","name":"gamePasses","type":"uint16"},{"internalType":"uint16","name":"mintCount","type":"uint16"},{"internalType":"uint16","name":"mergeCount","type":"uint16"},{"internalType":"uint16","name":"noRiskPlayCount","type":"uint16"},{"internalType":"uint16","name":"noRiskWinCount","type":"uint16"},{"internalType":"uint16","name":"highStakesPlayCount","type":"uint16"},{"internalType":"uint16","name":"highStakesWinCount","type":"uint16"},{"internalType":"uint16","name":"highStakesLossCount","type":"uint16"},{"internalType":"uint32","name":"totalEarned","type":"uint32"},{"internalType":"uint32","name":"totalRugged","type":"uint32"},{"internalType":"uint16","name":"unused","type":"uint16"},{"internalType":"bool","name":"flagA","type":"bool"},{"internalType":"bool","name":"flagB","type":"bool"},{"internalType":"bool","name":"flagC","type":"bool"},{"internalType":"bool","name":"flagD","type":"bool"},{"internalType":"bool","name":"flagE","type":"bool"},{"internalType":"bool","name":"flagF","type":"bool"},{"internalType":"bool","name":"flagG","type":"bool"}],"internalType":"struct DarkEnergyPackedStruct.PlayerData","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"provenanceHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"winner","type":"address"}],"name":"raffleReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"royaltyAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"royaltyBasisPoints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"royaltyAmount","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":"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":"","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"","type":"string"}],"name":"setContractURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newMaxSupply","type":"uint256"}],"name":"setMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"status","type":"bool"}],"name":"setOperatorStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"setProvenanceHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint8","name":"role","type":"uint8"},{"internalType":"bool","name":"status","type":"bool"}],"name":"setRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"royaltyAddress","type":"address"},{"internalType":"uint96","name":"royaltyBps","type":"uint96"}],"internalType":"struct ISeaDropTokenContractMetadata.RoyaltyInfo","name":"newInfo","type":"tuple"}],"name":"setRoyaltyInfo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"bool","name":"isActive","type":"bool"},{"internalType":"uint16","name":"oddsNoRiskEarn100","type":"uint16"},{"internalType":"uint16","name":"oddsNoRiskEarn300","type":"uint16"},{"internalType":"uint16","name":"oddsNoRiskEarn500","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesWinOrdinal","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesLose100","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesLose300","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesLose500","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesLose1000","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesEarn100","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesEarn300","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesEarn500","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesEarn1000","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesDoubles","type":"uint16"},{"internalType":"uint16","name":"oddsHighStakesHalves","type":"uint16"},{"internalType":"uint16","name":"oddsGamePassOnMint","type":"uint16"},{"internalType":"uint8","name":"remainingOrdinals","type":"uint8"},{"internalType":"bool","name":"flagA","type":"bool"},{"internalType":"bool","name":"flagB","type":"bool"},{"internalType":"bool","name":"flagC","type":"bool"},{"internalType":"bool","name":"flagD","type":"bool"},{"internalType":"bool","name":"flagE","type":"bool"},{"internalType":"bool","name":"flagF","type":"bool"},{"internalType":"bool","name":"flagG","type":"bool"}],"internalType":"struct DarkEnergyPackedStruct.GameRules","name":"config","type":"tuple"}],"name":"setRules","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":"pure","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":[{"internalType":"address","name":"seaDropImpl","type":"address"},{"components":[{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"internalType":"string[]","name":"publicKeyURIs","type":"string[]"},{"internalType":"string","name":"allowListURI","type":"string"}],"internalType":"struct AllowListData","name":"allowListData","type":"tuple"}],"name":"updateAllowList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"seaDrop","type":"address"},{"internalType":"address","name":"feeRecipient","type":"address"},{"internalType":"bool","name":"status","type":"bool"}],"name":"updateAllowedFeeRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"allowedSeaDrop","type":"address[]"}],"name":"updateAllowedSeaDrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"seaDrop","type":"address"},{"internalType":"address","name":"creator","type":"address"}],"name":"updateCreatorPayoutAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"seaDropImpl","type":"address"},{"internalType":"string","name":"dropURI","type":"string"}],"name":"updateDropURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"seaDropImpl","type":"address"},{"internalType":"address","name":"payer","type":"address"},{"internalType":"bool","name":"allowed","type":"bool"}],"name":"updatePayer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"seaDrop","type":"address"},{"components":[{"internalType":"uint80","name":"mintPrice","type":"uint80"},{"internalType":"uint48","name":"startTime","type":"uint48"},{"internalType":"uint48","name":"endTime","type":"uint48"},{"internalType":"uint16","name":"maxTotalMintableByWallet","type":"uint16"},{"internalType":"uint16","name":"feeBps","type":"uint16"},{"internalType":"bool","name":"restrictFeeRecipients","type":"bool"}],"internalType":"struct PublicDrop","name":"dropData","type":"tuple"}],"name":"updatePublicDrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"components":[{"internalType":"uint80","name":"minMintPrice","type":"uint80"},{"internalType":"uint24","name":"maxMaxTotalMintableByWallet","type":"uint24"},{"internalType":"uint40","name":"minStartTime","type":"uint40"},{"internalType":"uint40","name":"maxEndTime","type":"uint40"},{"internalType":"uint40","name":"maxMaxTokenSupplyForStage","type":"uint40"},{"internalType":"uint16","name":"minFeeBps","type":"uint16"},{"internalType":"uint16","name":"maxFeeBps","type":"uint16"}],"internalType":"struct SignedMintValidationParams","name":"","type":"tuple"}],"name":"updateSignedMintValidationParams","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"components":[{"internalType":"uint80","name":"mintPrice","type":"uint80"},{"internalType":"uint16","name":"maxTotalMintableByWallet","type":"uint16"},{"internalType":"uint48","name":"startTime","type":"uint48"},{"internalType":"uint48","name":"endTime","type":"uint48"},{"internalType":"uint8","name":"dropStageIndex","type":"uint8"},{"internalType":"uint32","name":"maxTokenSupplyForStage","type":"uint32"},{"internalType":"uint16","name":"feeBps","type":"uint16"},{"internalType":"bool","name":"restrictFeeRecipients","type":"bool"}],"internalType":"struct TokenGatedDropStage","name":"","type":"tuple"}],"name":"updateTokenGatedDrop","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000004468a5b725e2c63056131121cd33b66848e1dd870000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000005ea00ac477b1030ce78506496e8c2de24bf5

-----Decoded View---------------
Arg [0] : admin (address): 0x4468A5B725E2C63056131121cD33b66848E1dd87
Arg [1] : allowedSeaDrop (address[]): 0x00005EA00Ac477B1030CE78506496e8C2dE24bf5

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000004468a5b725e2c63056131121cd33b66848e1dd87
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [3] : 00000000000000000000000000005ea00ac477b1030ce78506496e8c2de24bf5