Feature Tip: Add private address tag to any address under My Name Tag !
ERC-721
Overview
Max Total Supply
9,990 CMR
Holders
892
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Balance
1 CMRLoading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Minimal Proxy Contract for 0x10c06f8b3695813276b4a921c06bb3b122aaf9d2
Contract Name:
SignatureDrop
Compiler Version
v0.8.12+commit.f00d7308
Optimization Enabled:
Yes with 490 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.11;// ========== External imports ==========import "@openzeppelin/contracts-upgradeable/utils/MulticallUpgradeable.sol";import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";import "@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";import "erc721a-upgradeable/contracts/ERC721AUpgradeable.sol";// ========== Internal imports ==========import "../openzeppelin-presets/metatx/ERC2771ContextUpgradeable.sol";import "../lib/CurrencyTransferLib.sol";// ========== Features ==========import "../extension/ContractMetadata.sol";import "../extension/PlatformFee.sol";import "../extension/Royalty.sol";import "../extension/PrimarySale.sol";import "../extension/Ownable.sol";import "../extension/DelayedReveal.sol";import "../extension/LazyMint.sol";import "../extension/PermissionsEnumerable.sol";
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* [EIP](https://eips.ethereum.org/EIPS/eip-165).** 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* [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)* to learn more about how these ids are created.** This function call must use less than 30 000 gas.*/function supportsInterface(bytes4 interfaceId) external view returns (bool);}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;/*** @title ERC20 interface* @dev see https://github.com/ethereum/EIPs/issues/20*/interface IERC20 {function totalSupply() external view returns (uint256);function balanceOf(address who) external view returns (uint256);function allowance(address owner, address spender) external view returns (uint256);function transfer(address to, uint256 value) external returns (bool);function approve(address spender, uint256 value) external returns (bool);function transferFrom(address from,address to,uint256 value) external returns (bool);event Transfer(address indexed from, address indexed to, uint256 value);
1234567891011121314151617181920212223// SPDX-License-Identifier: Apache 2.0pragma solidity ^0.8.0;import "./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 payed in that same unit of exchange.*/function royaltyInfo(uint256 tokenId, uint256 salePrice)externalviewreturns (address receiver, uint256 royaltyAmount);}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;/*** @title Batch-mint Metadata* @notice The `BatchMintMetadata` is a contract extension for any base NFT contract. It lets the smart contract* using this extension set metadata for `n` number of NFTs all at once. This is enabled by storing a single* base URI for a batch of `n` NFTs, where the metadata for each NFT in a relevant batch is `baseURI/tokenId`.*/contract BatchMintMetadata {/// @dev Largest tokenId of each batch of tokens with the same baseURI.uint256[] private batchIds;/// @dev Mapping from id of a batch of tokens => to base URI for the respective batch of tokens.mapping(uint256 => string) private baseURI;/*** @notice Returns the count of batches of NFTs.* @dev Each batch of tokens has an in ID and an associated `baseURI`.* See {batchIds}.*/function getBaseURICount() public view returns (uint256) {return batchIds.length;}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./interface/IContractMetadata.sol";/*** @title Contract Metadata* @notice Thirdweb's `ContractMetadata` is a contract extension for any base contracts. It lets you set a metadata URI* for you contract.* Additionally, `ContractMetadata` is necessary for NFT contracts that want royalties to get distributed on OpenSea.*/abstract contract ContractMetadata is IContractMetadata {/// @notice Returns the contract metadata URI.string public override contractURI;/*** @notice Lets a contract admin set the URI for contract-level metadata.* @dev Caller should be authorized to setup contractURI, e.g. contract admin.* See {_canSetContractURI}.* Emits {ContractURIUpdated Event}.** @param _uri keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")*/function setContractURI(string memory _uri) external override {if (!_canSetContractURI()) {
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./interface/IDelayedReveal.sol";/*** @title Delayed Reveal* @notice Thirdweb's `DelayedReveal` is a contract extension for base NFT contracts. It lets you create batches of* 'delayed-reveal' NFTs. You can learn more about the usage of delayed reveal NFTs here - https://blog.thirdweb.com/delayed-reveal-nfts*/abstract contract DelayedReveal is IDelayedReveal {/// @dev Mapping from tokenId of a batch of tokens => to delayed reveal data.mapping(uint256 => bytes) public encryptedData;/// @dev Sets the delayed reveal data for a batchId.function _setEncryptedData(uint256 _batchId, bytes memory _encryptedData) internal {encryptedData[_batchId] = _encryptedData;}/*** @notice Returns revealed URI for a batch of NFTs.* @dev Reveal encrypted base URI for `_batchId` with caller/admin's `_key` used for encryption.* Reverts if there's no encrypted URI for `_batchId`.* See {encryptDecrypt}.*
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./interface/IDropSinglePhase.sol";import "../lib/MerkleProof.sol";import "../lib/TWBitMaps.sol";abstract contract DropSinglePhase is IDropSinglePhase {using TWBitMaps for TWBitMaps.BitMap;/*///////////////////////////////////////////////////////////////State variables//////////////////////////////////////////////////////////////*//// @dev The active conditions for claiming tokens.ClaimCondition public claimCondition;/// @dev The ID for the active claim condition.bytes32 private conditionId;/*///////////////////////////////////////////////////////////////Mappings//////////////////////////////////////////////////////////////*//*** @dev Map from an account and uid for a claim condition, to the last timestamp
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./interface/ILazyMint.sol";import "./BatchMintMetadata.sol";/*** The `LazyMint` is a contract extension for any base NFT contract. It lets you 'lazy mint' any number of NFTs* at once. Here, 'lazy mint' means defining the metadata for particular tokenIds of your NFT contract, without actually* minting a non-zero balance of NFTs of those tokenIds.*/abstract contract LazyMint is ILazyMint, BatchMintMetadata {/// @notice The tokenId assigned to the next new NFT to be lazy minted.uint256 internal nextTokenIdToLazyMint;/*** @notice Lets an authorized address lazy mint a given amount of NFTs.** @param _amount The number of NFTs to lazy mint.* @param _baseURIForTokens The base URI for the 'n' number of NFTs being lazy minted, where the metadata for each* of those NFTs is `${baseURIForTokens}/${tokenId}`.* @param _data Additional bytes data to be used at the discretion of the consumer of the contract.* @return batchId A unique integer identifier for the batch of NFTs lazy minted together.*/function lazyMint(
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./interface/IOwnable.sol";/*** @title Ownable* @notice Thirdweb's `Ownable` is a contract extension to be used with any base contract. It exposes functions for setting and reading* who the 'owner' of the inheriting smart contract is, and lets the inheriting contract perform conditional logic that uses* information about who the contract's owner is.*/abstract contract Ownable is IOwnable {/// @dev Owner of the contract (purpose: OpenSea compatibility)address private _owner;/// @dev Reverts if caller is not the owner.modifier onlyOwner() {if (msg.sender != _owner) {revert("Not authorized");}_;}/*** @notice Returns the owner of the contract.
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./interface/IPermissions.sol";import "../lib/TWStrings.sol";/*** @title Permissions* @dev This contracts provides extending-contracts with role-based access control mechanisms*/contract Permissions is IPermissions {/// @dev Map from keccak256 hash of a role => a map from address => whether address has role.mapping(bytes32 => mapping(address => bool)) private _hasRole;/// @dev Map from keccak256 hash of a role to role admin. See {getRoleAdmin}.mapping(bytes32 => bytes32) private _getRoleAdmin;/// @dev Default admin role for all roles. Only accounts with this role can grant/revoke other roles.bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;/// @dev Modifier that checks if an account has the specified role; reverts otherwise.modifier onlyRole(bytes32 role) {_checkRole(role, msg.sender);_;}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./interface/IPermissionsEnumerable.sol";import "./Permissions.sol";/*** @title PermissionsEnumerable* @dev This contracts provides extending-contracts with role-based access control mechanisms.* Also provides interfaces to view all members with a given role, and total count of members.*/contract PermissionsEnumerable is IPermissionsEnumerable, Permissions {/*** @notice A data structure to store data of members for a given role.** @param index Current index in the list of accounts that have a role.* @param members map from index => address of account that has a role* @param indexOf map from address => index which the account has.*/struct RoleMembers {uint256 index;mapping(uint256 => address) members;mapping(address => uint256) indexOf;}/// @dev map from keccak256 hash of a role to its members' data. See {RoleMembers}.
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./interface/IPlatformFee.sol";/*** @title Platform Fee* @notice Thirdweb's `PlatformFee` is a contract extension to be used with any base contract. It exposes functions for setting and reading* the recipient of platform fee and the platform fee basis points, and lets the inheriting contract perform conditional logic* that uses information about platform fees, if desired.*/abstract contract PlatformFee is IPlatformFee {/// @dev The address that receives all platform fees from all sales.address private platformFeeRecipient;/// @dev The % of primary sales collected as platform fees.uint16 private platformFeeBps;/// @dev Returns the platform fee recipient and bps.function getPlatformFeeInfo() public view override returns (address, uint16) {return (platformFeeRecipient, uint16(platformFeeBps));}/*** @notice Updates the platform fee recipient and bps.
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./interface/IPrimarySale.sol";/*** @title Primary Sale* @notice Thirdweb's `PrimarySale` is a contract extension to be used with any base contract. It exposes functions for setting and reading* the recipient of primary sales, and lets the inheriting contract perform conditional logic that uses information about* primary sales, if desired.*/abstract contract PrimarySale is IPrimarySale {/// @dev The address that receives all primary sales value.address private recipient;/// @dev Returns primary sale recipient address.function primarySaleRecipient() public view override returns (address) {return recipient;}/*** @notice Updates primary sale recipient.* @dev Caller should be authorized to set primary sales info.* See {_canSetPrimarySaleRecipient}.* Emits {PrimarySaleRecipientUpdated Event}; See {_setupPrimarySaleRecipient}.
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./interface/IRoyalty.sol";/*** @title Royalty* @notice Thirdweb's `Royalty` is a contract extension to be used with any base contract. It exposes functions for setting and reading* the recipient of royalty fee and the royalty fee basis points, and lets the inheriting contract perform conditional logic* that uses information about royalty fees, if desired.** @dev The `Royalty` contract is ERC2981 compliant.*/abstract contract Royalty is IRoyalty {/// @dev The (default) address that receives all royalty value.address private royaltyRecipient;/// @dev The (default) % of a sale to take as royalty (in basis points).uint16 private royaltyBps;/// @dev Token ID => royalty recipient and bps for tokenmapping(uint256 => RoyaltyInfo) private royaltyInfoForToken;/*** @notice View royalty info for a given token and sale price.
12345678910111213141516171819202122232425// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./interface/ISignatureMintERC721.sol";import "@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol";import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";abstract contract SignatureMintERC721Upgradeable is Initializable, EIP712Upgradeable, ISignatureMintERC721 {using ECDSAUpgradeable for bytes32;bytes32 private constant TYPEHASH =keccak256("MintRequest(address to,address royaltyRecipient,uint256 royaltyBps,address primarySaleRecipient,string uri,uint256 quantity,uint256pricePerToken,address currency,uint128 validityStartTimestamp,uint128 validityEndTimestamp,bytes32 uid)");/// @dev Mapping from mint request UID => whether the mint request is processed.mapping(bytes32 => bool) private minted;function __SignatureMintERC721_init() internal onlyInitializing {__EIP712_init("SignatureMintERC721", "1");}function __SignatureMintERC721_init_unchained() internal onlyInitializing {}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "../../lib/TWBitMaps.sol";/*** Thirdweb's 'Drop' contracts are distribution mechanisms for tokens.** A contract admin (i.e. a holder of `DEFAULT_ADMIN_ROLE`) can set a series of claim conditions,* ordered by their respective `startTimestamp`. A claim condition defines criteria under which* accounts can mint tokens. Claim conditions can be overwritten or added to by the contract admin.* At any moment, there is only one active claim condition.*/interface IClaimCondition {/*** @notice The criteria that make up a claim condition.** @param startTimestamp The unix timestamp after which the claim condition applies.* The same claim condition applies until the `startTimestamp`* of the next claim condition.** @param maxClaimableSupply The maximum total number of tokens that can be claimed under* the claim condition.** @param supplyClaimed At any given point, the number of tokens that have been claimed
1234567891011121314151617181920212223// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;/*** Thirdweb's `ContractMetadata` is a contract extension for any base contracts. It lets you set a metadata URI* for you contract.** Additionally, `ContractMetadata` is necessary for NFT contracts that want royalties to get distributed on OpenSea.*/interface IContractMetadata {/// @dev Returns the metadata URI of the contract.function contractURI() external view returns (string memory);/*** @dev Sets contract URI for the storefront-level metadata of the contract.* Only module admin can call this function.*/function setContractURI(string calldata _uri) external;/// @dev Emitted when the contract URI is updated.event ContractURIUpdated(string prevURI, string newURI);}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;/*** Thirdweb's `DelayedReveal` is a contract extension for base NFT contracts. It lets you create batches of* 'delayed-reveal' NFTs. You can learn more about the usage of delayed reveal NFTs here - https://blog.thirdweb.com/delayed-reveal-nfts*/interface IDelayedReveal {/// @dev Emitted when tokens are revealed.event TokenURIRevealed(uint256 indexed index, string revealedURI);/*** @notice Reveals a batch of delayed reveal NFTs.** @param identifier The ID for the batch of delayed-reveal NFTs to reveal.** @param key The key with which the base URI for the relevant batch of NFTs was encrypted.*/function reveal(uint256 identifier, bytes calldata key) external returns (string memory revealedURI);/*** @notice Performs XOR encryption/decryption.** @param data The data to encrypt. In the case of delayed-reveal NFTs, this is the "revealed" state* base URI of the relevant batch of NFTs.
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./IClaimCondition.sol";interface IDropSinglePhase is IClaimCondition {struct AllowlistProof {bytes32[] proof;uint256 maxQuantityInAllowlist;}/// @dev Emitted when tokens are claimed via `claim`.event TokensClaimed(address indexed claimer,address indexed receiver,uint256 indexed startTokenId,uint256 quantityClaimed);/// @dev Emitted when the contract's claim conditions are updated.event ClaimConditionUpdated(ClaimCondition condition, bool resetEligibility);/*** @notice Lets an account claim a given quantity of NFTs.** @param receiver The receiver of the NFTs to claim.
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;/*** Thirdweb's `LazyMint` is a contract extension for any base NFT contract. It lets you 'lazy mint' any number of NFTs* at once. Here, 'lazy mint' means defining the metadata for particular tokenIds of your NFT contract, without actually* minting a non-zero balance of NFTs of those tokenIds.*/interface ILazyMint {/// @dev Emitted when tokens are lazy minted.event TokensLazyMinted(uint256 indexed startTokenId, uint256 endTokenId, string baseURI, bytes encryptedBaseURI);/*** @notice Lazy mints a given amount of NFTs.** @param amount The number of NFTs to lazy mint.** @param baseURIForTokens The base URI for the 'n' number of NFTs being lazy minted, where the metadata for each* of those NFTs is `${baseURIForTokens}/${tokenId}`.** @param extraData Additional bytes data to be used at the discretion of the consumer of the contract.** @return batchId A unique integer identifier for the batch of NFTs lazy minted together.*/function lazyMint(
12345678910111213141516171819// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;/*** Thirdweb's `Ownable` is a contract extension to be used with any base contract. It exposes functions for setting and reading* who the 'owner' of the inheriting smart contract is, and lets the inheriting contract perform conditional logic that uses* information about who the contract's owner is.*/interface IOwnable {/// @dev Returns the owner of the contract.function owner() external view returns (address);/// @dev Lets a module admin set a new owner for the contract. The new owner must be a module admin.function setOwner(address _newOwner) external;/// @dev Emitted when a new Owner is set.event OwnerUpdated(address indexed prevOwner, address indexed newOwner);}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;/*** @dev External interface of AccessControl declared to support ERC165 detection.*/interface IPermissions {/*** @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`** `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite* {RoleAdminChanged} not being emitted signaling this.** _Available since v3.1._*/event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);/*** @dev Emitted when `account` is granted `role`.** `sender` is the account that originated the contract call, an admin role* bearer except when using {AccessControl-_setupRole}.*/event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);/**
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./IPermissions.sol";/*** @dev External interface of AccessControlEnumerable declared to support ERC165 detection.*/interface IPermissionsEnumerable is IPermissions {/*** @dev Returns one of the accounts that have `role`. `index` must be a* value between 0 and {getRoleMemberCount}, non-inclusive.** Role bearers are not sorted in any particular way, and their ordering may* change at any point.** WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure* you perform all queries on the same block. See the following* [forum post](https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296)* for more information.*/function getRoleMember(bytes32 role, uint256 index) external view returns (address);/*** @dev Returns the number of accounts that have `role`. Can be used* together with {getRoleMember} to enumerate all bearers of a role.
12345678910111213141516171819// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;/*** Thirdweb's `PlatformFee` is a contract extension to be used with any base contract. It exposes functions for setting and reading* the recipient of platform fee and the platform fee basis points, and lets the inheriting contract perform conditional logic* that uses information about platform fees, if desired.*/interface IPlatformFee {/// @dev Returns the platform fee bps and recipient.function getPlatformFeeInfo() external view returns (address, uint16);/// @dev Lets a module admin update the fees on primary sales.function setPlatformFeeInfo(address _platformFeeRecipient, uint256 _platformFeeBps) external;/// @dev Emitted when fee on primary sales is updated.event PlatformFeeInfoUpdated(address indexed platformFeeRecipient, uint256 platformFeeBps);}
12345678910111213141516171819// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;/*** Thirdweb's `Primary` is a contract extension to be used with any base contract. It exposes functions for setting and reading* the recipient of primary sales, and lets the inheriting contract perform conditional logic that uses information about* primary sales, if desired.*/interface IPrimarySale {/// @dev The adress that receives all primary sales value.function primarySaleRecipient() external view returns (address);/// @dev Lets a module admin set the default recipient of all primary sales.function setPrimarySaleRecipient(address _saleRecipient) external;/// @dev Emitted when a new sale recipient is set.event PrimarySaleRecipientUpdated(address indexed recipient);}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "../../eip/interface/IERC2981.sol";/*** Thirdweb's `Royalty` is a contract extension to be used with any base contract. It exposes functions for setting and reading* the recipient of royalty fee and the royalty fee basis points, and lets the inheriting contract perform conditional logic* that uses information about royalty fees, if desired.** The `Royalty` contract is ERC2981 compliant.*/interface IRoyalty is IERC2981 {struct RoyaltyInfo {address recipient;uint256 bps;}/// @dev Returns the royalty recipient and fee bps.function getDefaultRoyaltyInfo() external view returns (address, uint16);/// @dev Lets a module admin update the royalty bps and recipient.function setDefaultRoyaltyInfo(address _royaltyRecipient, uint256 _royaltyBps) external;/// @dev Lets a module admin set the royalty recipient for a particular token Id.
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;/*** The 'signature minting' mechanism used in thirdweb Token smart contracts is a way for a contract admin to authorize an external party's* request to mint tokens on the admin's contract.** At a high level, this means you can authorize some external party to mint tokens on your contract, and specify what exactly will be* minted by that external party.*/interface ISignatureMintERC721 {/*** @notice The body of a request to mint tokens.** @param to The receiver of the tokens to mint.* @param royaltyRecipient The recipient of the minted token's secondary sales royalties. (Not applicable for ERC20 tokens)* @param royaltyBps The percentage of the minted token's secondary sales to take as royalties. (Not applicable for ERC20 tokens)* @param primarySaleRecipient The recipient of the minted token's primary sales proceeds.* @param uri The metadata URI of the token to mint. (Not applicable for ERC20 tokens)* @param quantity The quantity of tokens to mint.* @param pricePerToken The price to pay per quantity of tokens minted.* @param currency The currency in which to pay the price per token minted.* @param validityStartTimestamp The unix timestamp after which the payload is valid.* @param validityEndTimestamp The unix timestamp at which the payload expires.* @param uid A unique identifier for the payload.*/
12345678910// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;interface IWETH {function deposit() external payable;function withdraw(uint256 amount) external;function transfer(address to, uint256 value) external returns (bool);}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;// Helper interfacesimport { IWETH } from "../interfaces/IWETH.sol";import "../openzeppelin-presets/token/ERC20/utils/SafeERC20.sol";library CurrencyTransferLib {using SafeERC20 for IERC20;/// @dev The address interpreted as native token of the chain.address public constant NATIVE_TOKEN = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;/// @dev Transfers a given amount of currency.function transferCurrency(address _currency,address _from,address _to,uint256 _amount) internal {if (_amount == 0) {return;}if (_currency == NATIVE_TOKEN) {
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// Modified from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.3.0/contracts/utils/cryptography/MerkleProof.sol// Copied from https://github.com/ensdomains/governance/blob/master/contracts/MerkleProof.solpragma solidity ^0.8.0;/*** @dev These functions deal with verification of Merkle Trees proofs.** The proofs can be generated using the JavaScript library* https://github.com/miguelmota/merkletreejs[merkletreejs].* Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.** See `test/utils/cryptography/MerkleProof.test.js` for some examples.** Source: https://github.com/ensdomains/governance/blob/master/contracts/MerkleProof.sol*/library MerkleProof {/*** @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.*/function verify(bytes32[] memory proof,
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)pragma solidity ^0.8.0;/*** @dev Collection of functions related to the address type*/library TWAddress {/*** @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/structs/BitMaps.sol)pragma solidity ^0.8.0;/*** @dev Library for managing uint256 to bool mapping in a compact and efficient way, providing the keys are sequential.* Largely inspired by Uniswap's [merkle-distributor](https://github.com/Uniswap/merkle-distributor/blob/master/contracts/MerkleDistributor.sol).*/library TWBitMaps {struct BitMap {mapping(uint256 => uint256) _data;}/*** @dev Returns whether the bit at `index` is set.*/function get(BitMap storage bitmap, uint256 index) internal view returns (bool) {uint256 bucket = index >> 8;uint256 mask = 1 << (index & 0xff);return bitmap._data[bucket] & mask != 0;}/*** @dev Sets the bit at `index` to the boolean `value`.*/function setTo(
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)pragma solidity ^0.8.0;/*** @dev String operations.*/library TWStrings {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.solif (value == 0) {return "0";}uint256 temp = value;uint256 digits;while (temp != 0) {digits++;temp /= 10;
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.0 (metatx/ERC2771Context.sol)pragma solidity ^0.8.11;import "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";/*** @dev Context variant with ERC2771 support.*/abstract contract ERC2771ContextUpgradeable is Initializable, ContextUpgradeable {mapping(address => bool) private _trustedForwarder;function __ERC2771Context_init(address[] memory trustedForwarder) internal onlyInitializing {__Context_init_unchained();__ERC2771Context_init_unchained(trustedForwarder);}function __ERC2771Context_init_unchained(address[] memory trustedForwarder) internal onlyInitializing {for (uint256 i = 0; i < trustedForwarder.length; i++) {_trustedForwarder[trustedForwarder[i]] = true;}}function isTrustedForwarder(address forwarder) public view virtual returns (bool) {
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)pragma solidity ^0.8.0;import "../../../../eip/interface/IERC20.sol";import "../../../../lib/TWAddress.sol";/*** @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 TWAddress for address;function safeTransfer(IERC20 token,address to,uint256 value) internal {_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
123456// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.1 (interfaces/IERC165.sol)pragma solidity ^0.8.0;import "../utils/introspection/IERC165Upgradeable.sol";
12345678910111213141516171819202122232425// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/IERC2981.sol)pragma solidity ^0.8.0;import "./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 payed 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.5.0) (proxy/utils/Initializable.sol)pragma solidity ^0.8.0;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.** 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.** [CAUTION]* ====* Avoid leaving a contract uninitialized.** An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation* contract, which may impact the proxy. To initialize the implementation contract, you can either invoke the* initializer manually, or you can include a constructor to automatically mark it as initialized when it is deployed:
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// 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 IERC721ReceiverUpgradeable {/*** @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);
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)pragma solidity ^0.8.0;import "../../utils/introspection/IERC165Upgradeable.sol";/*** @dev Required interface of an ERC721 compliant contract.*/interface IERC721Upgradeable is IERC165Upgradeable {/*** @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 v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)pragma solidity ^0.8.0;import "../IERC721Upgradeable.sol";/*** @title ERC-721 Non-Fungible Token Standard, optional metadata extension* @dev See https://eips.ethereum.org/EIPS/eip-721*/interface IERC721MetadataUpgradeable is IERC721Upgradeable {/*** @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.5.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.5.0) (utils/Multicall.sol)pragma solidity ^0.8.0;import "./AddressUpgradeable.sol";import "../proxy/utils/Initializable.sol";/*** @dev Provides a function to batch together multiple calls in a single external call.** _Available since v4.1._*/abstract contract MulticallUpgradeable is Initializable {function __Multicall_init() internal onlyInitializing {}function __Multicall_init_unchained() internal onlyInitializing {}/*** @dev Receives and executes a batch of function calls on this contract.*/function multicall(bytes[] calldata data) external virtual returns (bytes[] memory results) {results = new bytes[](data.length);for (uint256 i = 0; i < data.length; i++) {results[i] = _functionDelegateCall(address(this), data[i]);
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)pragma solidity ^0.8.0;/*** @dev String operations.*/library StringsUpgradeable {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.solif (value == 0) {return "0";}uint256 temp = value;uint256 digits;while (temp != 0) {digits++;temp /= 10;
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.5.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}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/cryptography/draft-EIP712.sol)pragma solidity ^0.8.0;import "./ECDSAUpgradeable.sol";import "../../proxy/utils/Initializable.sol";/*** @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.** The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,* thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding* they need in their contracts using a combination of `abi.encode` and `keccak256`.** This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding* scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA* ({_hashTypedDataV4}).** The implementation of the domain separator was designed to be as efficient as possible while still properly updating* the chain id to protect against replay attacks on an eventual fork of the chain.** NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method* https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].** _Available since v3.4._
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)pragma solidity ^0.8.0;import "./IERC165Upgradeable.sol";import "../../proxy/utils/Initializable.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 ERC165Upgradeable is Initializable, IERC165Upgradeable {function __ERC165_init() internal onlyInitializing {}
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// ERC721A Contracts v3.3.0// Creator: Chiru Labspragma solidity ^0.8.4;import "./IERC721AUpgradeable.sol";import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol";import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";import "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";import "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";/*** @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including* the Metadata extension. Built to optimize for lower gas during batch mints.** Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).** Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.** Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).*/contract ERC721AUpgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721AUpgradeable {using AddressUpgradeable for address;
1234567891011121314151617181920212223242526// SPDX-License-Identifier: MIT// ERC721A Contracts v3.3.0// Creator: Chiru Labspragma solidity ^0.8.4;import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol";/*** @dev Interface of an ERC721A compliant contract.*/interface IERC721AUpgradeable is IERC721Upgradeable, IERC721MetadataUpgradeable {/*** The caller must own the token or be an approved operator.*/error ApprovalCallerNotOwnerNorApproved();/*** The token does not exist.*/error ApprovalQueryForNonexistentToken();/*** The caller cannot approve to their own address.*/
1234567891011121314151617181920212223242526{"optimizer": {"enabled": true,"runs": 490},"evmVersion": "london","remappings": [":@chainlink/contracts/src/=node_modules/@chainlink/contracts/src/",":@ds-test/=lib/ds-test/src/",":@openzeppelin/=node_modules/@openzeppelin/",":@std/=lib/forge-std/src/",":contracts/=contracts/",":ds-test/=lib/ds-test/src/",":erc721a-upgradeable/=node_modules/erc721a-upgradeable/",":erc721a/=node_modules/erc721a/",":forge-std/=lib/forge-std/src/"],"outputSelection": {"*": {"*": ["evm.bytecode","evm.deployedBytecode","devdoc","userdoc","metadata","abi"
[{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"uint256","name":"startTimestamp","type":"uint256"},{"internalType":"uint256","name":"maxClaimableSupply","type":"uint256"},{"internalType":"uint256","name":"supplyClaimed","type":"uint256"},{"internalType":"uint256","name":"quantityLimitPerTransaction","type":"uint256"},{"internalType":"uint256","name":"waitTimeInSecondsBetweenClaims","type":"uint256"},{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"internalType":"uint256","name":"pricePerToken","type":"uint256"},{"internalType":"address","name":"currency","type":"address"}],"indexed":false,"internalType":"struct IClaimCondition.ClaimCondition","name":"condition","type":"tuple"},{"indexed":false,"internalType":"bool","name":"resetEligibility","type":"bool"}],"name":"ClaimConditionUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"prevURI","type":"string"},{"indexed":false,"internalType":"string","name":"newURI","type":"string"}],"name":"ContractURIUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newRoyaltyRecipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"newRoyaltyBps","type":"uint256"}],"name":"DefaultRoyalty","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"prevOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"platformFeeRecipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"platformFeeBps","type":"uint256"}],"name":"PlatformFeeInfoUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"}],"name":"PrimarySaleRecipientUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":true,"internalType":"address","name":"royaltyRecipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"royaltyBps","type":"uint256"}],"name":"RoyaltyForToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":false,"internalType":"string","name":"revealedURI","type":"string"}],"name":"TokenURIRevealed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"claimer","type":"address"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":true,"internalType":"uint256","name":"startTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"quantityClaimed","type":"uint256"}],"name":"TokensClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"startTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"endTokenId","type":"uint256"},{"indexed":false,"internalType":"string","name":"baseURI","type":"string"},{"indexed":false,"internalType":"bytes","name":"encryptedBaseURI","type":"bytes"}],"name":"TokensLazyMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"signer","type":"address"},{"indexed":true,"internalType":"address","name":"mintedTo","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenIdMinted","type":"uint256"},{"components":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"royaltyRecipient","type":"address"},{"internalType":"uint256","name":"royaltyBps","type":"uint256"},{"internalType":"address","name":"primarySaleRecipient","type":"address"},{"internalType":"string","name":"uri","type":"string"},{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"uint256","name":"pricePerToken","type":"uint256"},{"internalType":"address","name":"currency","type":"address"},{"internalType":"uint128","name":"validityStartTimestamp","type":"uint128"},{"internalType":"uint128","name":"validityEndTimestamp","type":"uint128"},{"internalType":"bytes32","name":"uid","type":"bytes32"}],"indexed":false,"internalType":"struct ISignatureMintERC721.MintRequest","name":"mintRequest","type":"tuple"}],"name":"TokensMintedWithSignature","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":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"uint256","name":"_quantity","type":"uint256"},{"internalType":"address","name":"_currency","type":"address"},{"internalType":"uint256","name":"_pricePerToken","type":"uint256"},{"components":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"},{"internalType":"uint256","name":"maxQuantityInAllowlist","type":"uint256"}],"internalType":"struct IDropSinglePhase.AllowlistProof","name":"_allowlistProof","type":"tuple"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"claim","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"claimCondition","outputs":[{"internalType":"uint256","name":"startTimestamp","type":"uint256"},{"internalType":"uint256","name":"maxClaimableSupply","type":"uint256"},{"internalType":"uint256","name":"supplyClaimed","type":"uint256"},{"internalType":"uint256","name":"quantityLimitPerTransaction","type":"uint256"},{"internalType":"uint256","name":"waitTimeInSecondsBetweenClaims","type":"uint256"},{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"internalType":"uint256","name":"pricePerToken","type":"uint256"},{"internalType":"address","name":"currency","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractType","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractVersion","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"bytes","name":"key","type":"bytes"}],"name":"encryptDecrypt","outputs":[{"internalType":"bytes","name":"result","type":"bytes"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"encryptedData","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBaseURICount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"getBatchIdAtIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_claimer","type":"address"}],"name":"getClaimTimestamp","outputs":[{"internalType":"uint256","name":"lastClaimedAt","type":"uint256"},{"internalType":"uint256","name":"nextValidClaimTimestamp","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDefaultRoyaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPlatformFeeInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_batchId","type":"uint256"},{"internalType":"bytes","name":"_key","type":"bytes"}],"name":"getRevealURI","outputs":[{"internalType":"string","name":"revealedURI","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"member","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"getRoyaltyInfoForToken","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRoleWithSwitch","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_defaultAdmin","type":"address"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"string","name":"_contractURI","type":"string"},{"internalType":"address[]","name":"_trustedForwarders","type":"address[]"},{"internalType":"address","name":"_saleRecipient","type":"address"},{"internalType":"address","name":"_royaltyRecipient","type":"address"},{"internalType":"uint128","name":"_royaltyBps","type":"uint128"},{"internalType":"uint128","name":"_platformFeeBps","type":"uint128"},{"internalType":"address","name":"_platformFeeRecipient","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","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":"uint256","name":"_batchId","type":"uint256"}],"name":"isEncryptedBatch","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"forwarder","type":"address"}],"name":"isTrustedForwarder","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"string","name":"_baseURIForTokens","type":"string"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"lazyMint","outputs":[{"internalType":"uint256","name":"batchId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"royaltyRecipient","type":"address"},{"internalType":"uint256","name":"royaltyBps","type":"uint256"},{"internalType":"address","name":"primarySaleRecipient","type":"address"},{"internalType":"string","name":"uri","type":"string"},{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"uint256","name":"pricePerToken","type":"uint256"},{"internalType":"address","name":"currency","type":"address"},{"internalType":"uint128","name":"validityStartTimestamp","type":"uint128"},{"internalType":"uint128","name":"validityEndTimestamp","type":"uint128"},{"internalType":"bytes32","name":"uid","type":"bytes32"}],"internalType":"struct ISignatureMintERC721.MintRequest","name":"_req","type":"tuple"},{"internalType":"bytes","name":"_signature","type":"bytes"}],"name":"mintWithSignature","outputs":[{"internalType":"address","name":"signer","type":"address"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextTokenIdToMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"primarySaleRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_index","type":"uint256"},{"internalType":"bytes","name":"_key","type":"bytes"}],"name":"reveal","outputs":[{"internalType":"string","name":"revealedURI","type":"string"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"royaltyAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"startTimestamp","type":"uint256"},{"internalType":"uint256","name":"maxClaimableSupply","type":"uint256"},{"internalType":"uint256","name":"supplyClaimed","type":"uint256"},{"internalType":"uint256","name":"quantityLimitPerTransaction","type":"uint256"},{"internalType":"uint256","name":"waitTimeInSecondsBetweenClaims","type":"uint256"},{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"internalType":"uint256","name":"pricePerToken","type":"uint256"},{"internalType":"address","name":"currency","type":"address"}],"internalType":"struct IClaimCondition.ClaimCondition","name":"_condition","type":"tuple"},{"internalType":"bool","name":"_resetClaimEligibility","type":"bool"}],"name":"setClaimConditions","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uri","type":"string"}],"name":"setContractURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_royaltyRecipient","type":"address"},{"internalType":"uint256","name":"_royaltyBps","type":"uint256"}],"name":"setDefaultRoyaltyInfo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newOwner","type":"address"}],"name":"setOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_platformFeeRecipient","type":"address"},{"internalType":"uint256","name":"_platformFeeBps","type":"uint256"}],"name":"setPlatformFeeInfo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_saleRecipient","type":"address"}],"name":"setPrimarySaleRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_bps","type":"uint256"}],"name":"setRoyaltyInfoForToken","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":"totalMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[{"components":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"royaltyRecipient","type":"address"},{"internalType":"uint256","name":"royaltyBps","type":"uint256"},{"internalType":"address","name":"primarySaleRecipient","type":"address"},{"internalType":"string","name":"uri","type":"string"},{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"uint256","name":"pricePerToken","type":"uint256"},{"internalType":"address","name":"currency","type":"address"},{"internalType":"uint128","name":"validityStartTimestamp","type":"uint128"},{"internalType":"uint128","name":"validityEndTimestamp","type":"uint128"},{"internalType":"bytes32","name":"uid","type":"bytes32"}],"internalType":"struct ISignatureMintERC721.MintRequest","name":"_req","type":"tuple"},{"internalType":"bytes","name":"_signature","type":"bytes"}],"name":"verify","outputs":[{"internalType":"bool","name":"success","type":"bool"},{"internalType":"address","name":"signer","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_claimer","type":"address"},{"internalType":"uint256","name":"_quantity","type":"uint256"},{"internalType":"address","name":"_currency","type":"address"},{"internalType":"uint256","name":"_pricePerToken","type":"uint256"},{"internalType":"bool","name":"verifyMaxQuantityPerTransaction","type":"bool"}],"name":"verifyClaim","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_claimer","type":"address"},{"internalType":"uint256","name":"_quantity","type":"uint256"},{"components":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"},{"internalType":"uint256","name":"maxQuantityInAllowlist","type":"uint256"}],"internalType":"struct IDropSinglePhase.AllowlistProof","name":"_allowlistProof","type":"tuple"}],"name":"verifyClaimMerkleProof","outputs":[{"internalType":"bool","name":"validMerkleProof","type":"bool"},{"internalType":"uint256","name":"merkleProofIndex","type":"uint256"}],"stateMutability":"view","type":"function"}]
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.