ERC-721
Overview
Max Total Supply
777 HM-SON-BOOT
Holders
712
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Balance
2 HM-SON-BOOTLoading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
NFTERC721A
Compiler Version
v0.8.7+commit.e28d00a7
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2022-05-30 */ // File: eip712/ContextMixin.sol pragma solidity ^0.8.7; /** * https://github.com/maticnetwork/pos-portal/blob/master/contracts/common/ContextMixin.sol */ abstract contract ContextMixin { function msgSender() internal view returns (address payable sender) { if (msg.sender == address(this)) { bytes memory array = msg.data; uint256 index = msg.data.length; assembly { // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those. sender := and( mload(add(array, index)), 0xffffffffffffffffffffffffffffffffffffffff ) } } else { sender = payable(msg.sender); } return sender; } } // File: eip712/Initializable.sol pragma solidity ^0.8.7; /** * https://github.com/maticnetwork/pos-portal/blob/master/contracts/common/Initializable.sol */ contract Initializable { bool inited = false; modifier initializer() { require(!inited, "already inited"); _; inited = true; } } // File: eip712/EIP712Base.sol pragma solidity ^0.8.7; /** * https://github.com/maticnetwork/pos-portal/blob/master/contracts/common/EIP712Base.sol */ contract EIP712Base is Initializable { struct EIP712Domain { string name; string version; address verifyingContract; bytes32 salt; } string public constant ERC712_VERSION = "1"; bytes32 internal constant EIP712_DOMAIN_TYPEHASH = keccak256( bytes( "EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)" ) ); bytes32 internal domainSeperator; // supposed to be called once while initializing. // one of the contractsa that inherits this contract follows proxy pattern // so it is not possible to do this in a constructor function _initializeEIP712(string memory name) internal initializer { _setDomainSeperator(name); } function _setDomainSeperator(string memory name) internal { domainSeperator = keccak256( abi.encode( EIP712_DOMAIN_TYPEHASH, keccak256(bytes(name)), keccak256(bytes(ERC712_VERSION)), address(this), bytes32(getChainId()) ) ); } function getDomainSeperator() public view returns (bytes32) { return domainSeperator; } function getChainId() public view returns (uint256) { uint256 id; assembly { id := chainid() } return id; } /** * Accept message hash and returns hash message in EIP712 compatible form * So that it can be used to recover signer from signature signed using EIP712 formatted data * https://eips.ethereum.org/EIPS/eip-712 * "\\x19" makes the encoding deterministic * "\\x01" is the version byte to make it compatible to EIP-191 */ function toTypedMessageHash(bytes32 messageHash) internal view returns (bytes32) { return keccak256( abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash) ); } } // File: @openzeppelin/contracts/utils/math/SafeMath.sol // OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol) pragma solidity ^0.8.0; // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. /** * @dev Wrappers over Solidity's arithmetic operations. * * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler * now has built in overflow checking. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the subtraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { return a + b; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { return a * b; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a / b; } } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a % b; } } } // File: eip712/NativeMetaTransaction.sol pragma solidity ^0.8.0; contract NativeMetaTransaction is EIP712Base { using SafeMath for uint256; bytes32 private constant META_TRANSACTION_TYPEHASH = keccak256( bytes( "MetaTransaction(uint256 nonce,address from,bytes functionSignature)" ) ); event MetaTransactionExecuted( address userAddress, address payable relayerAddress, bytes functionSignature ); mapping(address => uint256) nonces; /* * Meta transaction structure. * No point of including value field here as if user is doing value transfer then he has the funds to pay for gas * He should call the desired function directly in that case. */ struct MetaTransaction { uint256 nonce; address from; bytes functionSignature; } function executeMetaTransaction( address userAddress, bytes memory functionSignature, bytes32 sigR, bytes32 sigS, uint8 sigV ) public payable returns (bytes memory) { MetaTransaction memory metaTx = MetaTransaction({ nonce: nonces[userAddress], from: userAddress, functionSignature: functionSignature }); require( verify(userAddress, metaTx, sigR, sigS, sigV), "Signer and signature do not match" ); // increase nonce for user (to avoid re-use) nonces[userAddress] = nonces[userAddress].add(1); emit MetaTransactionExecuted( userAddress, payable(msg.sender), functionSignature ); // Append userAddress and relayer address at the end to extract it from calling context (bool success, bytes memory returnData) = address(this).call( abi.encodePacked(functionSignature, userAddress) ); require(success, "Function call not successful"); return returnData; } function executeMetaTransactionWithExternalNonce( address userAddress, bytes memory functionSignature, bytes32 sigR, bytes32 sigS, uint8 sigV, uint256 userNonce ) public payable returns (bytes memory) { MetaTransaction memory metaTx = MetaTransaction({ nonce: userNonce, from: userAddress, functionSignature: functionSignature }); require( verify(userAddress, metaTx, sigR, sigS, sigV), "Signer and signature do not match" ); require(userNonce == nonces[userAddress]); // increase nonce for user (to avoid re-use) nonces[userAddress] = userNonce.add(1); emit MetaTransactionExecuted( userAddress, payable(msg.sender), functionSignature ); // Append userAddress and relayer address at the end to extract it from calling context (bool success, bytes memory returnData) = address(this).call( abi.encodePacked(functionSignature, userAddress) ); require(success, string(returnData)); return returnData; } function hashMetaTransaction(MetaTransaction memory metaTx) internal pure returns (bytes32) { return keccak256( abi.encode( META_TRANSACTION_TYPEHASH, metaTx.nonce, metaTx.from, keccak256(metaTx.functionSignature) ) ); } function getNonce(address user) public view returns (uint256 nonce) { nonce = nonces[user]; } function verify( address signer, MetaTransaction memory metaTx, bytes32 sigR, bytes32 sigS, uint8 sigV ) internal view returns (bool) { require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER"); return signer == ecrecover( toTypedMessageHash(hashMetaTransaction(metaTx)), sigV, sigR, sigS ); } } // File: erc721a/contracts/IERC721A.sol // ERC721A Contracts v4.0.0 // Creator: Chiru Labs pragma solidity ^0.8.4; /** * @dev Interface of an ERC721A compliant contract. */ interface IERC721A { /** * The caller must own the token or be an approved operator. */ error ApprovalCallerNotOwnerNorApproved(); /** * The token does not exist. */ error ApprovalQueryForNonexistentToken(); /** * The caller cannot approve to their own address. */ error ApproveToCaller(); /** * The caller cannot approve to the current owner. */ error ApprovalToCurrentOwner(); /** * Cannot query the balance for the zero address. */ error BalanceQueryForZeroAddress(); /** * Cannot mint to the zero address. */ error MintToZeroAddress(); /** * The quantity of tokens minted must be more than zero. */ error MintZeroQuantity(); /** * The token does not exist. */ error OwnerQueryForNonexistentToken(); /** * The caller must own the token or be an approved operator. */ error TransferCallerNotOwnerNorApproved(); /** * The token must be owned by `from`. */ error TransferFromIncorrectOwner(); /** * Cannot safely transfer to a contract that does not implement the ERC721Receiver interface. */ error TransferToNonERC721ReceiverImplementer(); /** * Cannot transfer to the zero address. */ error TransferToZeroAddress(); /** * The token does not exist. */ error URIQueryForNonexistentToken(); struct TokenOwnership { // The address of the owner. address addr; // Keeps track of the start time of ownership with minimal overhead for tokenomics. uint64 startTimestamp; // Whether the token has been burned. bool burned; } /** * @dev Returns the total amount of tokens stored by the contract. * * Burned tokens are calculated here, use `_totalMinted()` if you want to count just minted tokens. */ function totalSupply() external view returns (uint256); // ============================== // IERC165 // ============================== /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); // ============================== // IERC721 // ============================== /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); // ============================== // IERC721Metadata // ============================== /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); } // File: erc721a/contracts/extensions/IERC721AQueryable.sol // ERC721A Contracts v4.0.0 // Creator: Chiru Labs pragma solidity ^0.8.4; /** * @dev Interface of an ERC721AQueryable compliant contract. */ interface IERC721AQueryable is IERC721A { /** * Invalid query range (`start` >= `stop`). */ error InvalidQueryRange(); /** * @dev Returns the `TokenOwnership` struct at `tokenId` without reverting. * * If the `tokenId` is out of bounds: * - `addr` = `address(0)` * - `startTimestamp` = `0` * - `burned` = `false` * * If the `tokenId` is burned: * - `addr` = `<Address of owner before token was burned>` * - `startTimestamp` = `<Timestamp when token was burned>` * - `burned = `true` * * Otherwise: * - `addr` = `<Address of owner>` * - `startTimestamp` = `<Timestamp of start of ownership>` * - `burned = `false` */ function explicitOwnershipOf(uint256 tokenId) external view returns (TokenOwnership memory); /** * @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order. * See {ERC721AQueryable-explicitOwnershipOf} */ function explicitOwnershipsOf(uint256[] memory tokenIds) external view returns (TokenOwnership[] memory); /** * @dev Returns an array of token IDs owned by `owner`, * in the range [`start`, `stop`) * (i.e. `start <= tokenId < stop`). * * This function allows for tokens to be queried if the collection * grows too big for a single call of {ERC721AQueryable-tokensOfOwner}. * * Requirements: * * - `start` < `stop` */ function tokensOfOwnerIn( address owner, uint256 start, uint256 stop ) external view returns (uint256[] memory); /** * @dev Returns an array of token IDs owned by `owner`. * * This function scans the ownership mapping and is O(totalSupply) in complexity. * It is meant to be called off-chain. * * See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into * multiple smaller scans if the collection is large enough to cause * an out-of-gas error (10K pfp collections should be fine). */ function tokensOfOwner(address owner) external view returns (uint256[] memory); } // File: erc721a/contracts/extensions/IERC721ABurnable.sol // ERC721A Contracts v4.0.0 // Creator: Chiru Labs pragma solidity ^0.8.4; /** * @dev Interface of an ERC721ABurnable compliant contract. */ interface IERC721ABurnable is IERC721A { /** * @dev Burns `tokenId`. See {ERC721A-_burn}. * * Requirements: * * - The caller must own `tokenId` or be an approved operator. */ function burn(uint256 tokenId) external; } // File: erc721a/contracts/ERC721A.sol // ERC721A Contracts v4.0.0 // Creator: Chiru Labs pragma solidity ^0.8.4; /** * @dev ERC721 token receiver interface. */ interface ERC721A__IERC721Receiver { function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension. Built to optimize for lower gas during batch mints. * * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..). * * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply. * * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256). */ contract ERC721A is IERC721A { // Mask of an entry in packed address data. uint256 private constant BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1; // The bit position of `numberMinted` in packed address data. uint256 private constant BITPOS_NUMBER_MINTED = 64; // The bit position of `numberBurned` in packed address data. uint256 private constant BITPOS_NUMBER_BURNED = 128; // The bit position of `aux` in packed address data. uint256 private constant BITPOS_AUX = 192; // Mask of all 256 bits in packed address data except the 64 bits for `aux`. uint256 private constant BITMASK_AUX_COMPLEMENT = (1 << 192) - 1; // The bit position of `startTimestamp` in packed ownership. uint256 private constant BITPOS_START_TIMESTAMP = 160; // The bit mask of the `burned` bit in packed ownership. uint256 private constant BITMASK_BURNED = 1 << 224; // The bit position of the `nextInitialized` bit in packed ownership. uint256 private constant BITPOS_NEXT_INITIALIZED = 225; // The bit mask of the `nextInitialized` bit in packed ownership. uint256 private constant BITMASK_NEXT_INITIALIZED = 1 << 225; // The tokenId of the next token to be minted. uint256 private _currentIndex; // The number of tokens burned. uint256 private _burnCounter; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to ownership details // An empty struct value does not necessarily mean the token is unowned. // See `_packedOwnershipOf` implementation for details. // // Bits Layout: // - [0..159] `addr` // - [160..223] `startTimestamp` // - [224] `burned` // - [225] `nextInitialized` mapping(uint256 => uint256) private _packedOwnerships; // Mapping owner address to address data. // // Bits Layout: // - [0..63] `balance` // - [64..127] `numberMinted` // - [128..191] `numberBurned` // - [192..255] `aux` mapping(address => uint256) private _packedAddressData; // Mapping from token ID to approved address. mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; _currentIndex = _startTokenId(); } /** * @dev Returns the starting token ID. * To change the starting token ID, please override this function. */ function _startTokenId() internal view virtual returns (uint256) { return 0; } /** * @dev Returns the next token ID to be minted. */ function _nextTokenId() internal view returns (uint256) { return _currentIndex; } /** * @dev Returns the total number of tokens in existence. * Burned tokens will reduce the count. * To get the total number of tokens minted, please see `_totalMinted`. */ function totalSupply() public view override returns (uint256) { // Counter underflow is impossible as _burnCounter cannot be incremented // more than `_currentIndex - _startTokenId()` times. unchecked { return _currentIndex - _burnCounter - _startTokenId(); } } /** * @dev Returns the total amount of tokens minted in the contract. */ function _totalMinted() internal view returns (uint256) { // Counter underflow is impossible as _currentIndex does not decrement, // and it is initialized to `_startTokenId()` unchecked { return _currentIndex - _startTokenId(); } } /** * @dev Returns the total number of tokens burned. */ function _totalBurned() internal view returns (uint256) { return _burnCounter; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { // The interface IDs are constants representing the first 4 bytes of the XOR of // all function selectors in the interface. See: https://eips.ethereum.org/EIPS/eip-165 // e.g. `bytes4(i.functionA.selector ^ i.functionB.selector ^ ...)` return interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165. interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721. interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata. } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view override returns (uint256) { if (owner == address(0)) revert BalanceQueryForZeroAddress(); return _packedAddressData[owner] & BITMASK_ADDRESS_DATA_ENTRY; } /** * Returns the number of tokens minted by `owner`. */ function _numberMinted(address owner) internal view returns (uint256) { return (_packedAddressData[owner] >> BITPOS_NUMBER_MINTED) & BITMASK_ADDRESS_DATA_ENTRY; } /** * Returns the number of tokens burned by or on behalf of `owner`. */ function _numberBurned(address owner) internal view returns (uint256) { return (_packedAddressData[owner] >> BITPOS_NUMBER_BURNED) & BITMASK_ADDRESS_DATA_ENTRY; } /** * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used). */ function _getAux(address owner) internal view returns (uint64) { return uint64(_packedAddressData[owner] >> BITPOS_AUX); } /** * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used). * If there are multiple variables, please pack them into a uint64. */ function _setAux(address owner, uint64 aux) internal { uint256 packed = _packedAddressData[owner]; uint256 auxCasted; assembly { // Cast aux without masking. auxCasted := aux } packed = (packed & BITMASK_AUX_COMPLEMENT) | (auxCasted << BITPOS_AUX); _packedAddressData[owner] = packed; } /** * Returns the packed ownership data of `tokenId`. */ function _packedOwnershipOf(uint256 tokenId) private view returns (uint256) { uint256 curr = tokenId; unchecked { if (_startTokenId() <= curr) if (curr < _currentIndex) { uint256 packed = _packedOwnerships[curr]; // If not burned. if (packed & BITMASK_BURNED == 0) { // Invariant: // There will always be an ownership that has an address and is not burned // before an ownership that does not have an address and is not burned. // Hence, curr will not underflow. // // We can directly compare the packed value. // If the address is zero, packed is zero. while (packed == 0) { packed = _packedOwnerships[--curr]; } return packed; } } } revert OwnerQueryForNonexistentToken(); } /** * Returns the unpacked `TokenOwnership` struct from `packed`. */ function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) { ownership.addr = address(uint160(packed)); ownership.startTimestamp = uint64(packed >> BITPOS_START_TIMESTAMP); ownership.burned = packed & BITMASK_BURNED != 0; } /** * Returns the unpacked `TokenOwnership` struct at `index`. */ function _ownershipAt(uint256 index) internal view returns (TokenOwnership memory) { return _unpackedOwnership(_packedOwnerships[index]); } /** * @dev Initializes the ownership slot minted at `index` for efficiency purposes. */ function _initializeOwnershipAt(uint256 index) internal { if (_packedOwnerships[index] == 0) { _packedOwnerships[index] = _packedOwnershipOf(index); } } /** * Gas spent here starts off proportional to the maximum mint batch size. * It gradually moves to O(1) as tokens get transferred around in the collection over time. */ function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) { return _unpackedOwnership(_packedOwnershipOf(tokenId)); } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view override returns (address) { return address(uint160(_packedOwnershipOf(tokenId))); } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { if (!_exists(tokenId)) revert URIQueryForNonexistentToken(); string memory baseURI = _baseURI(); return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, _toString(tokenId))) : ''; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overriden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ''; } /** * @dev Casts the address to uint256 without masking. */ function _addressToUint256(address value) private pure returns (uint256 result) { assembly { result := value } } /** * @dev Casts the boolean to uint256 without branching. */ function _boolToUint256(bool value) private pure returns (uint256 result) { assembly { result := value } } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public override { address owner = address(uint160(_packedOwnershipOf(tokenId))); if (to == owner) revert ApprovalToCurrentOwner(); if (_msgSenderERC721A() != owner) if (!isApprovedForAll(owner, _msgSenderERC721A())) { revert ApprovalCallerNotOwnerNorApproved(); } _tokenApprovals[tokenId] = to; emit Approval(owner, to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view override returns (address) { if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken(); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { if (operator == _msgSenderERC721A()) revert ApproveToCaller(); _operatorApprovals[_msgSenderERC721A()][operator] = approved; emit ApprovalForAll(_msgSenderERC721A(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom( address from, address to, uint256 tokenId ) public virtual override { _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId ) public virtual override { safeTransferFrom(from, to, tokenId, ''); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory _data ) public virtual override { _transfer(from, to, tokenId); if (to.code.length != 0) if (!_checkContractOnERC721Received(from, to, tokenId, _data)) { revert TransferToNonERC721ReceiverImplementer(); } } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), */ function _exists(uint256 tokenId) internal view returns (bool) { return _startTokenId() <= tokenId && tokenId < _currentIndex && // If within bounds, _packedOwnerships[tokenId] & BITMASK_BURNED == 0; // and not burned. } /** * @dev Equivalent to `_safeMint(to, quantity, '')`. */ function _safeMint(address to, uint256 quantity) internal { _safeMint(to, quantity, ''); } /** * @dev Safely mints `quantity` tokens and transfers them to `to`. * * Requirements: * * - If `to` refers to a smart contract, it must implement * {IERC721Receiver-onERC721Received}, which is called for each safe transfer. * - `quantity` must be greater than 0. * * Emits a {Transfer} event. */ function _safeMint( address to, uint256 quantity, bytes memory _data ) internal { uint256 startTokenId = _currentIndex; if (to == address(0)) revert MintToZeroAddress(); if (quantity == 0) revert MintZeroQuantity(); _beforeTokenTransfers(address(0), to, startTokenId, quantity); // Overflows are incredibly unrealistic. // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1 // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1 unchecked { // Updates: // - `balance += quantity`. // - `numberMinted += quantity`. // // We can directly add to the balance and number minted. _packedAddressData[to] += quantity * ((1 << BITPOS_NUMBER_MINTED) | 1); // Updates: // - `address` to the owner. // - `startTimestamp` to the timestamp of minting. // - `burned` to `false`. // - `nextInitialized` to `quantity == 1`. _packedOwnerships[startTokenId] = _addressToUint256(to) | (block.timestamp << BITPOS_START_TIMESTAMP) | (_boolToUint256(quantity == 1) << BITPOS_NEXT_INITIALIZED); uint256 updatedIndex = startTokenId; uint256 end = updatedIndex + quantity; if (to.code.length != 0) { do { emit Transfer(address(0), to, updatedIndex); if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) { revert TransferToNonERC721ReceiverImplementer(); } } while (updatedIndex < end); // Reentrancy protection if (_currentIndex != startTokenId) revert(); } else { do { emit Transfer(address(0), to, updatedIndex++); } while (updatedIndex < end); } _currentIndex = updatedIndex; } _afterTokenTransfers(address(0), to, startTokenId, quantity); } /** * @dev Mints `quantity` tokens and transfers them to `to`. * * Requirements: * * - `to` cannot be the zero address. * - `quantity` must be greater than 0. * * Emits a {Transfer} event. */ function _mint(address to, uint256 quantity) internal { uint256 startTokenId = _currentIndex; if (to == address(0)) revert MintToZeroAddress(); if (quantity == 0) revert MintZeroQuantity(); _beforeTokenTransfers(address(0), to, startTokenId, quantity); // Overflows are incredibly unrealistic. // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1 // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1 unchecked { // Updates: // - `balance += quantity`. // - `numberMinted += quantity`. // // We can directly add to the balance and number minted. _packedAddressData[to] += quantity * ((1 << BITPOS_NUMBER_MINTED) | 1); // Updates: // - `address` to the owner. // - `startTimestamp` to the timestamp of minting. // - `burned` to `false`. // - `nextInitialized` to `quantity == 1`. _packedOwnerships[startTokenId] = _addressToUint256(to) | (block.timestamp << BITPOS_START_TIMESTAMP) | (_boolToUint256(quantity == 1) << BITPOS_NEXT_INITIALIZED); uint256 updatedIndex = startTokenId; uint256 end = updatedIndex + quantity; do { emit Transfer(address(0), to, updatedIndex++); } while (updatedIndex < end); _currentIndex = updatedIndex; } _afterTokenTransfers(address(0), to, startTokenId, quantity); } /** * @dev Transfers `tokenId` from `from` to `to`. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint256 tokenId ) private { uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId); if (address(uint160(prevOwnershipPacked)) != from) revert TransferFromIncorrectOwner(); bool isApprovedOrOwner = (_msgSenderERC721A() == from || isApprovedForAll(from, _msgSenderERC721A()) || getApproved(tokenId) == _msgSenderERC721A()); if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved(); if (to == address(0)) revert TransferToZeroAddress(); _beforeTokenTransfers(from, to, tokenId, 1); // Clear approvals from the previous owner. delete _tokenApprovals[tokenId]; // Underflow of the sender's balance is impossible because we check for // ownership above and the recipient's balance can't realistically overflow. // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256. unchecked { // We can directly increment and decrement the balances. --_packedAddressData[from]; // Updates: `balance -= 1`. ++_packedAddressData[to]; // Updates: `balance += 1`. // Updates: // - `address` to the next owner. // - `startTimestamp` to the timestamp of transfering. // - `burned` to `false`. // - `nextInitialized` to `true`. _packedOwnerships[tokenId] = _addressToUint256(to) | (block.timestamp << BITPOS_START_TIMESTAMP) | BITMASK_NEXT_INITIALIZED; // If the next slot may not have been initialized (i.e. `nextInitialized == false`) . if (prevOwnershipPacked & BITMASK_NEXT_INITIALIZED == 0) { uint256 nextTokenId = tokenId + 1; // If the next slot's address is zero and not burned (i.e. packed value is zero). if (_packedOwnerships[nextTokenId] == 0) { // If the next slot is within bounds. if (nextTokenId != _currentIndex) { // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`. _packedOwnerships[nextTokenId] = prevOwnershipPacked; } } } } emit Transfer(from, to, tokenId); _afterTokenTransfers(from, to, tokenId, 1); } /** * @dev Equivalent to `_burn(tokenId, false)`. */ function _burn(uint256 tokenId) internal virtual { _burn(tokenId, false); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId, bool approvalCheck) internal virtual { uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId); address from = address(uint160(prevOwnershipPacked)); if (approvalCheck) { bool isApprovedOrOwner = (_msgSenderERC721A() == from || isApprovedForAll(from, _msgSenderERC721A()) || getApproved(tokenId) == _msgSenderERC721A()); if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved(); } _beforeTokenTransfers(from, address(0), tokenId, 1); // Clear approvals from the previous owner. delete _tokenApprovals[tokenId]; // Underflow of the sender's balance is impossible because we check for // ownership above and the recipient's balance can't realistically overflow. // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256. unchecked { // Updates: // - `balance -= 1`. // - `numberBurned += 1`. // // We can directly decrement the balance, and increment the number burned. // This is equivalent to `packed -= 1; packed += 1 << BITPOS_NUMBER_BURNED;`. _packedAddressData[from] += (1 << BITPOS_NUMBER_BURNED) - 1; // Updates: // - `address` to the last owner. // - `startTimestamp` to the timestamp of burning. // - `burned` to `true`. // - `nextInitialized` to `true`. _packedOwnerships[tokenId] = _addressToUint256(from) | (block.timestamp << BITPOS_START_TIMESTAMP) | BITMASK_BURNED | BITMASK_NEXT_INITIALIZED; // If the next slot may not have been initialized (i.e. `nextInitialized == false`) . if (prevOwnershipPacked & BITMASK_NEXT_INITIALIZED == 0) { uint256 nextTokenId = tokenId + 1; // If the next slot's address is zero and not burned (i.e. packed value is zero). if (_packedOwnerships[nextTokenId] == 0) { // If the next slot is within bounds. if (nextTokenId != _currentIndex) { // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`. _packedOwnerships[nextTokenId] = prevOwnershipPacked; } } } } emit Transfer(from, address(0), tokenId); _afterTokenTransfers(from, address(0), tokenId, 1); // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times. unchecked { _burnCounter++; } } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param _data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkContractOnERC721Received( address from, address to, uint256 tokenId, bytes memory _data ) private returns (bool) { try ERC721A__IERC721Receiver(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data) returns ( bytes4 retval ) { return retval == ERC721A__IERC721Receiver(to).onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert TransferToNonERC721ReceiverImplementer(); } else { assembly { revert(add(32, reason), mload(reason)) } } } } /** * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting. * And also called before burning one token. * * startTokenId - the first token id to be transferred * quantity - the amount to be transferred * * Calling conditions: * * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be * transferred to `to`. * - When `from` is zero, `tokenId` will be minted for `to`. * - When `to` is zero, `tokenId` will be burned by `from`. * - `from` and `to` are never both zero. */ function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual {} /** * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes * minting. * And also called after one token has been burned. * * startTokenId - the first token id to be transferred * quantity - the amount to be transferred * * Calling conditions: * * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been * transferred to `to`. * - When `from` is zero, `tokenId` has been minted for `to`. * - When `to` is zero, `tokenId` has been burned by `from`. * - `from` and `to` are never both zero. */ function _afterTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual {} /** * @dev Returns the message sender (defaults to `msg.sender`). * * If you are writing GSN compatible contracts, you need to override this function. */ function _msgSenderERC721A() internal view virtual returns (address) { return msg.sender; } /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function _toString(uint256 value) internal pure returns (string memory ptr) { assembly { // The maximum value of a uint256 contains 78 digits (1 byte per digit), // but we allocate 128 bytes to keep the free memory pointer 32-byte word aliged. // We will need 1 32-byte word to store the length, // and 3 32-byte words to store a maximum of 78 digits. Total: 32 + 3 * 32 = 128. ptr := add(mload(0x40), 128) // Update the free memory pointer to allocate. mstore(0x40, ptr) // Cache the end of the memory to calculate the length later. let end := ptr // We write the string from the rightmost digit to the leftmost digit. // The following is essentially a do-while loop that also handles the zero case. // Costs a bit more than early returning for the zero case, // but cheaper in terms of deployment and overall runtime costs. for { // Initialize and perform the first pass without check. let temp := value // Move the pointer 1 byte leftwards to point to an empty character slot. ptr := sub(ptr, 1) // Write the character to the pointer. 48 is the ASCII index of '0'. mstore8(ptr, add(48, mod(temp, 10))) temp := div(temp, 10) } temp { // Keep dividing `temp` until zero. temp := div(temp, 10) } { // Body of the for loop. ptr := sub(ptr, 1) mstore8(ptr, add(48, mod(temp, 10))) } let length := sub(end, ptr) // Move the pointer 32 bytes leftwards to make room for the length. ptr := sub(ptr, 32) // Store the length. mstore(ptr, length) } } } // File: erc721a/contracts/extensions/ERC721AQueryable.sol // ERC721A Contracts v4.0.0 // Creator: Chiru Labs pragma solidity ^0.8.4; /** * @title ERC721A Queryable * @dev ERC721A subclass with convenience query functions. */ abstract contract ERC721AQueryable is ERC721A, IERC721AQueryable { /** * @dev Returns the `TokenOwnership` struct at `tokenId` without reverting. * * If the `tokenId` is out of bounds: * - `addr` = `address(0)` * - `startTimestamp` = `0` * - `burned` = `false` * * If the `tokenId` is burned: * - `addr` = `<Address of owner before token was burned>` * - `startTimestamp` = `<Timestamp when token was burned>` * - `burned = `true` * * Otherwise: * - `addr` = `<Address of owner>` * - `startTimestamp` = `<Timestamp of start of ownership>` * - `burned = `false` */ function explicitOwnershipOf(uint256 tokenId) public view override returns (TokenOwnership memory) { TokenOwnership memory ownership; if (tokenId < _startTokenId() || tokenId >= _nextTokenId()) { return ownership; } ownership = _ownershipAt(tokenId); if (ownership.burned) { return ownership; } return _ownershipOf(tokenId); } /** * @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order. * See {ERC721AQueryable-explicitOwnershipOf} */ function explicitOwnershipsOf(uint256[] memory tokenIds) external view override returns (TokenOwnership[] memory) { unchecked { uint256 tokenIdsLength = tokenIds.length; TokenOwnership[] memory ownerships = new TokenOwnership[](tokenIdsLength); for (uint256 i; i != tokenIdsLength; ++i) { ownerships[i] = explicitOwnershipOf(tokenIds[i]); } return ownerships; } } /** * @dev Returns an array of token IDs owned by `owner`, * in the range [`start`, `stop`) * (i.e. `start <= tokenId < stop`). * * This function allows for tokens to be queried if the collection * grows too big for a single call of {ERC721AQueryable-tokensOfOwner}. * * Requirements: * * - `start` < `stop` */ function tokensOfOwnerIn( address owner, uint256 start, uint256 stop ) external view override returns (uint256[] memory) { unchecked { if (start >= stop) revert InvalidQueryRange(); uint256 tokenIdsIdx; uint256 stopLimit = _nextTokenId(); // Set `start = max(start, _startTokenId())`. if (start < _startTokenId()) { start = _startTokenId(); } // Set `stop = min(stop, stopLimit)`. if (stop > stopLimit) { stop = stopLimit; } uint256 tokenIdsMaxLength = balanceOf(owner); // Set `tokenIdsMaxLength = min(balanceOf(owner), stop - start)`, // to cater for cases where `balanceOf(owner)` is too big. if (start < stop) { uint256 rangeLength = stop - start; if (rangeLength < tokenIdsMaxLength) { tokenIdsMaxLength = rangeLength; } } else { tokenIdsMaxLength = 0; } uint256[] memory tokenIds = new uint256[](tokenIdsMaxLength); if (tokenIdsMaxLength == 0) { return tokenIds; } // We need to call `explicitOwnershipOf(start)`, // because the slot at `start` may not be initialized. TokenOwnership memory ownership = explicitOwnershipOf(start); address currOwnershipAddr; // If the starting slot exists (i.e. not burned), initialize `currOwnershipAddr`. // `ownership.address` will not be zero, as `start` is clamped to the valid token ID range. if (!ownership.burned) { currOwnershipAddr = ownership.addr; } for (uint256 i = start; i != stop && tokenIdsIdx != tokenIdsMaxLength; ++i) { ownership = _ownershipAt(i); if (ownership.burned) { continue; } if (ownership.addr != address(0)) { currOwnershipAddr = ownership.addr; } if (currOwnershipAddr == owner) { tokenIds[tokenIdsIdx++] = i; } } // Downsize the array to fit. assembly { mstore(tokenIds, tokenIdsIdx) } return tokenIds; } } /** * @dev Returns an array of token IDs owned by `owner`. * * This function scans the ownership mapping and is O(totalSupply) in complexity. * It is meant to be called off-chain. * * See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into * multiple smaller scans if the collection is large enough to cause * an out-of-gas error (10K pfp collections should be fine). */ function tokensOfOwner(address owner) external view override returns (uint256[] memory) { unchecked { uint256 tokenIdsIdx; address currOwnershipAddr; uint256 tokenIdsLength = balanceOf(owner); uint256[] memory tokenIds = new uint256[](tokenIdsLength); TokenOwnership memory ownership; for (uint256 i = _startTokenId(); tokenIdsIdx != tokenIdsLength; ++i) { ownership = _ownershipAt(i); if (ownership.burned) { continue; } if (ownership.addr != address(0)) { currOwnershipAddr = ownership.addr; } if (currOwnershipAddr == owner) { tokenIds[tokenIdsIdx++] = i; } } return tokenIds; } } } // File: erc721a/contracts/extensions/ERC721ABurnable.sol // ERC721A Contracts v4.0.0 // Creator: Chiru Labs pragma solidity ^0.8.4; /** * @title ERC721A Burnable Token * @dev ERC721A Token that can be irreversibly burned (destroyed). */ abstract contract ERC721ABurnable is ERC721A, IERC721ABurnable { /** * @dev Burns `tokenId`. See {ERC721A-_burn}. * * Requirements: * * - The caller must own `tokenId` or be an approved operator. */ function burn(uint256 tokenId) public virtual override { _burn(tokenId, true); } } // File: @openzeppelin/contracts/utils/Address.sol // 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 Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } // File: @openzeppelin/contracts/utils/introspection/IERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: @openzeppelin/contracts/token/ERC721/IERC721.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); } // File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); } // File: @openzeppelin/contracts/utils/introspection/ERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } // File: @openzeppelin/contracts/utils/Strings.sol // OpenZeppelin Contracts v4.4.1 (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef"; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } return string(buffer); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { if (value == 0) { return "0x00"; } uint256 temp = value; uint256 length = 0; while (temp != 0) { length++; temp >>= 8; } return toHexString(value, length); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _HEX_SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } } // File: @openzeppelin/contracts/access/IAccessControl.sol // OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol) pragma solidity ^0.8.0; /** * @dev External interface of AccessControl declared to support ERC165 detection. */ interface IAccessControl { /** * @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); /** * @dev Emitted when `account` is revoked `role`. * * `sender` is the account that originated the contract call: * - if using `revokeRole`, it is the admin role bearer * - if using `renounceRole`, it is the role bearer (i.e. `account`) */ event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) external view returns (bool); /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {AccessControl-_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) external view returns (bytes32); /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) external; /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) external; /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been granted `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) external; } // File: @openzeppelin/contracts/utils/Context.sol // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File: @openzeppelin/contracts/security/Pausable.sol // OpenZeppelin Contracts v4.4.1 (security/Pausable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers `whenNotPaused` and `whenPaused`, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. */ abstract contract Pausable is Context { /** * @dev Emitted when the pause is triggered by `account`. */ event Paused(address account); /** * @dev Emitted when the pause is lifted by `account`. */ event Unpaused(address account); bool private _paused; /** * @dev Initializes the contract in unpaused state. */ constructor() { _paused = false; } /** * @dev Returns true if the contract is paused, and false otherwise. */ function paused() public view virtual returns (bool) { return _paused; } /** * @dev Modifier to make a function callable only when the contract is not paused. * * Requirements: * * - The contract must not be paused. */ modifier whenNotPaused() { require(!paused(), "Pausable: paused"); _; } /** * @dev Modifier to make a function callable only when the contract is paused. * * Requirements: * * - The contract must be paused. */ modifier whenPaused() { require(paused(), "Pausable: not paused"); _; } /** * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. */ function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } /** * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. */ function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } } // File: nft/ERC721APausable.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Pausable.sol) pragma solidity ^0.8.0; /** * @dev ERC721 token with pausable token transfers, minting and burning. * * Useful for scenarios such as preventing trades until the end of an evaluation * period, or having an emergency switch for freezing all token transfers in the * event of a large bug. */ abstract contract ERC721APausable is ERC721A, Pausable { /** * @dev See {ERC721A-_beforeTokenTransfers}. * * Requirements: * * - the contract must not be paused. */ function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual override(ERC721A) { super._beforeTokenTransfers(from, to, startTokenId, quantity); require(!paused(), "ERC721APausable: token transfer while paused"); } } // File: @openzeppelin/contracts/token/ERC721/ERC721.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/ERC721.sol) pragma solidity ^0.8.0; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata { using Address for address; using Strings for uint256; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) private _owners; // Mapping owner address to token count mapping(address => uint256) private _balances; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: balance query for the zero address"); return _balances[owner]; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { address owner = _owners[tokenId]; require(owner != address(0), "ERC721: owner query for nonexistent token"); return owner; } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token"); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overridden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not owner nor approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { require(_exists(tokenId), "ERC721: approved query for nonexistent token"); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { _setApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom( address from, address to, uint256 tokenId ) public virtual override { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved"); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId ) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory _data ) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved"); _safeTransfer(from, to, tokenId, _data); } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * `_data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer( address from, address to, uint256 tokenId, bytes memory _data ) internal virtual { _transfer(from, to, tokenId); require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return _owners[tokenId] != address(0); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { require(_exists(tokenId), "ERC721: operator query for nonexistent token"); address owner = ERC721.ownerOf(tokenId); return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: * * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint( address to, uint256 tokenId, bytes memory _data ) internal virtual { _mint(to, tokenId); require( _checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId); _balances[to] += 1; _owners[tokenId] = to; emit Transfer(address(0), to, tokenId); _afterTokenTransfer(address(0), to, tokenId); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ERC721.ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId); // Clear approvals _approve(address(0), tokenId); _balances[owner] -= 1; delete _owners[tokenId]; emit Transfer(owner, address(0), tokenId); _afterTokenTransfer(owner, address(0), tokenId); } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint256 tokenId ) internal virtual { require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId); // Clear approvals from the previous owner _approve(address(0), tokenId); _balances[from] -= 1; _balances[to] += 1; _owners[tokenId] = to; emit Transfer(from, to, tokenId); _afterTokenTransfer(from, to, tokenId); } /** * @dev Approve `to` to operate on `tokenId` * * Emits a {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.ownerOf(tokenId), to, tokenId); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits a {ApprovalForAll} event. */ function _setApprovalForAll( address owner, address operator, bool approved ) internal virtual { require(owner != operator, "ERC721: approve to caller"); _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param _data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 tokenId, bytes memory _data ) private returns (bool) { if (to.isContract()) { try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) { return retval == IERC721Receiver.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721: transfer to non ERC721Receiver implementer"); } else { assembly { revert(add(32, reason), mload(reason)) } } } } else { return true; } } /** * @dev Hook that is called before any token transfer. This includes minting * and burning. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be * transferred to `to`. * - When `from` is zero, `tokenId` will be minted for `to`. * - When `to` is zero, ``from``'s `tokenId` will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal virtual {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 tokenId ) internal virtual {} } // File: @openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Pausable.sol) pragma solidity ^0.8.0; /** * @dev ERC721 token with pausable token transfers, minting and burning. * * Useful for scenarios such as preventing trades until the end of an evaluation * period, or having an emergency switch for freezing all token transfers in the * event of a large bug. */ abstract contract ERC721Pausable is ERC721, Pausable { /** * @dev See {ERC721-_beforeTokenTransfer}. * * Requirements: * * - the contract must not be paused. */ function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal virtual override { super._beforeTokenTransfer(from, to, tokenId); require(!paused(), "ERC721Pausable: token transfer while paused"); } } // File: @openzeppelin/contracts/access/AccessControl.sol // OpenZeppelin Contracts (last updated v4.6.0) (access/AccessControl.sol) pragma solidity ^0.8.0; /** * @dev Contract module that allows children to implement role-based access * control mechanisms. This is a lightweight version that doesn't allow enumerating role * members except through off-chain means by accessing the contract event logs. Some * applications may benefit from on-chain enumerability, for those cases see * {AccessControlEnumerable}. * * Roles are referred to by their `bytes32` identifier. These should be exposed * in the external API and be unique. The best way to achieve this is by * using `public constant` hash digests: * * ``` * bytes32 public constant MY_ROLE = keccak256("MY_ROLE"); * ``` * * Roles can be used to represent a set of permissions. To restrict access to a * function call, use {hasRole}: * * ``` * function foo() public { * require(hasRole(MY_ROLE, msg.sender)); * ... * } * ``` * * Roles can be granted and revoked dynamically via the {grantRole} and * {revokeRole} functions. Each role has an associated admin role, and only * accounts that have a role's admin role can call {grantRole} and {revokeRole}. * * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means * that only accounts with this role will be able to grant or revoke other * roles. More complex role relationships can be created by using * {_setRoleAdmin}. * * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to * grant and revoke this role. Extra precautions should be taken to secure * accounts that have been granted it. */ abstract contract AccessControl is Context, IAccessControl, ERC165 { struct RoleData { mapping(address => bool) members; bytes32 adminRole; } mapping(bytes32 => RoleData) private _roles; bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00; /** * @dev Modifier that checks that an account has a specific role. Reverts * with a standardized message including the required role. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ * * _Available since v4.1._ */ modifier onlyRole(bytes32 role) { _checkRole(role); _; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId); } /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) public view virtual override returns (bool) { return _roles[role].members[account]; } /** * @dev Revert with a standard message if `_msgSender()` is missing `role`. * Overriding this function changes the behavior of the {onlyRole} modifier. * * Format of the revert message is described in {_checkRole}. * * _Available since v4.6._ */ function _checkRole(bytes32 role) internal view virtual { _checkRole(role, _msgSender()); } /** * @dev Revert with a standard message if `account` is missing `role`. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ */ function _checkRole(bytes32 role, address account) internal view virtual { if (!hasRole(role, account)) { revert( string( abi.encodePacked( "AccessControl: account ", Strings.toHexString(uint160(account), 20), " is missing role ", Strings.toHexString(uint256(role), 32) ) ) ); } } /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) { return _roles[role].adminRole; } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _grantRole(role, account); } /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _revokeRole(role, account); } /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been revoked `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) public virtual override { require(account == _msgSender(), "AccessControl: can only renounce roles for self"); _revokeRole(role, account); } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. Note that unlike {grantRole}, this function doesn't perform any * checks on the calling account. * * [WARNING] * ==== * This function should only be called from the constructor when setting * up the initial roles for the system. * * Using this function in any other way is effectively circumventing the admin * system imposed by {AccessControl}. * ==== * * NOTE: This function is deprecated in favor of {_grantRole}. */ function _setupRole(bytes32 role, address account) internal virtual { _grantRole(role, account); } /** * @dev Sets `adminRole` as ``role``'s admin role. * * Emits a {RoleAdminChanged} event. */ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual { bytes32 previousAdminRole = getRoleAdmin(role); _roles[role].adminRole = adminRole; emit RoleAdminChanged(role, previousAdminRole, adminRole); } /** * @dev Grants `role` to `account`. * * Internal function without access restriction. */ function _grantRole(bytes32 role, address account) internal virtual { if (!hasRole(role, account)) { _roles[role].members[account] = true; emit RoleGranted(role, account, _msgSender()); } } /** * @dev Revokes `role` from `account`. * * Internal function without access restriction. */ function _revokeRole(bytes32 role, address account) internal virtual { if (hasRole(role, account)) { _roles[role].members[account] = false; emit RoleRevoked(role, account, _msgSender()); } } } // File: @openzeppelin/contracts/access/Ownable.sol // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File: @openzeppelin/contracts/utils/Counters.sol // OpenZeppelin Contracts v4.4.1 (utils/Counters.sol) pragma solidity ^0.8.0; /** * @title Counters * @author Matt Condon (@shrugs) * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number * of elements in a mapping, issuing ERC721 ids, or counting request ids. * * Include with `using Counters for Counters.Counter;` */ library Counters { struct Counter { // This variable should never be directly accessed by users of the library: interactions must be restricted to // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add // this feature: see https://github.com/ethereum/solidity/issues/4637 uint256 _value; // default: 0 } function current(Counter storage counter) internal view returns (uint256) { return counter._value; } function increment(Counter storage counter) internal { unchecked { counter._value += 1; } } function decrement(Counter storage counter) internal { uint256 value = counter._value; require(value > 0, "Counter: decrement overflow"); unchecked { counter._value = value - 1; } } function reset(Counter storage counter) internal { counter._value = 0; } } // File: nft/NFTERC721A.sol pragma solidity ^0.8.7; contract NFTERC721A is ERC721A, ERC721ABurnable, ERC721AQueryable, ERC721APausable, AccessControl, Ownable, ContextMixin, NativeMetaTransaction { // Create a new role identifier for the minter role bytes32 public constant MINER_ROLE = keccak256("MINER_ROLE"); bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE"); // using Counters for Counters.Counter; // Counters.Counter private currentTokenId; /// @dev Base token URI used as a prefix by tokenURI(). string private baseTokenURI; string private collectionURI; // uint256 public constant TOTAL_SUPPLY = 10800; constructor() ERC721A("SONNY-BOOT", "HM-SON-BOOT") { _initializeEIP712("SONNY-BOOT"); baseTokenURI = "https://cdn.nftstar.com/hm-son-boot/metadata/"; collectionURI = "https://cdn.nftstar.com/hm-son-boot/meta-son-heung-min.json"; // Grant the contract deployer the default admin role: it will be able to grant and revoke any roles _setupRole(DEFAULT_ADMIN_ROLE, _msgSender()); _setupRole(MINER_ROLE, _msgSender()); _setupRole(PAUSER_ROLE, _msgSender()); } // function totalSupply() public view returns (uint256) { // return TOTAL_SUPPLY; // } // function remaining() public view returns (uint256) { // return TOTAL_SUPPLY - _totalMinted(); // } function mintTo(address to) public onlyRole(MINER_ROLE) { _mint(to, 1); } function mint(address to, uint256 quantity) public onlyRole(MINER_ROLE) { _safeMint(to, quantity); } /** * tokensOfOwner */ // function ownerTokens(address owner) public view returns (uint256[] memory) { // return tokensOfOwner(owner); // } /** * @dev Pauses all token transfers. * * See {ERC721Pausable} and {Pausable-_pause}. * * Requirements: * * - the caller must have the `PAUSER_ROLE`. */ function pause() public virtual { require( hasRole(PAUSER_ROLE, _msgSender()), "NFT: must have pauser role to pause" ); _pause(); } /** * @dev Unpauses all token transfers. * * See {ERC721Pausable} and {Pausable-_unpause}. * * Requirements: * * - the caller must have the `PAUSER_ROLE`. */ function unpause() public virtual { require( hasRole(PAUSER_ROLE, _msgSender()), "NFT: must have pauser role to unpause" ); _unpause(); } function current() public view returns (uint256) { return _totalMinted(); } function _startTokenId() internal pure override returns (uint256) { return 1; } function contractURI() public view returns (string memory) { return collectionURI; } function setContractURI(string memory _contractURI) public onlyOwner { collectionURI = _contractURI; } /// @dev Returns an URI for a given token ID function _baseURI() internal view virtual override returns (string memory) { return baseTokenURI; } /// @dev Sets the base token URI prefix. function setBaseTokenURI(string memory _baseTokenURI) public onlyOwner { baseTokenURI = _baseTokenURI; } function transferRoleAdmin(address newDefaultAdmin) external onlyRole(DEFAULT_ADMIN_ROLE) { _setupRole(DEFAULT_ADMIN_ROLE, newDefaultAdmin); } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControl, ERC721A) returns (bool) { return super.supportsInterface(interfaceId) || ERC721A.supportsInterface(interfaceId); } function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual override(ERC721A, ERC721APausable) { super._beforeTokenTransfers(from, to, startTokenId, quantity); } function _msgSender() internal view virtual override returns (address sender) { return ContextMixin.msgSender(); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"InvalidQueryRange","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":[{"indexed":false,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"address payable","name":"relayerAddress","type":"address"},{"indexed":false,"internalType":"bytes","name":"functionSignature","type":"bytes"}],"name":"MetaTransactionExecuted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","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":"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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ERC712_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAUSER_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":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"current","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"bytes","name":"functionSignature","type":"bytes"},{"internalType":"bytes32","name":"sigR","type":"bytes32"},{"internalType":"bytes32","name":"sigS","type":"bytes32"},{"internalType":"uint8","name":"sigV","type":"uint8"}],"name":"executeMetaTransaction","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"bytes","name":"functionSignature","type":"bytes"},{"internalType":"bytes32","name":"sigR","type":"bytes32"},{"internalType":"bytes32","name":"sigS","type":"bytes32"},{"internalType":"uint8","name":"sigV","type":"uint8"},{"internalType":"uint256","name":"userNonce","type":"uint256"}],"name":"executeMetaTransactionWithExternalNonce","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"explicitOwnershipOf","outputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint64","name":"startTimestamp","type":"uint64"},{"internalType":"bool","name":"burned","type":"bool"}],"internalType":"struct IERC721A.TokenOwnership","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"explicitOwnershipsOf","outputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint64","name":"startTimestamp","type":"uint64"},{"internalType":"bool","name":"burned","type":"bool"}],"internalType":"struct IERC721A.TokenOwnership[]","name":"","type":"tuple[]"}],"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":"getChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDomainSeperator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getNonce","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"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":"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":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"mintTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"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":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseTokenURI","type":"string"}],"name":"setBaseTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_contractURI","type":"string"}],"name":"setContractURI","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":[{"internalType":"address","name":"owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"stop","type":"uint256"}],"name":"tokensOfOwnerIn","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":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newDefaultAdmin","type":"address"}],"name":"transferRoleAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
116994:4427:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;120657:295;;;;;;;;;;-1:-1:-1;120657:295:0;;;;;:::i;:::-;;:::i;:::-;;;12664:14:1;;12657:22;12639:41;;12627:2;12612:18;120657:295:0;;;;;;;;35818:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;37886:204::-;;;;;;;;;;-1:-1:-1;37886:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;10162:32:1;;;10144:51;;10132:2;10117:18;37886:204:0;9998:203:1;37346:474:0;;;;;;;;;;-1:-1:-1;37346:474:0;;;;;:::i;:::-;;:::i;:::-;;11422:1151;;;;;;:::i;:::-;;:::i;1554:43::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1554:43:0;;;;;29859:315;;;;;;;;;;-1:-1:-1;119816:1:0;30125:12;29912:7;30109:13;:28;-1:-1:-1;;30109:46:0;29859:315;;;12837:25:1;;;12825:2;12810:18;29859:315:0;12691:177:1;2550:101:0;;;;;;;;;;-1:-1:-1;2628:15:0;;2550:101;;38772:170;;;;;;;;;;-1:-1:-1;38772:170:0;;;;;:::i;:::-;;:::i;109361:131::-;;;;;;;;;;-1:-1:-1;109361:131:0;;;;;:::i;:::-;109435:7;109462:12;;;:6;:12;;;;;:22;;;;109361:131;14221:107;;;;;;;;;;-1:-1:-1;14221:107:0;;;;;:::i;:::-;-1:-1:-1;;;;;14308:12:0;14274:13;14308:12;;;:6;:12;;;;;;;14221:107;12581:1214;;;;;;:::i;:::-;;:::i;109754:147::-;;;;;;;;;;-1:-1:-1;109754:147:0;;;;;:::i;:::-;;:::i;120280:118::-;;;;;;;;;;-1:-1:-1;120280:118:0;;;;;:::i;:::-;;:::i;2659:161::-;;;;;;;;;;-1:-1:-1;2773:9:0;2659:161;;110802:218;;;;;;;;;;-1:-1:-1;110802:218:0;;;;;:::i;:::-;;:::i;119432:195::-;;;;;;;;;;;;;:::i;118517:114::-;;;;;;;;;;-1:-1:-1;118517:114:0;;;;;:::i;:::-;;:::i;39013:185::-;;;;;;;;;;-1:-1:-1;39013:185:0;;;;;:::i;:::-;;:::i;62818:94::-;;;;;;;;;;-1:-1:-1;62818:94:0;;;;;:::i;:::-;;:::i;57601:468::-;;;;;;;;;;-1:-1:-1;57601:468:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;87302:86::-;;;;;;;;;;-1:-1:-1;87373:7:0;;;;87302:86;;35607:144;;;;;;;;;;-1:-1:-1;35607:144:0;;;;;:::i;:::-;;:::i;117243:60::-;;;;;;;;;;;;117280:23;117243:60;;31484:224;;;;;;;;;;-1:-1:-1;31484:224:0;;;;;:::i;:::-;;:::i;114632:103::-;;;;;;;;;;;;;:::i;118422:87::-;;;;;;;;;;-1:-1:-1;118422:87:0;;;;;:::i;:::-;;:::i;119024:189::-;;;;;;;;;;;;;:::i;61413:892::-;;;;;;;;;;-1:-1:-1;61413:892:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;113981:87::-;;;;;;;;;;-1:-1:-1;114054:6:0;;-1:-1:-1;;;;;114054:6:0;113981:87;;107821:147;;;;;;;;;;-1:-1:-1;107821:147:0;;;;;:::i;:::-;;:::i;119939:116::-;;;;;;;;;;-1:-1:-1;119939:116:0;;;;;:::i;:::-;;:::i;35987:104::-;;;;;;;;;;;;;:::i;58459:2505::-;;;;;;;;;;-1:-1:-1;58459:2505:0;;;;;:::i;:::-;;:::i;119635:89::-;;;;;;;;;;-1:-1:-1;119675:7:0;30507:13;-1:-1:-1;;30507:31:0;119635:89;;106926:49;;;;;;;;;;-1:-1:-1;106926:49:0;106971:4;106926:49;;38162:308;;;;;;;;;;-1:-1:-1;38162:308:0;;;;;:::i;:::-;;:::i;120406:179::-;;;;;;;;;;-1:-1:-1;120406:179:0;;;;;:::i;:::-;;:::i;39269:396::-;;;;;;;;;;-1:-1:-1;39269:396:0;;;;;:::i;:::-;;:::i;57022:420::-;;;;;;;;;;-1:-1:-1;57022:420:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;36162:318::-;;;;;;;;;;-1:-1:-1;36162:318:0;;;;;:::i;:::-;;:::i;110146:149::-;;;;;;;;;;-1:-1:-1;110146:149:0;;;;;:::i;:::-;;:::i;117310:62::-;;;;;;;;;;;;117348:24;117310:62;;119833:98;;;;;;;;;;;;;:::i;38541:164::-;;;;;;;;;;-1:-1:-1;38541:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;38662:25:0;;;38638:4;38662:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;38541:164;114890:201;;;;;;;;;;-1:-1:-1;114890:201:0;;;;;:::i;:::-;;:::i;120657:295::-;120811:4;120853:36;120877:11;120853:23;:36::i;:::-;:91;;;;120906:38;120932:11;120906:25;:38::i;:::-;120833:111;120657:295;-1:-1:-1;;120657:295:0:o;35818:100::-;35872:13;35905:5;35898:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35818:100;:::o;37886:204::-;37954:7;37979:16;37987:7;37979;:16::i;:::-;37974:64;;38004:34;;-1:-1:-1;;;38004:34:0;;;;;;;;;;;37974:64;-1:-1:-1;38058:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;38058:24:0;;37886:204::o;37346:474::-;37419:13;37451:27;37470:7;37451:18;:27::i;:::-;37419:61;;37501:5;-1:-1:-1;;;;;37495:11:0;:2;-1:-1:-1;;;;;37495:11:0;;37491:48;;;37515:24;;-1:-1:-1;;;37515:24:0;;;;;;;;;;;37491:48;53989:10;-1:-1:-1;;;;;37556:28:0;;;37552:175;;37604:44;37621:5;53989:10;38541:164;:::i;37604:44::-;37599:128;;37676:35;;-1:-1:-1;;;37676:35:0;;;;;;;;;;;37599:128;37739:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;37739:29:0;-1:-1:-1;;;;;37739:29:0;;;;;;;;;37784:28;;37739:24;;37784:28;;;;;;;37408:412;37346:474;;:::o;11422:1151::-;11680:152;;;11623:12;11680:152;;;;;-1:-1:-1;;;;;11718:19:0;;11648:29;11718:19;;;:6;:19;;;;;;;;;11680:152;;;;;;;;;;;11867:45;11725:11;11680:152;11895:4;11901;11907;11867:6;:45::i;:::-;11845:128;;;;-1:-1:-1;;;11845:128:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;12062:19:0;;;;;;:6;:19;;;;;;:26;;12086:1;12062:23;:26::i;:::-;-1:-1:-1;;;;;12040:19:0;;;;;;:6;:19;;;;;;;:48;;;;12106:126;;;;;12047:11;;12178:10;;12204:17;;12106:126;:::i;:::-;;;;;;;;12343:12;12357:23;12392:4;-1:-1:-1;;;;;12384:18:0;12434:17;12453:11;12417:48;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;12417:48:0;;;;;;;;;;12384:92;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12342:134;;;;12495:7;12487:48;;;;-1:-1:-1;;;12487:48:0;;15463:2:1;12487:48:0;;;15445:21:1;15502:2;15482:18;;;15475:30;15541;15521:18;;;15514:58;15589:18;;12487:48:0;15261:352:1;12487:48:0;12555:10;11422:1151;-1:-1:-1;;;;;;;;11422:1151:0:o;38772:170::-;38906:28;38916:4;38922:2;38926:7;38906:9;:28::i;:::-;38772:170;;;:::o;12581:1214::-;12884:142;;;12827:12;12884:142;;;;;;;;-1:-1:-1;;;;;12884:142:0;;;;;;;;;;;;13061:45;12952:11;12884:142;13089:4;13095;13101;13061:6;:45::i;:::-;13039:128;;;;-1:-1:-1;;;13039:128:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;13199:19:0;;;;;;:6;:19;;;;;;13186:32;;13178:41;;;;;;13306:16;:9;13320:1;13306:13;:16::i;:::-;-1:-1:-1;;;;;13284:19:0;;;;;;:6;:19;;;;;;;:38;;;;13340:126;;;;;13291:11;;13412:10;;13438:17;;13340:126;:::i;:::-;;;;;;;;13577:12;13591:23;13626:4;-1:-1:-1;;;;;13618:18:0;13668:17;13687:11;13651:48;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;13651:48:0;;;;;;;;;;13618:92;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13576:134;;;;13729:7;13745:10;13721:36;;;;;-1:-1:-1;;;13721:36:0;;;;;;;;:::i;:::-;-1:-1:-1;13777:10:0;12581:1214;-1:-1:-1;;;;;;;;;12581:1214:0:o;109754:147::-;109435:7;109462:12;;;:6;:12;;;;;:22;;;107417:16;107428:4;107417:10;:16::i;:::-;109868:25:::1;109879:4;109885:7;109868:10;:25::i;120280:118::-:0;114212:12;:10;:12::i;:::-;-1:-1:-1;;;;;114201:23:0;:7;114054:6;;-1:-1:-1;;;;;114054:6:0;;113981:87;114201:7;-1:-1:-1;;;;;114201:23:0;;114193:68;;;;-1:-1:-1;;;114193:68:0;;;;;;;:::i;:::-;120362:28;;::::1;::::0;:12:::1;::::0;:28:::1;::::0;::::1;::::0;::::1;:::i;:::-;;120280:118:::0;:::o;110802:218::-;110909:12;:10;:12::i;:::-;-1:-1:-1;;;;;110898:23:0;:7;-1:-1:-1;;;;;110898:23:0;;110890:83;;;;-1:-1:-1;;;110890:83:0;;18557:2:1;110890:83:0;;;18539:21:1;18596:2;18576:18;;;18569:30;18635:34;18615:18;;;18608:62;-1:-1:-1;;;18686:18:1;;;18679:45;18741:19;;110890:83:0;18355:411:1;110890:83:0;110986:26;110998:4;111004:7;110986:11;:26::i;119432:195::-;119499:34;117348:24;119520:12;:10;:12::i;119499:34::-;119477:121;;;;-1:-1:-1;;;119477:121:0;;17336:2:1;119477:121:0;;;17318:21:1;17375:2;17355:18;;;17348:30;17414:34;17394:18;;;17387:62;-1:-1:-1;;;17465:18:1;;;17458:35;17510:19;;119477:121:0;17134:401:1;119477:121:0;119609:10;:8;:10::i;:::-;119432:195::o;118517:114::-;117280:23;107417:16;107428:4;107417:10;:16::i;:::-;118600:23:::1;118610:2;118614:8;118600:9;:23::i;39013:185::-:0;39151:39;39168:4;39174:2;39178:7;39151:39;;;;;;;;;;;;:16;:39::i;62818:94::-;62884:20;62890:7;62899:4;62884:5;:20::i;:::-;62818:94;:::o;57601:468::-;57776:15;;57690:23;;57751:22;57776:15;-1:-1:-1;;;;;57843:36:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;57843:36:0;;-1:-1:-1;;57843:36:0;;;;;;;;;;;;57806:73;;57899:9;57894:125;57915:14;57910:1;:19;57894:125;;57971:32;57991:8;58000:1;57991:11;;;;;;;;:::i;:::-;;;;;;;57971:19;:32::i;:::-;57955:10;57966:1;57955:13;;;;;;;;:::i;:::-;;;;;;;;;;:48;57931:3;;57894:125;;;-1:-1:-1;58040:10:0;57601:468;-1:-1:-1;;;57601:468:0:o;35607:144::-;35671:7;35714:27;35733:7;35714:18;:27::i;31484:224::-;31548:7;-1:-1:-1;;;;;31572:19:0;;31568:60;;31600:28;;-1:-1:-1;;;31600:28:0;;;;;;;;;;;31568:60;-1:-1:-1;;;;;;31646:25:0;;;;;:18;:25;;;;;;-1:-1:-1;;;;;31646:54:0;;31484:224::o;114632:103::-;114212:12;:10;:12::i;:::-;-1:-1:-1;;;;;114201:23:0;:7;114054:6;;-1:-1:-1;;;;;114054:6:0;;113981:87;114201:7;-1:-1:-1;;;;;114201:23:0;;114193:68;;;;-1:-1:-1;;;114193:68:0;;;;;;;:::i;:::-;114697:30:::1;114724:1;114697:18;:30::i;118422:87::-:0;117280:23;107417:16;107428:4;107417:10;:16::i;:::-;118489:12:::1;118495:2;118499:1;118489:5;:12::i;119024:189::-:0;119089:34;117348:24;119110:12;:10;:12::i;119089:34::-;119067:119;;;;-1:-1:-1;;;119067:119:0;;16571:2:1;119067:119:0;;;16553:21:1;16610:2;16590:18;;;16583:30;16649:34;16629:18;;;16622:62;-1:-1:-1;;;16700:18:1;;;16693:33;16743:19;;119067:119:0;16369:399:1;119067:119:0;119197:8;:6;:8::i;61413:892::-;61483:16;61537:19;61571:25;61611:22;61636:16;61646:5;61636:9;:16::i;:::-;61611:41;;61667:25;61709:14;-1:-1:-1;;;;;61695:29:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;61695:29:0;;61667:57;;61739:31;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;61739:31:0;119816:1;61785:472;61834:14;61819:11;:29;61785:472;;61886:15;61899:1;61886:12;:15::i;:::-;61874:27;;61924:9;:16;;;61920:73;;;61965:8;;61920:73;62015:14;;-1:-1:-1;;;;;62015:28:0;;62011:111;;62088:14;;;-1:-1:-1;62011:111:0;62165:5;-1:-1:-1;;;;;62144:26:0;:17;-1:-1:-1;;;;;62144:26:0;;62140:102;;;62221:1;62195:8;62204:13;;;;;;62195:23;;;;;;;;:::i;:::-;;;;;;:27;;;;;62140:102;61850:3;;61785:472;;;-1:-1:-1;62278:8:0;;61413:892;-1:-1:-1;;;;;;61413:892:0:o;107821:147::-;107907:4;107931:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;107931:29:0;;;;;;;;;;;;;;;107821:147::o;119939:116::-;114212:12;:10;:12::i;:::-;-1:-1:-1;;;;;114201:23:0;:7;114054:6;;-1:-1:-1;;;;;114054:6:0;;113981:87;114201:7;-1:-1:-1;;;;;114201:23:0;;114193:68;;;;-1:-1:-1;;;114193:68:0;;;;;;;:::i;:::-;120019:28;;::::1;::::0;:13:::1;::::0;:28:::1;::::0;::::1;::::0;::::1;:::i;35987:104::-:0;36043:13;36076:7;36069:14;;;;;:::i;58459:2505::-;58594:16;58661:4;58652:5;:13;58648:45;;58674:19;;-1:-1:-1;;;58674:19:0;;;;;;;;;;;58648:45;58708:19;58742:17;58762:14;29600:7;29627:13;;29553:95;58762:14;58742:34;-1:-1:-1;119816:1:0;58854:5;:23;58850:87;;;119816:1;58898:23;;58850:87;59013:9;59006:4;:16;59002:73;;;59050:9;59043:16;;59002:73;59089:25;59117:16;59127:5;59117:9;:16::i;:::-;59089:44;;59311:4;59303:5;:12;59299:278;;;59358:12;;;59393:31;;;59389:111;;;59469:11;59449:31;;59389:111;59317:198;59299:278;;;-1:-1:-1;59560:1:0;59299:278;59591:25;59633:17;-1:-1:-1;;;;;59619:32:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59619:32:0;-1:-1:-1;59591:60:0;-1:-1:-1;59670:22:0;59666:78;;59720:8;-1:-1:-1;59713:15:0;;-1:-1:-1;;;59713:15:0;59666:78;59888:31;59922:26;59942:5;59922:19;:26::i;:::-;59888:60;;59963:25;60208:9;:16;;;60203:92;;-1:-1:-1;60265:14:0;;60203:92;60326:5;60309:478;60338:4;60333:1;:9;;:45;;;;;60361:17;60346:11;:32;;60333:45;60309:478;;;60416:15;60429:1;60416:12;:15::i;:::-;60404:27;;60454:9;:16;;;60450:73;;;60495:8;;60450:73;60545:14;;-1:-1:-1;;;;;60545:28:0;;60541:111;;60618:14;;;-1:-1:-1;60541:111:0;60695:5;-1:-1:-1;;;;;60674:26:0;:17;-1:-1:-1;;;;;60674:26:0;;60670:102;;;60751:1;60725:8;60734:13;;;;;;60725:23;;;;;;;;:::i;:::-;;;;;;:27;;;;;60670:102;60380:3;;60309:478;;;-1:-1:-1;;;60872:29:0;;;-1:-1:-1;60879:8:0;;-1:-1:-1;;58459:2505:0;;;;;;:::o;119702:14::-;119695:21;;119635:89;:::o;38162:308::-;-1:-1:-1;;;;;38261:31:0;;53989:10;38261:31;38257:61;;;38301:17;;-1:-1:-1;;;38301:17:0;;;;;;;;;;;38257:61;53989:10;38331:39;;;;:18;:39;;;;;;;;-1:-1:-1;;;;;38331:49:0;;;;;;;;;;;;:60;;-1:-1:-1;;38331:60:0;;;;;;;;;;38407:55;;12639:41:1;;;38331:49:0;;53989:10;38407:55;;12612:18:1;38407:55:0;;;;;;;38162:308;;:::o;120406:179::-;106971:4;107417:16;106971:4;107417:10;:16::i;:::-;120530:47:::1;106971:4;120561:15:::0;120530:10:::1;:47::i;39269:396::-:0;39436:28;39446:4;39452:2;39456:7;39436:9;:28::i;:::-;-1:-1:-1;;;;;39479:14:0;;;:19;39475:183;;39518:56;39549:4;39555:2;39559:7;39568:5;39518:30;:56::i;:::-;39513:145;;39602:40;;-1:-1:-1;;;39602:40:0;;;;;;;;;;;39513:145;39269:396;;;;:::o;57022:420::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;119816:1:0;57178:25;;;:54;;-1:-1:-1;29600:7:0;29627:13;57207:7;:25;;57178:54;57174:103;;;57256:9;57022:420;-1:-1:-1;;57022:420:0:o;57174:103::-;57299:21;57312:7;57299:12;:21::i;:::-;57287:33;;57335:9;:16;;;57331:65;;;57375:9;57022:420;-1:-1:-1;;57022:420:0:o;57331:65::-;57413:21;57426:7;57413:12;:21::i;36162:318::-;36235:13;36266:16;36274:7;36266;:16::i;:::-;36261:59;;36291:29;;-1:-1:-1;;;36291:29:0;;;;;;;;;;;36261:59;36333:21;36357:10;:8;:10::i;:::-;36333:34;;36391:7;36385:21;36410:1;36385:26;;:87;;;;;;;;;;;;;;;;;36438:7;36447:18;36457:7;36447:9;:18::i;:::-;36421:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;36378:94;36162:318;-1:-1:-1;;;36162:318:0:o;110146:149::-;109435:7;109462:12;;;:6;:12;;;;;:22;;;107417:16;107428:4;107417:10;:16::i;:::-;110261:26:::1;110273:4;110279:7;110261:11;:26::i;119833:98::-:0;119877:13;119910;119903:20;;;;;:::i;114890:201::-;114212:12;:10;:12::i;:::-;-1:-1:-1;;;;;114201:23:0;:7;114054:6;;-1:-1:-1;;;;;114054:6:0;;113981:87;114201:7;-1:-1:-1;;;;;114201:23:0;;114193:68;;;;-1:-1:-1;;;114193:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;114979:22:0;::::1;114971:73;;;::::0;-1:-1:-1;;;114971:73:0;;15056:2:1;114971:73:0::1;::::0;::::1;15038:21:1::0;15095:2;15075:18;;;15068:30;15134:34;15114:18;;;15107:62;-1:-1:-1;;;15185:18:1;;;15178:36;15231:19;;114971:73:0::1;14854:402:1::0;114971:73:0::1;115055:28;115074:8;115055:18;:28::i;204:650::-:0;275:22;319:10;341:4;319:27;315:508;;;363:18;384:8;;363:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;423:8:0;634:17;628:24;-1:-1:-1;;;;;602:134:0;;-1:-1:-1;315:508:0;;-1:-1:-1;315:508:0;;-1:-1:-1;800:10:0;315:508;204:650;:::o;107525:204::-;107610:4;-1:-1:-1;;;;;;107634:47:0;;-1:-1:-1;;;107634:47:0;;:87;;-1:-1:-1;;;;;;;;;;80057:40:0;;;107685:36;79948:157;30805:615;30890:4;-1:-1:-1;;;;;;;;;31190:25:0;;;;:102;;-1:-1:-1;;;;;;;;;;31267:25:0;;;31190:102;:179;;;-1:-1:-1;;;;;;;;31344:25:0;-1:-1:-1;;;31344:25:0;;30805:615::o;39920:273::-;39977:4;40033:7;119816:1;40014:26;;:66;;;;;40067:13;;40057:7;:23;40014:66;:152;;;;-1:-1:-1;;40118:26:0;;;;:17;:26;;;;;;-1:-1:-1;;;40118:43:0;:48;;39920:273::o;33122:1129::-;33189:7;33224;;119816:1;33273:23;33269:915;;33326:13;;33319:4;:20;33315:869;;;33364:14;33381:23;;;:17;:23;;;;;;-1:-1:-1;;;33470:23:0;;33466:699;;33989:113;33996:11;33989:113;;-1:-1:-1;;;34067:6:0;34049:25;;;;:17;:25;;;;;;33989:113;;33466:699;33341:843;33315:869;34212:31;;-1:-1:-1;;;34212:31:0;;;;;;;;;;;14336:486;14514:4;-1:-1:-1;;;;;14539:20:0;;14531:70;;;;-1:-1:-1;;;14531:70:0;;15820:2:1;14531:70:0;;;15802:21:1;15859:2;15839:18;;;15832:30;15898:34;15878:18;;;15871:62;-1:-1:-1;;;15949:18:1;;;15942:35;15994:19;;14531:70:0;15618:401:1;14531:70:0;14655:159;14683:47;14702:27;14722:6;14702:19;:27::i;:::-;14683:18;:47::i;:::-;14655:159;;;;;;;;;;;;13522:25:1;;;;13595:4;13583:17;;13563:18;;;13556:45;13617:18;;;13610:34;;;13660:18;;;13653:34;;;13494:19;;14655:159:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;14632:182:0;:6;-1:-1:-1;;;;;14632:182:0;;14612:202;;14336:486;;;;;;;:::o;6330:98::-;6388:7;6415:5;6419:1;6415;:5;:::i;45159:2515::-;45274:27;45304;45323:7;45304:18;:27::i;:::-;45274:57;;45389:4;-1:-1:-1;;;;;45348:45:0;45364:19;-1:-1:-1;;;;;45348:45:0;;45344:86;;45402:28;;-1:-1:-1;;;45402:28:0;;;;;;;;;;;45344:86;45443:22;53989:10;-1:-1:-1;;;;;45469:27:0;;;;:87;;-1:-1:-1;45513:43:0;45530:4;53989:10;38541:164;:::i;45513:43::-;45469:147;;;-1:-1:-1;53989:10:0;45573:20;45585:7;45573:11;:20::i;:::-;-1:-1:-1;;;;;45573:43:0;;45469:147;45443:174;;45635:17;45630:66;;45661:35;;-1:-1:-1;;;45661:35:0;;;;;;;;;;;45630:66;-1:-1:-1;;;;;45711:16:0;;45707:52;;45736:23;;-1:-1:-1;;;45736:23:0;;;;;;;;;;;45707:52;45772:43;45794:4;45800:2;45804:7;45813:1;45772:21;:43::i;:::-;45888:24;;;;:15;:24;;;;;;;;45881:31;;-1:-1:-1;;;;;;45881:31:0;;;-1:-1:-1;;;;;46280:24:0;;;;;:18;:24;;;;;46278:26;;-1:-1:-1;;46278:26:0;;;46349:22;;;;;;;46347:24;;-1:-1:-1;46347:24:0;;;46642:26;;;:17;:26;;;;;-1:-1:-1;;;46730:15:0;27477:3;46730:41;46688:84;;:128;;46642:174;;;46936:46;;46932:626;;47040:1;47030:11;;47008:19;47163:30;;;:17;:30;;;;;;47159:384;;47301:13;;47286:11;:28;47282:242;;47448:30;;;;:17;:30;;;;;:52;;;47282:242;46989:569;46932:626;47605:7;47601:2;-1:-1:-1;;;;;47586:27:0;47595:4;-1:-1:-1;;;;;47586:27:0;-1:-1:-1;;;;;;;;;;;47586:27:0;;;;;;;;;45263:2411;;45159:2515;;;:::o;108272:105::-;108339:30;108350:4;108356:12;:10;:12::i;:::-;108339:10;:30::i;112303:238::-;112387:22;112395:4;112401:7;112387;:22::i;:::-;112382:152;;112426:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;112426:29:0;;;;;;;;;:36;;-1:-1:-1;;112426:36:0;112458:4;112426:36;;;112509:12;:10;:12::i;:::-;-1:-1:-1;;;;;112482:40:0;112500:7;-1:-1:-1;;;;;112482:40:0;112494:4;112482:40;;;;;;;;;;112303:238;;:::o;121240:178::-;121347:14;121386:24;:22;:24::i;112673:239::-;112757:22;112765:4;112771:7;112757;:22::i;:::-;112753:152;;;112828:5;112796:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;112796:29:0;;;;;;;;;:37;;-1:-1:-1;;112796:37:0;;;112880:12;:10;:12::i;:::-;-1:-1:-1;;;;;112853:40:0;112871:7;-1:-1:-1;;;;;112853:40:0;112865:4;112853:40;;;;;;;;;;112673:239;;:::o;88361:120::-;87373:7;;;;87897:41;;;;-1:-1:-1;;;87897:41:0;;14707:2:1;87897:41:0;;;14689:21:1;14746:2;14726:18;;;14719:30;-1:-1:-1;;;14765:18:1;;;14758:50;14825:18;;87897:41:0;14505:344:1;87897:41:0;88420:7:::1;:15:::0;;-1:-1:-1;;88420:15:0::1;::::0;;88451:22:::1;88460:12;:10;:12::i;:::-;88451:22;::::0;-1:-1:-1;;;;;10162:32:1;;;10144:51;;10132:2;10117:18;88451:22:0::1;;;;;;;88361:120::o:0;40277:104::-;40346:27;40356:2;40360:8;40346:27;;;;;;;;;;;;:9;:27::i;48070:2809::-;48150:27;48180;48199:7;48180:18;:27::i;:::-;48150:57;-1:-1:-1;48150:57:0;48285:311;;;;48319:22;53989:10;-1:-1:-1;;;;;48345:27:0;;;;:91;;-1:-1:-1;48393:43:0;48410:4;53989:10;38541:164;:::i;48393:43::-;48345:155;;;-1:-1:-1;53989:10:0;48457:20;48469:7;48457:11;:20::i;:::-;-1:-1:-1;;;;;48457:43:0;;48345:155;48319:182;;48523:17;48518:66;;48549:35;;-1:-1:-1;;;48549:35:0;;;;;;;;;;;48518:66;48304:292;48285:311;48608:51;48630:4;48644:1;48648:7;48657:1;48608:21;:51::i;:::-;48732:24;;;;:15;:24;;;;;;;;48725:31;;-1:-1:-1;;;;;;48725:31:0;;;-1:-1:-1;;;;;49345:24:0;;;;:18;:24;;;;;:59;;49373:31;49345:59;;;49642:26;;;:17;:26;;;;;-1:-1:-1;;;49732:15:0;27477:3;49732:41;49688:86;;:165;49642:211;;-1:-1:-1;;;49973:46:0;;49969:626;;50077:1;50067:11;;50045:19;50200:30;;;:17;:30;;;;;;50196:384;;50338:13;;50323:11;:28;50319:242;;50485:30;;;;:17;:30;;;;;:52;;;50319:242;50026:569;49969:626;50623:35;;50650:7;;50646:1;;-1:-1:-1;;;;;50623:35:0;;;-1:-1:-1;;;;;;;;;;;50623:35:0;50646:1;;50623:35;-1:-1:-1;;50846:12:0;:14;;;;;;-1:-1:-1;;48070:2809:0:o;115251:191::-;115344:6;;;-1:-1:-1;;;;;115361:17:0;;;-1:-1:-1;;;;;;115361:17:0;;;;;;;115394:40;;115344:6;;;115361:17;115344:6;;115394:40;;115325:16;;115394:40;115314:128;115251:191;:::o;43249:1656::-;43314:20;43337:13;-1:-1:-1;;;;;43365:16:0;;43361:48;;43390:19;;-1:-1:-1;;;43390:19:0;;;;;;;;;;;43361:48;43424:13;43420:44;;43446:18;;-1:-1:-1;;;43446:18:0;;;;;;;;;;;43420:44;43477:61;43507:1;43511:2;43515:12;43529:8;43477:21;:61::i;:::-;-1:-1:-1;;;;;44013:22:0;;;;;;:18;:22;;;;26960:2;44013:22;;;:70;;44051:31;44039:44;;44013:70;;;44326:31;;;:17;:31;;;;;44419:15;27477:3;44419:41;44377:84;;-1:-1:-1;44497:13:0;;27740:3;44482:56;44377:162;44326:213;;:31;44620:23;;;44660:111;44687:40;;44712:14;;;;;-1:-1:-1;;;;;44687:40:0;;;44704:1;;-1:-1:-1;;;;;;;;;;;44687:40:0;44704:1;;44687:40;44766:3;44751:12;:18;44660:111;;-1:-1:-1;44787:13:0;:28;38772:170;;;:::o;88102:118::-;87373:7;;;;87627:9;87619:38;;;;-1:-1:-1;;;87619:38:0;;16226:2:1;87619:38:0;;;16208:21:1;16265:2;16245:18;;;16238:30;-1:-1:-1;;;16284:18:1;;;16277:46;16340:18;;87619:38:0;16024:340:1;87619:38:0;88162:7:::1;:14:::0;;-1:-1:-1;;88162:14:0::1;88172:4;88162:14;::::0;;88192:20:::1;88199:12;:10;:12::i;34731:153::-:0;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;34851:24:0;;;;:17;:24;;;;;;34832:44;;:18;:44::i;111679:112::-;111758:25;111769:4;111775:7;111758:10;:25::i;51371:716::-;51555:88;;-1:-1:-1;;;51555:88:0;;51534:4;;-1:-1:-1;;;;;51555:45:0;;;;;:88;;53989:10;;51622:4;;51628:7;;51637:5;;51555:88;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51555:88:0;;;;;;;;-1:-1:-1;;51555:88:0;;;;;;;;;;;;:::i;:::-;;;51551:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51838:13:0;;51834:235;;51884:40;;-1:-1:-1;;;51884:40:0;;;;;;;;;;;51834:235;52027:6;52021:13;52012:6;52008:2;52004:15;51997:38;51551:529;-1:-1:-1;;;;;;51714:64:0;-1:-1:-1;;;51714:64:0;;-1:-1:-1;51551:529:0;51371:716;;;;;;:::o;35387:158::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;35490:47:0;35509:27;35528:7;35509:18;:27::i;:::-;35490:18;:47::i;120113:113::-;120173:13;120206:12;120199:19;;;;;:::i;54113:1959::-;54584:4;54578:11;;54591:3;54574:21;;54669:17;;;;55366:11;;;55245:5;55498:2;55512;55502:13;;55494:22;55366:11;55481:36;55553:2;55543:13;;55136:682;55572:4;55136:682;;;55747:1;55742:3;55738:11;55731:18;;55798:2;55792:4;55788:13;55784:2;55780:22;55775:3;55767:36;55668:2;55658:13;;55136:682;;;-1:-1:-1;55860:13:0;;;-1:-1:-1;;55975:12:0;;;56035:19;;;55975:12;54113:1959;-1:-1:-1;54113:1959:0:o;13803:410::-;13913:7;10746:108;;;;;;;;;;;;;;;;;10722:143;;;;;;;14067:12;;14102:11;;;;14146:24;;;;;14136:35;;;;;;13986:204;;;;;13104:25:1;;;13160:2;13145:18;;13138:34;;;;-1:-1:-1;;;;;13208:32:1;13203:2;13188:18;;13181:60;13272:2;13257:18;;13250:34;13091:3;13076:19;;12873:417;13986:204:0;;;;;;;;;;;;;13958:247;;;;;;13938:267;;13803:410;;;:::o;3189:258::-;3288:7;3390:20;2628:15;;;2550:101;3390:20;3361:63;;-1:-1:-1;;;3361:63:0;;;9068:27:1;9111:11;;;9104:27;;;;9147:12;;;9140:28;;;9184:12;;3361:63:0;8810:392:1;120960:272:0;121163:61;121191:4;121197:2;121201:12;121215:8;121163:27;:61::i;108667:505::-;108756:22;108764:4;108770:7;108756;:22::i;:::-;108751:414;;108944:41;108972:7;-1:-1:-1;;;;;108944:41:0;108982:2;108944:19;:41::i;:::-;109058:38;109086:4;109093:2;109058:19;:38::i;:::-;108849:270;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;108849:270:0;;;;;;;;;;-1:-1:-1;;;108795:358:0;;;;;;;:::i;40754:2236::-;40877:20;40900:13;-1:-1:-1;;;;;40928:16:0;;40924:48;;40953:19;;-1:-1:-1;;;40953:19:0;;;;;;;;;;;40924:48;40987:13;40983:44;;41009:18;;-1:-1:-1;;;41009:18:0;;;;;;;;;;;40983:44;41040:61;41070:1;41074:2;41078:12;41092:8;41040:21;:61::i;:::-;-1:-1:-1;;;;;41576:22:0;;;;;;:18;:22;;;;26960:2;41576:22;;;:70;;41614:31;41602:44;;41576:70;;;41889:31;;;:17;:31;;;;;41982:15;27477:3;41982:41;41940:84;;-1:-1:-1;42060:13:0;;27740:3;42045:56;41940:162;41889:213;;:31;;42183:23;;;;42227:14;:19;42223:635;;42267:313;42298:38;;42323:12;;-1:-1:-1;;;;;42298:38:0;;;42315:1;;-1:-1:-1;;;;;;;;;;;42298:38:0;42315:1;;42298:38;42364:69;42403:1;42407:2;42411:14;;;;;;42427:5;42364:30;:69::i;:::-;42359:174;;42469:40;;-1:-1:-1;;;42469:40:0;;;;;;;;;;;42359:174;42575:3;42560:12;:18;42267:313;;42661:12;42644:13;;:29;42640:43;;42675:8;;;42640:43;42223:635;;;42724:119;42755:40;;42780:14;;;;;-1:-1:-1;;;;;42755:40:0;;;42772:1;;-1:-1:-1;;;;;;;;;;;42755:40:0;42772:1;;42755:40;42838:3;42823:12;:18;42724:119;;42223:635;-1:-1:-1;42872:13:0;:28;;;42922:60;;42955:2;42959:12;42973:8;42922:60;:::i;34345:295::-;-1:-1:-1;;;;;;;;;;;;;34455:41:0;;;;27477:3;34541:32;;;-1:-1:-1;;;;;34507:67:0;-1:-1:-1;;;34507:67:0;-1:-1:-1;;;34604:23:0;;;:28;;-1:-1:-1;;;34585:47:0;-1:-1:-1;34345:295:0:o;89127:332::-;87373:7;;;;89393:9;89385:66;;;;-1:-1:-1;;;89385:66:0;;18144:2:1;89385:66:0;;;18126:21:1;18183:2;18163:18;;;18156:30;18222:34;18202:18;;;18195:62;-1:-1:-1;;;18273:18:1;;;18266:42;18325:19;;89385:66:0;17942:408:1;81778:451:0;81853:13;81879:19;81911:10;81915:6;81911:1;:10;:::i;:::-;:14;;81924:1;81911:14;:::i;:::-;-1:-1:-1;;;;;81901:25:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;81901:25:0;;81879:47;;-1:-1:-1;;;81937:6:0;81944:1;81937:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;81937:15:0;;;;;;;;;-1:-1:-1;;;81963:6:0;81970:1;81963:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;81963:15:0;;;;;;;;-1:-1:-1;81994:9:0;82006:10;82010:6;82006:1;:10;:::i;:::-;:14;;82019:1;82006:14;:::i;:::-;81994:26;;81989:135;82026:1;82022;:5;81989:135;;;-1:-1:-1;;;82074:5:0;82082:3;82074:11;82061:25;;;;;;;:::i;:::-;;;;82049:6;82056:1;82049:9;;;;;;;;:::i;:::-;;;;:37;-1:-1:-1;;;;;82049:37:0;;;;;;;;-1:-1:-1;82111:1:0;82101:11;;;;;82029:3;;;:::i;:::-;;;81989:135;;;-1:-1:-1;82142:10:0;;82134:55;;;;-1:-1:-1;;;82134:55:0;;14346:2:1;82134:55:0;;;14328:21:1;;;14365:18;;;14358:30;14424:34;14404:18;;;14397:62;14476:18;;82134:55:0;14144:356:1;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:406:1;78:5;-1:-1:-1;;;;;104:6:1;101:30;98:56;;;134:18;;:::i;:::-;172:57;217:2;196:15;;-1:-1:-1;;192:29:1;223:4;188:40;172:57;:::i;:::-;163:66;;252:6;245:5;238:21;292:3;283:6;278:3;274:16;271:25;268:45;;;309:1;306;299:12;268:45;358:6;353:3;346:4;339:5;335:16;322:43;412:1;405:4;396:6;389:5;385:18;381:29;374:40;14:406;;;;;:::o;425:173::-;493:20;;-1:-1:-1;;;;;542:31:1;;532:42;;522:70;;588:1;585;578:12;522:70;425:173;;;:::o;603:220::-;645:5;698:3;691:4;683:6;679:17;675:27;665:55;;716:1;713;706:12;665:55;738:79;813:3;804:6;791:20;784:4;776:6;772:17;738:79;:::i;828:156::-;894:20;;954:4;943:16;;933:27;;923:55;;974:1;971;964:12;989:186;1048:6;1101:2;1089:9;1080:7;1076:23;1072:32;1069:52;;;1117:1;1114;1107:12;1069:52;1140:29;1159:9;1140:29;:::i;1180:260::-;1248:6;1256;1309:2;1297:9;1288:7;1284:23;1280:32;1277:52;;;1325:1;1322;1315:12;1277:52;1348:29;1367:9;1348:29;:::i;:::-;1338:39;;1396:38;1430:2;1419:9;1415:18;1396:38;:::i;:::-;1386:48;;1180:260;;;;;:::o;1445:328::-;1522:6;1530;1538;1591:2;1579:9;1570:7;1566:23;1562:32;1559:52;;;1607:1;1604;1597:12;1559:52;1630:29;1649:9;1630:29;:::i;:::-;1620:39;;1678:38;1712:2;1701:9;1697:18;1678:38;:::i;:::-;1668:48;;1763:2;1752:9;1748:18;1735:32;1725:42;;1445:328;;;;;:::o;1778:537::-;1873:6;1881;1889;1897;1950:3;1938:9;1929:7;1925:23;1921:33;1918:53;;;1967:1;1964;1957:12;1918:53;1990:29;2009:9;1990:29;:::i;:::-;1980:39;;2038:38;2072:2;2061:9;2057:18;2038:38;:::i;:::-;2028:48;;2123:2;2112:9;2108:18;2095:32;2085:42;;2178:2;2167:9;2163:18;2150:32;-1:-1:-1;;;;;2197:6:1;2194:30;2191:50;;;2237:1;2234;2227:12;2191:50;2260:49;2301:7;2292:6;2281:9;2277:22;2260:49;:::i;:::-;2250:59;;;1778:537;;;;;;;:::o;2320:347::-;2385:6;2393;2446:2;2434:9;2425:7;2421:23;2417:32;2414:52;;;2462:1;2459;2452:12;2414:52;2485:29;2504:9;2485:29;:::i;:::-;2475:39;;2564:2;2553:9;2549:18;2536:32;2611:5;2604:13;2597:21;2590:5;2587:32;2577:60;;2633:1;2630;2623:12;2577:60;2656:5;2646:15;;;2320:347;;;;;:::o;2672:602::-;2774:6;2782;2790;2798;2806;2859:3;2847:9;2838:7;2834:23;2830:33;2827:53;;;2876:1;2873;2866:12;2827:53;2899:29;2918:9;2899:29;:::i;:::-;2889:39;;2979:2;2968:9;2964:18;2951:32;-1:-1:-1;;;;;2998:6:1;2995:30;2992:50;;;3038:1;3035;3028:12;2992:50;3061:49;3102:7;3093:6;3082:9;3078:22;3061:49;:::i;:::-;3051:59;;;3157:2;3146:9;3142:18;3129:32;3119:42;;3208:2;3197:9;3193:18;3180:32;3170:42;;3231:37;3263:3;3252:9;3248:19;3231:37;:::i;:::-;3221:47;;2672:602;;;;;;;;:::o;3279:671::-;3390:6;3398;3406;3414;3422;3430;3483:3;3471:9;3462:7;3458:23;3454:33;3451:53;;;3500:1;3497;3490:12;3451:53;3523:29;3542:9;3523:29;:::i;:::-;3513:39;;3603:2;3592:9;3588:18;3575:32;-1:-1:-1;;;;;3622:6:1;3619:30;3616:50;;;3662:1;3659;3652:12;3616:50;3685:49;3726:7;3717:6;3706:9;3702:22;3685:49;:::i;:::-;3675:59;;;3781:2;3770:9;3766:18;3753:32;3743:42;;3832:2;3821:9;3817:18;3804:32;3794:42;;3855:37;3887:3;3876:9;3872:19;3855:37;:::i;:::-;3845:47;;3939:3;3928:9;3924:19;3911:33;3901:43;;3279:671;;;;;;;;:::o;3955:254::-;4023:6;4031;4084:2;4072:9;4063:7;4059:23;4055:32;4052:52;;;4100:1;4097;4090:12;4052:52;4123:29;4142:9;4123:29;:::i;:::-;4113:39;4199:2;4184:18;;;;4171:32;;-1:-1:-1;;;3955:254:1:o;4214:322::-;4291:6;4299;4307;4360:2;4348:9;4339:7;4335:23;4331:32;4328:52;;;4376:1;4373;4366:12;4328:52;4399:29;4418:9;4399:29;:::i;:::-;4389:39;4475:2;4460:18;;4447:32;;-1:-1:-1;4526:2:1;4511:18;;;4498:32;;4214:322;-1:-1:-1;;;4214:322:1:o;4541:957::-;4625:6;4656:2;4699;4687:9;4678:7;4674:23;4670:32;4667:52;;;4715:1;4712;4705:12;4667:52;4755:9;4742:23;-1:-1:-1;;;;;4825:2:1;4817:6;4814:14;4811:34;;;4841:1;4838;4831:12;4811:34;4879:6;4868:9;4864:22;4854:32;;4924:7;4917:4;4913:2;4909:13;4905:27;4895:55;;4946:1;4943;4936:12;4895:55;4982:2;4969:16;5004:2;5000;4997:10;4994:36;;;5010:18;;:::i;:::-;5056:2;5053:1;5049:10;5039:20;;5079:28;5103:2;5099;5095:11;5079:28;:::i;:::-;5141:15;;;5172:12;;;;5204:11;;;5234;;;5230:20;;5227:33;-1:-1:-1;5224:53:1;;;5273:1;5270;5263:12;5224:53;5295:1;5286:10;;5305:163;5319:2;5316:1;5313:9;5305:163;;;5376:17;;5364:30;;5337:1;5330:9;;;;;5414:12;;;;5446;;5305:163;;;-1:-1:-1;5487:5:1;4541:957;-1:-1:-1;;;;;;;;4541:957:1:o;5503:180::-;5562:6;5615:2;5603:9;5594:7;5590:23;5586:32;5583:52;;;5631:1;5628;5621:12;5583:52;-1:-1:-1;5654:23:1;;5503:180;-1:-1:-1;5503:180:1:o;5688:254::-;5756:6;5764;5817:2;5805:9;5796:7;5792:23;5788:32;5785:52;;;5833:1;5830;5823:12;5785:52;5869:9;5856:23;5846:33;;5898:38;5932:2;5921:9;5917:18;5898:38;:::i;5947:245::-;6005:6;6058:2;6046:9;6037:7;6033:23;6029:32;6026:52;;;6074:1;6071;6064:12;6026:52;6113:9;6100:23;6132:30;6156:5;6132:30;:::i;6197:249::-;6266:6;6319:2;6307:9;6298:7;6294:23;6290:32;6287:52;;;6335:1;6332;6325:12;6287:52;6367:9;6361:16;6386:30;6410:5;6386:30;:::i;6451:450::-;6520:6;6573:2;6561:9;6552:7;6548:23;6544:32;6541:52;;;6589:1;6586;6579:12;6541:52;6629:9;6616:23;-1:-1:-1;;;;;6654:6:1;6651:30;6648:50;;;6694:1;6691;6684:12;6648:50;6717:22;;6770:4;6762:13;;6758:27;-1:-1:-1;6748:55:1;;6799:1;6796;6789:12;6748:55;6822:73;6887:7;6882:2;6869:16;6864:2;6860;6856:11;6822:73;:::i;7091:257::-;7132:3;7170:5;7164:12;7197:6;7192:3;7185:19;7213:63;7269:6;7262:4;7257:3;7253:14;7246:4;7239:5;7235:16;7213:63;:::i;:::-;7330:2;7309:15;-1:-1:-1;;7305:29:1;7296:39;;;;7337:4;7292:50;;7091:257;-1:-1:-1;;7091:257:1:o;7636:274::-;7765:3;7803:6;7797:13;7819:53;7865:6;7860:3;7853:4;7845:6;7841:17;7819:53;:::i;:::-;7888:16;;;;;7636:274;-1:-1:-1;;7636:274:1:o;7915:415::-;8072:3;8110:6;8104:13;8126:53;8172:6;8167:3;8160:4;8152:6;8148:17;8126:53;:::i;:::-;8248:2;8244:15;;;;-1:-1:-1;;8240:53:1;8201:16;;;;8226:68;;;8321:2;8310:14;;7915:415;-1:-1:-1;;7915:415:1:o;8335:470::-;8514:3;8552:6;8546:13;8568:53;8614:6;8609:3;8602:4;8594:6;8590:17;8568:53;:::i;:::-;8684:13;;8643:16;;;;8706:57;8684:13;8643:16;8740:4;8728:17;;8706:57;:::i;:::-;8779:20;;8335:470;-1:-1:-1;;;;8335:470:1:o;9207:786::-;9618:25;9613:3;9606:38;9588:3;9673:6;9667:13;9689:62;9744:6;9739:2;9734:3;9730:12;9723:4;9715:6;9711:17;9689:62;:::i;:::-;-1:-1:-1;;;9810:2:1;9770:16;;;9802:11;;;9795:40;9860:13;;9882:63;9860:13;9931:2;9923:11;;9916:4;9904:17;;9882:63;:::i;:::-;9965:17;9984:2;9961:26;;9207:786;-1:-1:-1;;;;9207:786:1:o;10206:431::-;-1:-1:-1;;;;;10463:15:1;;;10445:34;;10515:15;;10510:2;10495:18;;10488:43;10567:2;10562;10547:18;;10540:30;;;10388:4;;10587:44;;10612:18;;10604:6;10587:44;:::i;:::-;10579:52;10206:431;-1:-1:-1;;;;;10206:431:1:o;10642:488::-;-1:-1:-1;;;;;10911:15:1;;;10893:34;;10963:15;;10958:2;10943:18;;10936:43;11010:2;10995:18;;10988:34;;;11058:3;11053:2;11038:18;;11031:31;;;10836:4;;11079:45;;11104:19;;11096:6;11079:45;:::i;:::-;11071:53;10642:488;-1:-1:-1;;;;;;10642:488:1:o;11135:722::-;11368:2;11420:21;;;11490:13;;11393:18;;;11512:22;;;11339:4;;11368:2;11591:15;;;;11565:2;11550:18;;;11339:4;11634:197;11648:6;11645:1;11642:13;11634:197;;;11697:52;11745:3;11736:6;11730:13;7437:12;;-1:-1:-1;;;;;7433:38:1;7421:51;;7525:4;7514:16;;;7508:23;-1:-1:-1;;;;;7504:48:1;7488:14;;;7481:72;7616:4;7605:16;;;7599:23;7592:31;7585:39;7569:14;;7562:63;7353:278;11697:52;11806:15;;;;11778:4;11769:14;;;;;11670:1;11663:9;11634:197;;11862:632;12033:2;12085:21;;;12155:13;;12058:18;;;12177:22;;;12004:4;;12033:2;12256:15;;;;12230:2;12215:18;;;12004:4;12299:169;12313:6;12310:1;12307:13;12299:169;;;12374:13;;12362:26;;12443:15;;;;12408:12;;;;12335:1;12328:9;12299:169;;13698:217;13845:2;13834:9;13827:21;13808:4;13865:44;13905:2;13894:9;13890:18;13882:6;13865:44;:::i;16773:356::-;16975:2;16957:21;;;16994:18;;;16987:30;17053:34;17048:2;17033:18;;17026:62;17120:2;17105:18;;16773:356::o;17540:397::-;17742:2;17724:21;;;17781:2;17761:18;;;17754:30;17820:34;17815:2;17800:18;;17793:62;-1:-1:-1;;;17886:2:1;17871:18;;17864:31;17927:3;17912:19;;17540:397::o;18771:265::-;7437:12;;-1:-1:-1;;;;;7433:38:1;7421:51;;7525:4;7514:16;;;7508:23;-1:-1:-1;;;;;7504:48:1;7488:14;;;7481:72;7616:4;7605:16;;;7599:23;7592:31;7585:39;7569:14;;;7562:63;18967:2;18952:18;;18979:51;7353:278;19223:275;19294:2;19288:9;19359:2;19340:13;;-1:-1:-1;;19336:27:1;19324:40;;-1:-1:-1;;;;;19379:34:1;;19415:22;;;19376:62;19373:88;;;19441:18;;:::i;:::-;19477:2;19470:22;19223:275;;-1:-1:-1;19223:275:1:o;19503:128::-;19543:3;19574:1;19570:6;19567:1;19564:13;19561:39;;;19580:18;;:::i;:::-;-1:-1:-1;19616:9:1;;19503:128::o;19636:168::-;19676:7;19742:1;19738;19734:6;19730:14;19727:1;19724:21;19719:1;19712:9;19705:17;19701:45;19698:71;;;19749:18;;:::i;:::-;-1:-1:-1;19789:9:1;;19636:168::o;19809:258::-;19881:1;19891:113;19905:6;19902:1;19899:13;19891:113;;;19981:11;;;19975:18;19962:11;;;19955:39;19927:2;19920:10;19891:113;;;20022:6;20019:1;20016:13;20013:48;;;-1:-1:-1;;20057:1:1;20039:16;;20032:27;19809:258::o;20072:136::-;20111:3;20139:5;20129:39;;20148:18;;:::i;:::-;-1:-1:-1;;;20184:18:1;;20072:136::o;20213:380::-;20292:1;20288:12;;;;20335;;;20356:61;;20410:4;20402:6;20398:17;20388:27;;20356:61;20463:2;20455:6;20452:14;20432:18;20429:38;20426:161;;;20509:10;20504:3;20500:20;20497:1;20490:31;20544:4;20541:1;20534:15;20572:4;20569:1;20562:15;20426:161;;20213:380;;;:::o;20598:127::-;20659:10;20654:3;20650:20;20647:1;20640:31;20690:4;20687:1;20680:15;20714:4;20711:1;20704:15;20730:127;20791:10;20786:3;20782:20;20779:1;20772:31;20822:4;20819:1;20812:15;20846:4;20843:1;20836:15;20862:127;20923:10;20918:3;20914:20;20911:1;20904:31;20954:4;20951:1;20944:15;20978:4;20975:1;20968:15;20994:131;-1:-1:-1;;;;;;21068:32:1;;21058:43;;21048:71;;21115:1;21112;21105:12
Swarm Source
ipfs://faa65ef7ebe3fba1bf5715765fd5b8add832fec2605a7cebc0b1d34b7999844d
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.