Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 81 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Claim | 17773471 | 408 days ago | IN | 0 ETH | 0.01057462 | ||||
Claim | 17731500 | 414 days ago | IN | 0 ETH | 0.00602343 | ||||
Claim | 17731487 | 414 days ago | IN | 0 ETH | 0.0225364 | ||||
Claim | 17731486 | 414 days ago | IN | 0 ETH | 0.04324088 | ||||
Claim | 17731408 | 414 days ago | IN | 0 ETH | 0.01123411 | ||||
Claim | 17731395 | 414 days ago | IN | 0 ETH | 0.00338541 | ||||
Binding | 17731014 | 414 days ago | IN | 0 ETH | 0.00227548 | ||||
Claim | 17724805 | 415 days ago | IN | 0 ETH | 0.00491127 | ||||
Binding | 17724765 | 415 days ago | IN | 0 ETH | 0.00333691 | ||||
Claim | 17704011 | 418 days ago | IN | 0 ETH | 0.02676532 | ||||
Binding | 17704009 | 418 days ago | IN | 0 ETH | 0.00350047 | ||||
Claim | 17652725 | 425 days ago | IN | 0 ETH | 0.00670053 | ||||
Claim | 17605909 | 431 days ago | IN | 0 ETH | 0.00797824 | ||||
Claim | 17598552 | 433 days ago | IN | 0 ETH | 0.00908908 | ||||
Claim | 17588850 | 434 days ago | IN | 0 ETH | 0.01751731 | ||||
Claim | 17578116 | 435 days ago | IN | 0 ETH | 0.0056809 | ||||
Claim | 17577792 | 435 days ago | IN | 0 ETH | 0.01516019 | ||||
Claim | 17577510 | 435 days ago | IN | 0 ETH | 0.00504862 | ||||
Claim | 17577027 | 436 days ago | IN | 0 ETH | 0.00831832 | ||||
Claim | 17575912 | 436 days ago | IN | 0 ETH | 0.0084827 | ||||
Claim | 17573417 | 436 days ago | IN | 0 ETH | 0.01900178 | ||||
Claim | 17570776 | 436 days ago | IN | 0 ETH | 0.00647608 | ||||
Claim | 17557860 | 438 days ago | IN | 0 ETH | 0.00626754 | ||||
Claim | 17544047 | 440 days ago | IN | 0 ETH | 0.00538389 | ||||
Claim | 17540458 | 441 days ago | IN | 0 ETH | 0.02051298 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
ERC721Distributor
Compiler Version
v0.8.7+commit.e28d00a7
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2023-04-15 */ // Sources flattened with hardhat v2.13.0 https://hardhat.org // File @openzeppelin/contracts/utils/[email protected] // SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File @openzeppelin/contracts/access/[email protected] // OpenZeppelin Contracts (last updated v4.7.0) (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 Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { 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/introspection/[email protected] // 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/[email protected] // OpenZeppelin Contracts (last updated v4.8.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 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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must * understand this adds an external call which potentially creates a reentrancy vulnerability. * * 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/[email protected] // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol) pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); } // File @openzeppelin/contracts/utils/math/[email protected] // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv( uint256 x, uint256 y, uint256 denominator, Rounding rounding ) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10**64) { value /= 10**64; result += 64; } if (value >= 10**32) { value /= 10**32; result += 32; } if (value >= 10**16) { value /= 10**16; result += 16; } if (value >= 10**8) { value /= 10**8; result += 8; } if (value >= 10**4) { value /= 10**4; result += 4; } if (value >= 10**2) { value /= 10**2; result += 2; } if (value >= 10**1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0); } } } // File @openzeppelin/contracts/utils/[email protected] // OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @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] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } } // File @openzeppelin/contracts/utils/cryptography/[email protected] // OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol) pragma solidity ^0.8.0; /** * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations. * * These functions can be used to verify that a message was signed by the holder * of the private keys of a given address. */ library ECDSA { enum RecoverError { NoError, InvalidSignature, InvalidSignatureLength, InvalidSignatureS, InvalidSignatureV // Deprecated in v4.8 } function _throwError(RecoverError error) private pure { if (error == RecoverError.NoError) { return; // no error: do nothing } else if (error == RecoverError.InvalidSignature) { revert("ECDSA: invalid signature"); } else if (error == RecoverError.InvalidSignatureLength) { revert("ECDSA: invalid signature length"); } else if (error == RecoverError.InvalidSignatureS) { revert("ECDSA: invalid signature 's' value"); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature` or error string. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. * * Documentation for signature generation: * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js] * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers] * * _Available since v4.3._ */ function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) { if (signature.length == 65) { bytes32 r; bytes32 s; uint8 v; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. /// @solidity memory-safe-assembly assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } return tryRecover(hash, v, r, s); } else { return (address(0), RecoverError.InvalidSignatureLength); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature`. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, signature); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately. * * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures] * * _Available since v4.3._ */ function tryRecover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address, RecoverError) { bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); uint8 v = uint8((uint256(vs) >> 255) + 27); return tryRecover(hash, v, r, s); } /** * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately. * * _Available since v4.2._ */ function recover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, r, vs); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `v`, * `r` and `s` signature fields separately. * * _Available since v4.3._ */ function tryRecover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address, RecoverError) { // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most // signatures from current libraries generate a unique signature with an s-value in the lower half order. // // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept // these malleable signatures as well. if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) { return (address(0), RecoverError.InvalidSignatureS); } // If the signature is valid (and not malleable), return the signer address address signer = ecrecover(hash, v, r, s); if (signer == address(0)) { return (address(0), RecoverError.InvalidSignature); } return (signer, RecoverError.NoError); } /** * @dev Overload of {ECDSA-recover} that receives the `v`, * `r` and `s` signature fields separately. */ function recover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, v, r, s); _throwError(error); return recovered; } /** * @dev Returns an Ethereum Signed Message, created from a `hash`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) { // 32 is the length in bytes of hash, // enforced by the type signature above return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)); } /** * @dev Returns an Ethereum Signed Message, created from `s`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s)); } /** * @dev Returns an Ethereum Signed Typed Data, created from a * `domainSeparator` and a `structHash`. This produces hash corresponding * to the one signed with the * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] * JSON-RPC method as part of EIP-712. * * See {recover}. */ function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); } } // File @openzeppelin/contracts/security/[email protected] // OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor() { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { _nonReentrantBefore(); _; _nonReentrantAfter(); } function _nonReentrantBefore() private { // On the first call to nonReentrant, _status will be _NOT_ENTERED require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; } function _nonReentrantAfter() private { // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } } // File @openzeppelin/contracts/utils/cryptography/[email protected] // OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol) pragma solidity ^0.8.0; /** * @dev These functions deal with verification of Merkle Tree proofs. * * The tree and the proofs can be generated using our * https://github.com/OpenZeppelin/merkle-tree[JavaScript library]. * You will find a quickstart guide in the readme. * * WARNING: You should avoid using leaf values that are 64 bytes long prior to * hashing, or use a hash function other than keccak256 for hashing leaves. * This is because the concatenation of a sorted pair of internal nodes in * the merkle tree could be reinterpreted as a leaf value. * OpenZeppelin's JavaScript library generates merkle trees that are safe * against this attack out of the box. */ library MerkleProof { /** * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree * defined by `root`. For this, a `proof` must be provided, containing * sibling hashes on the branch from the leaf to the root of the tree. Each * pair of leaves and each pair of pre-images are assumed to be sorted. */ function verify( bytes32[] memory proof, bytes32 root, bytes32 leaf ) internal pure returns (bool) { return processProof(proof, leaf) == root; } /** * @dev Calldata version of {verify} * * _Available since v4.7._ */ function verifyCalldata( bytes32[] calldata proof, bytes32 root, bytes32 leaf ) internal pure returns (bool) { return processProofCalldata(proof, leaf) == root; } /** * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt * hash matches the root of the tree. When processing the proof, the pairs * of leafs & pre-images are assumed to be sorted. * * _Available since v4.4._ */ function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) { bytes32 computedHash = leaf; for (uint256 i = 0; i < proof.length; i++) { computedHash = _hashPair(computedHash, proof[i]); } return computedHash; } /** * @dev Calldata version of {processProof} * * _Available since v4.7._ */ function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) { bytes32 computedHash = leaf; for (uint256 i = 0; i < proof.length; i++) { computedHash = _hashPair(computedHash, proof[i]); } return computedHash; } /** * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}. * * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details. * * _Available since v4.7._ */ function multiProofVerify( bytes32[] memory proof, bool[] memory proofFlags, bytes32 root, bytes32[] memory leaves ) internal pure returns (bool) { return processMultiProof(proof, proofFlags, leaves) == root; } /** * @dev Calldata version of {multiProofVerify} * * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details. * * _Available since v4.7._ */ function multiProofVerifyCalldata( bytes32[] calldata proof, bool[] calldata proofFlags, bytes32 root, bytes32[] memory leaves ) internal pure returns (bool) { return processMultiProofCalldata(proof, proofFlags, leaves) == root; } /** * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false * respectively. * * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer). * * _Available since v4.7._ */ function processMultiProof( bytes32[] memory proof, bool[] memory proofFlags, bytes32[] memory leaves ) internal pure returns (bytes32 merkleRoot) { // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of // the merkle tree. uint256 leavesLen = leaves.length; uint256 totalHashes = proofFlags.length; // Check proof validity. require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof"); // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop". bytes32[] memory hashes = new bytes32[](totalHashes); uint256 leafPos = 0; uint256 hashPos = 0; uint256 proofPos = 0; // At each step, we compute the next hash using two values: // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we // get the next hash. // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the // `proof` array. for (uint256 i = 0; i < totalHashes; i++) { bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]; bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++]; hashes[i] = _hashPair(a, b); } if (totalHashes > 0) { return hashes[totalHashes - 1]; } else if (leavesLen > 0) { return leaves[0]; } else { return proof[0]; } } /** * @dev Calldata version of {processMultiProof}. * * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details. * * _Available since v4.7._ */ function processMultiProofCalldata( bytes32[] calldata proof, bool[] calldata proofFlags, bytes32[] memory leaves ) internal pure returns (bytes32 merkleRoot) { // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of // the merkle tree. uint256 leavesLen = leaves.length; uint256 totalHashes = proofFlags.length; // Check proof validity. require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof"); // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop". bytes32[] memory hashes = new bytes32[](totalHashes); uint256 leafPos = 0; uint256 hashPos = 0; uint256 proofPos = 0; // At each step, we compute the next hash using two values: // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we // get the next hash. // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the // `proof` array. for (uint256 i = 0; i < totalHashes; i++) { bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]; bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++]; hashes[i] = _hashPair(a, b); } if (totalHashes > 0) { return hashes[totalHashes - 1]; } else if (leavesLen > 0) { return leaves[0]; } else { return proof[0]; } } function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) { return a < b ? _efficientHash(a, b) : _efficientHash(b, a); } function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) { /// @solidity memory-safe-assembly assembly { mstore(0x00, a) mstore(0x20, b) value := keccak256(0x00, 0x40) } } } // File @openzeppelin/contracts/utils/math/[email protected] // 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 contracts/interfaces/IRelationship.sol pragma solidity ^0.8.0; pragma abicoder v2; interface IRelationship { // Invitee is the address of the person being invited struct Invitee { address invitee; uint256 timestamp; } // User is the address of the person who is inviting struct User { Invitee[] inviteeList; address inviter; bytes code; mapping(address => uint256) indexes; } function binding(bytes memory c) external; function isInvited(address player) external view returns (bool); function getInviteeList(address player) external view returns (Invitee[] memory); function getParent(address player) external view returns (address); function getInviteCode(address player) external view returns (bytes memory); function getPlayerByCode(bytes memory code) external view returns (address); } // File contracts/utils/Relationship.sol pragma solidity ^0.8.0; /* @title Relationship * @author [email protected] * @dev This contract is used to manage the invitation relationship. * * @rules can't invite someone who has already invited you * @rules can't invite someone who has already been invited * @rules maximum of invitees is limited by gas */ contract Relationship is Ownable,IRelationship { bytes public defaultCode = "space0"; uint256 public beginsTime; uint256 public endsTime; // User is the address of the person who is invited mapping(address => User) private _relations; // code used to invite mapping(bytes => address) private _codeUsed; event Binding(address indexed inviter, address indexed invitee, bytes code); constructor(uint256 begins, uint256 ends) { beginsTime = begins; endsTime = ends; _relations[msg.sender].code = defaultCode; _relations[msg.sender].inviter = msg.sender; _codeUsed[defaultCode] = msg.sender; } modifier inDuration { require(block.timestamp < endsTime); _; } function setEnds(uint256 _end) public onlyOwner{ endsTime = _end; } function setStart(uint256 _start) public onlyOwner{ beginsTime = _start; } // @param inviter address of the person who is inviting function binding(bytes memory c) public override inDuration { address sender = msg.sender; address inviter = _codeUsed[c]; require(inviter != address(0), "code not found"); require(inviter != sender, "Not allow inviter by self"); // invitee address info User storage self = _relations[sender]; // inviter address info User storage parent = _relations[inviter]; require(parent.indexes[sender] == 0, "Can not accept child invitation"); require(self.inviter == address(0), "Already bond invite"); parent.inviteeList.push(Invitee(sender, block.timestamp)); parent.indexes[sender] = self.inviteeList.length; self.inviter = inviter; bytes memory code = _genCode(sender); require(_codeUsed[code] == address(0), "please try again"); self.code = code; _codeUsed[code] = sender; emit Binding(inviter, sender, code); } // @param player address if not invited function isInvited(address player) public view override returns (bool){ if (_relations[player].inviter != address(0)) return true; return false; } // @param get player address invitee list function getInviteeList(address player) public view override returns (Invitee[] memory){ return _relations[player].inviteeList; } // @param get player address inviter function getParent(address player) public view override returns (address){ return _relations[player].inviter; } // @param get player address invitation code function getInviteCode(address player) public view override returns (bytes memory){ return _relations[player].code; } // @param get player address by invitation code function getPlayerByCode(bytes memory code) public view override returns (address){ return _codeUsed[code]; } function _genCode(address player) private view returns (bytes memory){ bytes32 hash = keccak256(abi.encode(player, block.number)); bytes memory code = new bytes(6); for (uint256 i = 0; i < code.length; i++) { code[i] = hash[i]; } return code; } } // File contracts/ERC721Distributor.sol pragma solidity ^0.8.0; interface IMintNft is IERC721Enumerable { function mint(address to) external; } interface IERC20 { function transferFrom(address _from, address _to, uint _value) external; } contract ERC721Distributor is Ownable, ReentrancyGuard, Relationship { using SafeMath for uint256; address public nft; address public cashier; // uint256 public personalLimit; uint256 public started; uint256 public ended; uint256 public total; uint256 public sold; address public dead = 0x000000000000000000000000000000000000dEaD; // mapping(address => uint256) public bought; mapping(address => mapping(address => uint256)) private bought; mapping(address => uint256) public prices; constructor( uint256 end, address _nft, uint256 _total )Relationship(block.timestamp, end) { started = block.timestamp; ended = end; nft = _nft; total = _total; cashier = msg.sender; } event Claim(uint256 indexed tokenID, address indexed user); modifier isFilled(uint256 quantity) { require(total >= sold.add(quantity), "sold out"); _; } function removePrice(address currency) public onlyOwner { delete prices[currency]; } function setPrice(address currency, uint256 amount) public onlyOwner { prices[currency] = amount; } function setTotal(uint256 q) public onlyOwner { total = q; } function setNFT(address _nft) external onlyOwner { require(_nft != address(0), "Is zero address"); nft = _nft; } function setCashier(address _cashier) external onlyOwner { require(_cashier != address(0), "Is zero address"); cashier = _cashier; } function claim(address currency, uint256 quantity, bool isBlack) external nonReentrant inDuration { require(isInvited(msg.sender), "not invited"); _claim( currency, quantity, isBlack); } function transferStranded(address currency, uint256 quantity, bool isBlack) internal { require(prices[currency] != 0, 'not found this currency'); if (getParent(msg.sender) == address(0)) { IERC20(currency).transferFrom(msg.sender, cashier, prices[currency].mul(quantity)); } else { if (isBlack) { IERC20(currency).transferFrom(msg.sender, dead, prices[currency].mul(quantity).mul(90).div(100)); }else { IERC20(currency).transferFrom(msg.sender, cashier, prices[currency].mul(quantity).mul(90).div(100)); } IERC20(currency).transferFrom(msg.sender, getParent(msg.sender), prices[currency].mul(quantity).mul(10).div(100)); bought[getParent(msg.sender)][currency] = bought[getParent(msg.sender)][currency].add(prices[currency].mul(quantity).mul(10).div(100)); } } function _claim(address currency, uint256 quantity, bool isBlack) internal isFilled(quantity) { address user = msg.sender; transferStranded(currency, quantity, isBlack); for (uint256 i = 0; i < quantity; i++) { IMintNft(nft).mint(user); sold = sold.add(1); uint256 id = IMintNft(nft).totalSupply(); emit Claim(id, user); } } function getInviteReward(address user, address currency) public view returns (uint256) { if (getParent(user) == address(0)) return 0; return bought[user][currency]; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"uint256","name":"end","type":"uint256"},{"internalType":"address","name":"_nft","type":"address"},{"internalType":"uint256","name":"_total","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"inviter","type":"address"},{"indexed":true,"internalType":"address","name":"invitee","type":"address"},{"indexed":false,"internalType":"bytes","name":"code","type":"bytes"}],"name":"Binding","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenID","type":"uint256"},{"indexed":true,"internalType":"address","name":"user","type":"address"}],"name":"Claim","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"},{"inputs":[],"name":"beginsTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"c","type":"bytes"}],"name":"binding","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cashier","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"currency","type":"address"},{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"bool","name":"isBlack","type":"bool"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"dead","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"defaultCode","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ended","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"endsTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"player","type":"address"}],"name":"getInviteCode","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"currency","type":"address"}],"name":"getInviteReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"player","type":"address"}],"name":"getInviteeList","outputs":[{"components":[{"internalType":"address","name":"invitee","type":"address"},{"internalType":"uint256","name":"timestamp","type":"uint256"}],"internalType":"struct IRelationship.Invitee[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"player","type":"address"}],"name":"getParent","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"code","type":"bytes"}],"name":"getPlayerByCode","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"player","type":"address"}],"name":"isInvited","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nft","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"prices","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"currency","type":"address"}],"name":"removePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_cashier","type":"address"}],"name":"setCashier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_end","type":"uint256"}],"name":"setEnds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_nft","type":"address"}],"name":"setNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"currency","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_start","type":"uint256"}],"name":"setStart","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"q","type":"uint256"}],"name":"setTotal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"started","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"total","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
0x608060405234801561001057600080fd5b50600436106101ce5760003560e01c806389f3084e11610104578063ce4d2e04116100a2578063f2fde38b11610071578063f2fde38b1461051f578063f4961fa31461053b578063f56e9c6614610557578063f6a03ebf14610573576101ce565b8063ce4d2e0414610483578063cfed246b146104a1578063d0d0ff18146104d1578063ed740e9714610501576101ce565b8063a0b5f771116100de578063a0b5f771146103fd578063a94059231461041b578063b02ad48f1461044b578063c57be39814610467576101ce565b806389f3084e146103935780638da5cb5b146103af5780639bd86c34146103cd576101ce565b80632ddbd13a116101715780634cccf7c31161014b5780634cccf7c31461031f57806362a344fa1461033d578063715018a61461036d5780637a1ee1c014610377576101ce565b80632ddbd13a146102c557806336cf7c87146102e357806347ccca0214610301576101ce565b806312fa6feb116101ad57806312fa6feb1461023d5780631dcbe5001461025b5780631f2698ab1461028b5780631f8d1d50146102a9576101ce565b8062e4768b146101d357806302c7e7af146101ef578063050d0adf1461020d575b600080fd5b6101ed60048036038101906101e89190612124565b61058f565b005b6101f76105df565b60405161020491906127c9565b60405180910390f35b610227600480360381019061022291906120b7565b6105e5565b60405161023491906125ea565b60405180910390f35b6102456106e6565b60405161025291906127c9565b60405180910390f35b610275600480360381019061027091906120b7565b6106ec565b604051610282919061260c565b60405180910390f35b610293610796565b6040516102a091906127c9565b60405180910390f35b6102c360048036038101906102be9190612200565b61079c565b005b6102cd6107ae565b6040516102da91906127c9565b60405180910390f35b6102eb6107b4565b6040516102f8919061256f565b60405180910390f35b6103096107da565b604051610316919061256f565b60405180910390f35b610327610800565b60405161033491906127c9565b60405180910390f35b610357600480360381019061035291906121b7565b610806565b604051610364919061256f565b60405180910390f35b61037561084e565b005b610391600480360381019061038c9190612164565b610862565b005b6103ad60048036038101906103a89190612200565b6108d8565b005b6103b76108ea565b6040516103c4919061256f565b60405180910390f35b6103e760048036038101906103e291906120b7565b610913565b6040516103f49190612627565b60405180910390f35b6104056109e7565b6040516104129190612627565b60405180910390f35b610435600480360381019061043091906120b7565b610a75565b604051610442919061256f565b60405180910390f35b610465600480360381019061046091906120b7565b610ae1565b005b610481600480360381019061047c91906121b7565b610b9d565b005b61048b611147565b60405161049891906127c9565b60405180910390f35b6104bb60048036038101906104b691906120b7565b61114d565b6040516104c891906127c9565b60405180910390f35b6104eb60048036038101906104e691906120e4565b611165565b6040516104f891906127c9565b60405180910390f35b610509611232565b604051610516919061256f565b60405180910390f35b610539600480360381019061053491906120b7565b611258565b005b610555600480360381019061055091906120b7565b6112dc565b005b610571600480360381019061056c91906120b7565b61132a565b005b61058d60048036038101906105889190612200565b6113e6565b005b6105976113f8565b80600f60008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055505050565b600c5481565b6060600560008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600001805480602002602001604051908101604052809291908181526020016000905b828210156106db57838290600052602060002090600202016040518060400160405290816000820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200160018201548152505081526020019060010190610649565b505050509050919050565b600a5481565b60008073ffffffffffffffffffffffffffffffffffffffff16600560008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060010160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff161461078c5760019050610791565b600090505b919050565b60095481565b6107a46113f8565b80600b8190555050565b600b5481565b600d60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600760009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60045481565b60006006826040516108189190612558565b908152602001604051809103902060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050919050565b6108566113f8565b6108606000611476565b565b61086a61153a565b600454421061087857600080fd5b610881336106ec565b6108c0576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108b790612649565b60405180910390fd5b6108cb83838361158a565b6108d36117ac565b505050565b6108e06113f8565b8060048190555050565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6060600560008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600201805461096290612a16565b80601f016020809104026020016040519081016040528092919081815260200182805461098e90612a16565b80156109db5780601f106109b0576101008083540402835291602001916109db565b820191906000526020600020905b8154815290600101906020018083116109be57829003601f168201915b50505050509050919050565b600280546109f490612a16565b80601f0160208091040260200160405190810160405280929190818152602001828054610a2090612a16565b8015610a6d5780601f10610a4257610100808354040283529160200191610a6d565b820191906000526020600020905b815481529060010190602001808311610a5057829003601f168201915b505050505081565b6000600560008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060010160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050919050565b610ae96113f8565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610b59576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b50906126e9565b60405180910390fd5b80600860006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b6004544210610bab57600080fd5b60003390506000600683604051610bc29190612558565b908152602001604051809103902060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610c63576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c5a90612689565b60405180910390fd5b8173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610cd2576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610cc9906126a9565b60405180910390fd5b6000600560008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002090506000600560008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020905060008160030160008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205414610ddc576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610dd390612729565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168260010160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610e6f576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610e66906127a9565b60405180910390fd5b8060000160405180604001604052808673ffffffffffffffffffffffffffffffffffffffff16815260200142815250908060018154018082558091505060019003906000526020600020906002020160009091909190915060008201518160000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555060208201518160010155505081600001805490508160030160008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550828260010160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506000610fb5856117b5565b9050600073ffffffffffffffffffffffffffffffffffffffff16600682604051610fdf9190612558565b908152602001604051809103902060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614611064576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161105b90612769565b60405180910390fd5b8083600201908051906020019061107c929190611f50565b508460068260405161108e9190612558565b908152602001604051809103902060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508473ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167f6999f352a5e3cba57581ad80d080b117be848e91ed5beca3f78046d6379a36bc836040516111379190612627565b60405180910390a3505050505050565b60035481565b600f6020528060005260406000206000915090505481565b60008073ffffffffffffffffffffffffffffffffffffffff1661118784610a75565b73ffffffffffffffffffffffffffffffffffffffff1614156111ac576000905061122c565b600e60008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205490505b92915050565b600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6112606113f8565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156112d0576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112c790612669565b60405180910390fd5b6112d981611476565b50565b6112e46113f8565b600f60008273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000905550565b6113326113f8565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156113a2576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611399906126e9565b60405180910390fd5b80600760006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b6113ee6113f8565b8060038190555050565b6114006118b9565b73ffffffffffffffffffffffffffffffffffffffff1661141e6108ea565b73ffffffffffffffffffffffffffffffffffffffff1614611474576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161146b90612749565b60405180910390fd5b565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050816000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b60026001541415611580576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161157790612789565b60405180910390fd5b6002600181905550565b816115a081600c546118c190919063ffffffff16565b600b5410156115e4576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016115db906126c9565b60405180910390fd5b60003390506115f48585856118d7565b60005b848110156117a457600760009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16636a627842836040518263ffffffff1660e01b815260040161165a919061256f565b600060405180830381600087803b15801561167457600080fd5b505af1158015611688573d6000803e3d6000fd5b505050506116a26001600c546118c190919063ffffffff16565b600c819055506000600760009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166318160ddd6040518163ffffffff1660e01b815260040160206040518083038186803b15801561171257600080fd5b505afa158015611726573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061174a919061222d565b90508273ffffffffffffffffffffffffffffffffffffffff16817f35538759d80c1fd7bb450a0d05601db5a99fa8b5d073a07c847a9fd61029b10760405160405180910390a350808061179c90612a79565b9150506115f7565b505050505050565b60018081905550565b6060600082436040516020016117cc9291906125c1565b6040516020818303038152906040528051906020012090506000600667ffffffffffffffff81111561180157611800612b7e565b5b6040519080825280601f01601f1916602001820160405280156118335781602001600182028036833780820191505090505b50905060005b81518110156118ae5782816020811061185557611854612b4f565b5b1a60f81b82828151811061186c5761186b612b4f565b5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a90535080806118a690612a79565b915050611839565b508092505050919050565b600033905090565b600081836118cf91906128ab565b905092915050565b6000600f60008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054141561195a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161195190612709565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff1661197b33610a75565b73ffffffffffffffffffffffffffffffffffffffff161415611a7e578273ffffffffffffffffffffffffffffffffffffffff166323b872dd33600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16611a2986600f60008a73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054611f2490919063ffffffff16565b6040518463ffffffff1660e01b8152600401611a479392919061258a565b600060405180830381600087803b158015611a6157600080fd5b505af1158015611a75573d6000803e3d6000fd5b50505050611f1f565b8015611b91578273ffffffffffffffffffffffffffffffffffffffff166323b872dd33600d60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16611b3c6064611b2e605a611b208a600f60008e73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054611f2490919063ffffffff16565b611f2490919063ffffffff16565b611f3a90919063ffffffff16565b6040518463ffffffff1660e01b8152600401611b5a9392919061258a565b600060405180830381600087803b158015611b7457600080fd5b505af1158015611b88573d6000803e3d6000fd5b50505050611c9a565b8273ffffffffffffffffffffffffffffffffffffffff166323b872dd33600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16611c496064611c3b605a611c2d8a600f60008e73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054611f2490919063ffffffff16565b611f2490919063ffffffff16565b611f3a90919063ffffffff16565b6040518463ffffffff1660e01b8152600401611c679392919061258a565b600060405180830381600087803b158015611c8157600080fd5b505af1158015611c95573d6000803e3d6000fd5b505050505b8273ffffffffffffffffffffffffffffffffffffffff166323b872dd33611cc033610a75565b611d386064611d2a600a611d1c8a600f60008e73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054611f2490919063ffffffff16565b611f2490919063ffffffff16565b611f3a90919063ffffffff16565b6040518463ffffffff1660e01b8152600401611d569392919061258a565b600060405180830381600087803b158015611d7057600080fd5b505af1158015611d84573d6000803e3d6000fd5b50505050611e96611e036064611df5600a611de787600f60008b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054611f2490919063ffffffff16565b611f2490919063ffffffff16565b611f3a90919063ffffffff16565b600e6000611e1033610a75565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546118c190919063ffffffff16565b600e6000611ea333610a75565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055505b505050565b60008183611f329190612932565b905092915050565b60008183611f489190612901565b905092915050565b828054611f5c90612a16565b90600052602060002090601f016020900481019282611f7e5760008555611fc5565b82601f10611f9757805160ff1916838001178555611fc5565b82800160010185558215611fc5579182015b82811115611fc4578251825591602001919060010190611fa9565b5b509050611fd29190611fd6565b5090565b5b80821115611fef576000816000905550600101611fd7565b5090565b600061200661200184612809565b6127e4565b90508281526020810184848401111561202257612021612bb2565b5b61202d8482856129d4565b509392505050565b60008135905061204481612de4565b92915050565b60008135905061205981612dfb565b92915050565b600082601f83011261207457612073612bad565b5b8135612084848260208601611ff3565b91505092915050565b60008135905061209c81612e12565b92915050565b6000815190506120b181612e12565b92915050565b6000602082840312156120cd576120cc612bbc565b5b60006120db84828501612035565b91505092915050565b600080604083850312156120fb576120fa612bbc565b5b600061210985828601612035565b925050602061211a85828601612035565b9150509250929050565b6000806040838503121561213b5761213a612bbc565b5b600061214985828601612035565b925050602061215a8582860161208d565b9150509250929050565b60008060006060848603121561217d5761217c612bbc565b5b600061218b86828701612035565b935050602061219c8682870161208d565b92505060406121ad8682870161204a565b9150509250925092565b6000602082840312156121cd576121cc612bbc565b5b600082013567ffffffffffffffff8111156121eb576121ea612bb7565b5b6121f78482850161205f565b91505092915050565b60006020828403121561221657612215612bbc565b5b60006122248482850161208d565b91505092915050565b60006020828403121561224357612242612bbc565b5b6000612251848285016120a2565b91505092915050565b6000612266838361250b565b60408301905092915050565b61227b8161298c565b82525050565b61228a8161298c565b82525050565b600061229b8261284a565b6122a5818561286d565b93506122b08361283a565b8060005b838110156122e15781516122c8888261225a565b97506122d383612860565b9250506001810190506122b4565b5085935050505092915050565b6122f78161299e565b82525050565b600061230882612855565b612312818561287e565b93506123228185602086016129e3565b61232b81612bc1565b840191505092915050565b600061234182612855565b61234b818561288f565b935061235b8185602086016129e3565b80840191505092915050565b6000612374600b8361289a565b915061237f82612bd2565b602082019050919050565b600061239760268361289a565b91506123a282612bfb565b604082019050919050565b60006123ba600e8361289a565b91506123c582612c4a565b602082019050919050565b60006123dd60198361289a565b91506123e882612c73565b602082019050919050565b600061240060088361289a565b915061240b82612c9c565b602082019050919050565b6000612423600f8361289a565b915061242e82612cc5565b602082019050919050565b600061244660178361289a565b915061245182612cee565b602082019050919050565b6000612469601f8361289a565b915061247482612d17565b602082019050919050565b600061248c60208361289a565b915061249782612d40565b602082019050919050565b60006124af60108361289a565b91506124ba82612d69565b602082019050919050565b60006124d2601f8361289a565b91506124dd82612d92565b602082019050919050565b60006124f560138361289a565b915061250082612dbb565b602082019050919050565b6040820160008201516125216000850182612272565b506020820151612534602085018261253a565b50505050565b612543816129ca565b82525050565b612552816129ca565b82525050565b60006125648284612336565b915081905092915050565b60006020820190506125846000830184612281565b92915050565b600060608201905061259f6000830186612281565b6125ac6020830185612281565b6125b96040830184612549565b949350505050565b60006040820190506125d66000830185612281565b6125e36020830184612549565b9392505050565b600060208201905081810360008301526126048184612290565b905092915050565b600060208201905061262160008301846122ee565b92915050565b6000602082019050818103600083015261264181846122fd565b905092915050565b6000602082019050818103600083015261266281612367565b9050919050565b600060208201905081810360008301526126828161238a565b9050919050565b600060208201905081810360008301526126a2816123ad565b9050919050565b600060208201905081810360008301526126c2816123d0565b9050919050565b600060208201905081810360008301526126e2816123f3565b9050919050565b6000602082019050818103600083015261270281612416565b9050919050565b6000602082019050818103600083015261272281612439565b9050919050565b600060208201905081810360008301526127428161245c565b9050919050565b600060208201905081810360008301526127628161247f565b9050919050565b60006020820190508181036000830152612782816124a2565b9050919050565b600060208201905081810360008301526127a2816124c5565b9050919050565b600060208201905081810360008301526127c2816124e8565b9050919050565b60006020820190506127de6000830184612549565b92915050565b60006127ee6127ff565b90506127fa8282612a48565b919050565b6000604051905090565b600067ffffffffffffffff82111561282457612823612b7e565b5b61282d82612bc1565b9050602081019050919050565b6000819050602082019050919050565b600081519050919050565b600081519050919050565b6000602082019050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b60006128b6826129ca565b91506128c1836129ca565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff038211156128f6576128f5612ac2565b5b828201905092915050565b600061290c826129ca565b9150612917836129ca565b92508261292757612926612af1565b5b828204905092915050565b600061293d826129ca565b9150612948836129ca565b9250817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff048311821515161561298157612980612ac2565b5b828202905092915050565b6000612997826129aa565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b82818337600083830152505050565b60005b83811015612a015780820151818401526020810190506129e6565b83811115612a10576000848401525b50505050565b60006002820490506001821680612a2e57607f821691505b60208210811415612a4257612a41612b20565b5b50919050565b612a5182612bc1565b810181811067ffffffffffffffff82111715612a7057612a6f612b7e565b5b80604052505050565b6000612a84826129ca565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff821415612ab757612ab6612ac2565b5b600182019050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f6e6f7420696e7669746564000000000000000000000000000000000000000000600082015250565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f636f6465206e6f7420666f756e64000000000000000000000000000000000000600082015250565b7f4e6f7420616c6c6f7720696e76697465722062792073656c6600000000000000600082015250565b7f736f6c64206f7574000000000000000000000000000000000000000000000000600082015250565b7f4973207a65726f20616464726573730000000000000000000000000000000000600082015250565b7f6e6f7420666f756e6420746869732063757272656e6379000000000000000000600082015250565b7f43616e206e6f7420616363657074206368696c6420696e7669746174696f6e00600082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b7f706c656173652074727920616761696e00000000000000000000000000000000600082015250565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00600082015250565b7f416c726561647920626f6e6420696e7669746500000000000000000000000000600082015250565b612ded8161298c565b8114612df857600080fd5b50565b612e048161299e565b8114612e0f57600080fd5b50565b612e1b816129ca565b8114612e2657600080fd5b5056fea26469706673582212200d3f075819e184ec4b48931367fc75e253d0843a55d9a082e5375610fb9f179e64736f6c63430008070033
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000000000000000000000000000000000000661b8e26000000000000000000000000095ebcd862302e7f15b303d42ebe40a33f3794350000000000000000000000000000000000000000000000000000000000000c44
-----Decoded View---------------
Arg [0] : end (uint256): 1713081894
Arg [1] : _nft (address): 0x095EBCd862302e7f15b303d42EBE40A33f379435
Arg [2] : _total (uint256): 3140
-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000661b8e26
Arg [1] : 000000000000000000000000095ebcd862302e7f15b303d42ebe40a33f379435
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000c44
Deployed Bytecode Sourcemap
59278:3401:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60413:113;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59571:19;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57984:143;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59517:20;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57760:169;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59488:22;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60534:74;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59544:20;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59599:64;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59389:18;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55826:23;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58552:123;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2884:103;;;:::i;:::-;;60922:209;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56485:81;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2236:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58360:131;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55752:35;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58177:125;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60759:155;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56727:980;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;55794:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59793:41;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62487:189;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59416:22;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3142:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60307:100;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60616:135;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56572:88;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60413:113;2122:13;:11;:13::i;:::-;60512:6:::1;60493;:16;60500:8;60493:16;;;;;;;;;;;;;;;:25;;;;60413:113:::0;;:::o;59571:19::-;;;;:::o;57984:143::-;58054:16;58089:10;:18;58100:6;58089:18;;;;;;;;;;;;;;;:30;;58082:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57984:143;;;:::o;59517:20::-;;;;:::o;57760:169::-;57825:4;57883:1;57845:40;;:10;:18;57856:6;57845:18;;;;;;;;;;;;;;;:26;;;;;;;;;;;;:40;;;57841:57;;57894:4;57887:11;;;;57841:57;57916:5;57909:12;;57760:169;;;;:::o;59488:22::-;;;;:::o;60534:74::-;2122:13;:11;:13::i;:::-;60599:1:::1;60591:5;:9;;;;60534:74:::0;:::o;59544:20::-;;;;:::o;59599:64::-;;;;;;;;;;;;;:::o;59389:18::-;;;;;;;;;;;;;:::o;55826:23::-;;;;:::o;58552:123::-;58626:7;58652:9;58662:4;58652:15;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;58645:22;;58552:123;;;:::o;2884:103::-;2122:13;:11;:13::i;:::-;2949:30:::1;2976:1;2949:18;:30::i;:::-;2884:103::o:0;60922:209::-;37155:21;:19;:21::i;:::-;56450:8:::1;;56432:15;:26;56424:35;;;::::0;::::1;;61039:21:::2;61049:10;61039:9;:21::i;:::-;61031:45;;;;;;;;;;;;:::i;:::-;;;;;;;;;61087:36;61095:8;61105;61115:7;61087:6;:36::i;:::-;37199:20:::0;:18;:20::i;:::-;60922:209;;;:::o;56485:81::-;2122:13;:11;:13::i;:::-;56554:4:::1;56543:8;:15;;;;56485:81:::0;:::o;2236:87::-;2282:7;2309:6;;;;;;;;;;;2302:13;;2236:87;:::o;58360:131::-;58429:12;58460:10;:18;58471:6;58460:18;;;;;;;;;;;;;;;:23;;58453:30;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58360:131;;;:::o;55752:35::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;58177:125::-;58242:7;58268:10;:18;58279:6;58268:18;;;;;;;;;;;;;;;:26;;;;;;;;;;;;58261:33;;58177:125;;;:::o;60759:155::-;2122:13;:11;:13::i;:::-;60855:1:::1;60835:22;;:8;:22;;;;60827:50;;;;;;;;;;;;:::i;:::-;;;;;;;;;60898:8;60888:7;;:18;;;;;;;;;;;;;;;;;;60759:155:::0;:::o;56727:980::-;56450:8;;56432:15;:26;56424:35;;;;;;56798:14:::1;56815:10;56798:27;;56836:15;56854:9;56864:1;56854:12;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;56836:30;;56904:1;56885:21;;:7;:21;;;;56877:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;56955:6;56944:17;;:7;:17;;;;56936:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;57035:17;57055:10;:18;57066:6;57055:18;;;;;;;;;;;;;;;57035:38;;57117:19;57139:10;:19;57150:7;57139:19;;;;;;;;;;;;;;;57117:41;;57205:1;57179:6;:14;;:22;57194:6;57179:22;;;;;;;;;;;;;;;;:27;57171:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;57285:1;57261:26;;:4;:12;;;;;;;;;;;;:26;;;57253:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;57322:6;:18;;57346:32;;;;;;;;57354:6;57346:32;;;;;;57362:15;57346:32;;::::0;57322:57:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57415:4;:16;;:23;;;;57390:6;:14;;:22;57405:6;57390:22;;;;;;;;;;;;;;;:48;;;;57466:7;57451:4;:12;;;:22;;;;;;;;;;;;;;;;;;57484:17;57504:16;57513:6;57504:8;:16::i;:::-;57484:36;;57566:1;57539:29;;:9;57549:4;57539:15;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;:29;;;57531:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;57612:4;57600;:9;;:16;;;;;;;;;;;;:::i;:::-;;57647:6;57629:9;57639:4;57629:15;;;;;;:::i;:::-;;;;;;;;;;;;;;:24;;;;;;;;;;;;;;;;;;57686:6;57669:30;;57677:7;57669:30;;;57694:4;57669:30;;;;;;:::i;:::-;;;;;;;;56787:920;;;;;56727:980:::0;:::o;55794:25::-;;;;:::o;59793:41::-;;;;;;;;;;;;;;;;;:::o;62487:189::-;62565:7;62616:1;62589:29;;:15;62599:4;62589:9;:15::i;:::-;:29;;;62585:43;;;62627:1;62620:8;;;;62585:43;62646:6;:12;62653:4;62646:12;;;;;;;;;;;;;;;:22;62659:8;62646:22;;;;;;;;;;;;;;;;62639:29;;62487:189;;;;;:::o;59416:22::-;;;;;;;;;;;;;:::o;3142:201::-;2122:13;:11;:13::i;:::-;3251:1:::1;3231:22;;:8;:22;;;;3223:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;3307:28;3326:8;3307:18;:28::i;:::-;3142:201:::0;:::o;60307:100::-;2122:13;:11;:13::i;:::-;60381:6:::1;:16;60388:8;60381:16;;;;;;;;;;;;;;;60374:23;;;60307:100:::0;:::o;60616:135::-;2122:13;:11;:13::i;:::-;60700:1:::1;60684:18;;:4;:18;;;;60676:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;60739:4;60733:3;;:10;;;;;;;;;;;;;;;;;;60616:135:::0;:::o;56572:88::-;2122:13;:11;:13::i;:::-;56646:6:::1;56633:10;:19;;;;56572:88:::0;:::o;2401:132::-;2476:12;:10;:12::i;:::-;2465:23;;:7;:5;:7::i;:::-;:23;;;2457:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2401:132::o;3503:191::-;3577:16;3596:6;;;;;;;;;;;3577:25;;3622:8;3613:6;;:17;;;;;;;;;;;;;;;;;;3677:8;3646:40;;3667:8;3646:40;;;;;;;;;;;;3566:128;3503:191;:::o;37235:293::-;36637:1;37369:7;;:19;;37361:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;36637:1;37502:7;:18;;;;37235:293::o;62060:419::-;62144:8;60248:18;60257:8;60248:4;;:8;;:18;;;;:::i;:::-;60239:5;;:27;;60231:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;62165:12:::1;62180:10;62165:25;;62201:45;62218:8;62228;62238:7;62201:16;:45::i;:::-;62264:9;62259:213;62283:8;62279:1;:12;62259:213;;;62322:3;;;;;;;;;;;62313:18;;;62332:4;62313:24;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;62359:11;62368:1;62359:4;;:8;;:11;;;;:::i;:::-;62352:4;:18;;;;62385:10;62407:3;;;;;;;;;;;62398:25;;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;62385:40;;62455:4;62445:15;;62451:2;62445:15;;;;;;;;;;62298:174;62293:3;;;;;:::i;:::-;;;;62259:213;;;;62154:325;62060:419:::0;;;;:::o;37536:213::-;36593:1;37719:7;:22;;;;37536:213::o;58683:308::-;58740:12;58764;58800:6;58808:12;58789:32;;;;;;;;;:::i;:::-;;;;;;;;;;;;;58779:43;;;;;;58764:58;;58833:17;58863:1;58853:12;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58833:32;;58881:9;58876:86;58900:4;:11;58896:1;:15;58876:86;;;58943:4;58948:1;58943:7;;;;;;;:::i;:::-;;;;;58933:4;58938:1;58933:7;;;;;;;;:::i;:::-;;;;;:17;;;;;;;;;;;58913:3;;;;;:::i;:::-;;;;58876:86;;;;58979:4;58972:11;;;;58683:308;;;:::o;781:98::-;834:7;861:10;854:17;;781:98;:::o;50209:::-;50267:7;50298:1;50294;:5;;;;:::i;:::-;50287:12;;50209:98;;;;:::o;61139:913::-;61263:1;61243:6;:16;61250:8;61243:16;;;;;;;;;;;;;;;;:21;;61235:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;61340:1;61307:35;;:21;61317:10;61307:9;:21::i;:::-;:35;;;61303:742;;;61366:8;61359:29;;;61389:10;61401:7;;;;;;;;;;;61410:30;61431:8;61410:6;:16;61417:8;61410:16;;;;;;;;;;;;;;;;:20;;:30;;;;:::i;:::-;61359:82;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61303:742;;;61478:7;61474:283;;;61513:8;61506:29;;;61536:10;61548:4;;;;;;;;;;;61554:47;61597:3;61554:38;61589:2;61554:30;61575:8;61554:6;:16;61561:8;61554:16;;;;;;;;;;;;;;;;:20;;:30;;;;:::i;:::-;:34;;:38;;;;:::i;:::-;:42;;:47;;;;:::i;:::-;61506:96;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61474:283;;;61649:8;61642:29;;;61672:10;61684:7;;;;;;;;;;;61693:47;61736:3;61693:38;61728:2;61693:30;61714:8;61693:6;:16;61700:8;61693:16;;;;;;;;;;;;;;;;:20;;:30;;;;:::i;:::-;:34;;:38;;;;:::i;:::-;:42;;:47;;;;:::i;:::-;61642:99;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61474:283;61778:8;61771:29;;;61801:10;61813:21;61823:10;61813:9;:21::i;:::-;61836:47;61879:3;61836:38;61871:2;61836:30;61857:8;61836:6;:16;61843:8;61836:16;;;;;;;;;;;;;;;;:20;;:30;;;;:::i;:::-;:34;;:38;;;;:::i;:::-;:42;;:47;;;;:::i;:::-;61771:113;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61941:92;61985:47;62028:3;61985:38;62020:2;61985:30;62006:8;61985:6;:16;61992:8;61985:16;;;;;;;;;;;;;;;;:20;;:30;;;;:::i;:::-;:34;;:38;;;;:::i;:::-;:42;;:47;;;;:::i;:::-;61941:6;:29;61948:21;61958:10;61948:9;:21::i;:::-;61941:29;;;;;;;;;;;;;;;:39;61971:8;61941:39;;;;;;;;;;;;;;;;:43;;:92;;;;:::i;:::-;61899:6;:29;61906:21;61916:10;61906:9;:21::i;:::-;61899:29;;;;;;;;;;;;;;;:39;61929:8;61899:39;;;;;;;;;;;;;;;:134;;;;61303:742;61139:913;;;:::o;50947:98::-;51005:7;51036:1;51032;:5;;;;:::i;:::-;51025:12;;50947:98;;;;:::o;51346:::-;51404:7;51435:1;51431;:5;;;;:::i;:::-;51424:12;;51346:98;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:410:1:-;84:5;109:65;125:48;166:6;125:48;:::i;:::-;109:65;:::i;:::-;100:74;;197:6;190:5;183:21;235:4;228:5;224:16;273:3;264:6;259:3;255:16;252:25;249:112;;;280:79;;:::i;:::-;249:112;370:41;404:6;399:3;394;370:41;:::i;:::-;90:327;7:410;;;;;:::o;423:139::-;469:5;507:6;494:20;485:29;;523:33;550:5;523:33;:::i;:::-;423:139;;;;:::o;568:133::-;611:5;649:6;636:20;627:29;;665:30;689:5;665:30;:::i;:::-;568:133;;;;:::o;720:338::-;775:5;824:3;817:4;809:6;805:17;801:27;791:122;;832:79;;:::i;:::-;791:122;949:6;936:20;974:78;1048:3;1040:6;1033:4;1025:6;1021:17;974:78;:::i;:::-;965:87;;781:277;720:338;;;;:::o;1064:139::-;1110:5;1148:6;1135:20;1126:29;;1164:33;1191:5;1164:33;:::i;:::-;1064:139;;;;:::o;1209:143::-;1266:5;1297:6;1291:13;1282:22;;1313:33;1340:5;1313:33;:::i;:::-;1209:143;;;;:::o;1358:329::-;1417:6;1466:2;1454:9;1445:7;1441:23;1437:32;1434:119;;;1472:79;;:::i;:::-;1434:119;1592:1;1617:53;1662:7;1653:6;1642:9;1638:22;1617:53;:::i;:::-;1607:63;;1563:117;1358:329;;;;:::o;1693:474::-;1761:6;1769;1818:2;1806:9;1797:7;1793:23;1789:32;1786:119;;;1824:79;;:::i;:::-;1786:119;1944:1;1969:53;2014:7;2005:6;1994:9;1990:22;1969:53;:::i;:::-;1959:63;;1915:117;2071:2;2097:53;2142:7;2133:6;2122:9;2118:22;2097:53;:::i;:::-;2087:63;;2042:118;1693:474;;;;;:::o;2173:::-;2241:6;2249;2298:2;2286:9;2277:7;2273:23;2269:32;2266:119;;;2304:79;;:::i;:::-;2266:119;2424:1;2449:53;2494:7;2485:6;2474:9;2470:22;2449:53;:::i;:::-;2439:63;;2395:117;2551:2;2577:53;2622:7;2613:6;2602:9;2598:22;2577:53;:::i;:::-;2567:63;;2522:118;2173:474;;;;;:::o;2653:613::-;2727:6;2735;2743;2792:2;2780:9;2771:7;2767:23;2763:32;2760:119;;;2798:79;;:::i;:::-;2760:119;2918:1;2943:53;2988:7;2979:6;2968:9;2964:22;2943:53;:::i;:::-;2933:63;;2889:117;3045:2;3071:53;3116:7;3107:6;3096:9;3092:22;3071:53;:::i;:::-;3061:63;;3016:118;3173:2;3199:50;3241:7;3232:6;3221:9;3217:22;3199:50;:::i;:::-;3189:60;;3144:115;2653:613;;;;;:::o;3272:507::-;3340:6;3389:2;3377:9;3368:7;3364:23;3360:32;3357:119;;;3395:79;;:::i;:::-;3357:119;3543:1;3532:9;3528:17;3515:31;3573:18;3565:6;3562:30;3559:117;;;3595:79;;:::i;:::-;3559:117;3700:62;3754:7;3745:6;3734:9;3730:22;3700:62;:::i;:::-;3690:72;;3486:286;3272:507;;;;:::o;3785:329::-;3844:6;3893:2;3881:9;3872:7;3868:23;3864:32;3861:119;;;3899:79;;:::i;:::-;3861:119;4019:1;4044:53;4089:7;4080:6;4069:9;4065:22;4044:53;:::i;:::-;4034:63;;3990:117;3785:329;;;;:::o;4120:351::-;4190:6;4239:2;4227:9;4218:7;4214:23;4210:32;4207:119;;;4245:79;;:::i;:::-;4207:119;4365:1;4390:64;4446:7;4437:6;4426:9;4422:22;4390:64;:::i;:::-;4380:74;;4336:128;4120:351;;;;:::o;4477:279::-;4596:10;4617:96;4709:3;4701:6;4617:96;:::i;:::-;4745:4;4740:3;4736:14;4722:28;;4477:279;;;;:::o;4762:108::-;4839:24;4857:5;4839:24;:::i;:::-;4834:3;4827:37;4762:108;;:::o;4876:118::-;4963:24;4981:5;4963:24;:::i;:::-;4958:3;4951:37;4876:118;;:::o;5072:932::-;5241:3;5270:79;5343:5;5270:79;:::i;:::-;5365:111;5469:6;5464:3;5365:111;:::i;:::-;5358:118;;5500:81;5575:5;5500:81;:::i;:::-;5604:7;5635:1;5620:359;5645:6;5642:1;5639:13;5620:359;;;5721:6;5715:13;5748:113;5857:3;5842:13;5748:113;:::i;:::-;5741:120;;5884:85;5962:6;5884:85;:::i;:::-;5874:95;;5680:299;5667:1;5664;5660:9;5655:14;;5620:359;;;5624:14;5995:3;5988:10;;5246:758;;;5072:932;;;;:::o;6010:109::-;6091:21;6106:5;6091:21;:::i;:::-;6086:3;6079:34;6010:109;;:::o;6125:360::-;6211:3;6239:38;6271:5;6239:38;:::i;:::-;6293:70;6356:6;6351:3;6293:70;:::i;:::-;6286:77;;6372:52;6417:6;6412:3;6405:4;6398:5;6394:16;6372:52;:::i;:::-;6449:29;6471:6;6449:29;:::i;:::-;6444:3;6440:39;6433:46;;6215:270;6125:360;;;;:::o;6491:373::-;6595:3;6623:38;6655:5;6623:38;:::i;:::-;6677:88;6758:6;6753:3;6677:88;:::i;:::-;6670:95;;6774:52;6819:6;6814:3;6807:4;6800:5;6796:16;6774:52;:::i;:::-;6851:6;6846:3;6842:16;6835:23;;6599:265;6491:373;;;;:::o;6870:366::-;7012:3;7033:67;7097:2;7092:3;7033:67;:::i;:::-;7026:74;;7109:93;7198:3;7109:93;:::i;:::-;7227:2;7222:3;7218:12;7211:19;;6870:366;;;:::o;7242:::-;7384:3;7405:67;7469:2;7464:3;7405:67;:::i;:::-;7398:74;;7481:93;7570:3;7481:93;:::i;:::-;7599:2;7594:3;7590:12;7583:19;;7242:366;;;:::o;7614:::-;7756:3;7777:67;7841:2;7836:3;7777:67;:::i;:::-;7770:74;;7853:93;7942:3;7853:93;:::i;:::-;7971:2;7966:3;7962:12;7955:19;;7614:366;;;:::o;7986:::-;8128:3;8149:67;8213:2;8208:3;8149:67;:::i;:::-;8142:74;;8225:93;8314:3;8225:93;:::i;:::-;8343:2;8338:3;8334:12;8327:19;;7986:366;;;:::o;8358:365::-;8500:3;8521:66;8585:1;8580:3;8521:66;:::i;:::-;8514:73;;8596:93;8685:3;8596:93;:::i;:::-;8714:2;8709:3;8705:12;8698:19;;8358:365;;;:::o;8729:366::-;8871:3;8892:67;8956:2;8951:3;8892:67;:::i;:::-;8885:74;;8968:93;9057:3;8968:93;:::i;:::-;9086:2;9081:3;9077:12;9070:19;;8729:366;;;:::o;9101:::-;9243:3;9264:67;9328:2;9323:3;9264:67;:::i;:::-;9257:74;;9340:93;9429:3;9340:93;:::i;:::-;9458:2;9453:3;9449:12;9442:19;;9101:366;;;:::o;9473:::-;9615:3;9636:67;9700:2;9695:3;9636:67;:::i;:::-;9629:74;;9712:93;9801:3;9712:93;:::i;:::-;9830:2;9825:3;9821:12;9814:19;;9473:366;;;:::o;9845:::-;9987:3;10008:67;10072:2;10067:3;10008:67;:::i;:::-;10001:74;;10084:93;10173:3;10084:93;:::i;:::-;10202:2;10197:3;10193:12;10186:19;;9845:366;;;:::o;10217:::-;10359:3;10380:67;10444:2;10439:3;10380:67;:::i;:::-;10373:74;;10456:93;10545:3;10456:93;:::i;:::-;10574:2;10569:3;10565:12;10558:19;;10217:366;;;:::o;10589:::-;10731:3;10752:67;10816:2;10811:3;10752:67;:::i;:::-;10745:74;;10828:93;10917:3;10828:93;:::i;:::-;10946:2;10941:3;10937:12;10930:19;;10589:366;;;:::o;10961:::-;11103:3;11124:67;11188:2;11183:3;11124:67;:::i;:::-;11117:74;;11200:93;11289:3;11200:93;:::i;:::-;11318:2;11313:3;11309:12;11302:19;;10961:366;;;:::o;11401:505::-;11538:4;11533:3;11529:14;11628:4;11621:5;11617:16;11611:23;11647:63;11704:4;11699:3;11695:14;11681:12;11647:63;:::i;:::-;11553:167;11807:4;11800:5;11796:16;11790:23;11826:63;11883:4;11878:3;11874:14;11860:12;11826:63;:::i;:::-;11730:169;11507:399;11401:505;;:::o;11912:108::-;11989:24;12007:5;11989:24;:::i;:::-;11984:3;11977:37;11912:108;;:::o;12026:118::-;12113:24;12131:5;12113:24;:::i;:::-;12108:3;12101:37;12026:118;;:::o;12150:271::-;12280:3;12302:93;12391:3;12382:6;12302:93;:::i;:::-;12295:100;;12412:3;12405:10;;12150:271;;;;:::o;12427:222::-;12520:4;12558:2;12547:9;12543:18;12535:26;;12571:71;12639:1;12628:9;12624:17;12615:6;12571:71;:::i;:::-;12427:222;;;;:::o;12655:442::-;12804:4;12842:2;12831:9;12827:18;12819:26;;12855:71;12923:1;12912:9;12908:17;12899:6;12855:71;:::i;:::-;12936:72;13004:2;12993:9;12989:18;12980:6;12936:72;:::i;:::-;13018;13086:2;13075:9;13071:18;13062:6;13018:72;:::i;:::-;12655:442;;;;;;:::o;13103:332::-;13224:4;13262:2;13251:9;13247:18;13239:26;;13275:71;13343:1;13332:9;13328:17;13319:6;13275:71;:::i;:::-;13356:72;13424:2;13413:9;13409:18;13400:6;13356:72;:::i;:::-;13103:332;;;;;:::o;13441:473::-;13634:4;13672:2;13661:9;13657:18;13649:26;;13721:9;13715:4;13711:20;13707:1;13696:9;13692:17;13685:47;13749:158;13902:4;13893:6;13749:158;:::i;:::-;13741:166;;13441:473;;;;:::o;13920:210::-;14007:4;14045:2;14034:9;14030:18;14022:26;;14058:65;14120:1;14109:9;14105:17;14096:6;14058:65;:::i;:::-;13920:210;;;;:::o;14136:309::-;14247:4;14285:2;14274:9;14270:18;14262:26;;14334:9;14328:4;14324:20;14320:1;14309:9;14305:17;14298:47;14362:76;14433:4;14424:6;14362:76;:::i;:::-;14354:84;;14136:309;;;;:::o;14451:419::-;14617:4;14655:2;14644:9;14640:18;14632:26;;14704:9;14698:4;14694:20;14690:1;14679:9;14675:17;14668:47;14732:131;14858:4;14732:131;:::i;:::-;14724:139;;14451:419;;;:::o;14876:::-;15042:4;15080:2;15069:9;15065:18;15057:26;;15129:9;15123:4;15119:20;15115:1;15104:9;15100:17;15093:47;15157:131;15283:4;15157:131;:::i;:::-;15149:139;;14876:419;;;:::o;15301:::-;15467:4;15505:2;15494:9;15490:18;15482:26;;15554:9;15548:4;15544:20;15540:1;15529:9;15525:17;15518:47;15582:131;15708:4;15582:131;:::i;:::-;15574:139;;15301:419;;;:::o;15726:::-;15892:4;15930:2;15919:9;15915:18;15907:26;;15979:9;15973:4;15969:20;15965:1;15954:9;15950:17;15943:47;16007:131;16133:4;16007:131;:::i;:::-;15999:139;;15726:419;;;:::o;16151:::-;16317:4;16355:2;16344:9;16340:18;16332:26;;16404:9;16398:4;16394:20;16390:1;16379:9;16375:17;16368:47;16432:131;16558:4;16432:131;:::i;:::-;16424:139;;16151:419;;;:::o;16576:::-;16742:4;16780:2;16769:9;16765:18;16757:26;;16829:9;16823:4;16819:20;16815:1;16804:9;16800:17;16793:47;16857:131;16983:4;16857:131;:::i;:::-;16849:139;;16576:419;;;:::o;17001:::-;17167:4;17205:2;17194:9;17190:18;17182:26;;17254:9;17248:4;17244:20;17240:1;17229:9;17225:17;17218:47;17282:131;17408:4;17282:131;:::i;:::-;17274:139;;17001:419;;;:::o;17426:::-;17592:4;17630:2;17619:9;17615:18;17607:26;;17679:9;17673:4;17669:20;17665:1;17654:9;17650:17;17643:47;17707:131;17833:4;17707:131;:::i;:::-;17699:139;;17426:419;;;:::o;17851:::-;18017:4;18055:2;18044:9;18040:18;18032:26;;18104:9;18098:4;18094:20;18090:1;18079:9;18075:17;18068:47;18132:131;18258:4;18132:131;:::i;:::-;18124:139;;17851:419;;;:::o;18276:::-;18442:4;18480:2;18469:9;18465:18;18457:26;;18529:9;18523:4;18519:20;18515:1;18504:9;18500:17;18493:47;18557:131;18683:4;18557:131;:::i;:::-;18549:139;;18276:419;;;:::o;18701:::-;18867:4;18905:2;18894:9;18890:18;18882:26;;18954:9;18948:4;18944:20;18940:1;18929:9;18925:17;18918:47;18982:131;19108:4;18982:131;:::i;:::-;18974:139;;18701:419;;;:::o;19126:::-;19292:4;19330:2;19319:9;19315:18;19307:26;;19379:9;19373:4;19369:20;19365:1;19354:9;19350:17;19343:47;19407:131;19533:4;19407:131;:::i;:::-;19399:139;;19126:419;;;:::o;19551:222::-;19644:4;19682:2;19671:9;19667:18;19659:26;;19695:71;19763:1;19752:9;19748:17;19739:6;19695:71;:::i;:::-;19551:222;;;;:::o;19779:129::-;19813:6;19840:20;;:::i;:::-;19830:30;;19869:33;19897:4;19889:6;19869:33;:::i;:::-;19779:129;;;:::o;19914:75::-;19947:6;19980:2;19974:9;19964:19;;19914:75;:::o;19995:307::-;20056:4;20146:18;20138:6;20135:30;20132:56;;;20168:18;;:::i;:::-;20132:56;20206:29;20228:6;20206:29;:::i;:::-;20198:37;;20290:4;20284;20280:15;20272:23;;19995:307;;;:::o;20308:157::-;20400:4;20423:3;20415:11;;20453:4;20448:3;20444:14;20436:22;;20308:157;;;:::o;20471:139::-;20563:6;20597:5;20591:12;20581:22;;20471:139;;;:::o;20616:98::-;20667:6;20701:5;20695:12;20685:22;;20616:98;;;:::o;20720:138::-;20815:4;20847;20842:3;20838:14;20830:22;;20720:138;;;:::o;20864:209::-;20988:11;21022:6;21017:3;21010:19;21062:4;21057:3;21053:14;21038:29;;20864:209;;;;:::o;21079:168::-;21162:11;21196:6;21191:3;21184:19;21236:4;21231:3;21227:14;21212:29;;21079:168;;;;:::o;21253:147::-;21354:11;21391:3;21376:18;;21253:147;;;;:::o;21406:169::-;21490:11;21524:6;21519:3;21512:19;21564:4;21559:3;21555:14;21540:29;;21406:169;;;;:::o;21581:305::-;21621:3;21640:20;21658:1;21640:20;:::i;:::-;21635:25;;21674:20;21692:1;21674:20;:::i;:::-;21669:25;;21828:1;21760:66;21756:74;21753:1;21750:81;21747:107;;;21834:18;;:::i;:::-;21747:107;21878:1;21875;21871:9;21864:16;;21581:305;;;;:::o;21892:185::-;21932:1;21949:20;21967:1;21949:20;:::i;:::-;21944:25;;21983:20;22001:1;21983:20;:::i;:::-;21978:25;;22022:1;22012:35;;22027:18;;:::i;:::-;22012:35;22069:1;22066;22062:9;22057:14;;21892:185;;;;:::o;22083:348::-;22123:7;22146:20;22164:1;22146:20;:::i;:::-;22141:25;;22180:20;22198:1;22180:20;:::i;:::-;22175:25;;22368:1;22300:66;22296:74;22293:1;22290:81;22285:1;22278:9;22271:17;22267:105;22264:131;;;22375:18;;:::i;:::-;22264:131;22423:1;22420;22416:9;22405:20;;22083:348;;;;:::o;22437:96::-;22474:7;22503:24;22521:5;22503:24;:::i;:::-;22492:35;;22437:96;;;:::o;22539:90::-;22573:7;22616:5;22609:13;22602:21;22591:32;;22539:90;;;:::o;22635:126::-;22672:7;22712:42;22705:5;22701:54;22690:65;;22635:126;;;:::o;22767:77::-;22804:7;22833:5;22822:16;;22767:77;;;:::o;22850:154::-;22934:6;22929:3;22924;22911:30;22996:1;22987:6;22982:3;22978:16;22971:27;22850:154;;;:::o;23010:307::-;23078:1;23088:113;23102:6;23099:1;23096:13;23088:113;;;23187:1;23182:3;23178:11;23172:18;23168:1;23163:3;23159:11;23152:39;23124:2;23121:1;23117:10;23112:15;;23088:113;;;23219:6;23216:1;23213:13;23210:101;;;23299:1;23290:6;23285:3;23281:16;23274:27;23210:101;23059:258;23010:307;;;:::o;23323:320::-;23367:6;23404:1;23398:4;23394:12;23384:22;;23451:1;23445:4;23441:12;23472:18;23462:81;;23528:4;23520:6;23516:17;23506:27;;23462:81;23590:2;23582:6;23579:14;23559:18;23556:38;23553:84;;;23609:18;;:::i;:::-;23553:84;23374:269;23323:320;;;:::o;23649:281::-;23732:27;23754:4;23732:27;:::i;:::-;23724:6;23720:40;23862:6;23850:10;23847:22;23826:18;23814:10;23811:34;23808:62;23805:88;;;23873:18;;:::i;:::-;23805:88;23913:10;23909:2;23902:22;23692:238;23649:281;;:::o;23936:233::-;23975:3;23998:24;24016:5;23998:24;:::i;:::-;23989:33;;24044:66;24037:5;24034:77;24031:103;;;24114:18;;:::i;:::-;24031:103;24161:1;24154:5;24150:13;24143:20;;23936:233;;;:::o;24175:180::-;24223:77;24220:1;24213:88;24320:4;24317:1;24310:15;24344:4;24341:1;24334:15;24361:180;24409:77;24406:1;24399:88;24506:4;24503:1;24496:15;24530:4;24527:1;24520:15;24547:180;24595:77;24592:1;24585:88;24692:4;24689:1;24682:15;24716:4;24713:1;24706:15;24733:180;24781:77;24778:1;24771:88;24878:4;24875:1;24868:15;24902:4;24899:1;24892:15;24919:180;24967:77;24964:1;24957:88;25064:4;25061:1;25054:15;25088:4;25085:1;25078:15;25105:117;25214:1;25211;25204:12;25228:117;25337:1;25334;25327:12;25351:117;25460:1;25457;25450:12;25474:117;25583:1;25580;25573:12;25597:102;25638:6;25689:2;25685:7;25680:2;25673:5;25669:14;25665:28;25655:38;;25597:102;;;:::o;25705:161::-;25845:13;25841:1;25833:6;25829:14;25822:37;25705:161;:::o;25872:225::-;26012:34;26008:1;26000:6;25996:14;25989:58;26081:8;26076:2;26068:6;26064:15;26057:33;25872:225;:::o;26103:164::-;26243:16;26239:1;26231:6;26227:14;26220:40;26103:164;:::o;26273:175::-;26413:27;26409:1;26401:6;26397:14;26390:51;26273:175;:::o;26454:158::-;26594:10;26590:1;26582:6;26578:14;26571:34;26454:158;:::o;26618:165::-;26758:17;26754:1;26746:6;26742:14;26735:41;26618:165;:::o;26789:173::-;26929:25;26925:1;26917:6;26913:14;26906:49;26789:173;:::o;26968:181::-;27108:33;27104:1;27096:6;27092:14;27085:57;26968:181;:::o;27155:182::-;27295:34;27291:1;27283:6;27279:14;27272:58;27155:182;:::o;27343:166::-;27483:18;27479:1;27471:6;27467:14;27460:42;27343:166;:::o;27515:181::-;27655:33;27651:1;27643:6;27639:14;27632:57;27515:181;:::o;27702:169::-;27842:21;27838:1;27830:6;27826:14;27819:45;27702:169;:::o;27877:122::-;27950:24;27968:5;27950:24;:::i;:::-;27943:5;27940:35;27930:63;;27989:1;27986;27979:12;27930:63;27877:122;:::o;28005:116::-;28075:21;28090:5;28075:21;:::i;:::-;28068:5;28065:32;28055:60;;28111:1;28108;28101:12;28055:60;28005:116;:::o;28127:122::-;28200:24;28218:5;28200:24;:::i;:::-;28193:5;28190:35;28180:63;;28239:1;28236;28229:12;28180:63;28127:122;:::o
Swarm Source
ipfs://0d3f075819e184ec4b48931367fc75e253d0843a55d9a082e5375610fb9f179e
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.