Token

Gangz Of New York (GONY)

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

ERC-721

Overview

Max Total Supply

2,222 GONY

Holders

285

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xe74ef730aef509cdcdf4309d87c7a0449db3a664

Filtered by Token Holder

0xB5cDd5e0e6147a7C2aeE88c1CB5514AC27f6B75B

Balance

2 GONY

0xb5cdd5e0e6147a7c2aee88c1cb5514ac27f6b75b

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

GangzOfNewYork

Compiler Version

v0.8.20+commit.a1b79de6

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2024-02-04
*/

// SPDX-License-Identifier: MIT

// File: @openzeppelin/contracts/utils/Strings.sol


// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts v4.4.1 (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() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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

// File: @openzeppelin/contracts/utils/Context.sol


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

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

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

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


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

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/interfaces/IERC2981.sol


// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/token/common/ERC2981.sol


// OpenZeppelin Contracts (last updated v4.7.0) (token/common/ERC2981.sol)

pragma solidity ^0.8.0;



/**
 * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
 *
 * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
 * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
 *
 * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
 * fee is specified in basis points by default.
 *
 * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
 * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
 * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
 *
 * _Available since v4.5._
 */
abstract contract ERC2981 is IERC2981, ERC165 {
    struct RoyaltyInfo {
        address receiver;
        uint96 royaltyFraction;
    }

    RoyaltyInfo private _defaultRoyaltyInfo;
    mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;

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

    /**
     * @inheritdoc IERC2981
     */
    function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256) {
        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];

        if (royalty.receiver == address(0)) {
            royalty = _defaultRoyaltyInfo;
        }

        uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator();

        return (royalty.receiver, royaltyAmount);
    }

    /**
     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
     * override.
     */
    function _feeDenominator() internal pure virtual returns (uint96) {
        return 10000;
    }

    /**
     * @dev Sets the royalty information that all ids in this contract will default to.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: invalid receiver");

        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Removes default royalty information.
     */
    function _deleteDefaultRoyalty() internal virtual {
        delete _defaultRoyaltyInfo;
    }

    /**
     * @dev Sets the royalty information for a specific token id, overriding the global default.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setTokenRoyalty(
        uint256 tokenId,
        address receiver,
        uint96 feeNumerator
    ) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: Invalid parameters");

        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Resets royalty information for the token id back to the global default.
     */
    function _resetTokenRoyalty(uint256 tokenId) internal virtual {
        delete _tokenRoyaltyInfo[tokenId];
    }
}

// File: contracts/IOperatorFilterRegistry.sol


pragma solidity ^0.8.13;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


pragma solidity ^0.8.13;


/**
 * @title  UpdatableOperatorFilterer
 * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
 *         registrant's entries in the OperatorFilterRegistry. This contract allows the Owner to update the
 *         OperatorFilterRegistry address via updateOperatorFilterRegistryAddress, including to the zero address,
 *         which will bypass registry checks.
 *         Note that OpenSea will still disable creator earnings enforcement if filtered operators begin fulfilling orders
 *         on-chain, eg, if the registry is revoked or bypassed.
 * @dev    This smart contract is meant to be inherited by token contracts so they can use the following:
 *         - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
 *         - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
 */
abstract contract UpdatableOperatorFilterer {
    /// @dev Emitted when an operator is not allowed.
    error OperatorNotAllowed(address operator);
    /// @dev Emitted when someone other than the owner is trying to call an only owner function.
    error OnlyOwner();

    event OperatorFilterRegistryAddressUpdated(address newRegistry);

    IOperatorFilterRegistry public operatorFilterRegistry;

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

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

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

    /**
     * @notice Update the address that the contract will make OperatorFilter checks against. When set to the zero
     *         address, checks will be bypassed. OnlyOwner.
     */
    function updateOperatorFilterRegistryAddress(address newRegistry) public virtual {
        if (msg.sender != owner()) {
            revert OnlyOwner();
        }
        operatorFilterRegistry = IOperatorFilterRegistry(newRegistry);
        emit OperatorFilterRegistryAddressUpdated(newRegistry);
    }

    /**
     * @dev Assume the contract has an owner, but leave specific Ownable implementation up to inheriting contract.
     */
    function owner() public view virtual returns (address);

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


pragma solidity ^0.8.13;



/**
 * @title  RevokableOperatorFilterer
 * @notice This contract is meant to allow contracts to permanently skip OperatorFilterRegistry checks if desired. The
 *         Registry itself has an "unregister" function, but if the contract is ownable, the owner can re-register at
 *         any point. As implemented, this abstract contract allows the contract owner to permanently skip the
 *         OperatorFilterRegistry checks by calling revokeOperatorFilterRegistry. Once done, the registry
 *         address cannot be further updated.
 *         Note that OpenSea will still disable creator earnings enforcement if filtered operators begin fulfilling orders
 *         on-chain, eg, if the registry is revoked or bypassed.
 */
abstract contract RevokableOperatorFilterer is UpdatableOperatorFilterer {
    /// @dev Emitted when the registry has already been revoked.
    error RegistryHasBeenRevoked();
    /// @dev Emitted when the initial registry address is attempted to be set to the zero address.
    error InitialRegistryAddressCannotBeZeroAddress();

    event OperatorFilterRegistryRevoked();

    bool public isOperatorFilterRegistryRevoked;

    /// @dev The constructor that is called when the contract is being deployed.
    constructor(address _registry, address subscriptionOrRegistrantToCopy, bool subscribe)
        UpdatableOperatorFilterer(_registry, subscriptionOrRegistrantToCopy, subscribe)
    {
        // don't allow creating a contract with a permanently revoked registry
        if (_registry == address(0)) {
            revert InitialRegistryAddressCannotBeZeroAddress();
        }
    }

    /**
     * @notice Update the address that the contract will make OperatorFilter checks against. When set to the zero
     *         address, checks will be permanently bypassed, and the address cannot be updated again. OnlyOwner.
     */
    function updateOperatorFilterRegistryAddress(address newRegistry) public override {
        if (msg.sender != owner()) {
            revert OnlyOwner();
        }
        // if registry has been revoked, do not allow further updates
        if (isOperatorFilterRegistryRevoked) {
            revert RegistryHasBeenRevoked();
        }

        operatorFilterRegistry = IOperatorFilterRegistry(newRegistry);
        emit OperatorFilterRegistryAddressUpdated(newRegistry);
    }

    /**
     * @notice Revoke the OperatorFilterRegistry address, permanently bypassing checks. OnlyOwner.
     */
    function revokeOperatorFilterRegistry() public {
        if (msg.sender != owner()) {
            revert OnlyOwner();
        }
        // if registry has been revoked, do not allow further updates
        if (isOperatorFilterRegistryRevoked) {
            revert RegistryHasBeenRevoked();
        }

        // set to zero address to bypass checks
        operatorFilterRegistry = IOperatorFilterRegistry(address(0));
        isOperatorFilterRegistryRevoked = true;
        emit OperatorFilterRegistryRevoked();
    }
}
// File: contracts/lib/Constants.sol


pragma solidity ^0.8.13;

address constant CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS = 0x000000000000AAeB6D7670E522A718067333cd4E;
address constant CANONICAL_CORI_SUBSCRIPTION = 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6;
// File: contracts/RevokableDefaultOperatorFilterer.sol


pragma solidity ^0.8.13;




/**
 * @title  RevokableDefaultOperatorFilterer
 * @notice Inherits from RevokableOperatorFilterer and automatically subscribes to the default OpenSea subscription.
 *         Note that OpenSea will disable creator earnings enforcement if filtered operators begin fulfilling orders
 *         on-chain, eg, if the registry is revoked or bypassed.
 */

abstract contract RevokableDefaultOperatorFilterer is RevokableOperatorFilterer {
    /// @dev The constructor that is called when the contract is being deployed.
    constructor()
        RevokableOperatorFilterer(CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS, CANONICAL_CORI_SUBSCRIPTION, true)
    {}
}
// File: contracts/IERC721A.sol


// ERC721A Contracts v4.0.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);

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

    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

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

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

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

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

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

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

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

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

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

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

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

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

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

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

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


// ERC721A Contracts v4.0.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;


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

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

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

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

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

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

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

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

    // The bit position of the `nextInitialized` bit in packed ownership.
    uint256 private constant BITPOS_NEXT_INITIALIZED = 225;

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

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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(
        uint256 tokenId
    ) public view virtual override returns (string memory) {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

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

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

    /**
     * @dev Casts the address to uint256 without masking.
     */
    function _addressToUint256(
        address value
    ) private pure returns (uint256 result) {
        assembly {
            result := value
        }
    }

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

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

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

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

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

        return _tokenApprovals[tokenId];
    }

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

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

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

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

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        _transfer(from, to, tokenId);
        if (to.code.length != 0)
            if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {
                revert TransferToNonERC721ReceiverImplementer();
            }
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        return
            _startTokenId() <= tokenId &&
            tokenId < _currentIndex && // If within bounds,
            _packedOwnerships[tokenId] & BITMASK_BURNED == 0; // and not burned.
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) private {
        uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

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

        address approvedAddress = _tokenApprovals[tokenId];

        bool isApprovedOrOwner = (_msgSenderERC721A() == from ||
            isApprovedForAll(from, _msgSenderERC721A()) ||
            approvedAddress == _msgSenderERC721A());

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

        _beforeTokenTransfers(from, to, tokenId, 1);

        // Clear approvals from the previous owner.
        if (_addressToUint256(approvedAddress) != 0) {
            delete _tokenApprovals[tokenId];
        }

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

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

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

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

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

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

        address from = address(uint160(prevOwnershipPacked));
        address approvedAddress = _tokenApprovals[tokenId];

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

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

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

        // Clear approvals from the previous owner.
        if (_addressToUint256(approvedAddress) != 0) {
            delete _tokenApprovals[tokenId];
        }

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

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

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

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

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

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

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

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

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function _toString(
        uint256 value
    ) internal pure returns (string memory ptr) {
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit),
            // but we allocate 128 bytes to keep the free memory pointer 32-byte word aliged.
            // We will need 1 32-byte word to store the length,
            // and 3 32-byte words to store a maximum of 78 digits. Total: 32 + 3 * 32 = 128.
            ptr := add(mload(0x40), 128)
            // Update the free memory pointer to allocate.
            mstore(0x40, ptr)

            // Cache the end of the memory to calculate the length later.
            let end := ptr

            // We write the string from the rightmost digit to the leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            // Costs a bit more than early returning for the zero case,
            // but cheaper in terms of deployment and overall runtime costs.
            for {
                // Initialize and perform the first pass without check.
                let temp := value
                // Move the pointer 1 byte leftwards to point to an empty character slot.
                ptr := sub(ptr, 1)
                // Write the character to the pointer. 48 is the ASCII index of '0'.
                mstore8(ptr, add(48, mod(temp, 10)))
                temp := div(temp, 10)
            } temp {
                // Keep dividing `temp` until zero.
                temp := div(temp, 10)
            } {
                // Body of the for loop.
                ptr := sub(ptr, 1)
                mstore8(ptr, add(48, mod(temp, 10)))
            }

            let length := sub(end, ptr)
            // Move the pointer 32 bytes leftwards to make room for the length.
            ptr := sub(ptr, 32)
            // Store the length.
            mstore(ptr, length)
        }
    }
}
// File: contracts/GangzOfNewYork.sol


pragma solidity ^0.8.20;








contract GangzOfNewYork is ERC721A, ERC2981, Ownable, RevokableDefaultOperatorFilterer, ReentrancyGuard {

    uint256 public maxSupply = 2222;
    uint256 public publicSupply = 1751;
    uint256 public limit = 6;
    uint256 public price = 0.05 ether;

    bool public mintEnabled;
    bool public revealed;
    string public hiddenURI;
    string public baseURI;

    mapping(address => bool) whitelistedWallets;
    mapping(address => uint256) mintedWallets;

    constructor() ERC721A("Gangz Of New York", "GONY") {
        setDefaultRoyalty(msg.sender, 1000); // 10% default royalty
    }

    function mint(uint256 numberOfTokens) external payable nonReentrant {
        uint256 amount = numberOfTokens * price;
        require(mintEnabled, "Mint Disabled");
        require(whitelistedWallets[msg.sender], "Not Whitelisted");
        require(totalSupply() + numberOfTokens <= publicSupply, "Sold Out");
        require(mintedWallets[msg.sender] + numberOfTokens <= limit, "Too Many");
        require(msg.value >= amount, "Not Enough Ether");

        mintedWallets[msg.sender] += numberOfTokens;
        _mint(msg.sender, numberOfTokens);
    }

    function teamMint(address to, uint256 numberOfTokens) external onlyOwner nonReentrant {
        require(totalSupply() + numberOfTokens <= maxSupply, "Sold Out");

        _mint(to, numberOfTokens);
    }

    function whitelistWallets(address[] memory walletAddresses) external onlyOwner {
        for (uint i = 0; i < walletAddresses.length; i++) {
            whitelistedWallets[walletAddresses[i]] = true;
        }
    }

    function unwhitelistWallets(address[] memory walletAddresses) external onlyOwner {
        for (uint i = 0; i < walletAddresses.length; i++) {
            whitelistedWallets[walletAddresses[i]] = false;
        }
    }

    function setMaxSupply(uint256 _maxSupply) external onlyOwner {
        maxSupply = _maxSupply;
    }

    function setPublicSupply(uint256 _publicSupply) external onlyOwner {
        publicSupply = _publicSupply;
    }

    function setLimit(uint256 _limit) external onlyOwner {
        limit = _limit;
    }

    function setPrice(uint256 _price) external onlyOwner {
        price = _price;
    }

    function toggleMinting() external onlyOwner {
        mintEnabled = !mintEnabled;
    }

    function toggleRevealed() external onlyOwner {
        revealed = !revealed;
    }

    function setHiddenURI(string calldata hiddenURI_) external onlyOwner {
        hiddenURI = hiddenURI_;
    }

    function setBaseURI(string calldata baseURI_) external onlyOwner {
        baseURI = baseURI_;
    }

    function _baseURI() internal view virtual override returns (string memory) {
        return baseURI;
    }

    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        require(_exists(tokenId), "GONY Does Not Exist");

        if (revealed) {
            return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, Strings.toString(tokenId))) : "";
        }

        return hiddenURI;
    }

    function withdraw() external onlyOwner nonReentrant {
        (bool success, ) = msg.sender.call{value: address(this).balance}("");
        require(success, "Withdraw Eth Failed");
    }

    function getMintedAmount(address _address) public view returns (uint256) {
        return mintedWallets[_address];
    }

    // =========================================================================
    //                                 ERC2891
    // =========================================================================

    function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner {
        _setDefaultRoyalty(receiver, feeNumerator);
    }

    function deleteDefaultRoyalty() public onlyOwner {
        _deleteDefaultRoyalty();
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
        return ERC721A.supportsInterface(interfaceId)
            || ERC2981.supportsInterface(interfaceId);
    }

    function owner() public view override(Ownable, UpdatableOperatorFilterer) returns (address) {
        return Ownable.owner();
    }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"InitialRegistryAddressCannotBeZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OnlyOwner","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"RegistryHasBeenRevoked","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newRegistry","type":"address"}],"name":"OperatorFilterRegistryAddressUpdated","type":"event"},{"anonymous":false,"inputs":[],"name":"OperatorFilterRegistryRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deleteDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"getMintedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hiddenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"isOperatorFilterRegistryRevoked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"limit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operatorFilterRegistry","outputs":[{"internalType":"contract IOperatorFilterRegistry","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":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"revokeOperatorFilterRegistry","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"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":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI_","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint96","name":"feeNumerator","type":"uint96"}],"name":"setDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"hiddenURI_","type":"string"}],"name":"setHiddenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_limit","type":"uint256"}],"name":"setLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxSupply","type":"uint256"}],"name":"setMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_price","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_publicSupply","type":"uint256"}],"name":"setPublicSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"teamMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleRevealed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"walletAddresses","type":"address[]"}],"name":"unwhitelistWallets","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRegistry","type":"address"}],"name":"updateOperatorFilterRegistryAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"walletAddresses","type":"address[]"}],"name":"whitelistWallets","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

70118:4382:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74126:228;;;;;;;;;;-1:-1:-1;74126:228:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;74126:228:0;;;;;;;;73811:144;;;;;;;;;;-1:-1:-1;73811:144:0;;;;;:::i;:::-;;:::i;:::-;;48974:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;51121:220::-;;;;;;;;;;-1:-1:-1;51121:220:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2246:32:1;;;2228:51;;2216:2;2201:18;51121:220:0;2082:203:1;50581:474:0;;;;;;;;;;-1:-1:-1;50581:474:0;;;;;:::i;:::-;;:::i;71749:222::-;;;;;;;;;;-1:-1:-1;71749:222:0;;;;;:::i;:::-;;:::i;42860:315::-;;;;;;;;;;-1:-1:-1;42467:1:0;43126:12;42913:7;43110:13;:28;-1:-1:-1;;43110:46:0;42860:315;;;4064:25:1;;;4052:2;4037:18;42860:315:0;3918:177:1;52073:170:0;;;;;;;;;;-1:-1:-1;52073:170:0;;;;;:::i;:::-;;:::i;72089:114::-;;;;;;;;;;-1:-1:-1;72089:114:0;;;;;:::i;:::-;;:::i;72211:86::-;;;;;;;;;;-1:-1:-1;72211:86:0;;;;;:::i;:::-;;:::i;13011:442::-;;;;;;;;;;-1:-1:-1;13011:442:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;4878:32:1;;;4860:51;;4942:2;4927:18;;4920:34;;;;4833:18;13011:442:0;4686:274:1;71522:219:0;;;;;;;;;;-1:-1:-1;71522:219:0;;;;;:::i;:::-;;:::i;73270:189::-;;;;;;;;;;;;;:::i;52314:185::-;;;;;;;;;;-1:-1:-1;52314:185:0;;;;;:::i;:::-;;:::i;70413:20::-;;;;;;;;;;-1:-1:-1;70413:20:0;;;;;;;;;;;72706:102;;;;;;;;;;-1:-1:-1;72706:102:0;;;;;:::i;:::-;;:::i;72496:84::-;;;;;;;;;;;;;:::i;70269:34::-;;;;;;;;;;;;;;;;29189:531;;;;;;;;;;;;;:::i;48763:144::-;;;;;;;;;;-1:-1:-1;48763:144:0;;;;;:::i;:::-;;:::i;73467:122::-;;;;;;;;;;-1:-1:-1;73467:122:0;;;;;:::i;:::-;-1:-1:-1;;;;;73558:23:0;73531:7;73558:23;;;:13;:23;;;;;;;73467:122;70470:21;;;;;;;;;;;;;:::i;71979:102::-;;;;;;;;;;-1:-1:-1;71979:102:0;;;;;:::i;:::-;;:::i;44501:234::-;;;;;;;;;;-1:-1:-1;44501:234:0;;;;;:::i;:::-;;:::i;7694:103::-;;;;;;;;;;;;;:::i;72399:89::-;;;;;;;;;;;;;:::i;70440:23::-;;;;;;;;;;;;;:::i;74362:133::-;;;;;;;;;;;;;:::i;72305:86::-;;;;;;;;;;-1:-1:-1;72305:86:0;;;;;:::i;:::-;;:::i;49143:104::-;;;;;;;;;;;;;:::i;70341:33::-;;;;;;;;;;;;;;;;70736:563;;;;;;:::i;:::-;;:::i;51413:333::-;;;;;;;;;;-1:-1:-1;51413:333:0;;;;;:::i;:::-;;:::i;70310:24::-;;;;;;;;;;;;;;;;73963:91;;;;;;;;;;;;;:::i;71307:207::-;;;;;;;;;;-1:-1:-1;71307:207:0;;;;;:::i;:::-;;:::i;23239:53::-;;;;;;;;;;-1:-1:-1;23239:53:0;;;;-1:-1:-1;;;;;23239:53:0;;;52570:396;;;;;;;;;;-1:-1:-1;52570:396:0;;;;;:::i;:::-;;:::i;28576:487::-;;;;;;;;;;-1:-1:-1;28576:487:0;;;;;:::i;:::-;;:::i;72588:110::-;;;;;;;;;;-1:-1:-1;72588:110:0;;;;;:::i;:::-;;:::i;72932:330::-;;;;;;;;;;-1:-1:-1;72932:330:0;;;;;:::i;:::-;;:::i;70383:23::-;;;;;;;;;;-1:-1:-1;70383:23:0;;;;;;;;70231:31;;;;;;;;;;;;;;;;51817:189;;;;;;;;;;-1:-1:-1;51817:189:0;;;;;:::i;:::-;;:::i;27802:43::-;;;;;;;;;;-1:-1:-1;27802:43:0;;;;-1:-1:-1;;;27802:43:0;;;;;;7952:201;;;;;;;;;;-1:-1:-1;7952:201:0;;;;;:::i;:::-;;:::i;74126:228::-;74229:4;74253:38;74279:11;74253:25;:38::i;:::-;:93;;;;74308:38;74334:11;74308:25;:38::i;:::-;74246:100;74126:228;-1:-1:-1;;74126:228:0:o;73811:144::-;6932:13;:11;:13::i;:::-;73905:42:::1;73924:8;73934:12;73905:18;:42::i;:::-;73811:144:::0;;:::o;48974:100::-;49028:13;49061:5;49054:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48974:100;:::o;51121:220::-;51205:7;51230:16;51238:7;51230;:16::i;:::-;51225:64;;51255:34;;-1:-1:-1;;;51255:34:0;;;;;;;;;;;51225:64;-1:-1:-1;51309:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;51309:24:0;;51121:220::o;50581:474::-;50654:13;50686:27;50705:7;50686:18;:27::i;:::-;50654:61;;50736:5;-1:-1:-1;;;;;50730:11:0;:2;-1:-1:-1;;;;;50730:11:0;;50726:48;;50750:24;;-1:-1:-1;;;50750:24:0;;;;;;;;;;;50726:48;67928:10;-1:-1:-1;;;;;50791:28:0;;;50787:175;;50839:44;50856:5;67928:10;51817:189;:::i;50839:44::-;50834:128;;50911:35;;-1:-1:-1;;;50911:35:0;;;;;;;;;;;50834:128;50974:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;50974:29:0;-1:-1:-1;;;;;50974:29:0;;;;;;;;;51019:28;;50974:24;;51019:28;;;;;;;50643:412;50581:474;;:::o;71749:222::-;6932:13;:11;:13::i;:::-;71846:6:::1;71841:123;71862:15;:22;71858:1;:26;71841:123;;;71947:5;71906:18;:38;71925:15;71941:1;71925:18;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;-1:-1:-1;;;;;71906:38:0::1;::::0;;;::::1;::::0;;;;;;-1:-1:-1;71906:38:0;:46;;-1:-1:-1;;71906:46:0::1;::::0;::::1;;::::0;;;::::1;::::0;;71886:3;::::1;::::0;::::1;:::i;:::-;;;;71841:123;;52073:170:::0;52207:28;52217:4;52223:2;52227:7;52207:9;:28::i;:::-;52073:170;;;:::o;72089:114::-;6932:13;:11;:13::i;:::-;72167:12:::1;:28:::0;72089:114::o;72211:86::-;6932:13;:11;:13::i;:::-;72275:5:::1;:14:::0;72211:86::o;13011:442::-;13108:7;13166:27;;;:17;:27;;;;;;;;13137:56;;;;;;;;;-1:-1:-1;;;;;13137:56:0;;;;;-1:-1:-1;;;13137:56:0;;;-1:-1:-1;;;;;13137:56:0;;;;;;;;13108:7;;13206:92;;-1:-1:-1;13257:29:0;;;;;;;;;13267:19;13257:29;-1:-1:-1;;;;;13257:29:0;;;;-1:-1:-1;;;13257:29:0;;-1:-1:-1;;;;;13257:29:0;;;;;13206:92;13348:23;;;;13310:21;;13819:5;;13335:36;;-1:-1:-1;;;;;13335:36:0;:10;:36;:::i;:::-;13334:58;;;;:::i;:::-;13413:16;;;;;-1:-1:-1;13011:442:0;;-1:-1:-1;;;;13011:442:0:o;71522:219::-;6932:13;:11;:13::i;:::-;71617:6:::1;71612:122;71633:15;:22;71629:1;:26;71612:122;;;71718:4;71677:18;:38;71696:15;71712:1;71696:18;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;-1:-1:-1;;;;;71677:38:0::1;::::0;;;::::1;::::0;;;;;;-1:-1:-1;71677:38:0;:45;;-1:-1:-1;;71677:45:0::1;::::0;::::1;;::::0;;;::::1;::::0;;71657:3;::::1;::::0;::::1;:::i;:::-;;;;71612:122;;73270:189:::0;6932:13;:11;:13::i;:::-;3971:1:::1;4569:7;;:19:::0;4561:63:::1;;;;-1:-1:-1::0;;;4561:63:0::1;;;;;;;:::i;:::-;;;;;;;;;3971:1;4702:7;:18:::0;73352:49:::2;::::0;73334:12:::2;::::0;73352:10:::2;::::0;73375:21:::2;::::0;73334:12;73352:49;73334:12;73352:49;73375:21;73352:10;:49:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73333:68;;;73420:7;73412:39;;;::::0;-1:-1:-1;;;73412:39:0;;9585:2:1;73412:39:0::2;::::0;::::2;9567:21:1::0;9624:2;9604:18;;;9597:30;-1:-1:-1;;;9643:18:1;;;9636:49;9702:18;;73412:39:0::2;9383:343:1::0;73412:39:0::2;-1:-1:-1::0;3927:1:0::1;4881:7;:22:::0;73270:189::o;52314:185::-;52452:39;52469:4;52475:2;52479:7;52452:39;;;;;;;;;;;;:16;:39::i;72706:102::-;6932:13;:11;:13::i;:::-;72782:7:::1;:18;72792:8:::0;;72782:7;:18:::1;:::i;72496:84::-:0;6932:13;:11;:13::i;:::-;72564:8:::1;::::0;;-1:-1:-1;;72552:20:0;::::1;72564:8;::::0;;;::::1;;;72563:9;72552:20:::0;;::::1;;::::0;;72496:84::o;29189:531::-;29265:7;:5;:7::i;:::-;-1:-1:-1;;;;;29251:21:0;:10;-1:-1:-1;;;;;29251:21:0;;29247:72;;29296:11;;-1:-1:-1;;;29296:11:0;;;;;;;;;;;29247:72;29404:31;;-1:-1:-1;;;29404:31:0;;;;29400:95;;;29459:24;;-1:-1:-1;;;29459:24:0;;;;;;;;;;;29400:95;29556:22;:60;;-1:-1:-1;;;;;;29627:38:0;-1:-1:-1;;;29627:38:0;;;29681:31;;;;29613:1;;29681:31;29189:531::o;48763:144::-;48827:7;48870:27;48889:7;48870:18;:27::i;70470:21::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;71979:102::-;6932:13;:11;:13::i;:::-;72051:9:::1;:22:::0;71979:102::o;44501:234::-;44565:7;44607:5;44617:1;44589:29;44585:70;;44627:28;;-1:-1:-1;;;44627:28:0;;;;;;;;;;;44585:70;-1:-1:-1;;;;;;44673:25:0;;;;;:18;:25;;;;;;39830:13;44673:54;;44501:234::o;7694:103::-;6932:13;:11;:13::i;:::-;7759:30:::1;7786:1;7759:18;:30::i;:::-;7694:103::o:0;72399:89::-;6932:13;:11;:13::i;:::-;72469:11:::1;::::0;;-1:-1:-1;;72454:26:0;::::1;72469:11;::::0;;::::1;72468:12;72454:26;::::0;;72399:89::o;70440:23::-;;;;;;;:::i;74362:133::-;74445:7;74472:15;7119:6;;-1:-1:-1;;;;;7119:6:0;;7046:87;74472:15;74465:22;;74362:133;:::o;72305:86::-;6932:13;:11;:13::i;:::-;72369:5:::1;:14:::0;72305:86::o;49143:104::-;49199:13;49232:7;49225:14;;;;;:::i;70736:563::-;3971:1;4569:7;;:19;4561:63;;;;-1:-1:-1;;;4561:63:0;;;;;;;:::i;:::-;3971:1;4702:7;:18;70849:5:::1;::::0;70815:14:::1;::::0;70832:22:::1;::::0;:14;:22:::1;:::i;:::-;70873:11;::::0;70815:39;;-1:-1:-1;70873:11:0::1;;70865:37;;;::::0;-1:-1:-1;;;70865:37:0;;11991:2:1;70865:37:0::1;::::0;::::1;11973:21:1::0;12030:2;12010:18;;;12003:30;-1:-1:-1;;;12049:18:1;;;12042:43;12102:18;;70865:37:0::1;11789:337:1::0;70865:37:0::1;70940:10;70921:30;::::0;;;:18:::1;:30;::::0;;;;;::::1;;70913:58;;;::::0;-1:-1:-1;;;70913:58:0;;12333:2:1;70913:58:0::1;::::0;::::1;12315:21:1::0;12372:2;12352:18;;;12345:30;-1:-1:-1;;;12391:18:1;;;12384:45;12446:18;;70913:58:0::1;12131:339:1::0;70913:58:0::1;71024:12;::::0;42467:1;43126:12;42913:7;43110:13;71006:14;;43110:28;;-1:-1:-1;;43110:46:0;70990:30:::1;;;;:::i;:::-;:46;;70982:67;;;::::0;-1:-1:-1;;;70982:67:0;;12807:2:1;70982:67:0::1;::::0;::::1;12789:21:1::0;12846:1;12826:18;;;12819:29;-1:-1:-1;;;12864:18:1;;;12857:38;12912:18;;70982:67:0::1;12605:331:1::0;70982:67:0::1;71114:5;::::0;71082:10:::1;71068:25;::::0;;;:13:::1;:25;::::0;;;;;:42:::1;::::0;71096:14;;71068:42:::1;:::i;:::-;:51;;71060:72;;;::::0;-1:-1:-1;;;71060:72:0;;13143:2:1;71060:72:0::1;::::0;::::1;13125:21:1::0;13182:1;13162:18;;;13155:29;-1:-1:-1;;;13200:18:1;;;13193:38;13248:18;;71060:72:0::1;12941:331:1::0;71060:72:0::1;71164:6;71151:9;:19;;71143:48;;;::::0;-1:-1:-1;;;71143:48:0;;13479:2:1;71143:48:0::1;::::0;::::1;13461:21:1::0;13518:2;13498:18;;;13491:30;-1:-1:-1;;;13537:18:1;;;13530:46;13593:18;;71143:48:0::1;13277:340:1::0;71143:48:0::1;71218:10;71204:25;::::0;;;:13:::1;:25;::::0;;;;:43;;71233:14;;71204:25;:43:::1;::::0;71233:14;;71204:43:::1;:::i;:::-;::::0;;;-1:-1:-1;71258:33:0::1;::::0;-1:-1:-1;71264:10:0::1;71276:14:::0;71258:5:::1;:33::i;:::-;-1:-1:-1::0;;3927:1:0;4881:7;:22;70736:563::o;51413:333::-;67928:10;-1:-1:-1;;;;;51537:31:0;;;51533:61;;51577:17;;-1:-1:-1;;;51577:17:0;;;;;;;;;;;51533:61;67928:10;51607:39;;;;:18;:39;;;;;;;;-1:-1:-1;;;;;51607:49:0;;;;;;;;;;;;:60;;-1:-1:-1;;51607:60:0;;;;;;;;;;51683:55;;540:41:1;;;51607:49:0;;67928:10;51683:55;;513:18:1;51683:55:0;;;;;;;51413:333;;:::o;73963:91::-;6932:13;:11;:13::i;:::-;74023:23:::1;14579:19:::0;;14572:26;14511:95;71307:207;6932:13;:11;:13::i;:::-;3971:1:::1;4569:7;;:19:::0;4561:63:::1;;;;-1:-1:-1::0;;;4561:63:0::1;;;;;;;:::i;:::-;3971:1;4702:7;:18:::0;71446:9:::2;::::0;42467:1;43126:12;42913:7;43110:13;71428:14;;43110:28;;-1:-1:-1;;43110:46:0;71412:30:::2;;;;:::i;:::-;:43;;71404:64;;;::::0;-1:-1:-1;;;71404:64:0;;12807:2:1;71404:64:0::2;::::0;::::2;12789:21:1::0;12846:1;12826:18;;;12819:29;-1:-1:-1;;;12864:18:1;;;12857:38;12912:18;;71404:64:0::2;12605:331:1::0;71404:64:0::2;71481:25;71487:2;71491:14;71481:5;:25::i;52570:396::-:0;52737:28;52747:4;52753:2;52757:7;52737:9;:28::i;:::-;-1:-1:-1;;;;;52780:14:0;;;:19;52776:183;;52819:56;52850:4;52856:2;52860:7;52869:5;52819:30;:56::i;:::-;52814:145;;52903:40;;-1:-1:-1;;;52903:40:0;;;;;;;;;;;52814:145;52570:396;;;;:::o;28576:487::-;28687:7;:5;:7::i;:::-;-1:-1:-1;;;;;28673:21:0;:10;-1:-1:-1;;;;;28673:21:0;;28669:72;;28718:11;;-1:-1:-1;;;28718:11:0;;;;;;;;;;;28669:72;28826:31;;-1:-1:-1;;;28826:31:0;;;;28822:95;;;28881:24;;-1:-1:-1;;;28881:24:0;;;;;;;;;;;28822:95;28929:22;:61;;-1:-1:-1;;;;;;28929:61:0;-1:-1:-1;;;;;28929:61:0;;;;;;;;29006:49;;2228:51:1;;;29006:49:0;;2216:2:1;2201:18;29006:49:0;;;;;;;28576:487;:::o;72588:110::-;6932:13;:11;:13::i;:::-;72668:9:::1;:22;72680:10:::0;;72668:9;:22:::1;:::i;72932:330::-:0;72997:13;73031:16;73039:7;73031;:16::i;:::-;73023:48;;;;-1:-1:-1;;;73023:48:0;;13824:2:1;73023:48:0;;;13806:21:1;13863:2;13843:18;;;13836:30;-1:-1:-1;;;13882:18:1;;;13875:49;13941:18;;73023:48:0;13622:343:1;73023:48:0;73088:8;;;;;;;73084:142;;;73126:7;73120:21;;;;;:::i;:::-;;;73145:1;73120:26;:94;;;;;;;;;;;;;;;;;73173:7;73182:25;73199:7;73182:16;:25::i;:::-;73156:52;;;;;;;;;:::i;:::-;;;;;;;;;;;;;73113:101;72932:330;-1:-1:-1;;72932:330:0:o;73084:142::-;73245:9;73238:16;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72932:330;;;:::o;51817:189::-;-1:-1:-1;;;;;51963:25:0;;;51939:4;51963:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;51817:189::o;7952:201::-;6932:13;:11;:13::i;:::-;-1:-1:-1;;;;;8041:22:0;::::1;8033:73;;;::::0;-1:-1:-1;;;8033:73:0;;15197:2:1;8033:73:0::1;::::0;::::1;15179:21:1::0;15236:2;15216:18;;;15209:30;15275:34;15255:18;;;15248:62;-1:-1:-1;;;15326:18:1;;;15319:36;15372:19;;8033:73:0::1;14995:402:1::0;8033:73:0::1;8117:28;8136:8;8117:18;:28::i;:::-;7952:201:::0;:::o;43806:631::-;43907:4;-1:-1:-1;;;;;;;;;44207:25:0;;;;:102;;-1:-1:-1;;;;;;;;;;44284:25:0;;;44207:102;:179;;;-1:-1:-1;;;;;;;;44361:25:0;-1:-1:-1;;;44361:25:0;;43806:631::o;12741:215::-;12843:4;-1:-1:-1;;;;;;12867:41:0;;-1:-1:-1;;;12867:41:0;;:81;;-1:-1:-1;;;;;;;;;;10402:40:0;;;12912:36;10293:157;7211:132;67928:10;7275:7;:5;:7::i;:::-;-1:-1:-1;;;;;7275:23:0;;7267:68;;;;-1:-1:-1;;;7267:68:0;;15604:2:1;7267:68:0;;;15586:21:1;;;15623:18;;;15616:30;15682:34;15662:18;;;15655:62;15734:18;;7267:68:0;15402:356:1;14103:332:0;13819:5;-1:-1:-1;;;;;14206:33:0;;;;14198:88;;;;-1:-1:-1;;;14198:88:0;;15965:2:1;14198:88:0;;;15947:21:1;16004:2;15984:18;;;15977:30;16043:34;16023:18;;;16016:62;-1:-1:-1;;;16094:18:1;;;16087:40;16144:19;;14198:88:0;15763:406:1;14198:88:0;-1:-1:-1;;;;;14305:22:0;;14297:60;;;;-1:-1:-1;;;14297:60:0;;16376:2:1;14297:60:0;;;16358:21:1;16415:2;16395:18;;;16388:30;16454:27;16434:18;;;16427:55;16499:18;;14297:60:0;16174:349:1;14297:60:0;14392:35;;;;;;;;;-1:-1:-1;;;;;14392:35:0;;;;;;-1:-1:-1;;;;;14392:35:0;;;;;;;;;;-1:-1:-1;;;14370:57:0;;;;:19;:57;14103:332::o;53221:273::-;53278:4;53334:7;42467:1;53315:26;;:66;;;;;53368:13;;53358:7;:23;53315:66;:152;;;;-1:-1:-1;;53419:26:0;;;;:17;:26;;;;;;-1:-1:-1;;;53419:43:0;:48;;53221:273::o;46214:1145::-;46297:7;46332;;42467:1;46381:23;46377:915;;46434:13;;46427:4;:20;46423:869;;;46472:14;46489:23;;;:17;:23;;;;;;;-1:-1:-1;;;46578:23:0;;:28;;46574:699;;47097:113;47104:6;47114:1;47104:11;47097:113;;-1:-1:-1;;;47175:6:0;47157:25;;;;:17;:25;;;;;;47097:113;;;47243:6;46214:1145;-1:-1:-1;;;46214:1145:0:o;46574:699::-;46449:843;46423:869;47320:31;;-1:-1:-1;;;47320:31:0;;;;;;;;;;;58739:2633;58820:27;58850;58869:7;58850:18;:27::i;:::-;58820:57;;58935:4;-1:-1:-1;;;;;58894:45:0;58910:19;-1:-1:-1;;;;;58894:45:0;;58890:99;;58961:28;;-1:-1:-1;;;58961:28:0;;;;;;;;;;;58890:99;59002:23;59028:24;;;:15;:24;;;;;;-1:-1:-1;;;;;59028:24:0;;;;59002:23;59091:27;;67928:10;59091:27;;:87;;-1:-1:-1;59135:43:0;59152:4;67928:10;51817:189;:::i;59135:43::-;59091:142;;;-1:-1:-1;;;;;;59195:38:0;;67928:10;59195:38;59091:142;59065:169;;59252:17;59247:66;;59278:35;;-1:-1:-1;;;59278:35:0;;;;;;;;;;;59247:66;59346:2;59353:1;59328:26;59324:62;;59363:23;;-1:-1:-1;;;59363:23:0;;;;;;;;;;;59324:62;59530:15;59512:39;59508:103;;59575:24;;;;:15;:24;;;;;59568:31;;-1:-1:-1;;;;;;59568:31:0;;;59508:103;-1:-1:-1;;;;;59978:24:0;;;;;;;:18;:24;;;;;;;;59976:26;;-1:-1:-1;;59976:26:0;;;60047:22;;;;;;;;60045:24;;-1:-1:-1;60045:24:0;;;60340:26;;;:17;:26;;;;;-1:-1:-1;;;60428:15:0;40484:3;60428:41;60386:84;;:128;;60340:174;;;60634:46;;:51;;60630:626;;60738:1;60728:11;;60706:19;60861:30;;;:17;:30;;;;;;:35;;60857:384;;60999:13;;60984:11;:28;60980:242;;61146:30;;;;:17;:30;;;;;:52;;;60980:242;60687:569;60630:626;61303:7;61299:2;-1:-1:-1;;;;;61284:27:0;61293:4;-1:-1:-1;;;;;61284:27:0;;;;;;;;;;;61322:42;58809:2563;;;58739:2633;;;:::o;8313:191::-;8406:6;;;-1:-1:-1;;;;;8423:17:0;;;-1:-1:-1;;;;;;8423:17:0;;;;;;;8456:40;;8406:6;;;8423:17;8406:6;;8456:40;;8387:16;;8456:40;8376:128;8313:191;:::o;56785:1700::-;56850:20;56873:13;56919:2;56926:1;56901:26;56897:58;;56936:19;;-1:-1:-1;;;56936:19:0;;;;;;;;;;;56897:58;56970:8;56982:1;56970:13;56966:44;;56992:18;;-1:-1:-1;;;56992:18:0;;;;;;;;;;;56966:44;-1:-1:-1;;;;;57559:22:0;;;;;;:18;:22;;;;39967:2;57559:22;;;:104;;57631:31;57602:61;;57559:104;;;57906:31;;;:17;:31;;;;;57999:15;40484:3;57999:41;57957:84;;-1:-1:-1;58077:13:0;;40743:3;58062:56;57957:162;57906:213;;:31;58200:23;;;58240:111;58267:40;;58292:14;;;;;-1:-1:-1;;;;;58267:40:0;;;58284:1;;58267:40;;58284:1;;58267:40;58346:3;58331:12;:18;58240:111;;-1:-1:-1;58367:13:0;:28;52073:170;;;:::o;65195:831::-;65392:171;;-1:-1:-1;;;65392:171:0;;65358:4;;-1:-1:-1;;;;;65392:45:0;;;;;:171;;67928:10;;65494:4;;65517:7;;65543:5;;65392:171;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65392:171:0;;;;;;;;-1:-1:-1;;65392:171:0;;;;;;;;;;;;:::i;:::-;;;65375:644;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65777:6;:13;65794:1;65777:18;65773:235;;65823:40;;-1:-1:-1;;;65823:40:0;;;;;;;;;;;65773:235;65966:6;65960:13;65951:6;65947:2;65943:15;65936:38;65375:644;-1:-1:-1;;;;;;65636:81:0;-1:-1:-1;;;65636:81:0;;-1:-1:-1;65375:644:0;65195:831;;;;;;:::o;400:723::-;456:13;677:5;686:1;677:10;673:53;;-1:-1:-1;;704:10:0;;;;;;;;;;;;-1:-1:-1;;;704:10:0;;;;;400:723::o;673:53::-;751:5;736:12;792:78;799:9;;792:78;;825:8;;;;:::i;:::-;;-1:-1:-1;848:10:0;;-1:-1:-1;856:2:0;848:10;;:::i;:::-;;;792:78;;;880:19;912:6;902:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;902:17:0;;880:39;;930:154;937:10;;930:154;;964:11;974:1;964:11;;:::i;:::-;;-1:-1:-1;1033:10:0;1041:2;1033:5;:10;:::i;:::-;1020:24;;:2;:24;:::i;:::-;1007:39;;990:6;997;990:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;990:56:0;;;;;;;;-1:-1:-1;1061:11:0;1070:2;1061:11;;:::i;:::-;;;930:154;;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:173::-;660:20;;-1:-1:-1;;;;;709:31:1;;699:42;;689:70;;755:1;752;745:12;689:70;592:173;;;:::o;770:366::-;837:6;845;898:2;886:9;877:7;873:23;869:32;866:52;;;914:1;911;904:12;866:52;937:29;956:9;937:29;:::i;:::-;927:39;;1016:2;1005:9;1001:18;988:32;-1:-1:-1;;;;;1053:5:1;1049:38;1042:5;1039:49;1029:77;;1102:1;1099;1092:12;1029:77;1125:5;1115:15;;;770:366;;;;;:::o;1141:250::-;1226:1;1236:113;1250:6;1247:1;1244:13;1236:113;;;1326:11;;;1320:18;1307:11;;;1300:39;1272:2;1265:10;1236:113;;;-1:-1:-1;;1383:1:1;1365:16;;1358:27;1141:250::o;1396:271::-;1438:3;1476:5;1470:12;1503:6;1498:3;1491:19;1519:76;1588:6;1581:4;1576:3;1572:14;1565:4;1558:5;1554:16;1519:76;:::i;:::-;1649:2;1628:15;-1:-1:-1;;1624:29:1;1615:39;;;;1656:4;1611:50;;1396:271;-1:-1:-1;;1396:271:1:o;1672:220::-;1821:2;1810:9;1803:21;1784:4;1841:45;1882:2;1871:9;1867:18;1859:6;1841:45;:::i;1897:180::-;1956:6;2009:2;1997:9;1988:7;1984:23;1980:32;1977:52;;;2025:1;2022;2015:12;1977:52;-1:-1:-1;2048:23:1;;1897:180;-1:-1:-1;1897:180:1:o;2290:254::-;2358:6;2366;2419:2;2407:9;2398:7;2394:23;2390:32;2387:52;;;2435:1;2432;2425:12;2387:52;2458:29;2477:9;2458:29;:::i;:::-;2448:39;2534:2;2519:18;;;;2506:32;;-1:-1:-1;;;2290:254:1:o;2549:127::-;2610:10;2605:3;2601:20;2598:1;2591:31;2641:4;2638:1;2631:15;2665:4;2662:1;2655:15;2681:275;2752:2;2746:9;2817:2;2798:13;;-1:-1:-1;;2794:27:1;2782:40;;2852:18;2837:34;;2873:22;;;2834:62;2831:88;;;2899:18;;:::i;:::-;2935:2;2928:22;2681:275;;-1:-1:-1;2681:275:1:o;2961:952::-;3045:6;3076:2;3119;3107:9;3098:7;3094:23;3090:32;3087:52;;;3135:1;3132;3125:12;3087:52;3175:9;3162:23;3204:18;3245:2;3237:6;3234:14;3231:34;;;3261:1;3258;3251:12;3231:34;3299:6;3288:9;3284:22;3274:32;;3344:7;3337:4;3333:2;3329:13;3325:27;3315:55;;3366:1;3363;3356:12;3315:55;3402:2;3389:16;3424:2;3420;3417:10;3414:36;;;3430:18;;:::i;:::-;3476:2;3473:1;3469:10;3459:20;;3499:28;3523:2;3519;3515:11;3499:28;:::i;:::-;3561:15;;;3631:11;;;3627:20;;;3592:12;;;;3659:19;;;3656:39;;;3691:1;3688;3681:12;3656:39;3715:11;;;;3735:148;3751:6;3746:3;3743:15;3735:148;;;3817:23;3836:3;3817:23;:::i;:::-;3805:36;;3768:12;;;;3861;;;;3735:148;;;3902:5;2961:952;-1:-1:-1;;;;;;;;2961:952:1:o;4100:328::-;4177:6;4185;4193;4246:2;4234:9;4225:7;4221:23;4217:32;4214:52;;;4262:1;4259;4252:12;4214:52;4285:29;4304:9;4285:29;:::i;:::-;4275:39;;4333:38;4367:2;4356:9;4352:18;4333:38;:::i;:::-;4323:48;;4418:2;4407:9;4403:18;4390:32;4380:42;;4100:328;;;;;:::o;4433:248::-;4501:6;4509;4562:2;4550:9;4541:7;4537:23;4533:32;4530:52;;;4578:1;4575;4568:12;4530:52;-1:-1:-1;;4601:23:1;;;4671:2;4656:18;;;4643:32;;-1:-1:-1;4433:248:1:o;4965:592::-;5036:6;5044;5097:2;5085:9;5076:7;5072:23;5068:32;5065:52;;;5113:1;5110;5103:12;5065:52;5153:9;5140:23;5182:18;5223:2;5215:6;5212:14;5209:34;;;5239:1;5236;5229:12;5209:34;5277:6;5266:9;5262:22;5252:32;;5322:7;5315:4;5311:2;5307:13;5303:27;5293:55;;5344:1;5341;5334:12;5293:55;5384:2;5371:16;5410:2;5402:6;5399:14;5396:34;;;5426:1;5423;5416:12;5396:34;5471:7;5466:2;5457:6;5453:2;5449:15;5445:24;5442:37;5439:57;;;5492:1;5489;5482:12;5439:57;5523:2;5515:11;;;;;5545:6;;-1:-1:-1;4965:592:1;;-1:-1:-1;;;;4965:592:1:o;5562:186::-;5621:6;5674:2;5662:9;5653:7;5649:23;5645:32;5642:52;;;5690:1;5687;5680:12;5642:52;5713:29;5732:9;5713:29;:::i;5753:347::-;5818:6;5826;5879:2;5867:9;5858:7;5854:23;5850:32;5847:52;;;5895:1;5892;5885:12;5847:52;5918:29;5937:9;5918:29;:::i;:::-;5908:39;;5997:2;5986:9;5982:18;5969:32;6044:5;6037:13;6030:21;6023:5;6020:32;6010:60;;6066:1;6063;6056:12;6344:980;6439:6;6447;6455;6463;6516:3;6504:9;6495:7;6491:23;6487:33;6484:53;;;6533:1;6530;6523:12;6484:53;6556:29;6575:9;6556:29;:::i;:::-;6546:39;;6604:2;6625:38;6659:2;6648:9;6644:18;6625:38;:::i;:::-;6615:48;;6710:2;6699:9;6695:18;6682:32;6672:42;;6765:2;6754:9;6750:18;6737:32;6788:18;6829:2;6821:6;6818:14;6815:34;;;6845:1;6842;6835:12;6815:34;6883:6;6872:9;6868:22;6858:32;;6928:7;6921:4;6917:2;6913:13;6909:27;6899:55;;6950:1;6947;6940:12;6899:55;6986:2;6973:16;7008:2;7004;7001:10;6998:36;;;7014:18;;:::i;:::-;7056:53;7099:2;7080:13;;-1:-1:-1;;7076:27:1;7072:36;;7056:53;:::i;:::-;7043:66;;7132:2;7125:5;7118:17;7172:7;7167:2;7162;7158;7154:11;7150:20;7147:33;7144:53;;;7193:1;7190;7183:12;7144:53;7248:2;7243;7239;7235:11;7230:2;7223:5;7219:14;7206:45;7292:1;7287:2;7282;7275:5;7271:14;7267:23;7260:34;;7313:5;7303:15;;;;;6344:980;;;;;;;:::o;7329:260::-;7397:6;7405;7458:2;7446:9;7437:7;7433:23;7429:32;7426:52;;;7474:1;7471;7464:12;7426:52;7497:29;7516:9;7497:29;:::i;:::-;7487:39;;7545:38;7579:2;7568:9;7564:18;7545:38;:::i;:::-;7535:48;;7329:260;;;;;:::o;7594:380::-;7673:1;7669:12;;;;7716;;;7737:61;;7791:4;7783:6;7779:17;7769:27;;7737:61;7844:2;7836:6;7833:14;7813:18;7810:38;7807:161;;7890:10;7885:3;7881:20;7878:1;7871:31;7925:4;7922:1;7915:15;7953:4;7950:1;7943:15;7807:161;;7594:380;;;:::o;7979:127::-;8040:10;8035:3;8031:20;8028:1;8021:31;8071:4;8068:1;8061:15;8095:4;8092:1;8085:15;8111:127;8172:10;8167:3;8163:20;8160:1;8153:31;8203:4;8200:1;8193:15;8227:4;8224:1;8217:15;8243:135;8282:3;8303:17;;;8300:43;;8323:18;;:::i;:::-;-1:-1:-1;8370:1:1;8359:13;;8243:135::o;8383:168::-;8456:9;;;8487;;8504:15;;;8498:22;;8484:37;8474:71;;8525:18;;:::i;8556:127::-;8617:10;8612:3;8608:20;8605:1;8598:31;8648:4;8645:1;8638:15;8672:4;8669:1;8662:15;8688:120;8728:1;8754;8744:35;;8759:18;;:::i;:::-;-1:-1:-1;8793:9:1;;8688:120::o;8813:355::-;9015:2;8997:21;;;9054:2;9034:18;;;9027:30;9093:33;9088:2;9073:18;;9066:61;9159:2;9144:18;;8813:355::o;9857:545::-;9959:2;9954:3;9951:11;9948:448;;;9995:1;10020:5;10016:2;10009:17;10065:4;10061:2;10051:19;10135:2;10123:10;10119:19;10116:1;10112:27;10106:4;10102:38;10171:4;10159:10;10156:20;10153:47;;;-1:-1:-1;10194:4:1;10153:47;10249:2;10244:3;10240:12;10237:1;10233:20;10227:4;10223:31;10213:41;;10304:82;10322:2;10315:5;10312:13;10304:82;;;10367:17;;;10348:1;10337:13;10304:82;;10578:1206;10702:18;10697:3;10694:27;10691:53;;;10724:18;;:::i;:::-;10753:94;10843:3;10803:38;10835:4;10829:11;10803:38;:::i;:::-;10797:4;10753:94;:::i;:::-;10873:1;10898:2;10893:3;10890:11;10915:1;10910:616;;;;11570:1;11587:3;11584:93;;;-1:-1:-1;11643:19:1;;;11630:33;11584:93;-1:-1:-1;;10535:1:1;10531:11;;;10527:24;10523:29;10513:40;10559:1;10555:11;;;10510:57;11690:78;;10883:895;;10910:616;9804:1;9797:14;;;9841:4;9828:18;;-1:-1:-1;;10946:17:1;;;11047:9;11069:229;11083:7;11080:1;11077:14;11069:229;;;11172:19;;;11159:33;11144:49;;11279:4;11264:20;;;;11232:1;11220:14;;;;11099:12;11069:229;;;11073:3;11326;11317:7;11314:16;11311:159;;;11450:1;11446:6;11440:3;11434;11431:1;11427:11;11423:21;11419:34;11415:39;11402:9;11397:3;11393:19;11380:33;11376:79;11368:6;11361:95;11311:159;;;11513:1;11507:3;11504:1;11500:11;11496:19;11490:4;11483:33;10883:895;;;10578:1206;;;:::o;12475:125::-;12540:9;;;12561:10;;;12558:36;;;12574:18;;:::i;13970:1020::-;14146:3;14175:1;14208:6;14202:13;14238:36;14264:9;14238:36;:::i;:::-;14293:1;14310:18;;;14337:133;;;;14484:1;14479:356;;;;14303:532;;14337:133;-1:-1:-1;;14370:24:1;;14358:37;;14443:14;;14436:22;14424:35;;14415:45;;;-1:-1:-1;14337:133:1;;14479:356;14510:6;14507:1;14500:17;14540:4;14585:2;14582:1;14572:16;14610:1;14624:165;14638:6;14635:1;14632:13;14624:165;;;14716:14;;14703:11;;;14696:35;14759:16;;;;14653:10;;14624:165;;;14628:3;;;14818:6;14813:3;14809:16;14802:23;;14303:532;;;;;14866:6;14860:13;14882:68;14941:8;14936:3;14929:4;14921:6;14917:17;14882:68;:::i;:::-;14966:18;;13970:1020;-1:-1:-1;;;;13970:1020:1:o;16528:489::-;-1:-1:-1;;;;;16797:15:1;;;16779:34;;16849:15;;16844:2;16829:18;;16822:43;16896:2;16881:18;;16874:34;;;16944:3;16939:2;16924:18;;16917:31;;;16722:4;;16965:46;;16991:19;;16983:6;16965:46;:::i;:::-;16957:54;16528:489;-1:-1:-1;;;;;;16528:489:1:o;17022:249::-;17091:6;17144:2;17132:9;17123:7;17119:23;17115:32;17112:52;;;17160:1;17157;17150:12;17112:52;17192:9;17186:16;17211:30;17235:5;17211:30;:::i;17276:128::-;17343:9;;;17364:11;;;17361:37;;;17378:18;;:::i;17409:112::-;17441:1;17467;17457:35;;17472:18;;:::i;:::-;-1:-1:-1;17506:9:1;;17409:112::o

Swarm Source

ipfs://705d1cabf4f9bc044941ac575730698c92fc61bf5df64c268f5bd895d0ac6ec2

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

Tools & Services