Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
TokenTracker
Latest 9 from a total of 9 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Claim | 15614839 | 883 days ago | IN | 0 ETH | 0.00038754 | ||||
Claim | 15614818 | 883 days ago | IN | 0 ETH | 0.00090801 | ||||
Claim | 15499148 | 901 days ago | IN | 0 ETH | 0.00364721 | ||||
Claim | 15339588 | 926 days ago | IN | 0 ETH | 0.00111179 | ||||
Claim | 15326295 | 928 days ago | IN | 0 ETH | 0.00186091 | ||||
Claim | 15319786 | 929 days ago | IN | 0 ETH | 0.00267206 | ||||
Claim | 15318756 | 929 days ago | IN | 0 ETH | 0.00300985 | ||||
Multicall | 15315579 | 930 days ago | IN | 0 ETH | 0.0113533 | ||||
Lazy Mint | 15315487 | 930 days ago | IN | 0 ETH | 0.01121181 |
Latest 1 internal transaction
Advanced mode:
Parent Transaction Hash | Block |
From
|
To
|
|||
---|---|---|---|---|---|---|
15315450 | 930 days ago | Contract Creation | 0 ETH |
Loading...
Loading
Minimal Proxy Contract for 0x196e4db2f3779d292f634308d7b11045094bdc3b
Contract Name:
SignatureDrop
Compiler Version
v0.8.12+commit.f00d7308
Optimization Enabled:
Yes with 600 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";
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;
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// 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// 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: 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: Apache-2.0pragma solidity ^0.8.0;import "./interface/IContractMetadata.sol";/*** 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 {/// @dev Contract level metadata.string public override contractURI;/// @dev Lets a contract admin set the URI for contract-level metadata.function setContractURI(string memory _uri) external override {if (!_canSetContractURI()) {revert("Not authorized");}_setupContractURI(_uri);}/// @dev Lets a contract admin set the URI for contract-level metadata.
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./interface/IPlatformFee.sol";/*** 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));}/// @dev Lets a contract admin update the platform fee recipient and bpsfunction setPlatformFeeInfo(address _platformFeeRecipient, uint256 _platformFeeBps) external override {if (!_canSetPlatformFeeInfo()) {
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./interface/IRoyalty.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.*/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;/// @dev Returns the royalty recipient and amount, given a tokenId and sale price.function royaltyInfo(uint256 tokenId, uint256 salePrice)external
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./interface/IPrimarySale.sol";/*** 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;function primarySaleRecipient() public view override returns (address) {return recipient;}/// @dev Lets a contract admin set the recipient for all primary sales.function setPrimarySaleRecipient(address _saleRecipient) external override {if (!_canSetPrimarySaleRecipient()) {revert("Not authorized");}_setupPrimarySaleRecipient(_saleRecipient);}
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./interface/IOwnable.sol";/*** 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");}_;}/// @dev Returns the owner of the contract.function owner() public view override returns (address) {return _owner;
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./interface/IDelayedReveal.sol";/*** 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 id of a batch of tokens => to encrypted base URI for the respective batch of tokens.mapping(uint256 => bytes) public encryptedBaseURI;/// @dev Sets the encrypted baseURI for a batch of tokenIds.function _setEncryptedBaseURI(uint256 _batchId, bytes memory _encryptedBaseURI) internal {encryptedBaseURI[_batchId] = _encryptedBaseURI;}/// @dev Returns the decrypted i.e. revealed URI for a batch of tokens.function getRevealURI(uint256 _batchId, bytes calldata _key) public view returns (string memory revealedURI) {bytes memory encryptedURI = encryptedBaseURI[_batchId];if (encryptedURI.length == 0) {revert("Nothing to reveal");}
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/IPermissionsEnumerable.sol";import "./Permissions.sol";contract PermissionsEnumerable is IPermissionsEnumerable, Permissions {struct RoleMembers {uint256 index;mapping(uint256 => address) members;mapping(address => uint256) indexOf;}mapping(bytes32 => RoleMembers) private roleMembers;function getRoleMember(bytes32 role, uint256 index) external view override returns (address member) {uint256 currentIndex = roleMembers[role].index;uint256 check;for (uint256 i = 0; i < currentIndex; i += 1) {if (roleMembers[role].members[i] != address(0)) {if (check == index) {member = roleMembers[role].members[i];return member;}check += 1;
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
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: 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 (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:
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 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 "@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// 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 (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 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 {}
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);
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: 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));
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);
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* ====*
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);}
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);}
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.
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);}
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);}
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);}
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;/*** 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;/*** 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(
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;/*** 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;/// @dev Returns the number of batches of tokens having the same baseURI.function getBaseURICount() public view returns (uint256) {return batchIds.length;}/// @dev Returns the id for the batch of tokens the given tokenId belongs to.function getBatchIdAtIndex(uint256 _index) public view returns (uint256) {if (_index >= getBaseURICount()) {revert("Invalid index");}
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* https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]* 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.
1234567891011121314151617181920212223242526// SPDX-License-Identifier: Apache-2.0pragma solidity ^0.8.0;import "./interface/IPermissions.sol";import "../lib/TWStrings.sol";contract Permissions is IPermissions {mapping(bytes32 => mapping(address => bool)) private _hasRole;mapping(bytes32 => bytes32) private _getRoleAdmin;bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;modifier onlyRole(bytes32 role) {_checkRole(role, msg.sender);_;}function hasRole(bytes32 role, address account) public view override returns (bool) {return _hasRole[role][account];}function hasRoleWithSwitch(bytes32 role, address account) public view returns (bool) {if (!_hasRole[role][address(0)]) {return _hasRole[role][account];}
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: 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: 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: 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 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.* Largelly inspired by Uniswap's https://github.com/Uniswap/merkle-distributor/blob/master/contracts/MerkleDistributor.sol[merkle-distributor].*/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: 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
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.*/
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._
12345678910111213141516171819202122{"metadata": {"bytecodeHash": "ipfs"},"optimizer": {"enabled": true,"runs": 600},"outputSelection": {"*": {"*": ["evm.bytecode","evm.deployedBytecode","devdoc","userdoc","metadata","abi"]}},"libraries": {}}
[{"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":"encryptedBaseURI","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":"_encryptedBaseURI","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
Multichain Portfolio | 31 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.