Feature Tip: Add private address tag to any address under My Name Tag !
ERC-721
NFT
Overview
Max Total Supply
10,000 NPS
Holders
1,755
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Balance
4 NPSLoading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Source Code Verified (Exact Match)
Contract Name:
NeoPunksSaga
Compiler Version
v0.8.18+commit.87f61d96
Contract Source Code (Solidity Standard Json-Input format)
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma solidity 0.8.18;//// ███╗ ██╗███████╗ ██████╗ ██████╗ ██╗ ██╗███╗ ██╗██╗ ██╗███████╗███████╗ █████╗ ██████╗ █████╗// ████╗ ██║██╔════╝██╔═══██╗██╔══██╗██║ ██║████╗ ██║██║ ██╔╝██╔════╝██╔════╝██╔══██╗██╔════╝ ██╔══██╗// ██╔██╗ ██║█████╗ ██║ ██║██████╔╝██║ ██║██╔██╗ ██║█████╔╝ ███████╗███████╗███████║██║ ███╗███████║// ██║╚██╗██║██╔══╝ ██║ ██║██╔═══╝ ██║ ██║██║╚██╗██║██╔═██╗ ╚════██║╚════██║██╔══██║██║ ██║██╔══██║// ██║ ╚████║███████╗╚██████╔╝██║ ╚██████╔╝██║ ╚████║██║ ██╗███████║███████║██║ ██║╚██████╔╝██║ ██║// ╚═╝ ╚═══╝╚══════╝ ╚═════╝ ╚═╝ ╚═════╝ ╚═╝ ╚═══╝╚═╝ ╚═╝╚══════╝╚══════╝╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝//// NeoPunksSaga - generated with HeyMint.xyz Launchpad - https://nft-launchpad.heymint.xyz//
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)pragma solidity ^0.8.0;import "../utils/ContextUpgradeable.sol";import "../proxy/utils/Initializable.sol";/*** @dev Contract module which provides a basic access control mechanism, where* there is an account (an owner) that can be granted exclusive access to* specific functions.** By default, the owner account will be the one that deploys the contract. This* can later be changed with {transferOwnership}.** This module is used through inheritance. It will make available the modifier* `onlyOwner`, which can be applied to your functions to restrict their use to* the owner.*/abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {address private _owner;event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);/**
12345678910111213141516171819202122232425// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)pragma solidity ^0.8.0;import "../utils/introspection/IERC165Upgradeable.sol";/*** @dev Interface for the NFT Royalty Standard.** A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal* support for royalty payments across all NFT marketplaces and ecosystem participants.** _Available since v4.5._*/interface IERC2981Upgradeable is IERC165Upgradeable {/*** @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)externalviewreturns (address receiver, uint256 royaltyAmount);}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.1) (proxy/utils/Initializable.sol)pragma solidity ^0.8.2;import "../../utils/AddressUpgradeable.sol";/*** @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.** The initialization functions use a version number. Once a version number is used, it is consumed and cannot be* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in* case an upgrade adds a module that needs to be initialized.** For example:** [.hljs-theme-light.nopadding]* ```* contract MyToken is ERC20Upgradeable {* function initialize() initializer public {* __ERC20_init("MyToken", "MTK");* }* }
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)pragma solidity ^0.8.0;import "../utils/ContextUpgradeable.sol";import "../proxy/utils/Initializable.sol";/*** @dev Contract module which allows children to implement an emergency stop* mechanism that can be triggered by an authorized account.** This module is used through inheritance. It will make available the* modifiers `whenNotPaused` and `whenPaused`, which can be applied to* the functions of your contract. Note that they will not be pausable by* simply including this module, only once the modifiers are put in place.*/abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {/*** @dev Emitted when the pause is triggered by `account`.*/event Paused(address account);/*** @dev Emitted when the pause is lifted by `account`.*/
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)pragma solidity ^0.8.0;import "../proxy/utils/Initializable.sol";/*** @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 ReentrancyGuardUpgradeable is Initializable {// 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
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)pragma solidity ^0.8.1;/*** @dev Collection of functions related to the address type*/library AddressUpgradeable {/*** @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* ====*
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)pragma solidity ^0.8.0;import "../proxy/utils/Initializable.sol";/*** @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 ContextUpgradeable is Initializable {function __Context_init() internal onlyInitializing {}function __Context_init_unchained() internal onlyInitializing {}function _msgSender() internal view virtual returns (address) {return msg.sender;}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)pragma solidity ^0.8.0;import "../StringsUpgradeable.sol";/*** @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.** These functions can be used to verify that a message was signed by the holder* of the private keys of a given address.*/library ECDSAUpgradeable {enum RecoverError {NoError,InvalidSignature,InvalidSignatureLength,InvalidSignatureS,InvalidSignatureV // Deprecated in v4.8}function _throwError(RecoverError error) private pure {if (error == RecoverError.NoError) {return; // no error: do nothing} else if (error == RecoverError.InvalidSignature) {
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol)pragma solidity ^0.8.0;/*** @dev These functions deal with verification of Merkle Tree proofs.** The tree and the proofs can be generated using our* https://github.com/OpenZeppelin/merkle-tree[JavaScript library].* You will find a quickstart guide in the readme.** WARNING: You should avoid using leaf values that are 64 bytes long prior to* hashing, or use a hash function other than keccak256 for hashing leaves.* This is because the concatenation of a sorted pair of internal nodes in* the merkle tree could be reinterpreted as a leaf value.* OpenZeppelin's JavaScript library generates merkle trees that are safe* against this attack out of the box.*/library MerkleProofUpgradeable {/*** @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree* defined by `root`. For this, a `proof` must be provided, containing* sibling hashes on the branch from the leaf to the root of the tree. Each* pair of leaves and each pair of pre-images are assumed to be sorted.*/
12345678910111213141516171819202122232425// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)pragma solidity ^0.8.0;/*** @dev Interface of the ERC165 standard, as defined in the* https://eips.ethereum.org/EIPS/eip-165[EIP].** Implementers can declare support of contract interfaces, which can then be* queried by others ({ERC165Checker}).** For an implementation, see {ERC165}.*/interface IERC165Upgradeable {/*** @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);}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)pragma solidity ^0.8.0;/*** @dev Standard math utilities missing in the Solidity language.*/library MathUpgradeable {enum Rounding {Down, // Toward negative infinityUp, // Toward infinityZero // Toward zero}/*** @dev Returns the largest of two numbers.*/function max(uint256 a, uint256 b) internal pure returns (uint256) {return a > b ? a : b;}/*** @dev Returns the smallest of two numbers.*/function min(uint256 a, uint256 b) internal pure returns (uint256) {
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)pragma solidity ^0.8.0;import "./math/MathUpgradeable.sol";/*** @dev String operations.*/library StringsUpgradeable {bytes16 private constant _SYMBOLS = "0123456789abcdef";uint8 private constant _ADDRESS_LENGTH = 20;/*** @dev Converts a `uint256` to its ASCII `string` decimal representation.*/function toString(uint256 value) internal pure returns (string memory) {unchecked {uint256 length = MathUpgradeable.log10(value) + 1;string memory buffer = new string(length);uint256 ptr;/// @solidity memory-safe-assemblyassembly {ptr := add(buffer, add(32, length))}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)pragma solidity ^0.8.0;import "../utils/Context.sol";/*** @dev Contract module which provides a basic access control mechanism, where* there is an account (an owner) that can be granted exclusive access to* specific functions.** By default, the owner account will be the one that deploys the contract. This* can later be changed with {transferOwnership}.** This module is used through inheritance. It will make available the modifier* `onlyOwner`, which can be applied to your functions to restrict their use to* the owner.*/abstract contract Ownable is Context {address private _owner;event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);/*** @dev Initializes the contract setting the deployer as the initial owner.
12345678910111213141516171819202122232425// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)pragma solidity ^0.8.0;import "../utils/introspection/IERC165.sol";/*** @dev Interface for the NFT Royalty Standard.** A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal* support for royalty payments across all NFT marketplaces and ecosystem participants.** _Available since v4.5._*/interface IERC2981 is IERC165 {/*** @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of* exchange. The royalty amount is denominated and should be paid in that same unit of exchange.*/function royaltyInfo(uint256 tokenId, uint256 salePrice)externalviewreturns (address receiver, uint256 royaltyAmount);}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)pragma solidity ^0.8.0;import "../utils/Context.sol";/*** @dev Contract module which allows children to implement an emergency stop* mechanism that can be triggered by an authorized account.** This module is used through inheritance. It will make available the* modifiers `whenNotPaused` and `whenPaused`, which can be applied to* the functions of your contract. Note that they will not be pausable by* simply including this module, only once the modifiers are put in place.*/abstract contract Pausable is Context {/*** @dev Emitted when the pause is triggered by `account`.*/event Paused(address account);/*** @dev Emitted when the pause is lifted by `account`.*/event Unpaused(address account);
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)pragma solidity ^0.8.0;/*** @dev Contract module that helps prevent reentrant calls to a function.** Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier* available, which can be applied to functions to make sure there are no nested* (reentrant) calls to them.** Note that because there is a single `nonReentrant` guard, functions marked as* `nonReentrant` may not call one another. This can be worked around by making* those functions `private`, and then adding `external` `nonReentrant` entry* points to them.** TIP: If you would like to learn more about reentrancy and alternative ways* to protect against it, check out our blog post* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].*/abstract contract ReentrancyGuard {// Booleans are more expensive than uint256 or any type that takes up a full// word because each write operation emits an extra SLOAD to first read the// slot's contents, replace the bits taken up by the boolean, and then write// back. This is the compiler's defense against contract upgrades and
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.7.0) (token/common/ERC2981.sol)pragma solidity ^0.8.0;import "../../interfaces/IERC2981.sol";import "../../utils/introspection/ERC165.sol";/*** @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;
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC1155/ERC1155.sol)pragma solidity ^0.8.0;import "./IERC1155.sol";import "./IERC1155Receiver.sol";import "./extensions/IERC1155MetadataURI.sol";import "../../utils/Address.sol";import "../../utils/Context.sol";import "../../utils/introspection/ERC165.sol";/*** @dev Implementation of the basic standard multi-token.* See https://eips.ethereum.org/EIPS/eip-1155* Originally based on code by Enjin: https://github.com/enjin/erc-1155** _Available since v3.1._*/contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {using Address for address;// Mapping from token ID to account balancesmapping(uint256 => mapping(address => uint256)) private _balances;// Mapping from account to operator approvals
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC1155/extensions/ERC1155Supply.sol)pragma solidity ^0.8.0;import "../ERC1155.sol";/*** @dev Extension of ERC1155 that adds tracking of total supply per id.** Useful for scenarios where Fungible and Non-fungible tokens have to be* clearly identified. Note: While a totalSupply of 1 might mean the* corresponding is an NFT, there is no guarantees that no other token with the* same id are not going to be minted.*/abstract contract ERC1155Supply is ERC1155 {mapping(uint256 => uint256) private _totalSupply;/*** @dev Total amount of tokens in with a given id.*/function totalSupply(uint256 id) public view virtual returns (uint256) {return _totalSupply[id];}/**
12345678910111213141516171819202122// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)pragma solidity ^0.8.0;import "../IERC1155.sol";/*** @dev Interface of the optional ERC1155MetadataExtension interface, as defined* in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].** _Available since v3.1._*/interface IERC1155MetadataURI is IERC1155 {/*** @dev Returns the URI for token type `id`.** If the `\{id\}` substring is present in the URI, it must be replaced by* clients with the actual token type ID.*/function uri(uint256 id) external view returns (string memory);}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol)pragma solidity ^0.8.0;import "../../utils/introspection/IERC165.sol";/*** @dev Required interface of an ERC1155 compliant contract, as defined in the* https://eips.ethereum.org/EIPS/eip-1155[EIP].** _Available since v3.1._*/interface IERC1155 is IERC165 {/*** @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.*/event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);/*** @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all* transfers.*/event TransferBatch(address indexed operator,address indexed from,
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)pragma solidity ^0.8.0;import "../../utils/introspection/IERC165.sol";/*** @dev _Available since v3.1._*/interface IERC1155Receiver is IERC165 {/*** @dev Handles the receipt of a single ERC1155 token type. This function is* called at the end of a `safeTransferFrom` after the balance has been updated.** NOTE: To accept the transfer, this must return* `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`* (i.e. 0xf23a6e61, or its own function selector).** @param operator The address which initiated the transfer (i.e. msg.sender)* @param from The address which previously owned the token* @param id The ID of the token being transferred* @param value The amount of tokens being transferred* @param data Additional data with no specified format* @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed*/
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.2) (token/ERC721/ERC721.sol)pragma solidity ^0.8.0;import "./IERC721.sol";import "./IERC721Receiver.sol";import "./extensions/IERC721Metadata.sol";import "../../utils/Address.sol";import "../../utils/Context.sol";import "../../utils/Strings.sol";import "../../utils/introspection/ERC165.sol";/*** @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including* the Metadata extension, but not including the Enumerable extension, which is available separately as* {ERC721Enumerable}.*/contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {using Address for address;using Strings for uint256;// Token namestring private _name;// Token symbol
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Enumerable.sol)pragma solidity ^0.8.0;import "../ERC721.sol";import "./IERC721Enumerable.sol";/*** @dev This implements an optional extension of {ERC721} defined in the EIP that adds* enumerability of all the token ids in the contract as well as all token ids owned by each* account.*/abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {// Mapping from owner to list of owned token IDsmapping(address => mapping(uint256 => uint256)) private _ownedTokens;// Mapping from token ID to index of the owner tokens listmapping(uint256 => uint256) private _ownedTokensIndex;// Array with all token ids, used for enumerationuint256[] private _allTokens;// Mapping from token id to position in the allTokens arraymapping(uint256 => uint256) private _allTokensIndex;
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)pragma solidity ^0.8.0;import "../IERC721.sol";/*** @title ERC-721 Non-Fungible Token Standard, optional enumeration extension* @dev See https://eips.ethereum.org/EIPS/eip-721*/interface IERC721Enumerable is IERC721 {/*** @dev Returns the total amount of tokens stored by the contract.*/function totalSupply() external view returns (uint256);/*** @dev Returns a token ID owned by `owner` at a given `index` of its token list.* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.*/function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);/*** @dev Returns a token ID at a given `index` of all the tokens stored by the contract.* Use along with {totalSupply} to enumerate all tokens.
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)pragma solidity ^0.8.0;import "../IERC721.sol";/*** @title ERC-721 Non-Fungible Token Standard, optional metadata extension* @dev See https://eips.ethereum.org/EIPS/eip-721*/interface IERC721Metadata is IERC721 {/*** @dev Returns the token collection name.*/function name() external view returns (string memory);/*** @dev Returns the token collection symbol.*/function symbol() external view returns (string memory);/*** @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.*/function tokenURI(uint256 tokenId) external view returns (string memory);
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)pragma solidity ^0.8.0;import "../../utils/introspection/IERC165.sol";/*** @dev Required interface of an ERC721 compliant contract.*/interface IERC721 is IERC165 {/*** @dev Emitted when `tokenId` token is transferred from `from` to `to`.*/event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);/*** @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.*/event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);/*** @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.*/event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)pragma solidity ^0.8.0;/*** @title ERC721 token receiver interface* @dev Interface for any contract that wants to support safeTransfers* from ERC721 asset contracts.*/interface IERC721Receiver {/*** @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}* by `operator` from `from`, this function is called.** It must return its Solidity selector to confirm the token transfer.* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.** The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.*/function onERC721Received(address operator,address from,uint256 tokenId,bytes calldata data) external returns (bytes4);
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)pragma solidity ^0.8.1;/*** @dev Collection of functions related to the address type*/library Address {/*** @dev Returns true if `account` is a contract.** [IMPORTANT]* ====* It is unsafe to assume that an address for which this function returns* false is an externally-owned account (EOA) and not a contract.** Among others, `isContract` will return false for the following* types of addresses:** - an externally-owned account* - a contract in construction* - an address where a contract will be created* - an address where a contract lived, but was destroyed* ====*
123456789101112131415161718192021222324// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)pragma solidity ^0.8.0;/*** @dev Provides information about the current execution context, including the* sender of the transaction and its data. While these are generally available* via msg.sender and msg.data, they should not be accessed in such a direct* manner, since when dealing with meta-transactions the account sending and* paying for execution may not be the actual sender (as far as an application* is concerned).** This contract is only required for intermediate, library-like contracts.*/abstract contract Context {function _msgSender() internal view virtual returns (address) {return msg.sender;}function _msgData() internal view virtual returns (bytes calldata) {return msg.data;}}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)pragma solidity ^0.8.0;/*** @title Counters* @author Matt Condon (@shrugs)* @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number* of elements in a mapping, issuing ERC721 ids, or counting request ids.** Include with `using Counters for Counters.Counter;`*/library Counters {struct Counter {// This variable should never be directly accessed by users of the library: interactions must be restricted to// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add// this feature: see https://github.com/ethereum/solidity/issues/4637uint256 _value; // default: 0}function current(Counter storage counter) internal view returns (uint256) {return counter._value;}function increment(Counter storage counter) internal {
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)pragma solidity ^0.8.0;import "../Strings.sol";/*** @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.** These functions can be used to verify that a message was signed by the holder* of the private keys of a given address.*/library ECDSA {enum RecoverError {NoError,InvalidSignature,InvalidSignatureLength,InvalidSignatureS,InvalidSignatureV // Deprecated in v4.8}function _throwError(RecoverError error) private pure {if (error == RecoverError.NoError) {return; // no error: do nothing} else if (error == RecoverError.InvalidSignature) {
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)pragma solidity ^0.8.0;import "./IERC165.sol";/*** @dev Implementation of the {IERC165} interface.** Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check* for the additional interface id that will be supported. For example:** ```solidity* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);* }* ```** Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.*/abstract contract ERC165 is IERC165 {/*** @dev See {IERC165-supportsInterface}.*/function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
12345678910111213141516171819202122232425// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)pragma solidity ^0.8.0;/*** @dev Interface of the ERC165 standard, as defined in the* https://eips.ethereum.org/EIPS/eip-165[EIP].** Implementers can declare support of contract interfaces, which can then be* queried by others ({ERC165Checker}).** For an implementation, see {ERC165}.*/interface IERC165 {/*** @dev Returns true if this contract implements the interface defined by* `interfaceId`. See the corresponding* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]* to learn more about how these ids are created.** This function call must use less than 30 000 gas.*/function supportsInterface(bytes4 interfaceId) external view returns (bool);}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)pragma solidity ^0.8.0;/*** @dev Standard math utilities missing in the Solidity language.*/library Math {enum Rounding {Down, // Toward negative infinityUp, // Toward infinityZero // Toward zero}/*** @dev Returns the largest of two numbers.*/function max(uint256 a, uint256 b) internal pure returns (uint256) {return a > b ? a : b;}/*** @dev Returns the smallest of two numbers.*/function min(uint256 a, uint256 b) internal pure returns (uint256) {
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)pragma solidity ^0.8.0;/*** @dev Library for reading and writing primitive types to specific storage slots.** Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.* This library helps with reading and writing to such slots without the need for inline assembly.** The functions in this library return Slot structs that contain a `value` member that can be used to read or write.** Example usage to set ERC1967 implementation slot:* ```* contract ERC1967 {* bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;** function _getImplementation() internal view returns (address) {* return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;* }** function _setImplementation(address newImplementation) internal {* require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");* StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;* }
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)pragma solidity ^0.8.0;import "./math/Math.sol";/*** @dev String operations.*/library Strings {bytes16 private constant _SYMBOLS = "0123456789abcdef";uint8 private constant _ADDRESS_LENGTH = 20;/*** @dev Converts a `uint256` to its ASCII `string` decimal representation.*/function toString(uint256 value) internal pure returns (string memory) {unchecked {uint256 length = Math.log10(value) + 1;string memory buffer = new string(length);uint256 ptr;/// @solidity memory-safe-assemblyassembly {ptr := add(buffer, add(32, length))}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma solidity 0.8.18;import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";import {IAddressRelay, Implementation} from "./interfaces/IAddressRelay.sol";import {IERC165} from "./interfaces/IERC165.sol";import {IERC173} from "./interfaces/IERC173.sol";/*** @author Created by HeyMint Launchpad https://join.heymint.xyz* @notice This contract contains the base logic for ERC-721A tokens deployed with HeyMint*/contract AddressRelay is IAddressRelay, Ownable {mapping(bytes4 => address) public selectorToImplAddress;mapping(bytes4 => bool) public supportedInterfaces;bytes4[] selectors;address[] implAddresses;address public fallbackImplAddress;bool public relayFrozen;constructor() {supportedInterfaces[0x01ffc9a7] = true; // IERC165supportedInterfaces[0x7f5828d0] = true; // IERC173supportedInterfaces[0x80ac58cd] = true; // IERC721supportedInterfaces[0x5b5e139f] = true; // IERC721MetadatasupportedInterfaces[0x2a55205a] = true; // IERC2981
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma solidity 0.8.18;import {HeyMintERC721AUpgradeable} from "./HeyMintERC721AUpgradeable.sol";import {BaseConfig, HeyMintStorage} from "../libraries/HeyMintStorage.sol";import {ERC721AUpgradeable, IERC721AUpgradeable} from "erc721a-upgradeable/contracts/ERC721AUpgradeable.sol";import {ECDSAUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol";import {IERC2981Upgradeable, IERC165Upgradeable} from "@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";contract HeyMintERC721ABase is HeyMintERC721AUpgradeable, IERC2981Upgradeable {using HeyMintStorage for HeyMintStorage.State;using ECDSAUpgradeable for bytes32;// Default subscription address to use to enable royalty enforcement on certain exchanges like OpenSeaaddress public constant CORI_SUBSCRIPTION_ADDRESS =0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6;// Default subscription address to use as a placeholder for no royalty enforcementaddress public constant EMPTY_SUBSCRIPTION_ADDRESS =0x511af84166215d528ABf8bA6437ec4BEcF31934B;/*** @notice Initializes a new child deposit contract* @param _name The name of the token* @param _symbol The symbol of the token* @param _config Base configuration settings
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma solidity 0.8.18;import {HeyMintERC721AUpgradeable} from "./HeyMintERC721AUpgradeable.sol";import {BaseConfig, AdvancedConfig, BurnToken, HeyMintStorage} from "../libraries/HeyMintStorage.sol";contract HeyMintERC721AExtensionA is HeyMintERC721AUpgradeable {using HeyMintStorage for HeyMintStorage.State;event Stake(uint256 indexed tokenId);event Unstake(uint256 indexed tokenId);event Loan(address from, address to, uint256 tokenId);event LoanRetrieved(address from, address to, uint256 tokenId);// ============ BASE FUNCTIONALITY ============/*** @notice Returns all storage variables for the contract*/function getSettings()externalviewreturns (BaseConfig memory,AdvancedConfig memory,BurnToken[] memory,
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma solidity 0.8.18;import {HeyMintERC721AUpgradeable} from "./HeyMintERC721AUpgradeable.sol";import {HeyMintStorage, BaseConfig, BurnToken} from "../libraries/HeyMintStorage.sol";import {ECDSAUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol";import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";contract HeyMintERC721AExtensionB is HeyMintERC721AUpgradeable {using HeyMintStorage for HeyMintStorage.State;using ECDSAUpgradeable for bytes32;// Address where burnt tokens are sent.address public constant burnAddress =0x000000000000000000000000000000000000dEaD;// ============ PRESALE ============/*** @notice Returns the presale price in wei. Presale price is stored with 5 decimals (1 = 0.00001 ETH), so total 5 + 13 == 18 decimals*/function presalePriceInWei() public view returns (uint256) {return uint256(HeyMintStorage.state().cfg.presalePrice) * 10 ** 13;}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma solidity 0.8.18;import {HeyMintERC721AUpgradeable} from "./HeyMintERC721AUpgradeable.sol";import {AdvancedConfig, Data, BaseConfig, HeyMintStorage} from "../libraries/HeyMintStorage.sol";import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";contract HeyMintERC721AExtensionC is HeyMintERC721AUpgradeable {using HeyMintStorage for HeyMintStorage.State;event Stake(uint256 indexed tokenId);event Unstake(uint256 indexed tokenId);// ============ BASE FUNCTIONALITY ============/*** @notice Update the specific token URI for a set of tokens* @param _tokenIds The token IDs to update* @param _newURIs The new URIs to use*/function setTokenURIs(uint256[] calldata _tokenIds,string[] calldata _newURIs) external onlyOwner {require(!HeyMintStorage.state().advCfg.metadataFrozen, "NOT_ACTIVE");uint256 tokenIdsLength = _tokenIds.length;
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma solidity 0.8.18;import {HeyMintERC721AUpgradeable} from "./HeyMintERC721AUpgradeable.sol";import {AdvancedConfig, HeyMintStorage} from "../libraries/HeyMintStorage.sol";import {MerkleProofUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/cryptography/MerkleProofUpgradeable.sol";import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";contract HeyMintERC721AExtensionD is HeyMintERC721AUpgradeable {using HeyMintStorage for HeyMintStorage.State;event Loan(address from, address to, uint256 tokenId);event LoanRetrieved(address from, address to, uint256 tokenId);// Address of the HeyMint admin addressaddress public constant heymintAdminAddress =0x52EA5F96f004d174470901Ba3F1984D349f0D3eF;// Address where burnt tokens are sent.address public constant burnAddress =0x000000000000000000000000000000000000dEaD;// ============ HEYMINT FEE ============/*** @notice Allows the heymintAdminAddress to set the heymint fee per token* @param _heymintFeePerToken The new fee per token in wei
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma solidity 0.8.18;/*** @title HeyMint ERC721A Function Reference* @author HeyMint Launchpad (https://join.heymint.xyz)* @notice This is a function reference contract for Etherscan reference purposes only.* This contract includes all the functions from multiple implementation contracts.*/contract HeyMintERC721AReference {struct BaseConfig {bool publicSaleActive;bool usePublicSaleTimes;bool presaleActive;bool usePresaleTimes;bool soulbindingActive;bool randomHashActive;bool enforceRoyalties;bool heyMintFeeActive;uint8 publicMintsAllowedPerAddress;uint8 presaleMintsAllowedPerAddress;uint8 publicMintsAllowedPerTransaction;uint8 presaleMintsAllowedPerTransaction;uint16 maxSupply;uint16 presaleMaxSupply;uint16 royaltyBps;
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma solidity 0.8.18;import {Data, HeyMintStorage} from "../libraries/HeyMintStorage.sol";import {ERC721AUpgradeable, IERC721AUpgradeable, ERC721AStorage} from "erc721a-upgradeable/contracts/ERC721AUpgradeable.sol";import {ERC4907AUpgradeable} from "erc721a-upgradeable/contracts/extensions/ERC4907AUpgradeable.sol";import {ERC721AQueryableUpgradeable} from "erc721a-upgradeable/contracts/extensions/ERC721AQueryableUpgradeable.sol";import {IERC2981Upgradeable, IERC165Upgradeable} from "@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";import {PausableUpgradeable} from "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";import {RevokableOperatorFiltererUpgradeable} from "operator-filter-registry/src/upgradeable/RevokableOperatorFiltererUpgradeable.sol";/*** @title HeyMintERC721AUpgradeable* @author HeyMint Launchpad (https://join.heymint.xyz)* @notice This contract contains shared logic to be inherited by all implementation contracts*/contract HeyMintERC721AUpgradeable isERC4907AUpgradeable,ERC721AQueryableUpgradeable,OwnableUpgradeable,PausableUpgradeable,ReentrancyGuardUpgradeable,RevokableOperatorFiltererUpgradeable{
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma solidity ^0.8.18;struct Implementation {address implAddress;bytes4[] selectors;}interface IAddressRelay {/*** @notice Returns the fallback implementation address*/function fallbackImplAddress() external returns (address);/*** @notice Adds or updates selectors and their implementation addresses* @param _selectors The selectors to add or update* @param _implAddress The implementation address the selectors will point to*/function addOrUpdateSelectors(bytes4[] memory _selectors,address _implAddress) external;/*** @notice Removes selectors
123456789101112// SPDX-License-Identifier: MITpragma solidity ^0.8.18;interface IERC165 {/// @notice Query if a contract implements an interface/// @param interfaceId The interface identifier, as specified in ERC-165/// @dev Interface identification is specified in ERC-165. This function/// uses less than 30,000 gas./// @return `true` if the contract implements `interfaceID` and/// `interfaceID` is not 0xffffffff, `false` otherwisefunction supportsInterface(bytes4 interfaceId) external view returns (bool);}
12345678910111213141516171819202122// SPDX-License-Identifier: MITpragma solidity ^0.8.18;/// @title ERC-173 Contract Ownership Standard/// Note: the ERC-165 identifier for this interface is 0x7f5828d0/* is ERC165 */interface IERC173 {/// @dev This emits when ownership of a contract changes.event OwnershipTransferred(address indexed previousOwner,address indexed newOwner);/// @notice Get the address of the owner/// @return owner_ The address of the owner.function owner() external view returns (address owner_);/// @notice Set the address of the new owner of the contract/// @dev Set _newOwner to address(0) to renounce any ownership./// @param _newOwner The address of the new owner of the contractfunction transferOwnership(address _newOwner) external;}
123456789101112// SPDX-License-Identifier: MITpragma solidity ^0.8.18;interface IExchangeOperatorAddressList {/*** @notice Returns an integer representing the exchange a given operator address belongs to (0 if none)* @param _operatorAddress The operator address to map to an exchange*/function operatorAddressToExchange(address _operatorAddress) external view returns (uint256);}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma solidity 0.8.18;struct BaseConfig {// If true tokens can be minted in the public salebool publicSaleActive;// If enabled, automatic start and stop times for the public sale will be enforced, otherwise ignoredbool usePublicSaleTimes;// If true tokens can be minted in the presalebool presaleActive;// If enabled, automatic start and stop times for the presale will be enforced, otherwise ignoredbool usePresaleTimes;// If true, all tokens will be soulboundbool soulbindingActive;// If true, a random hash will be generated for each tokenbool randomHashActive;// If true, the default CORI subscription address will be used to enforce royalties with the Operator Filter Registrybool enforceRoyalties;// If true, HeyMint fees will be charged for minting tokensbool heyMintFeeActive;// The number of tokens that can be minted in the public sale per addressuint8 publicMintsAllowedPerAddress;// The number of tokens that can be minted in the presale per addressuint8 presaleMintsAllowedPerAddress;// The number of tokens that can be minted in the public sale per transactionuint8 publicMintsAllowedPerTransaction;
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma solidity ^0.8.17;import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";import "@openzeppelin/contracts/access/Ownable.sol";import "@openzeppelin/contracts/security/Pausable.sol";import "@openzeppelin/contracts/security/ReentrancyGuard.sol";import "@openzeppelin/contracts/token/common/ERC2981.sol";/*** @author Created with HeyMint Launchpad https://launchpad.heymint.xyz* @notice This contract handles minting Verification test tokens.*/contract EnumerableERC1155 isERC1155Supply,Ownable,Pausable,ReentrancyGuard,ERC2981{using ECDSA for bytes32;// Used to validate authorized presale mint addressesaddress private presaleSignerAddress =0x0fE6E0D15E6F775138Ab556dE54B96d5C1358F3D;
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma solidity 0.8.18;import {ERC721Enumerable, ERC721} from "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";import {Counters} from "@openzeppelin/contracts/utils/Counters.sol";/*** @title Basic Enumerable ERC721 Contract* @author Ben Yu* @notice An ERC721Enumerable contract with basic functionality*/contract EnumerableERC721 is ERC721Enumerable, Ownable {using Counters for Counters.Counter;Counters.Counter private supplyCounter;uint256 public constant PRICE = 0.01 ether;uint256 public constant MAX_SUPPLY = 1000;string public baseTokenURI ="ipfs://bafybeih5lgrstt7kredzhpcvmft2qefue5pl3ykrdktadw5w62zd7cbkja/";bool public publicSaleActive;/*** @notice Initialize the contract*/
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma solidity ^0.8.0;/*** @dev This is a base contract to aid in writing upgradeable diamond facet contracts, or any kind of contract that will be deployed* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.** TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.** CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.*/import {ERC721A__InitializableStorage} from './ERC721A__InitializableStorage.sol';abstract contract ERC721A__Initializable {using ERC721A__InitializableStorage for ERC721A__InitializableStorage.Layout;/*** @dev Modifier to protect an initializer function from being invoked twice.*/modifier initializerERC721A() {// If the contract is initializing we ignore whether _initialized is set in order to support multiple
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma solidity ^0.8.0;/*** @dev This is a base storage for the initialization function for upgradeable diamond facet contracts**/library ERC721A__InitializableStorage {struct Layout {/** Indicates that the contract has been initialized.*/bool _initialized;/** Indicates that the contract is in the process of being initialized.*/bool _initializing;}bytes32 internal constant STORAGE_SLOT = keccak256('ERC721A.contracts.storage.initializable.facet');function layout() internal pure returns (Layout storage l) {bytes32 slot = STORAGE_SLOT;assembly {l.slot := slot
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma solidity ^0.8.0;library ERC721AStorage {// Bypass for a `--via-ir` bug (https://github.com/chiru-labs/ERC721A/pull/364).struct TokenApprovalRef {address value;}struct Layout {// =============================================================// STORAGE// =============================================================// The next token ID to be minted.uint256 _currentIndex;// The number of tokens burned.uint256 _burnCounter;// Token namestring _name;// Token symbolstring _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.
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// ERC721A Contracts v4.2.3// Creator: Chiru Labspragma solidity ^0.8.4;import './IERC721AUpgradeable.sol';import {ERC721AStorage} from './ERC721AStorage.sol';import './ERC721A__Initializable.sol';/*** @dev Interface of ERC721 token receiver.*/interface ERC721A__IERC721ReceiverUpgradeable {function onERC721Received(address operator,address from,uint256 tokenId,bytes calldata data) external returns (bytes4);}/*** @title ERC721A** @dev Implementation of the [ERC721](https://eips.ethereum.org/EIPS/eip-721)
12345678910111213141516171819202122232425// SPDX-License-Identifier: MITpragma solidity ^0.8.0;import {ERC4907AUpgradeable} from './ERC4907AUpgradeable.sol';library ERC4907AStorage {struct Layout {// Mapping from token ID to user info.//// Bits Layout:// - [0..159] `user`// - [160..223] `expires`mapping(uint256 => uint256) _packedUserInfo;}bytes32 internal constant STORAGE_SLOT = keccak256('ERC721A.contracts.storage.ERC4907A');function layout() internal pure returns (Layout storage l) {bytes32 slot = STORAGE_SLOT;assembly {l.slot := slot}}}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// ERC721A Contracts v4.2.3// Creator: Chiru Labspragma solidity ^0.8.4;import './IERC4907AUpgradeable.sol';import '../ERC721AUpgradeable.sol';import {ERC4907AStorage} from './ERC4907AStorage.sol';import '../ERC721A__Initializable.sol';/*** @title ERC4907A** @dev [ERC4907](https://eips.ethereum.org/EIPS/eip-4907) compliant* extension of ERC721A, which allows owners and authorized addresses* to add a time-limited role with restricted permissions to ERC721 tokens.*/abstract contract ERC4907AUpgradeable is ERC721A__Initializable, ERC721AUpgradeable, IERC4907AUpgradeable {using ERC4907AStorage for ERC4907AStorage.Layout;function __ERC4907A_init() internal onlyInitializingERC721A {__ERC4907A_init_unchained();}function __ERC4907A_init_unchained() internal onlyInitializingERC721A {}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// ERC721A Contracts v4.2.3// Creator: Chiru Labspragma solidity ^0.8.4;import './IERC721AQueryableUpgradeable.sol';import '../ERC721AUpgradeable.sol';import '../ERC721A__Initializable.sol';/*** @title ERC721AQueryable.** @dev ERC721A subclass with convenience query functions.*/abstract contract ERC721AQueryableUpgradeable isERC721A__Initializable,ERC721AUpgradeable,IERC721AQueryableUpgradeable{function __ERC721AQueryable_init() internal onlyInitializingERC721A {__ERC721AQueryable_init_unchained();}function __ERC721AQueryable_init_unchained() internal onlyInitializingERC721A {}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// ERC721A Contracts v4.2.3// Creator: Chiru Labspragma solidity ^0.8.4;import '../IERC721AUpgradeable.sol';/*** @dev Interface of ERC4907A.*/interface IERC4907AUpgradeable is IERC721AUpgradeable {/*** The caller must own the token or be an approved operator.*/error SetUserCallerNotOwnerNorApproved();/*** @dev Emitted when the `user` of an NFT or the `expires` of the `user` is changed.* The zero address for user indicates that there is no user address.*/event UpdateUser(uint256 indexed tokenId, address indexed user, uint64 expires);/*** @dev Sets the `user` and `expires` for `tokenId`.* The zero address indicates there is no user.
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// ERC721A Contracts v4.2.3// Creator: Chiru Labspragma solidity ^0.8.4;import '../IERC721AUpgradeable.sol';/*** @dev Interface of ERC721AQueryable.*/interface IERC721AQueryableUpgradeable is IERC721AUpgradeable {/*** Invalid query range (`start` >= `stop`).*/error InvalidQueryRange();/*** @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.** If the `tokenId` is out of bounds:** - `addr = address(0)`* - `startTimestamp = 0`* - `burned = false`* - `extraData = 0`
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// ERC721A Contracts v4.2.3// Creator: Chiru Labspragma solidity ^0.8.4;/*** @dev Interface of ERC721A.*/interface IERC721AUpgradeable {/*** The caller must own the token or be an approved operator.*/error ApprovalCallerNotOwnerNorApproved();/*** The token does not exist.*/error ApprovalQueryForNonexistentToken();/*** Cannot query the balance for the zero address.*/error BalanceQueryForZeroAddress();/**
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma 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;
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma solidity ^0.8.13;import {IOperatorFilterRegistry} from "../IOperatorFilterRegistry.sol";import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";/*** @title OperatorFiltererUpgradeable* @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another* registrant's entries in the OperatorFilterRegistry when the init function is called.* @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 OperatorFiltererUpgradeable is Initializable {/// @notice Emitted when an operator is not allowed.error OperatorNotAllowed(address operator);IOperatorFilterRegistry constant OPERATOR_FILTER_REGISTRY =IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);/// @dev The upgradeable initialize function that should be called when the contract is being upgraded.function __OperatorFilterer_init(address subscriptionOrRegistrantToCopy, bool subscribe)internalonlyInitializing{
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MITpragma solidity ^0.8.13;import {OperatorFiltererUpgradeable} from "./OperatorFiltererUpgradeable.sol";/*** @title Upgradeable storage layout for RevokableOperatorFiltererUpgradeable.* @notice Upgradeable contracts must use a storage layout that can be used across upgrades.* Only append new variables to the end of the layout.*/library RevokableOperatorFiltererUpgradeableStorage {struct Layout {/// @dev Whether the OperatorFilterRegistry has been revoked.bool _isOperatorFilterRegistryRevoked;}/// @dev The storage slot for the layout.bytes32 internal constant STORAGE_SLOT = keccak256("RevokableOperatorFiltererUpgradeable.contracts.storage");/// @dev The layout of the storage.function layout() internal pure returns (Layout storage l) {bytes32 slot = STORAGE_SLOT;assembly {l.slot := slot}}
123456789101112131415161718{"optimizer": {"enabled": true,"runs": 10000},"outputSelection": {"*": {"*": ["evm.bytecode","evm.deployedBytecode","devdoc","userdoc","metadata","abi"]}}}
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"_addressRelay","type":"address"},{"internalType":"address","name":"_implementation","type":"address"},{"components":[{"internalType":"bool","name":"publicSaleActive","type":"bool"},{"internalType":"bool","name":"usePublicSaleTimes","type":"bool"},{"internalType":"bool","name":"presaleActive","type":"bool"},{"internalType":"bool","name":"usePresaleTimes","type":"bool"},{"internalType":"bool","name":"soulbindingActive","type":"bool"},{"internalType":"bool","name":"randomHashActive","type":"bool"},{"internalType":"bool","name":"enforceRoyalties","type":"bool"},{"internalType":"bool","name":"heyMintFeeActive","type":"bool"},{"internalType":"uint8","name":"publicMintsAllowedPerAddress","type":"uint8"},{"internalType":"uint8","name":"presaleMintsAllowedPerAddress","type":"uint8"},{"internalType":"uint8","name":"publicMintsAllowedPerTransaction","type":"uint8"},{"internalType":"uint8","name":"presaleMintsAllowedPerTransaction","type":"uint8"},{"internalType":"uint16","name":"maxSupply","type":"uint16"},{"internalType":"uint16","name":"presaleMaxSupply","type":"uint16"},{"internalType":"uint16","name":"royaltyBps","type":"uint16"},{"internalType":"uint32","name":"publicPrice","type":"uint32"},{"internalType":"uint32","name":"presalePrice","type":"uint32"},{"internalType":"uint24","name":"projectId","type":"uint24"},{"internalType":"string","name":"uriBase","type":"string"},{"internalType":"address","name":"presaleSignerAddress","type":"address"},{"internalType":"uint32","name":"publicSaleStartTime","type":"uint32"},{"internalType":"uint32","name":"publicSaleEndTime","type":"uint32"},{"internalType":"uint32","name":"presaleStartTime","type":"uint32"},{"internalType":"uint32","name":"presaleEndTime","type":"uint32"},{"internalType":"uint32","name":"fundingEndsAt","type":"uint32"},{"internalType":"uint32","name":"fundingTarget","type":"uint32"}],"internalType":"struct BaseConfig","name":"_baseConfig","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"payable","type":"fallback"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Deployed Bytecode
0x60806040523661000b57005b60007fbec77a503c47907b093281e779d211f6b514083b5f8064a268e3b9dcae86aa87546040517fc2c95814000000000000000000000000000000000000000000000000000000008152600080357fffffffff0000000000000000000000000000000000000000000000000000000016600483015273ffffffffffffffffffffffffffffffffffffffff9092169250829063c2c9581490602401602060405180830381865afa1580156100c2573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906100e6919061010f565b90503660008037600080366000845af43d6000803e808015610107573d6000f35b3d6000fd5b90565b60006020828403121561012157600080fd5b815173ffffffffffffffffffffffffffffffffffffffff8116811461014557600080fd5b939250505056fea2646970667358221220170ad76dae73e7b33686c8c290b71d946c8f96600999a65e37e81b60bb8df2f064736f6c63430008120033
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
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
-----Decoded View---------------
Arg [0] : _name (string): NeoPunksSaga
Arg [1] : _symbol (string): NPS
Arg [2] : _addressRelay (address): 0x2bf64b3eDeD9DDa6A83068fbC4e6ba91028a6917
Arg [3] : _implementation (address): 0xC1e97d3FC2810577289EE35E895a4f0E59481700
Arg [4] : _baseConfig (tuple): System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput]
-----Encoded View---------------
39 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [2] : 0000000000000000000000002bf64b3eded9dda6a83068fbc4e6ba91028a6917
Arg [3] : 000000000000000000000000c1e97d3fc2810577289ee35e895a4f0e59481700
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [5] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [6] : 4e656f50756e6b73536167610000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [8] : 4e50530000000000000000000000000000000000000000000000000000000000
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [10] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [11] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [13] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [14] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [15] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [16] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [17] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [18] : 0000000000000000000000000000000000000000000000000000000000000032
Arg [19] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [20] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [21] : 0000000000000000000000000000000000000000000000000000000000002710
Arg [22] : 000000000000000000000000000000000000000000000000000000000000251c
Arg [23] : 00000000000000000000000000000000000000000000000000000000000003e8
Arg [24] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [25] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [26] : 0000000000000000000000000000000000000000000000000000000000002d9e
Arg [27] : 0000000000000000000000000000000000000000000000000000000000000340
Arg [28] : 000000000000000000000000638d9cfbd5e750d877ec5a133dcc2272ca219fd6
Arg [29] : 0000000000000000000000000000000000000000000000000000000064dbbd20
Arg [30] : 0000000000000000000000000000000000000000000000000000000064dbe750
Arg [31] : 0000000000000000000000000000000000000000000000000000000064db84e0
Arg [32] : 0000000000000000000000000000000000000000000000000000000064dbbd20
Arg [33] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [34] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [35] : 0000000000000000000000000000000000000000000000000000000000000043
Arg [36] : 697066733a2f2f62616679626569686d68756e67766e77367974367369646c77
Arg [37] : 73676372376a733463686571653374736e7a357a6a71327661357866646c3378
Arg [38] : 7a6d2f0000000000000000000000000000000000000000000000000000000000
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
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.