Token

Cryptoboyz (BOYZ)

ERC-721

Overview

Max Total Supply

6,969 BOYZ

Holders

683

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x4b2afd12c80d3beac113b31f818858624521b57c

Filtered by Token Holder

0xefCBC56e48d51B9d93d647Ba7Bfa501eb3aaC398

diamondhanders.eth

Balance

10 BOYZ

0xefcbc56e48d51b9d93d647ba7bfa501eb3aac398

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Cryptoboyz

Compiler Version

v0.8.7+commit.e28d00a7

Optimization Enabled:

Yes with 1000 runs

Other Settings:

default evmVersion, GNU GPLv3 license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-03-13
*/

//SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.7;
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// File: @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/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 v4.4.1 (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 Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _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/Address.sol


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

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;



/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: @openzeppelin/contracts/finance/PaymentSplitter.sol


// OpenZeppelin Contracts v4.4.1 (finance/PaymentSplitter.sol)

pragma solidity ^0.8.0;




/**
 * @title PaymentSplitter
 * @dev This contract allows to split Ether payments among a group of accounts. The sender does not need to be aware
 * that the Ether will be split in this way, since it is handled transparently by the contract.
 *
 * The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each
 * account to a number of shares. Of all the Ether that this contract receives, each account will then be able to claim
 * an amount proportional to the percentage of total shares they were assigned.
 *
 * `PaymentSplitter` follows a _pull payment_ model. This means that payments are not automatically forwarded to the
 * accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}
 * function.
 *
 * NOTE: This contract assumes that ERC20 tokens will behave similarly to native tokens (Ether). Rebasing tokens, and
 * tokens that apply fees during transfers, are likely to not be supported as expected. If in doubt, we encourage you
 * to run tests before sending real value to this contract.
 */
contract PaymentSplitter is Context {
    event PayeeAdded(address account, uint256 shares);
    event PaymentReleased(address to, uint256 amount);
    event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount);
    event PaymentReceived(address from, uint256 amount);

    uint256 private _totalShares;
    uint256 private _totalReleased;

    mapping(address => uint256) private _shares;
    mapping(address => uint256) private _released;
    address[] private _payees;

    mapping(IERC20 => uint256) private _erc20TotalReleased;
    mapping(IERC20 => mapping(address => uint256)) private _erc20Released;

    /**
     * @dev Creates an instance of `PaymentSplitter` where each account in `payees` is assigned the number of shares at
     * the matching position in the `shares` array.
     *
     * All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no
     * duplicates in `payees`.
     */
    constructor(address[] memory payees, uint256[] memory shares_) payable {
        require(payees.length == shares_.length, "PaymentSplitter: payees and shares length mismatch");
        require(payees.length > 0, "PaymentSplitter: no payees");

        for (uint256 i = 0; i < payees.length; i++) {
            _addPayee(payees[i], shares_[i]);
        }
    }

    /**
     * @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully
     * reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the
     * reliability of the events, and not the actual splitting of Ether.
     *
     * To learn more about this see the Solidity documentation for
     * https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback
     * functions].
     */
    receive() external payable virtual {
        emit PaymentReceived(_msgSender(), msg.value);
    }

    /**
     * @dev Getter for the total shares held by payees.
     */
    function totalShares() public view returns (uint256) {
        return _totalShares;
    }

    /**
     * @dev Getter for the total amount of Ether already released.
     */
    function totalReleased() public view returns (uint256) {
        return _totalReleased;
    }

    /**
     * @dev Getter for the total amount of `token` already released. `token` should be the address of an IERC20
     * contract.
     */
    function totalReleased(IERC20 token) public view returns (uint256) {
        return _erc20TotalReleased[token];
    }

    /**
     * @dev Getter for the amount of shares held by an account.
     */
    function shares(address account) public view returns (uint256) {
        return _shares[account];
    }

    /**
     * @dev Getter for the amount of Ether already released to a payee.
     */
    function released(address account) public view returns (uint256) {
        return _released[account];
    }

    /**
     * @dev Getter for the amount of `token` tokens already released to a payee. `token` should be the address of an
     * IERC20 contract.
     */
    function released(IERC20 token, address account) public view returns (uint256) {
        return _erc20Released[token][account];
    }

    /**
     * @dev Getter for the address of the payee number `index`.
     */
    function payee(uint256 index) public view returns (address) {
        return _payees[index];
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
     * total shares and their previous withdrawals.
     */
    function release(address payable account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 totalReceived = address(this).balance + totalReleased();
        uint256 payment = _pendingPayment(account, totalReceived, released(account));

        require(payment != 0, "PaymentSplitter: account is not due payment");

        _released[account] += payment;
        _totalReleased += payment;

        Address.sendValue(account, payment);
        emit PaymentReleased(account, payment);
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of `token` tokens they are owed, according to their
     * percentage of the total shares and their previous withdrawals. `token` must be the address of an IERC20
     * contract.
     */
    function release(IERC20 token, address account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 totalReceived = token.balanceOf(address(this)) + totalReleased(token);
        uint256 payment = _pendingPayment(account, totalReceived, released(token, account));

        require(payment != 0, "PaymentSplitter: account is not due payment");

        _erc20Released[token][account] += payment;
        _erc20TotalReleased[token] += payment;

        SafeERC20.safeTransfer(token, account, payment);
        emit ERC20PaymentReleased(token, account, payment);
    }

    /**
     * @dev internal logic for computing the pending payment of an `account` given the token historical balances and
     * already released amounts.
     */
    function _pendingPayment(
        address account,
        uint256 totalReceived,
        uint256 alreadyReleased
    ) private view returns (uint256) {
        return (totalReceived * _shares[account]) / _totalShares - alreadyReleased;
    }

    /**
     * @dev Add a new payee to the contract.
     * @param account The address of the payee to add.
     * @param shares_ The number of shares owned by the payee.
     */
    function _addPayee(address account, uint256 shares_) private {
        require(account != address(0), "PaymentSplitter: account is the zero address");
        require(shares_ > 0, "PaymentSplitter: shares are 0");
        require(_shares[account] == 0, "PaymentSplitter: account already has shares");

        _payees.push(account);
        _shares[account] = shares_;
        _totalShares = _totalShares + shares_;
        emit PayeeAdded(account, shares_);
    }
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

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

// 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/token/ERC721/IERC721.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;


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

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

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

// File: contracts/ERC721LowGas.sol


pragma solidity 0.8.7;









error TransferToNonERC721ReceiverImplementer();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToZeroAddress();
error ApproveToCaller();
error BalanceQueryForZeroAddress();
error QueryForNonexistentToken();
error ApprovalToCurrentOwner();
error ApprovalCallerNotOwnerNorApproved();

/**
 * @dev Custom implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard and Chiru Labs ERC721A, including
 * the Metadata extension, but not including the Enumerable extension.
 * 
 * Assumes that no burn will ever be executed.
 *
 * Assumes that safeMint will never be called, no contracts being allowed to mint.
 */
contract ERC721LowGas is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Compiler will pack this into a single 256bit word.
    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;
    }

    // Compiler will pack this into a single 256bit word.
    struct AddressData {
        // Realistically, 2**64-1 is more than enough.
        uint64 balance;
        // Keeps track of mint count with minimal overhead for tokenomics.
        uint64 numberMinted;
        // Keeps track of burn count with minimal overhead for tokenomics.
        uint64 numberBurned;
        // For miscellaneous variable(s) pertaining to the address
        // (e.g. number of whitelist mint slots used).
        // If there are multiple variables, please pack them into a uint64.
        uint64 aux;
    }

    // The tokenId of the next token to be minted.
    uint128 internal _currentIndex = 1;

    // 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 _ownershipOf implementation for details.
    mapping(uint256 => TokenOwnership) internal _ownerships;

    // Mapping owner address to address data
    mapping(address => AddressData) private _addressData;

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

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

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

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

     /**
     * @dev See {IERC721Enumerable-totalSupply}.
     * @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
     */
    function totalSupply() public view returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than _currentIndex - _startTokenId() times
        unchecked {
            return _currentIndex - _startTokenId();
        }
    }

    /**
     * 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 See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId);
    }

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

    /**
     * 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) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr && (curr < 7000 || (curr > 100000 && curr <100020))) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (!ownership.burned) {
                    if (ownership.addr != address(0)) {
                        return ownership;
                    }
                    // 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.
                    while (true) {
                        curr--;
                        ownership = _ownerships[curr];
                        if (ownership.addr != address(0)) {
                            return ownership;
                        }
                    }
                }
            }
        }
        revert OwnerQueryForNonexistentToken();
    }

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

    /**
     * @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 QueryForNonexistentToken();
            string memory baseURI = _baseURI();
            return string(abi.encodePacked(baseURI, tokenId.toString()));

    }

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

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public override {
        address owner = ownerOf(tokenId);
        if (to == owner) revert ApprovalToCurrentOwner();
        if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) revert ApprovalCallerNotOwnerNorApproved();
        _approve(to, tokenId, owner);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        if (!_exists(tokenId)) revert QueryForNonexistentToken();
        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public override {
        if (operator == _msgSender()) revert ApproveToCaller();
        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

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

     /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual override {
        _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 (!_checkOnERC721Received(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 < 7000 || (tokenId > 100000 && tokenId <100020)) &&
            !_ownerships[tokenId].burned;
    }

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

        // 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 {
            _addressData[to].balance += uint64(quantity);
            _addressData[to].numberMinted += uint64(quantity);

            _ownerships[startTokenId].addr = to;
            _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

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

            if (safe && to.isContract()) {
                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;
        }
    }

      /**
     * @dev Mints specific token and transfers it to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mintSpecial(address to, uint256 id) internal {
        if (to == address(0)) revert MintToZeroAddress();

        unchecked {

            _addressData[to].balance ++;
            _addressData[to].numberMinted ++;

            _ownerships[id].addr = to;
            _ownerships[id].startTimestamp = uint64(block.timestamp);

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

    

    /**
     * @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 {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
            isApprovedForAll(prevOwnership.addr, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();
        if (to == address(0)) revert TransferToZeroAddress();


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

        // 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 {
            _addressData[from].balance -= 1;
            _addressData[to].balance += 1;

            _ownerships[tokenId].addr = to;
            _ownerships[tokenId].startTimestamp = uint64(block.timestamp);

            // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            if (_ownerships[nextTokenId].addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId < _currentIndex) {
                    _ownerships[nextTokenId].addr = prevOwnership.addr;
                    _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, to, tokenId);
    }

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

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

}
 /**
     * @dev 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
    ) returns (bool) {
        try IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, _data) returns (bytes4 retval) {
            return retval == IERC721Receiver(to).onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == 0) {
                revert TransferToNonERC721ReceiverImplementer();
            } else {
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    }
// File: contracts/Cryptoboyz.sol


pragma solidity 0.8.7;





   /**********************************************************************************************\
   |*                                                                                            *|
   |*                                                                                            *|
   |*     ██████ ██████  ██    ██ ██████  ████████  ██████  ██████   ██████  ██    ██ ███████    *|
   |*    ██      ██   ██  ██  ██  ██   ██    ██    ██    ██ ██   ██ ██    ██  ██  ██     ███     *|
   |*    ██      ██████    ████   ██████     ██    ██    ██ ██████  ██    ██   ████     ███      *|
   |*    ██      ██   ██    ██    ██         ██    ██    ██ ██   ██ ██    ██    ██     ███       *|
   |*     ██████ ██   ██    ██    ██         ██     ██████  ██████   ██████     ██    ███████    *|
   |*                                                                                            *| 
   |*                                                                                            *|
   \**********************************************************************************************/


contract Cryptoboyz is ERC721LowGas, Ownable {

    string baseURI_ = 'ipfs://QmerYfiTbXZVRwANvPcoM6jCXxhM6R7gRYk9Rn8v7w3JLR/'; 

    constructor() ERC721LowGas("Cryptoboyz", "BOYZ") payable {}

    // Minting
    function mint(address[] calldata addresses, uint[] calldata quantity) external onlyOwner {
        for (uint i=0;i<addresses.length;i++)
        _mint(addresses[i], quantity[i],abi.encodePacked(quantity[i]), true);
    }

    // 1/1 mint only
    function mintUnique(address[] calldata addresses, uint[] calldata ids) external onlyOwner {        
            for (uint i=0;i<addresses.length;i++)
            _mintSpecial(addresses[i],ids[i]+100000);
        
    }

    // baseURI internal getter
    function _baseURI() internal view override returns (string memory) {
        return baseURI_;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"payable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"QueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"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":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"uint256[]","name":"quantity","type":"uint256[]"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"mintUnique","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"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"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

55967:840:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41008:266;;;;;;:::i;:::-;;:::i;:::-;;;6433:14:1;;6426:22;6408:41;;6396:2;6381:18;41008:266:0;;;;;;;;43137:100;;;:::i;:::-;;;;;;;:::i;44574:202::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;5685:55:1;;;5667:74;;5655:2;5640:18;44574:202:0;5521:226:1;44175:333:0;;;;;;:::i;:::-;;:::i;:::-;;40272:288;40316:7;40510:13;-1:-1:-1;;;;;40510:13:0;-1:-1:-1;;40510:31:0;40272:288;;;8017:25:1;;;8005:2;7990:18;40272:288:0;7871:177:1;45428:136:0;;;;;;:::i;:::-;;:::i;45635:151::-;;;;;;:::i;:::-;;:::i;42945:125::-;;;;;;:::i;:::-;;:::i;41338:206::-;;;;;;:::i;:::-;;:::i;7686:103::-;;;:::i;56441:222::-;;;;;;:::i;:::-;;:::i;7035:87::-;7108:6;;-1:-1:-1;;;;;7108:6:0;7035:87;;43306:104;;;:::i;44848:277::-;;;;;;:::i;:::-;;:::i;45857:273::-;;;;;;:::i;:::-;;:::i;43481:289::-;;;;;;:::i;:::-;;:::i;56188:223::-;;;;;;:::i;:::-;;:::i;45196:164::-;;;;;;:::i;:::-;-1:-1:-1;;;;;45317:25:0;;;45293:4;45317:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;45196:164;7944:201;;;;;;:::i;:::-;;:::i;41008:266::-;41110:4;-1:-1:-1;;;;;;41134:40:0;;41149:25;41134:40;;:92;;-1:-1:-1;;;;;;;41178:48:0;;41193:33;41178:48;41134:92;:132;;;-1:-1:-1;31187:25:0;-1:-1:-1;;;;;;31172:40:0;;;41230:36;41127:139;41008:266;-1:-1:-1;;41008:266:0:o;43137:100::-;43191:13;43224:5;43217:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43137:100;:::o;44574:202::-;44650:7;44675:16;44683:7;44675;:16::i;:::-;44670:56;;44700:26;;-1:-1:-1;;;44700:26:0;;;;;;;;;;;44670:56;-1:-1:-1;44744:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;44744:24:0;;44574:202::o;44175:333::-;44248:13;44264:16;44272:7;44264;:16::i;:::-;44248:32;;44301:5;-1:-1:-1;;;;;44295:11:0;:2;-1:-1:-1;;;;;44295:11:0;;44291:48;;;44315:24;;;;;;;;;;;;;;44291:48;5839:10;-1:-1:-1;;;;;44354:21:0;;;;;;:63;;-1:-1:-1;44380:37:0;44397:5;5839:10;45196:164;:::i;44380:37::-;44379:38;44354:63;44350:111;;;44426:35;;;;;;;;;;;;;;44350:111;44472:28;44481:2;44485:7;44494:5;44472:8;:28::i;:::-;44237:271;44175:333;;:::o;45428:136::-;45528:28;45538:4;45544:2;45548:7;45528:9;:28::i;45635:151::-;45739:39;45756:4;45762:2;45766:7;45739:39;;;;;;;;;;;;:16;:39::i;42945:125::-;43009:7;43036:21;43049:7;43036:12;:21::i;:::-;:26;;42945:125;-1:-1:-1;;42945:125:0:o;41338:206::-;41402:7;-1:-1:-1;;;;;41426:19:0;;41422:60;;41454:28;;;;;;;;;;;;;;41422:60;-1:-1:-1;;;;;;41508:19:0;;;;;:12;:19;;;;;:27;;;;41338:206::o;7686:103::-;7108:6;;-1:-1:-1;;;;;7108:6:0;5839:10;7255:23;7247:68;;;;-1:-1:-1;;;7247:68:0;;7712:2:1;7247:68:0;;;7694:21:1;;;7731:18;;;7724:30;7790:34;7770:18;;;7763:62;7842:18;;7247:68:0;;;;;;;;;7751:30:::1;7778:1;7751:18;:30::i;:::-;7686:103::o:0;56441:222::-;7108:6;;-1:-1:-1;;;;;7108:6:0;5839:10;7255:23;7247:68;;;;-1:-1:-1;;;7247:68:0;;7712:2:1;7247:68:0;;;7694:21:1;;;7731:18;;;7724:30;7790:34;7770:18;;;7763:62;7842:18;;7247:68:0;7510:356:1;7247:68:0;56559:6:::1;56554:91;56568:18:::0;;::::1;56554:91;;;56605:40;56618:9;;56628:1;56618:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;56631:3;;56635:1;56631:6;;;;;;;:::i;:::-;;;;;;;56638;56631:13;;;;:::i;:::-;56605:12;:40::i;:::-;56587:3:::0;::::1;::::0;::::1;:::i;:::-;;;;56554:91;;;;56441:222:::0;;;;:::o;43306:104::-;43362:13;43395:7;43388:14;;;;;:::i;44848:277::-;-1:-1:-1;;;;;44939:24:0;;5839:10;44939:24;44935:54;;;44972:17;;;;;;;;;;;;;;44935:54;5839:10;45000:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;45000:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;45000:53:0;;;;;;;;;;45069:48;;6408:41:1;;;45000:42:0;;5839:10;45069:48;;6381:18:1;45069:48:0;;;;;;;44848:277;;:::o;45857:273::-;45981:28;45991:4;45997:2;46001:7;45981:9;:28::i;:::-;46025:48;46048:4;46054:2;46058:7;46067:5;46025:22;:48::i;:::-;46020:102;;46082:40;;-1:-1:-1;;;46082:40:0;;;;;;;;;;;46020:102;45857:273;;;;:::o;43481:289::-;43554:13;43585:16;43593:7;43585;:16::i;:::-;43580:56;;43610:26;;-1:-1:-1;;;43610:26:0;;;;;;;;;;;43580:56;43651:21;43675:10;:8;:10::i;:::-;43651:34;;43731:7;43740:18;:7;:16;:18::i;:::-;43714:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;43700:60;;;43481:289;;;:::o;56188:223::-;7108:6;;-1:-1:-1;;;;;7108:6:0;5839:10;7255:23;7247:68;;;;-1:-1:-1;;;7247:68:0;;7712:2:1;7247:68:0;;;7694:21:1;;;7731:18;;;7724:30;7790:34;7770:18;;;7763:62;7842:18;;7247:68:0;7510:356:1;7247:68:0;56293:6:::1;56288:115;56302:18:::0;;::::1;56288:115;;;56335:68;56341:9;;56351:1;56341:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;56355:8;;56364:1;56355:11;;;;;;;:::i;:::-;;;;;;;56384:8;;56393:1;56384:11;;;;;;;:::i;:::-;;;;;;;56367:29;;;;;;5463:19:1::0;;5507:2;5498:12;;5334:182;56367:29:0::1;;;;;;;;;;;;;56398:4;56335:5;:68::i;:::-;56321:3:::0;::::1;::::0;::::1;:::i;:::-;;;;56288:115;;7944:201:::0;7108:6;;-1:-1:-1;;;;;7108:6:0;5839:10;7255:23;7247:68;;;;-1:-1:-1;;;7247:68:0;;7712:2:1;7247:68:0;;;7694:21:1;;;7731:18;;;7724:30;7790:34;7770:18;;;7763:62;7842:18;;7247:68:0;7510:356:1;7247:68:0;-1:-1:-1;;;;;8033:22:0;::::1;8025:73;;;::::0;-1:-1:-1;;;8025:73:0;;7305:2:1;8025:73:0::1;::::0;::::1;7287:21:1::0;7344:2;7324:18;;;7317:30;7383:34;7363:18;;;7356:62;7454:8;7434:18;;;7427:36;7480:19;;8025:73:0::1;7103:402:1::0;8025:73:0::1;8109:28;8128:8;8109:18;:28::i;:::-;7944:201:::0;:::o;46388:221::-;46445:4;46488:7;40078:1;46469:26;;:87;;;;;46510:4;46500:7;:14;:55;;;;46529:6;46519:7;:16;:35;;;;;46548:6;46539:7;:15;46519:35;46469:132;;;;-1:-1:-1;;46574:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;46574:27:0;;;;46573:28;;46388:221::o;51506:162::-;51587:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;51587:29:0;-1:-1:-1;;;;;51587:29:0;;;;;;;;;51632:28;;51587:24;;51632:28;;;;;;;51506:162;;;:::o;49382:2006::-;49497:35;49535:21;49548:7;49535:12;:21::i;:::-;49611:18;;49497:59;;-1:-1:-1;49569:22:0;;-1:-1:-1;;;;;49595:34:0;5839:10;-1:-1:-1;;;;;49595:34:0;;:101;;;-1:-1:-1;49663:18:0;;49646:50;;5839:10;45196:164;:::i;49646:50::-;49595:154;;;-1:-1:-1;5839:10:0;49713:20;49725:7;49713:11;:20::i;:::-;-1:-1:-1;;;;;49713:36:0;;49595:154;49569:181;;49768:17;49763:66;;49794:35;;;;;;;;;;;;;;49763:66;49866:4;-1:-1:-1;;;;;49844:26:0;:13;:18;;;-1:-1:-1;;;;;49844:26:0;;49840:67;;49879:28;;;;;;;;;;;;;;49840:67;-1:-1:-1;;;;;49922:16:0;;49918:52;;49947:23;;;;;;;;;;;;;;49918:52;50037:49;50054:1;50058:7;50067:13;:18;;;50037:8;:49::i;:::-;-1:-1:-1;;;;;50382:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;50382:31:0;;;;;;;-1:-1:-1;;50382:31:0;;;;;;;50428:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;50428:29:0;;;;;;;;;;;50474:20;;;:11;:20;;;;;;:30;;-1:-1:-1;;;;;;50519:61:0;;;;-1:-1:-1;;;50564:15:0;50519:61;;;;;;;;;;;50854:11;;;50884:24;;;;;:29;50854:11;;50884:29;50880:445;;51109:13;;-1:-1:-1;;;;;51109:13:0;51095:27;;51091:219;;;51179:18;;;51147:24;;;:11;:24;;;;;;;;:50;;51262:28;;;;51220:70;;-1:-1:-1;;;51220:70:0;-1:-1:-1;;;;;;51220:70:0;;;-1:-1:-1;;;;;51147:50:0;;;51220:70;;;;;;;51091:219;50357:979;51372:7;51368:2;-1:-1:-1;;;;;51353:27:0;51362:4;-1:-1:-1;;;;;51353:27:0;;;;;;;;;;;49486:1902;;49382:2006;;;:::o;41746:1137::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;41857:7:0;;40078:1;41906:23;;:75;;;;;41941:4;41934;:11;:46;;;;41957:6;41950:4;:13;:29;;;;;41973:6;41967:4;:12;41950:29;41902:914;;;42002:31;42036:17;;;:11;:17;;;;;;;;;42002:51;;;;;;;;;-1:-1:-1;;;;;42002:51:0;;;;-1:-1:-1;;;42002:51:0;;;;;;;;;;;-1:-1:-1;;;42002:51:0;;;;;;;;;;;;;;42072:729;;42122:14;;-1:-1:-1;;;;;42122:28:0;;42118:101;;42186:9;41746:1137;-1:-1:-1;;;41746:1137:0:o;42118:101::-;-1:-1:-1;;;42561:6:0;42606:17;;;;:11;:17;;;;;;;;;42594:29;;;;;;;;;-1:-1:-1;;;;;42594:29:0;;;;;-1:-1:-1;;;42594:29:0;;;;;;;;;;;-1:-1:-1;;;42594:29:0;;;;;;;;;;;;;42654:28;42650:109;;42722:9;41746:1137;-1:-1:-1;;;41746:1137:0:o;42650:109::-;42521:261;;;41983:833;41902:914;42844:31;;;;;;;;;;;;;;8305:191;8398:6;;;-1:-1:-1;;;;;8415:17:0;;;-1:-1:-1;;8415:17:0;;;;;;;8448:40;;8398:6;;;8415:17;8398:6;;8448:40;;8379:16;;8448:40;8368:128;8305:191;:::o;48710:410::-;-1:-1:-1;;;;;48780:16:0;;48776:48;;48805:19;;-1:-1:-1;;;48805:19:0;;;;;;;;;;;48776:48;-1:-1:-1;;;;;48864:16:0;;;;;;:12;:16;;;;;;;;:27;;48906:32;-1:-1:-1;;48864:27:0;;;;;;;;;;;;;;;48906:32;;;;;;;;;;;-1:-1:-1;;48906:32:0;;;;;;;;;;;48955:15;;;:11;:15;;;;;;:25;;49035:15;48995:56;;;-1:-1:-1;;;48995:56:0;-1:-1:-1;;;;;;48995:56:0;;;;;;;;;;;;49073:28;48955:15;;48864:16;;49073:28;;48864:16;;49073:28;48710:410;;:::o;52233:732::-;52345:4;-1:-1:-1;;;;;52366:13:0;;9646:20;9694:8;52362:585;;52401:72;;-1:-1:-1;;;52401:72:0;;-1:-1:-1;;;;;52401:36:0;;;;;:72;;5839:10;;52452:4;;52458:7;;52467:5;;52401:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52401:72:0;;;;;;;;-1:-1:-1;;52401:72:0;;;;;;;;;;;;:::i;:::-;;;52397:524;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52643:13:0;;52639:249;;52685:60;;-1:-1:-1;;;52685:60:0;;6886:2:1;52685:60:0;;;6868:21:1;6925:2;6905:18;;;6898:30;6964:34;6944:18;;;6937:62;7035:20;7015:18;;;7008:48;7073:19;;52685:60:0;6684:414:1;52639:249:0;52857:6;52851:13;52842:6;52838:2;52834:15;52827:38;52397:524;-1:-1:-1;;;;;;52524:51:0;-1:-1:-1;;;52524:51:0;;-1:-1:-1;52517:58:0;;52362:585;-1:-1:-1;52943:4:0;52362:585;52233:732;;;;;;:::o;56703:101::-;56755:13;56788:8;56781:15;;;;;:::i;3321:723::-;3377:13;3598:10;3594:53;;-1:-1:-1;;3625:10:0;;;;;;;;;;;;;;;;;;3321:723::o;3594:53::-;3672:5;3657:12;3713:78;3720:9;;3713:78;;3746:8;;;;:::i;:::-;;-1:-1:-1;3769:10:0;;-1:-1:-1;3777:2:0;3769:10;;:::i;:::-;;;3713:78;;;3801:19;3833:6;3823:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3823:17:0;;3801:39;;3851:154;3858:10;;3851:154;;3885:11;3895:1;3885:11;;:::i;:::-;;-1:-1:-1;3954:10:0;3962:2;3954:5;:10;:::i;:::-;3941:24;;:2;:24;:::i;:::-;3928:39;;3911:6;3918;3911:14;;;;;;;;:::i;:::-;;;;:56;;;;;;;;;;-1:-1:-1;3982:11:0;3991:2;3982:11;;:::i;:::-;;;3851:154;;46869:1630;47008:20;47031:13;-1:-1:-1;;;;;47031:13:0;-1:-1:-1;;;;;47059:16:0;;47055:48;;47084:19;;-1:-1:-1;;;47084:19:0;;;;;;;;;;;47055:48;47118:13;47114:44;;47140:18;;;;;;;;;;;;;;47114:44;-1:-1:-1;;;;;47435:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;47494:49:0;;47435:44;;;;;;;;47494:49;;;;-1:-1:-1;;47435:44:0;;;;;;47494:49;;;;;;;;;;;;;;;;-1:-1:-1;;;;;47560:25:0;;;;;:11;:25;;;;;:35;;-1:-1:-1;;;;;;47610:66:0;;;;-1:-1:-1;;;47660:15:0;47610:66;;;;;;;;;;;;;;47560:25;;47757:23;;47801:4;:23;;;;-1:-1:-1;;;;;;47809:13:0;;9646:20;9694:8;;47809:15;47797:641;;;47845:314;47876:38;;-1:-1:-1;;;;;47876:38:0;;;-1:-1:-1;;;;;47876:38:0;;;47893:1;;47876:38;;47893:1;;47876:38;47942:69;47981:1;47985:2;47989:14;;;;;;-1:-1:-1;;;;;47942:69:0;48005:5;47942:30;:69::i;:::-;47937:174;;48047:40;;-1:-1:-1;;;48047:40:0;;;;;;;;;;;47937:174;48154:3;48138:12;-1:-1:-1;;;;;48138:19:0;;;47845:314;;48223:13;;-1:-1:-1;;;;;48223:29:0;;;:13;;:29;48219:43;;48254:8;;;48219:43;47797:641;;;48303:120;48334:40;;48359:14;;;;-1:-1:-1;;;;;48334:40:0;;-1:-1:-1;;;;;48334:40:0;;;48351:1;;48334:40;;48351:1;;48334:40;48418:3;48402:12;-1:-1:-1;;;;;48402:19:0;;;48303:120;;47797:641;-1:-1:-1;48452:13:0;:28;;-1:-1:-1;;48452:28:0;-1:-1:-1;;;;;48452:28:0;;;;;;;;;;-1:-1:-1;;;;;46869:1630:0:o;53457:657::-;53633:70;;-1:-1:-1;;;53633:70:0;;53612:4;;-1:-1:-1;;;;;53633:36:0;;;;;:70;;53670:10;;53682:4;;53688:7;;53697:5;;53633:70;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53633:70:0;;;;;;;;-1:-1:-1;;53633:70:0;;;;;;;;;;;;:::i;:::-;;;53629:478;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53865:13:0;;53861:235;;53911:40;;-1:-1:-1;;;53911:40:0;;;;;;;;;;;14:196:1;82:20;;-1:-1:-1;;;;;131:54:1;;121:65;;111:93;;200:1;197;190:12;111:93;14:196;;;:::o;215:367::-;278:8;288:6;342:3;335:4;327:6;323:17;319:27;309:55;;360:1;357;350:12;309:55;-1:-1:-1;383:20:1;;426:18;415:30;;412:50;;;458:1;455;448:12;412:50;495:4;487:6;483:17;471:29;;555:3;548:4;538:6;535:1;531:14;523:6;519:27;515:38;512:47;509:67;;;572:1;569;562:12;509:67;215:367;;;;;:::o;587:186::-;646:6;699:2;687:9;678:7;674:23;670:32;667:52;;;715:1;712;705:12;667:52;738:29;757:9;738:29;:::i;:::-;728:39;587:186;-1:-1:-1;;;587:186:1:o;778:260::-;846:6;854;907:2;895:9;886:7;882:23;878:32;875:52;;;923:1;920;913:12;875:52;946:29;965:9;946:29;:::i;:::-;936:39;;994:38;1028:2;1017:9;1013:18;994:38;:::i;:::-;984:48;;778:260;;;;;:::o;1043:328::-;1120:6;1128;1136;1189:2;1177:9;1168:7;1164:23;1160:32;1157:52;;;1205:1;1202;1195:12;1157:52;1228:29;1247:9;1228:29;:::i;:::-;1218:39;;1276:38;1310:2;1299:9;1295:18;1276:38;:::i;:::-;1266:48;;1361:2;1350:9;1346:18;1333:32;1323:42;;1043:328;;;;;:::o;1376:1138::-;1471:6;1479;1487;1495;1548:3;1536:9;1527:7;1523:23;1519:33;1516:53;;;1565:1;1562;1555:12;1516:53;1588:29;1607:9;1588:29;:::i;:::-;1578:39;;1636:38;1670:2;1659:9;1655:18;1636:38;:::i;:::-;1626:48;;1721:2;1710:9;1706:18;1693:32;1683:42;;1776:2;1765:9;1761:18;1748:32;1799:18;1840:2;1832:6;1829:14;1826:34;;;1856:1;1853;1846:12;1826:34;1894:6;1883:9;1879:22;1869:32;;1939:7;1932:4;1928:2;1924:13;1920:27;1910:55;;1961:1;1958;1951:12;1910:55;1997:2;1984:16;2019:2;2015;2012:10;2009:36;;;2025:18;;:::i;:::-;2100:2;2094:9;2068:2;2154:13;;-1:-1:-1;;2150:22:1;;;2174:2;2146:31;2142:40;2130:53;;;2198:18;;;2218:22;;;2195:46;2192:72;;;2244:18;;:::i;:::-;2284:10;2280:2;2273:22;2319:2;2311:6;2304:18;2359:7;2354:2;2349;2345;2341:11;2337:20;2334:33;2331:53;;;2380:1;2377;2370:12;2331:53;2436:2;2431;2427;2423:11;2418:2;2410:6;2406:15;2393:46;2481:1;2476:2;2471;2463:6;2459:15;2455:24;2448:35;2502:6;2492:16;;;;;;;1376:1138;;;;;;;:::o;2519:347::-;2584:6;2592;2645:2;2633:9;2624:7;2620:23;2616:32;2613:52;;;2661:1;2658;2651:12;2613:52;2684:29;2703:9;2684:29;:::i;:::-;2674:39;;2763:2;2752:9;2748:18;2735:32;2810:5;2803:13;2796:21;2789:5;2786:32;2776:60;;2832:1;2829;2822:12;2776:60;2855:5;2845:15;;;2519:347;;;;;:::o;2871:254::-;2939:6;2947;3000:2;2988:9;2979:7;2975:23;2971:32;2968:52;;;3016:1;3013;3006:12;2968:52;3039:29;3058:9;3039:29;:::i;:::-;3029:39;3115:2;3100:18;;;;3087:32;;-1:-1:-1;;;2871:254:1:o;3130:773::-;3252:6;3260;3268;3276;3329:2;3317:9;3308:7;3304:23;3300:32;3297:52;;;3345:1;3342;3335:12;3297:52;3385:9;3372:23;3414:18;3455:2;3447:6;3444:14;3441:34;;;3471:1;3468;3461:12;3441:34;3510:70;3572:7;3563:6;3552:9;3548:22;3510:70;:::i;:::-;3599:8;;-1:-1:-1;3484:96:1;-1:-1:-1;3687:2:1;3672:18;;3659:32;;-1:-1:-1;3703:16:1;;;3700:36;;;3732:1;3729;3722:12;3700:36;;3771:72;3835:7;3824:8;3813:9;3809:24;3771:72;:::i;:::-;3130:773;;;;-1:-1:-1;3862:8:1;-1:-1:-1;;;;3130:773:1:o;3908:245::-;3966:6;4019:2;4007:9;3998:7;3994:23;3990:32;3987:52;;;4035:1;4032;4025:12;3987:52;4074:9;4061:23;4093:30;4117:5;4093:30;:::i;4158:249::-;4227:6;4280:2;4268:9;4259:7;4255:23;4251:32;4248:52;;;4296:1;4293;4286:12;4248:52;4328:9;4322:16;4347:30;4371:5;4347:30;:::i;4412:180::-;4471:6;4524:2;4512:9;4503:7;4499:23;4495:32;4492:52;;;4540:1;4537;4530:12;4492:52;-1:-1:-1;4563:23:1;;4412:180;-1:-1:-1;4412:180:1:o;4597:257::-;4638:3;4676:5;4670:12;4703:6;4698:3;4691:19;4719:63;4775:6;4768:4;4763:3;4759:14;4752:4;4745:5;4741:16;4719:63;:::i;:::-;4836:2;4815:15;-1:-1:-1;;4811:29:1;4802:39;;;;4843:4;4798:50;;4597:257;-1:-1:-1;;4597:257:1:o;4859:470::-;5038:3;5076:6;5070:13;5092:53;5138:6;5133:3;5126:4;5118:6;5114:17;5092:53;:::i;:::-;5208:13;;5167:16;;;;5230:57;5208:13;5167:16;5264:4;5252:17;;5230:57;:::i;:::-;5303:20;;4859:470;-1:-1:-1;;;;4859:470:1:o;5752:511::-;5946:4;-1:-1:-1;;;;;6056:2:1;6048:6;6044:15;6033:9;6026:34;6108:2;6100:6;6096:15;6091:2;6080:9;6076:18;6069:43;;6148:6;6143:2;6132:9;6128:18;6121:34;6191:3;6186:2;6175:9;6171:18;6164:31;6212:45;6252:3;6241:9;6237:19;6229:6;6212:45;:::i;:::-;6204:53;5752:511;-1:-1:-1;;;;;;5752:511:1:o;6460:219::-;6609:2;6598:9;6591:21;6572:4;6629:44;6669:2;6658:9;6654:18;6646:6;6629:44;:::i;8053:128::-;8093:3;8124:1;8120:6;8117:1;8114:13;8111:39;;;8130:18;;:::i;:::-;-1:-1:-1;8166:9:1;;8053:128::o;8186:120::-;8226:1;8252;8242:35;;8257:18;;:::i;:::-;-1:-1:-1;8291:9:1;;8186:120::o;8311:125::-;8351:4;8379:1;8376;8373:8;8370:34;;;8384:18;;:::i;:::-;-1:-1:-1;8421:9:1;;8311:125::o;8441:258::-;8513:1;8523:113;8537:6;8534:1;8531:13;8523:113;;;8613:11;;;8607:18;8594:11;;;8587:39;8559:2;8552:10;8523:113;;;8654:6;8651:1;8648:13;8645:48;;;-1:-1:-1;;8689:1:1;8671:16;;8664:27;8441:258::o;8704:437::-;8783:1;8779:12;;;;8826;;;8847:61;;8901:4;8893:6;8889:17;8879:27;;8847:61;8954:2;8946:6;8943:14;8923:18;8920:38;8917:218;;;-1:-1:-1;;;8988:1:1;8981:88;9092:4;9089:1;9082:15;9120:4;9117:1;9110:15;8917:218;;8704:437;;;:::o;9146:135::-;9185:3;-1:-1:-1;;9206:17:1;;9203:43;;;9226:18;;:::i;:::-;-1:-1:-1;9273:1:1;9262:13;;9146:135::o;9286:112::-;9318:1;9344;9334:35;;9349:18;;:::i;:::-;-1:-1:-1;9383:9:1;;9286:112::o;9403:184::-;-1:-1:-1;;;9452:1:1;9445:88;9552:4;9549:1;9542:15;9576:4;9573:1;9566:15;9592:184;-1:-1:-1;;;9641:1:1;9634:88;9741:4;9738:1;9731:15;9765:4;9762:1;9755:15;9781:184;-1:-1:-1;;;9830:1:1;9823:88;9930:4;9927:1;9920:15;9954:4;9951:1;9944:15;9970:184;-1:-1:-1;;;10019:1:1;10012:88;10119:4;10116:1;10109:15;10143:4;10140:1;10133:15;10159:177;-1:-1:-1;;;;;;10237:5:1;10233:78;10226:5;10223:89;10213:117;;10326:1;10323;10316:12

Swarm Source

ipfs://39db87f0c9751808f816d83766adaf4084e7a0036ded8cbb96e37f550a0e855b

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