Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
TokenTracker
Latest 25 from a total of 497 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Set Approval For... | 18410565 | 308 days ago | IN | 0 ETH | 0.00043225 | ||||
Set Approval For... | 18402435 | 309 days ago | IN | 0 ETH | 0.00031444 | ||||
Set Approval For... | 18398557 | 309 days ago | IN | 0 ETH | 0.00036403 | ||||
Safe Transfer Fr... | 18392575 | 310 days ago | IN | 0 ETH | 0.00102436 | ||||
Safe Transfer Fr... | 18391982 | 310 days ago | IN | 0 ETH | 0.001257 | ||||
Set Approval For... | 18386880 | 311 days ago | IN | 0 ETH | 0.0003639 | ||||
Set Approval For... | 18385786 | 311 days ago | IN | 0 ETH | 0.00054548 | ||||
Set Approval For... | 18385369 | 311 days ago | IN | 0 ETH | 0.00072873 | ||||
Set Approval For... | 18385334 | 311 days ago | IN | 0 ETH | 0.00082491 | ||||
Set Approval For... | 18385316 | 311 days ago | IN | 0 ETH | 0.00084247 | ||||
Set Approval For... | 18385290 | 311 days ago | IN | 0 ETH | 0.0009528 | ||||
Safe Transfer Fr... | 18384915 | 311 days ago | IN | 0 ETH | 0.00153855 | ||||
Safe Transfer Fr... | 18384907 | 311 days ago | IN | 0 ETH | 0.00150709 | ||||
Set Approval For... | 18384785 | 311 days ago | IN | 0 ETH | 0.00071424 | ||||
Set Approval For... | 18384781 | 311 days ago | IN | 0 ETH | 0.0007759 | ||||
Set Approval For... | 18384774 | 311 days ago | IN | 0 ETH | 0.00076053 | ||||
Safe Transfer Fr... | 18384642 | 311 days ago | IN | 0 ETH | 0.00069147 | ||||
Safe Transfer Fr... | 18384624 | 311 days ago | IN | 0 ETH | 0.00066867 | ||||
Safe Transfer Fr... | 18384618 | 311 days ago | IN | 0 ETH | 0.00097524 | ||||
Safe Transfer Fr... | 18384615 | 311 days ago | IN | 0 ETH | 0.00072949 | ||||
Safe Transfer Fr... | 18384612 | 311 days ago | IN | 0 ETH | 0.00077839 | ||||
Safe Transfer Fr... | 18384609 | 311 days ago | IN | 0 ETH | 0.00081873 | ||||
Safe Transfer Fr... | 18384604 | 311 days ago | IN | 0 ETH | 0.0004875 | ||||
Safe Transfer Fr... | 18384603 | 311 days ago | IN | 0 ETH | 0.00107833 | ||||
Safe Transfer Fr... | 18384600 | 311 days ago | IN | 0 ETH | 0.00115962 |
Loading...
Loading
Contract Name:
TKTVPresaleMintPass
Compiler Version
v0.8.20+commit.a1b79de6
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2023-07-03 */ // File: @openzeppelin/contracts/utils/cryptography/MerkleProof.sol // OpenZeppelin Contracts (last updated v4.9.2) (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 rebuilds 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 proofLen = proof.length; uint256 totalHashes = proofFlags.length; // Check proof validity. require(leavesLen + proofLen - 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 from 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) { require(proofPos == proofLen, "MerkleProof: invalid multiproof"); unchecked { 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 rebuilds 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 proofLen = proof.length; uint256 totalHashes = proofFlags.length; // Check proof validity. require(leavesLen + proofLen - 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 from 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) { require(proofPos == proofLen, "MerkleProof: invalid multiproof"); unchecked { 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/SignedMath.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol) pragma solidity ^0.8.0; /** * @dev Standard signed math utilities missing in the Solidity language. */ library SignedMath { /** * @dev Returns the largest of two signed numbers. */ function max(int256 a, int256 b) internal pure returns (int256) { return a > b ? a : b; } /** * @dev Returns the smallest of two signed numbers. */ function min(int256 a, int256 b) internal pure returns (int256) { return a < b ? a : b; } /** * @dev Returns the average of two signed numbers without overflow. * The result is rounded towards zero. */ function average(int256 a, int256 b) internal pure returns (int256) { // Formula from the book "Hacker's Delight" int256 x = (a & b) + ((a ^ b) >> 1); return x + (int256(uint256(x) >> 255) & (a ^ b)); } /** * @dev Returns the absolute unsigned value of a signed value. */ function abs(int256 n) internal pure returns (uint256) { unchecked { // must be unchecked in order to support `n = type(int256).min` return uint256(n >= 0 ? n : -n); } } } // File: @openzeppelin/contracts/utils/math/Math.sol // OpenZeppelin Contracts (last updated v4.9.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) { // Solidity will revert if denominator == 0, unlike the div opcode on its own. // The surrounding unchecked block does not change this fact. // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic. return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1, "Math: mulDiv overflow"); /////////////////////////////////////////////// // 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 256, 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 << 3) < value ? 1 : 0); } } } // File: @openzeppelin/contracts/utils/Strings.sol // OpenZeppelin Contracts (last updated v4.9.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 `int256` to its ASCII `string` decimal representation. */ function toString(int256 value) internal pure returns (string memory) { return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value)))); } /** * @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); } /** * @dev Returns true if the two strings are equal. */ function equal(string memory a, string memory b) internal pure returns (bool) { return keccak256(bytes(a)) == keccak256(bytes(b)); } } // File: @openzeppelin/contracts/utils/Context.sol // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File: @openzeppelin/contracts/access/Ownable.sol // OpenZeppelin Contracts (last updated v4.9.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. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling 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/Address.sol // OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * * Furthermore, `isContract` will also return true if the target contract within * the same transaction is already scheduled for destruction by `SELFDESTRUCT`, * which only has an effect at the end of a transaction. * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } // File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } // File: @openzeppelin/contracts/utils/introspection/IERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: @openzeppelin/contracts/utils/introspection/ERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } // File: @openzeppelin/contracts/token/ERC721/IERC721.sol // OpenZeppelin Contracts (last updated v4.9.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/IERC721Enumerable.sol // 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/token/ERC721/extensions/IERC721Metadata.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); } // File: utils/ERC721A.sol // Creator: Chiru Labs pragma solidity ^0.8.4; error ApprovalCallerNotOwnerNorApproved(); error ApprovalQueryForNonexistentToken(); error ApproveToCaller(); error ApprovalToCurrentOwner(); error BalanceQueryForZeroAddress(); error MintedQueryForZeroAddress(); error BurnedQueryForZeroAddress(); error AuxQueryForZeroAddress(); error MintToZeroAddress(); error MintZeroQuantity(); error OwnerIndexOutOfBounds(); error OwnerQueryForNonexistentToken(); error TokenIndexOutOfBounds(); error TransferCallerNotOwnerNorApproved(); error TransferFromIncorrectOwner(); error TransferToNonERC721ReceiverImplementer(); error TransferToZeroAddress(); error URIQueryForNonexistentToken(); /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension. Built to optimize for lower gas during batch mints. * * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..). * * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply. * * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256). */ contract ERC721A is Context, ERC165, IERC721, IERC721Metadata { using Address for address; using Strings for uint256; // Compiler will pack this into a single 256bit word. struct TokenOwnership { // The address of the owner. address addr; // Keeps track of the start time of ownership with minimal overhead for tokenomics. uint64 startTimestamp; // Whether the token has been burned. bool burned; } // Compiler will pack this into a single 256bit word. struct AddressData { // Realistically, 2**64-1 is more than enough. uint64 balance; // Keeps track of mint count with minimal overhead for tokenomics. uint64 numberMinted; // Keeps track of burn count with minimal overhead for tokenomics. uint64 numberBurned; // For miscellaneous variable(s) pertaining to the address // (e.g. number of whitelist mint slots used). // If there are multiple variables, please pack them into a uint64. uint64 aux; } // The tokenId of the next token to be minted. uint256 internal _currentIndex; // The number of tokens burned. uint256 internal _burnCounter; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to ownership details // An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details. mapping(uint256 => TokenOwnership) internal _ownerships; // Mapping owner address to address data mapping(address => AddressData) private _addressData; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; _currentIndex = _startTokenId(); } /** * To change the starting tokenId, please override this function. */ function _startTokenId() internal view virtual returns (uint256) { return 0; } /** * @dev See {IERC721Enumerable-totalSupply}. * @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens. */ function totalSupply() public view returns (uint256) { // Counter underflow is impossible as _burnCounter cannot be incremented // more than _currentIndex - _startTokenId() times unchecked { return _currentIndex - _burnCounter - _startTokenId(); } } /** * Returns the total amount of tokens minted in the contract. */ function _totalMinted() internal view returns (uint256) { // Counter underflow is impossible as _currentIndex does not decrement, // and it is initialized to _startTokenId() unchecked { return _currentIndex - _startTokenId(); } } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view override returns (uint256) { if (owner == address(0)) revert BalanceQueryForZeroAddress(); return uint256(_addressData[owner].balance); } /** * Returns the number of tokens minted by `owner`. */ function _numberMinted(address owner) internal view returns (uint256) { if (owner == address(0)) revert MintedQueryForZeroAddress(); return uint256(_addressData[owner].numberMinted); } /** * Returns the number of tokens burned by or on behalf of `owner`. */ function _numberBurned(address owner) internal view returns (uint256) { if (owner == address(0)) revert BurnedQueryForZeroAddress(); return uint256(_addressData[owner].numberBurned); } /** * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used). */ function _getAux(address owner) internal view returns (uint64) { if (owner == address(0)) revert AuxQueryForZeroAddress(); return _addressData[owner].aux; } /** * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used). * If there are multiple variables, please pack them into a uint64. */ function _setAux(address owner, uint64 aux) internal { if (owner == address(0)) revert AuxQueryForZeroAddress(); _addressData[owner].aux = aux; } /** * Gas spent here starts off proportional to the maximum mint batch size. * It gradually moves to O(1) as tokens get transferred around in the collection over time. */ function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) { uint256 curr = tokenId; unchecked { if (_startTokenId() <= curr && curr < _currentIndex) { TokenOwnership memory ownership = _ownerships[curr]; if (!ownership.burned) { if (ownership.addr != address(0)) { return ownership; } // Invariant: // There will always be an ownership that has an address and is not burned // before an ownership that does not have an address and is not burned. // Hence, curr will not underflow. while (true) { curr--; ownership = _ownerships[curr]; if (ownership.addr != address(0)) { return ownership; } } } } } revert OwnerQueryForNonexistentToken(); } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view override returns (address) { return ownershipOf(tokenId).addr; } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { if (!_exists(tokenId)) revert URIQueryForNonexistentToken(); string memory baseURI = _baseURI(); return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ''; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overriden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ''; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public override { address owner = ERC721A.ownerOf(tokenId); if (to == owner) revert ApprovalToCurrentOwner(); if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) { revert ApprovalCallerNotOwnerNorApproved(); } _approve(to, tokenId, owner); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view override returns (address) { if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken(); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public override { if (operator == _msgSender()) revert ApproveToCaller(); _operatorApprovals[_msgSender()][operator] = approved; emit ApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom( address from, address to, uint256 tokenId ) public virtual override { _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId ) public virtual override { safeTransferFrom(from, to, tokenId, ''); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory _data ) public virtual override { _transfer(from, to, tokenId); if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) { revert TransferToNonERC721ReceiverImplementer(); } } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), */ function _exists(uint256 tokenId) internal view returns (bool) { return _startTokenId() <= tokenId && tokenId < _currentIndex && !_ownerships[tokenId].burned; } function _safeMint(address to, uint256 quantity) internal { _safeMint(to, quantity, ''); } /** * @dev Safely mints `quantity` tokens and transfers them to `to`. * * Requirements: * * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer. * - `quantity` must be greater than 0. * * Emits a {Transfer} event. */ function _safeMint( address to, uint256 quantity, bytes memory _data ) internal { _mint(to, quantity, _data, true); } /** * @dev Mints `quantity` tokens and transfers them to `to`. * * Requirements: * * - `to` cannot be the zero address. * - `quantity` must be greater than 0. * * Emits a {Transfer} event. */ function _mint( address to, uint256 quantity, bytes memory _data, bool safe ) internal { uint256 startTokenId = _currentIndex; if (to == address(0)) revert MintToZeroAddress(); if (quantity == 0) revert MintZeroQuantity(); _beforeTokenTransfers(address(0), to, startTokenId, quantity); // Overflows are incredibly unrealistic. // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1 // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1 unchecked { _addressData[to].balance += uint64(quantity); _addressData[to].numberMinted += uint64(quantity); _ownerships[startTokenId].addr = to; _ownerships[startTokenId].startTimestamp = uint64(block.timestamp); uint256 updatedIndex = startTokenId; uint256 end = updatedIndex + quantity; if (safe && to.isContract()) { do { emit Transfer(address(0), to, updatedIndex); if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) { revert TransferToNonERC721ReceiverImplementer(); } } while (updatedIndex != end); // Reentrancy protection if (_currentIndex != startTokenId) revert(); } else { do { emit Transfer(address(0), to, updatedIndex++); } while (updatedIndex != end); } _currentIndex = updatedIndex; } _afterTokenTransfers(address(0), to, startTokenId, quantity); } /** * @dev Transfers `tokenId` from `from` to `to`. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint256 tokenId ) private { TokenOwnership memory prevOwnership = ownershipOf(tokenId); bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr || isApprovedForAll(prevOwnership.addr, _msgSender()) || getApproved(tokenId) == _msgSender()); if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved(); if (prevOwnership.addr != from) revert TransferFromIncorrectOwner(); if (to == address(0)) revert TransferToZeroAddress(); _beforeTokenTransfers(from, to, tokenId, 1); // Clear approvals from the previous owner _approve(address(0), tokenId, prevOwnership.addr); // Underflow of the sender's balance is impossible because we check for // ownership above and the recipient's balance can't realistically overflow. // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256. unchecked { _addressData[from].balance -= 1; _addressData[to].balance += 1; _ownerships[tokenId].addr = to; _ownerships[tokenId].startTimestamp = uint64(block.timestamp); // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it. // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls. uint256 nextTokenId = tokenId + 1; if (_ownerships[nextTokenId].addr == address(0)) { // This will suffice for checking _exists(nextTokenId), // as a burned slot cannot contain the zero address. if (nextTokenId < _currentIndex) { _ownerships[nextTokenId].addr = prevOwnership.addr; _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp; } } } emit Transfer(from, to, tokenId); _afterTokenTransfers(from, to, tokenId, 1); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { TokenOwnership memory prevOwnership = ownershipOf(tokenId); _beforeTokenTransfers(prevOwnership.addr, address(0), tokenId, 1); // Clear approvals from the previous owner _approve(address(0), tokenId, prevOwnership.addr); // Underflow of the sender's balance is impossible because we check for // ownership above and the recipient's balance can't realistically overflow. // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256. unchecked { _addressData[prevOwnership.addr].balance -= 1; _addressData[prevOwnership.addr].numberBurned += 1; // Keep track of who burned the token, and the timestamp of burning. _ownerships[tokenId].addr = prevOwnership.addr; _ownerships[tokenId].startTimestamp = uint64(block.timestamp); _ownerships[tokenId].burned = true; // If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it. // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls. uint256 nextTokenId = tokenId + 1; if (_ownerships[nextTokenId].addr == address(0)) { // This will suffice for checking _exists(nextTokenId), // as a burned slot cannot contain the zero address. if (nextTokenId < _currentIndex) { _ownerships[nextTokenId].addr = prevOwnership.addr; _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp; } } } emit Transfer(prevOwnership.addr, address(0), tokenId); _afterTokenTransfers(prevOwnership.addr, address(0), tokenId, 1); // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times. unchecked { _burnCounter++; } } /** * @dev Approve `to` to operate on `tokenId` * * Emits a {Approval} event. */ function _approve( address to, uint256 tokenId, address owner ) private { _tokenApprovals[tokenId] = to; emit Approval(owner, to, tokenId); } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param _data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkContractOnERC721Received( address from, address to, uint256 tokenId, bytes memory _data ) private returns (bool) { try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) { return retval == IERC721Receiver(to).onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert TransferToNonERC721ReceiverImplementer(); } else { assembly { revert(add(32, reason), mload(reason)) } } } } /** * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting. * And also called before burning one token. * * startTokenId - the first token id to be transferred * quantity - the amount to be transferred * * Calling conditions: * * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be * transferred to `to`. * - When `from` is zero, `tokenId` will be minted for `to`. * - When `to` is zero, `tokenId` will be burned by `from`. * - `from` and `to` are never both zero. */ function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual {} /** * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes * minting. * And also called after one token has been burned. * * startTokenId - the first token id to be transferred * quantity - the amount to be transferred * * Calling conditions: * * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been * transferred to `to`. * - When `from` is zero, `tokenId` has been minted for `to`. * - When `to` is zero, `tokenId` has been burned by `from`. * - `from` and `to` are never both zero. */ function _afterTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual {} } // File: TKTVPresaleMintPass.sol pragma solidity 0.8.20; contract TKTVPresaleMintPass is ERC721A, Ownable { using Strings for uint256; // Supply uint256 public maxSupply = 521; uint256 public maxSupplyLimit = 77; // URI string public baseURI = "https://bafybeigqzgamjl5iyuobtjkop5bnhxoszruwjpeomw4bcq3hbhc2g2ukm4.ipfs.nftstorage.link/"; string public hiddenURI = "https://bafkreidfdux7klxqgcpom24rf6mkz2zilpk4bcp7kabmyzzmiepnpccncq.ipfs.nftstorage.link/"; // Costs uint256 public whitelistMintCost = 0.0111 ether; // Per wallet Limits uint256 public nftFreeMintPerWalletLimit = 1; uint256 public nftWhitelistMintPerWalletLimit = 1; // States bool public paused = false; bool public freeMintActive = true; bool public whitelistMintActive = true; bool public revealed = false; // Merkle Tree Roots bytes32 public freeMintMerkleTreeRoot; bytes32 public whitelistMintMerkleTreeRoot; // Balances mapping(address => uint256) public walletFreeMintBalance; mapping(address => uint256) public walletWhitelistMintBalance; // Constructor constructor() ERC721A("Vindico Studios - TKTV Presale Mint Pass", "TKTV Presale Mint Pass") {} // Free Mint - Functions function freeMint(uint256 _mintAmount, bytes32[] memory _merkleTreeProof) public payable freeMintCompliance(_mintAmount, _merkleTreeProof) { require(!paused, "MSG: The contract is paused"); require(freeMintActive == true, "MSG: free mint is not live yet"); _safeMint(msg.sender, _mintAmount); for (uint256 i = 0; i < _mintAmount; i++) { walletFreeMintBalance[msg.sender]++; } } modifier freeMintCompliance(uint256 _mintAmount, bytes32[] memory _merkleTreeProof) { uint256 freeMintOwnerMintCount = walletFreeMintBalance[msg.sender]; uint256 whitelistOwnerMintCount = walletWhitelistMintBalance[msg.sender]; require(freeMintOwnerMintCount + _mintAmount <= nftFreeMintPerWalletLimit, "MSG: Max NFTs per wallet exceeded for free mint"); require(whitelistOwnerMintCount + _mintAmount <= nftFreeMintPerWalletLimit, "MSG: Max NFTs per wallet exceeded for whitelist mint"); require(isValidFreeMintMerkleTreeProof(_merkleTreeProof, keccak256(abi.encodePacked(msg.sender))), "MSG: User is not whitelisted"); require(totalSupply() + _mintAmount <= maxSupplyLimit, "MSG: Max supply exceeded for current phase"); require(totalSupply() + _mintAmount <= maxSupply, "MSG: Max supply exceeded"); _; } function isValidFreeMintMerkleTreeProof(bytes32[] memory proof, bytes32 leaf) public view returns (bool) { return MerkleProof.verify(proof, freeMintMerkleTreeRoot, leaf); } // Whitelist Mint - Functions function whitelistMint(uint256 _mintAmount, bytes32[] memory _merkleTreeProof) public payable whitelistMintCompliance(_mintAmount, _merkleTreeProof) { require(!paused, "MSG: The contract is paused"); require(whitelistMintActive == true, "MSG: Whitelist mint is not live yet"); require(msg.value == whitelistMintCost * _mintAmount, "MSG: Insufficient funds"); _safeMint(msg.sender, _mintAmount); for (uint256 i = 0; i < _mintAmount; i++) { walletWhitelistMintBalance[msg.sender]++; } } modifier whitelistMintCompliance(uint256 _mintAmount, bytes32[] memory _merkleTreeProof) { uint256 freeMintOwnerMintCount = walletFreeMintBalance[msg.sender]; uint256 whitelistOwnerMintCount = walletWhitelistMintBalance[msg.sender]; require(freeMintOwnerMintCount + _mintAmount <= nftWhitelistMintPerWalletLimit, "MSG: Max NFTs per wallet exceeded for free mint"); require(whitelistOwnerMintCount + _mintAmount <= nftWhitelistMintPerWalletLimit, "MSG: Max NFTs per wallet exceeded for whitelist mint"); require(isValidWhitelistMintMerkleTreeProof(_merkleTreeProof, keccak256(abi.encodePacked(msg.sender))), "MSG: User is not whitelisted"); require(totalSupply() + _mintAmount <= maxSupplyLimit, "MSG: Max supply exceeded for current phase"); require(totalSupply() + _mintAmount <= maxSupply, "MSG: Max supply exceeded"); _; } function isValidWhitelistMintMerkleTreeProof(bytes32[] memory proof, bytes32 leaf) public view returns (bool) { return MerkleProof.verify(proof, whitelistMintMerkleTreeRoot, leaf); } // Owner Mint - Functions function ownerMint(uint256 _mintAmount) public onlyOwner { require(!paused, "MSG: The contract is paused"); require(totalSupply() + _mintAmount <= maxSupplyLimit, "MSG: Max supply exceeded for current phase"); require(totalSupply() + _mintAmount <= maxSupply, "MSG: Max supply exceeded"); _safeMint(msg.sender, _mintAmount); } function ownerMintForOthers(address _receiver, uint256 _mintAmount) public onlyOwner { require(!paused, "MSG: The contract is paused"); require(totalSupply() + _mintAmount <= maxSupplyLimit, "MSG: Max supply exceeded for current phase"); require(totalSupply() + _mintAmount <= maxSupply, "MSG: Max supply exceeded"); _safeMint(_receiver, _mintAmount); } // Supply - Functions function setMaxSupply(uint256 _supply) public onlyOwner { maxSupply = _supply; } function setMaxSupplyLimit(uint256 _supply) public onlyOwner { maxSupplyLimit = _supply; } // URI - Functions function _baseURI() internal view override returns (string memory) { return baseURI; } function setBaseURI(string memory _uri) public onlyOwner { baseURI = _uri; } function setHiddenURI(string memory _uri) public onlyOwner { hiddenURI = _uri; } function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) { require(_exists(_tokenId), "MSG: URI query for nonexistent token."); if (revealed == false) { return hiddenURI; } string memory currentBaseURI = _baseURI(); return bytes(currentBaseURI).length > 0 ? string(abi.encodePacked(currentBaseURI, _tokenId.toString(), ".json")) : ""; } // Cost - Functions function setWhitelistMintCost(uint256 _cost) public onlyOwner { whitelistMintCost = _cost; } // Per wallet Limit - Functions function setNFTFreeMintPerWalletLimit(uint256 _limit) public onlyOwner { nftFreeMintPerWalletLimit = _limit; } function setNFTWhitelistMintPerWalletLimit(uint256 _limit) public onlyOwner { nftWhitelistMintPerWalletLimit = _limit; } // State - Functions function setPaused(bool _state) public onlyOwner { paused = _state; } function setFreeMintActive(bool _state) public onlyOwner { freeMintActive = _state; } function setWhitelistMintActive(bool _state) public onlyOwner { whitelistMintActive = _state; } function setRevealed(bool _state) public onlyOwner { revealed = _state; } // Merkle Tree Root - Functions function setFreeMintMerkleTreeRoot(bytes32 _root) public onlyOwner { freeMintMerkleTreeRoot = _root; } function setWhitelistMintMerkleTreeRoot(bytes32 _root) public onlyOwner { whitelistMintMerkleTreeRoot = _root; } // Other Functions function walletOfOwner(address _owner) public view returns (uint256[] memory) { uint256 ownerTokenCount = balanceOf(_owner); uint256[] memory ownedTokenIds = new uint256[](ownerTokenCount); uint256 currentTokenId = _startTokenId(); uint256 ownedTokenIndex = 0; address latestOwnerAddress; while (ownedTokenIndex < ownerTokenCount && currentTokenId <= maxSupply) { TokenOwnership memory ownership = _ownerships[currentTokenId]; if (!ownership.burned && ownership.addr != address(0)) { latestOwnerAddress = ownership.addr; } if (latestOwnerAddress == _owner) { ownedTokenIds[ownedTokenIndex] = currentTokenId; ownedTokenIndex++; } currentTokenId++; } return ownedTokenIds; } // Withdraw - Function function withdraw() public payable { payable(owner()).transfer(address(this).balance); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"},{"internalType":"bytes32[]","name":"_merkleTreeProof","type":"bytes32[]"}],"name":"freeMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"freeMintActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"freeMintMerkleTreeRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hiddenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"},{"internalType":"bytes32","name":"leaf","type":"bytes32"}],"name":"isValidFreeMintMerkleTreeProof","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"},{"internalType":"bytes32","name":"leaf","type":"bytes32"}],"name":"isValidWhitelistMintMerkleTreeProof","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupplyLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nftFreeMintPerWalletLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nftWhitelistMintPerWalletLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"ownerMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"ownerMintForOthers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uri","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setFreeMintActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_root","type":"bytes32"}],"name":"setFreeMintMerkleTreeRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uri","type":"string"}],"name":"setHiddenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_supply","type":"uint256"}],"name":"setMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_supply","type":"uint256"}],"name":"setMaxSupplyLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_limit","type":"uint256"}],"name":"setNFTFreeMintPerWalletLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_limit","type":"uint256"}],"name":"setNFTWhitelistMintPerWalletLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setRevealed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setWhitelistMintActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_cost","type":"uint256"}],"name":"setWhitelistMintCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_root","type":"bytes32"}],"name":"setWhitelistMintMerkleTreeRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"walletFreeMintBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"walletOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"walletWhitelistMintBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"},{"internalType":"bytes32[]","name":"_merkleTreeProof","type":"bytes32[]"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"whitelistMintActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistMintCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistMintMerkleTreeRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
72327:8588:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54793:305;;;;;;;;;;-1:-1:-1;54793:305:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;54793:305:0;;;;;;;;58178:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;59681:204::-;;;;;;;;;;-1:-1:-1;59681:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1697:32:1;;;1679:51;;1667:2;1652:18;59681:204:0;1533:203:1;59244:371:0;;;;;;;;;;-1:-1:-1;59244:371:0;;;;;:::i;:::-;;:::i;:::-;;78987:134;;;;;;;;;;-1:-1:-1;78987:134:0;;;;;:::i;:::-;;:::i;79155:83::-;;;;;;;;;;-1:-1:-1;79155:83:0;;;;;:::i;:::-;;:::i;54042:303::-;;;;;;;;;;-1:-1:-1;54296:12:0;;54086:7;54280:13;:28;54042:303;;;2674:25:1;;;2662:2;2647:18;54042:303:0;2528:177:1;79353:109:0;;;;;;;;;;-1:-1:-1;79353:109:0;;;;;:::i;:::-;;:::i;60538:170::-;;;;;;;;;;-1:-1:-1;60538:170:0;;;;;:::i;:::-;;:::i;72919:49::-;;;;;;;;;;;;;;;;76645:196;;;;;;;;;;-1:-1:-1;76645:196:0;;;;;:::i;:::-;;:::i;80810:102::-;;;:::i;60779:185::-;;;;;;;;;;-1:-1:-1;60779:185:0;;;;;:::i;:::-;;:::i;79884:890::-;;;;;;;;;;-1:-1:-1;79884:890:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;79602:116::-;;;;;;;;;;-1:-1:-1;79602:116:0;;;;;:::i;:::-;;:::i;79246:99::-;;;;;;;;;;-1:-1:-1;79246:99:0;;;;;:::i;:::-;;:::i;73110:28::-;;;;;;;;;;-1:-1:-1;73110:28:0;;;;;;;;;;;78034:90;;;;;;;;;;-1:-1:-1;78034:90:0;;;;;:::i;:::-;;:::i;72992:26::-;;;;;;;;;;-1:-1:-1;72992:26:0;;;;;;;;74924:186;;;;;;;;;;-1:-1:-1;74924:186:0;;;;;:::i;:::-;;:::i;57987:124::-;;;;;;;;;;-1:-1:-1;57987:124:0;;;;;:::i;:::-;;:::i;73065:38::-;;;;;;;;;;-1:-1:-1;73065:38:0;;;;;;;;;;;72524:115;;;;;;;;;;;;;:::i;77688:94::-;;;;;;;;;;-1:-1:-1;77688:94:0;;;;;:::i;:::-;;:::i;55162:206::-;;;;;;;;;;-1:-1:-1;55162:206:0;;;;;:::i;:::-;;:::i;29982:103::-;;;;;;;;;;;;;:::i;78855:124::-;;;;;;;;;;-1:-1:-1;78855:124:0;;;;;:::i;:::-;;:::i;78704:106::-;;;;;;;;;;-1:-1:-1;78704:106:0;;;;;:::i;:::-;;:::i;79726:126::-;;;;;;;;;;-1:-1:-1;79726:126:0;;;;;:::i;:::-;;:::i;73285:56::-;;;;;;;;;;-1:-1:-1;73285:56:0;;;;;:::i;:::-;;;;;;;;;;;;;;72646:117;;;;;;;;;;;;;:::i;29341:87::-;;;;;;;;;;-1:-1:-1;29414:6:0;;-1:-1:-1;;;;;29414:6:0;29341:87;;58347:104;;;;;;;;;;;;;:::i;59957:279::-;;;;;;;;;;-1:-1:-1;59957:279:0;;;;;:::i;:::-;;:::i;72786:47::-;;;;;;;;;;;;;;;;72868:44;;;;;;;;;;;;;;;;61035:369;;;;;;;;;;-1:-1:-1;61035:369:0;;;;;:::i;:::-;;:::i;73217:42::-;;;;;;;;;;;;;;;;73348:61;;;;;;;;;;-1:-1:-1;73348:61:0;;;;;:::i;:::-;;;;;;;;;;;;;;78132:94;;;;;;;;;;-1:-1:-1;78132:94:0;;;;;:::i;:::-;;:::i;77257:396::-;;;;;;;;;;-1:-1:-1;77257:396:0;;;;;:::i;:::-;;:::i;73173:37::-;;;;;;;;;;;;;;;;78234:437;;;;;;;;;;-1:-1:-1;78234:437:0;;;;;:::i;:::-;;:::i;73025:33::-;;;;;;;;;;-1:-1:-1;73025:33:0;;;;;;;;;;;75153:570;;;;;;:::i;:::-;;:::i;72432:30::-;;;;;;;;;;;;;;;;79470:87;;;;;;;;;;-1:-1:-1;79470:87:0;;;;;:::i;:::-;;:::i;73570:452::-;;;;;;:::i;:::-;;:::i;77790:104::-;;;;;;;;;;-1:-1:-1;77790:104:0;;;;;:::i;:::-;;:::i;60307:164::-;;;;;;;;;;-1:-1:-1;60307:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;60428:25:0;;;60404:4;60428:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;60307:164;72469:34;;;;;;;;;;;;;;;;76880:369;;;;;;;;;;-1:-1:-1;76880:369:0;;;;;:::i;:::-;;:::i;30240:201::-;;;;;;;;;;-1:-1:-1;30240:201:0;;;;;:::i;:::-;;:::i;54793:305::-;54895:4;-1:-1:-1;;;;;;54932:40:0;;-1:-1:-1;;;54932:40:0;;:105;;-1:-1:-1;;;;;;;54989:48:0;;-1:-1:-1;;;54989:48:0;54932:105;:158;;;-1:-1:-1;;;;;;;;;;43377:40:0;;;55054:36;54912:178;54793:305;-1:-1:-1;;54793:305:0:o;58178:100::-;58232:13;58265:5;58258:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58178:100;:::o;59681:204::-;59749:7;59774:16;59782:7;59774;:16::i;:::-;59769:64;;59799:34;;-1:-1:-1;;;59799:34:0;;;;;;;;;;;59769:64;-1:-1:-1;59853:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;59853:24:0;;59681:204::o;59244:371::-;59317:13;59333:24;59349:7;59333:15;:24::i;:::-;59317:40;;59378:5;-1:-1:-1;;;;;59372:11:0;:2;-1:-1:-1;;;;;59372:11:0;;59368:48;;59392:24;;-1:-1:-1;;;59392:24:0;;;;;;;;;;;59368:48;27972:10;-1:-1:-1;;;;;59433:21:0;;;;;;:63;;-1:-1:-1;59459:37:0;59476:5;27972:10;60307:164;:::i;59459:37::-;59458:38;59433:63;59429:138;;;59520:35;;-1:-1:-1;;;59520:35:0;;;;;;;;;;;59429:138;59579:28;59588:2;59592:7;59601:5;59579:8;:28::i;:::-;59306:309;59244:371;;:::o;78987:134::-;29227:13;:11;:13::i;:::-;79074:30:::1;:39:::0;78987:134::o;79155:83::-;29227:13;:11;:13::i;:::-;79215:6:::1;:15:::0;;-1:-1:-1;;79215:15:0::1;::::0;::::1;;::::0;;;::::1;::::0;;79155:83::o;79353:109::-;29227:13;:11;:13::i;:::-;79426:19:::1;:28:::0;;;::::1;;::::0;::::1;-1:-1:-1::0;;79426:28:0;;::::1;::::0;;;::::1;::::0;;79353:109::o;60538:170::-;60672:28;60682:4;60688:2;60692:7;60672:9;:28::i;76645:196::-;76749:4;76773:60;76792:5;76799:27;;76828:4;76773:18;:60::i;:::-;76766:67;76645:196;-1:-1:-1;;;76645:196:0:o;80810:102::-;29414:6;;80856:48;;-1:-1:-1;;;;;29414:6:0;;;;80882:21;80856:48;;;;;;;;;80882:21;29414:6;80856:48;;;;;;;;;;;;;;;;;;;;;80810:102::o;60779:185::-;60917:39;60934:4;60940:2;60944:7;60917:39;;;;;;;;;;;;:16;:39::i;79884:890::-;79944:16;79973:23;79999:17;80009:6;79999:9;:17::i;:::-;79973:43;;80027:30;80074:15;-1:-1:-1;;;;;80060:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;80060:30:0;-1:-1:-1;80027:63:0;-1:-1:-1;80101:22:0;80152:23;80190:26;80229:505;80254:15;80236;:33;:64;;;;;80291:9;;80273:14;:27;;80236:64;80229:505;;;80317:31;80351:27;;;:11;:27;;;;;;;;;80317:61;;;;;;;;;-1:-1:-1;;;;;80317:61:0;;;;-1:-1:-1;;;80317:61:0;;-1:-1:-1;;;;;80317:61:0;;;;;;;;-1:-1:-1;;;80317:61:0;;;;;;;;;;;;;;;;80399:49;;-1:-1:-1;80420:14:0;;-1:-1:-1;;;;;80420:28:0;;;80399:49;80395:125;;;80490:14;;;-1:-1:-1;80395:125:0;80562:6;-1:-1:-1;;;;;80540:28:0;:18;-1:-1:-1;;;;;80540:28:0;;80536:154;;80622:14;80589:13;80603:15;80589:30;;;;;;;;:::i;:::-;;;;;;;;;;:47;80657:17;;;;:::i;:::-;;;;80536:154;80706:16;;;;:::i;:::-;;;;80302:432;80229:505;;;-1:-1:-1;80753:13:0;;79884:890;-1:-1:-1;;;;;79884:890:0:o;79602:116::-;29227:13;:11;:13::i;:::-;79680:22:::1;:30:::0;79602:116::o;79246:99::-;29227:13;:11;:13::i;:::-;79314:14:::1;:23:::0;;;::::1;;;;-1:-1:-1::0;;79314:23:0;;::::1;::::0;;;::::1;::::0;;79246:99::o;78034:90::-;29227:13;:11;:13::i;:::-;78102:7:::1;:14;78112:4:::0;78102:7;:14:::1;:::i;:::-;;78034:90:::0;:::o;74924:186::-;75023:4;75047:55;75066:5;75073:22;;75097:4;75047:18;:55::i;57987:124::-;58051:7;58078:20;58090:7;58078:11;:20::i;:::-;:25;;57987:124;-1:-1:-1;;57987:124:0:o;72524:115::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;77688:94::-;29227:13;:11;:13::i;:::-;77755:9:::1;:19:::0;77688:94::o;55162:206::-;55226:7;-1:-1:-1;;;;;55250:19:0;;55246:60;;55278:28;;-1:-1:-1;;;55278:28:0;;;;;;;;;;;55246:60;-1:-1:-1;;;;;;55332:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;55332:27:0;;55162:206::o;29982:103::-;29227:13;:11;:13::i;:::-;30047:30:::1;30074:1;30047:18;:30::i;:::-;29982:103::o:0;78855:124::-;29227:13;:11;:13::i;:::-;78937:25:::1;:34:::0;78855:124::o;78704:106::-;29227:13;:11;:13::i;:::-;78777:17:::1;:25:::0;78704:106::o;79726:126::-;29227:13;:11;:13::i;:::-;79809:27:::1;:35:::0;79726:126::o;72646:117::-;;;;;;;:::i;58347:104::-;58403:13;58436:7;58429:14;;;;;:::i;59957:279::-;27972:10;-1:-1:-1;;;;;60048:24:0;;;60044:54;;60081:17;;-1:-1:-1;;;60081:17:0;;;;;;;;;;;60044:54;27972:10;60111:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;60111:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;60111:53:0;;;;;;;;;;60180:48;;540:41:1;;;60111:42:0;;27972:10;60180:48;;513:18:1;60180:48:0;;;;;;;59957:279;;:::o;61035:369::-;61202:28;61212:4;61218:2;61222:7;61202:9;:28::i;:::-;-1:-1:-1;;;;;61245:13:0;;32568:19;:23;;61245:76;;;;;61265:56;61296:4;61302:2;61306:7;61315:5;61265:30;:56::i;:::-;61264:57;61245:76;61241:156;;;61345:40;;-1:-1:-1;;;61345:40:0;;;;;;;;;;;61241:156;61035:369;;;;:::o;78132:94::-;29227:13;:11;:13::i;:::-;78202:9:::1;:16;78214:4:::0;78202:9;:16:::1;:::i;77257:396::-:0;29227:13;:11;:13::i;:::-;77362:6:::1;::::0;::::1;;77361:7;77353:47;;;;-1:-1:-1::0;;;77353:47:0::1;;;;;;;:::i;:::-;;;;;;;;;77450:14;;77435:11;77419:13;54296:12:::0;;54086:7;54280:13;:28;;54042:303;77419:13:::1;:27;;;;:::i;:::-;:45;;77411:100;;;;-1:-1:-1::0;;;77411:100:0::1;;;;;;;:::i;:::-;77561:9;;77546:11;77530:13;54296:12:::0;;54086:7;54280:13;:28;;54042:303;77530:13:::1;:27;;;;:::i;:::-;:40;;77522:77;;;;-1:-1:-1::0;;;77522:77:0::1;;;;;;;:::i;:::-;77612:33;77622:9;77633:11;77612:9;:33::i;78234:437::-:0;78308:13;78342:17;78350:8;78342:7;:17::i;:::-;78334:67;;;;-1:-1:-1;;;78334:67:0;;12718:2:1;78334:67:0;;;12700:21:1;12757:2;12737:18;;;12730:30;12796:34;12776:18;;;12769:62;-1:-1:-1;;;12847:18:1;;;12840:35;12892:19;;78334:67:0;12516:401:1;78334:67:0;78418:8;;;;;;;:17;;78430:5;78418:17;78414:66;;78459:9;78452:16;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78234:437;;;:::o;78414:66::-;78492:28;78523:10;:8;:10::i;:::-;78492:41;;78584:1;78559:14;78553:28;:32;:110;;;;;;;;;;;;;;;;;78612:14;78628:19;:8;:17;:19::i;:::-;78595:62;;;;;;;;;:::i;:::-;;;;;;;;;;;;;78546:117;78234:437;-1:-1:-1;;;78234:437:0:o;75153:570::-;75886:10;75831:30;75864:33;;;:21;:33;;;;;;;;;75942:26;:38;;;;;;;76041:30;;75271:11;;75284:16;;75864:33;;76001:36;75271:11;75864:33;76001:36;:::i;:::-;:70;;75993:130;;;;-1:-1:-1;;;75993:130:0;;;;;;;:::i;:::-;76183:30;;76142:37;76168:11;76142:23;:37;:::i;:::-;:71;;76134:136;;;;-1:-1:-1;;;76134:136:0;;;;;;;:::i;:::-;76353:28;;-1:-1:-1;;76370:10:0;14576:2:1;14572:15;14568:53;76353:28:0;;;14556:66:1;76289:94:0;;76325:16;;14638:12:1;;76353:28:0;;;;;;;;;;;;76343:39;;;;;;76289:35;:94::i;:::-;76281:135;;;;-1:-1:-1;;;76281:135:0;;14863:2:1;76281:135:0;;;14845:21:1;14902:2;14882:18;;;14875:30;14941;14921:18;;;14914:58;14989:18;;76281:135:0;14661:352:1;76281:135:0;76466:14;;76451:11;76435:13;54296:12;;54086:7;54280:13;:28;;54042:303;76435:13;:27;;;;:::i;:::-;:45;;76427:100;;;;-1:-1:-1;;;76427:100:0;;;;;;;:::i;:::-;76577:9;;76562:11;76546:13;54296:12;;54086:7;54280:13;:28;;54042:303;76546:13;:27;;;;:::i;:::-;:40;;76538:77;;;;-1:-1:-1;;;76538:77:0;;;;;;;:::i;:::-;75322:6:::1;::::0;::::1;;75321:7;75313:47;;;;-1:-1:-1::0;;;75313:47:0::1;;;;;;;:::i;:::-;75379:19;::::0;;;::::1;;;:27;;75402:4;75379:27;75371:75;;;::::0;-1:-1:-1;;;75371:75:0;;15220:2:1;75371:75:0::1;::::0;::::1;15202:21:1::0;15259:2;15239:18;;;15232:30;15298:34;15278:18;;;15271:62;-1:-1:-1;;;15349:18:1;;;15342:33;15392:19;;75371:75:0::1;15018:399:1::0;75371:75:0::1;75500:11;75480:17;;:31;;;;:::i;:::-;75467:9;:44;75459:80;;;::::0;-1:-1:-1;;;75459:80:0;;15797:2:1;75459:80:0::1;::::0;::::1;15779:21:1::0;15836:2;15816:18;;;15809:30;15875:25;15855:18;;;15848:53;15918:18;;75459:80:0::1;15595:347:1::0;75459:80:0::1;75560:34;75570:10;75582:11;75560:9;:34::i;:::-;75612:9;75607:109;75631:11;75627:1;:15;75607:109;;;75691:10;75664:38;::::0;;;:26:::1;:38;::::0;;;;:40;;;::::1;::::0;::::1;:::i;:::-;;;;;;75644:3;;;;;:::i;:::-;;;;75607:109;;;;75820:817:::0;;75153:570;;;;:::o;79470:87::-;29227:13;:11;:13::i;:::-;79532:8:::1;:17:::0;;;::::1;;::::0;::::1;-1:-1:-1::0;;79532:17:0;;::::1;::::0;;;::::1;::::0;;79470:87::o;73570:452::-;74180:10;74125:30;74158:33;;;:21;:33;;;;;;;;;74236:26;:38;;;;;;;74335:25;;73678:11;;73691:16;;74158:33;;74295:36;73678:11;74158:33;74295:36;:::i;:::-;:65;;74287:125;;;;-1:-1:-1;;;74287:125:0;;;;;;;:::i;:::-;74472:25;;74431:37;74457:11;74431:23;:37;:::i;:::-;:66;;74423:131;;;;-1:-1:-1;;;74423:131:0;;;;;;;:::i;:::-;74632:28;;-1:-1:-1;;74649:10:0;14576:2:1;14572:15;14568:53;74632:28:0;;;14556:66:1;74573:89:0;;74604:16;;14638:12:1;;74632:28:0;;;;;;;;;;;;74622:39;;;;;;74573:30;:89::i;:::-;74565:130;;;;-1:-1:-1;;;74565:130:0;;14863:2:1;74565:130:0;;;14845:21:1;14902:2;14882:18;;;14875:30;14941;14921:18;;;14914:58;14989:18;;74565:130:0;14661:352:1;74565:130:0;74745:14;;74730:11;74714:13;54296:12;;54086:7;54280:13;:28;;54042:303;74714:13;:27;;;;:::i;:::-;:45;;74706:100;;;;-1:-1:-1;;;74706:100:0;;;;;;;:::i;:::-;74856:9;;74841:11;74825:13;54296:12;;54086:7;54280:13;:28;;54042:303;74825:13;:27;;;;:::i;:::-;:40;;74817:77;;;;-1:-1:-1;;;74817:77:0;;;;;;;:::i;:::-;73729:6:::1;::::0;::::1;;73728:7;73720:47;;;;-1:-1:-1::0;;;73720:47:0::1;;;;;;;:::i;:::-;73786:14;::::0;::::1;;::::0;;::::1;;:22;;:14;:22;73778:65;;;::::0;-1:-1:-1;;;73778:65:0;;16149:2:1;73778:65:0::1;::::0;::::1;16131:21:1::0;16188:2;16168:18;;;16161:30;16227:32;16207:18;;;16200:60;16277:18;;73778:65:0::1;15947:354:1::0;73778:65:0::1;73864:34;73874:10;73886:11;73864:9;:34::i;:::-;73916:9;73911:104;73935:11;73931:1;:15;73911:104;;;73990:10;73968:33;::::0;;;:21:::1;:33;::::0;;;;:35;;;::::1;::::0;::::1;:::i;:::-;;;;;;73948:3;;;;;:::i;:::-;;;;73911:104;;77790::::0;29227:13;:11;:13::i;:::-;77862:14:::1;:24:::0;77790:104::o;76880:369::-;29227:13;:11;:13::i;:::-;76957:6:::1;::::0;::::1;;76956:7;76948:47;;;;-1:-1:-1::0;;;76948:47:0::1;;;;;;;:::i;:::-;77045:14;;77030:11;77014:13;54296:12:::0;;54086:7;54280:13;:28;;54042:303;77014:13:::1;:27;;;;:::i;:::-;:45;;77006:100;;;;-1:-1:-1::0;;;77006:100:0::1;;;;;;;:::i;:::-;77156:9;;77141:11;77125:13;54296:12:::0;;54086:7;54280:13;:28;;54042:303;77125:13:::1;:27;;;;:::i;:::-;:40;;77117:77;;;;-1:-1:-1::0;;;77117:77:0::1;;;;;;;:::i;:::-;77207:34;77217:10;77229:11;77207:9;:34::i;30240:201::-:0;29227:13;:11;:13::i;:::-;-1:-1:-1;;;;;30329:22:0;::::1;30321:73;;;::::0;-1:-1:-1;;;30321:73:0;;16508:2:1;30321:73:0::1;::::0;::::1;16490:21:1::0;16547:2;16527:18;;;16520:30;16586:34;16566:18;;;16559:62;-1:-1:-1;;;16637:18:1;;;16630:36;16683:19;;30321:73:0::1;16306:402:1::0;30321:73:0::1;30405:28;30424:8;30405:18;:28::i;61659:187::-:0;61716:4;61780:13;;61770:7;:23;61740:98;;;;-1:-1:-1;;61811:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;61811:27:0;;;;61810:28;;61659:187::o;69270:196::-;69385:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;69385:29:0;-1:-1:-1;;;;;69385:29:0;;;;;;;;;69430:28;;69385:24;;69430:28;;;;;;;69270:196;;;:::o;29506:132::-;29414:6;;-1:-1:-1;;;;;29414:6:0;27972:10;29570:23;29562:68;;;;-1:-1:-1;;;29562:68:0;;16915:2:1;29562:68:0;;;16897:21:1;;;16934:18;;;16927:30;16993:34;16973:18;;;16966:62;17045:18;;29562:68:0;16713:356:1;64772:2112:0;64887:35;64925:20;64937:7;64925:11;:20::i;:::-;65000:18;;64887:58;;-1:-1:-1;64958:22:0;;-1:-1:-1;;;;;64984:34:0;27972:10;-1:-1:-1;;;;;64984:34:0;;:101;;;-1:-1:-1;65052:18:0;;65035:50;;27972:10;60307:164;:::i;65035:50::-;64984:154;;;-1:-1:-1;27972:10:0;65102:20;65114:7;65102:11;:20::i;:::-;-1:-1:-1;;;;;65102:36:0;;64984:154;64958:181;;65157:17;65152:66;;65183:35;;-1:-1:-1;;;65183:35:0;;;;;;;;;;;65152:66;65255:4;-1:-1:-1;;;;;65233:26:0;:13;:18;;;-1:-1:-1;;;;;65233:26:0;;65229:67;;65268:28;;-1:-1:-1;;;65268:28:0;;;;;;;;;;;65229:67;-1:-1:-1;;;;;65311:16:0;;65307:52;;65336:23;;-1:-1:-1;;;65336:23:0;;;;;;;;;;;65307:52;65480:49;65497:1;65501:7;65510:13;:18;;;65480:8;:49::i;:::-;-1:-1:-1;;;;;65825:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;65825:31:0;;;-1:-1:-1;;;;;65825:31:0;;;-1:-1:-1;;65825:31:0;;;;;;;65871:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;65871:29:0;;;;;;;;;;;65917:20;;;:11;:20;;;;;;:30;;-1:-1:-1;;;;;;65962:61:0;;;;-1:-1:-1;;;66007:15:0;65962:61;;;;;;;;;;;66297:11;;;66327:24;;;;;:29;66297:11;;66327:29;66323:445;;66552:13;;66538:11;:27;66534:219;;;66622:18;;;66590:24;;;:11;:24;;;;;;;;:50;;66705:28;;;;-1:-1:-1;;;;;66663:70:0;-1:-1:-1;;;66663:70:0;-1:-1:-1;;;;;;66663:70:0;;;-1:-1:-1;;;;;66590:50:0;;;66663:70;;;;;;;66534:219;65800:979;66815:7;66811:2;-1:-1:-1;;;;;66796:27:0;66805:4;-1:-1:-1;;;;;66796:27:0;;;;;;;;;;;66834:42;64876:2008;;64772:2112;;;:::o;1222:156::-;1313:4;1366;1337:25;1350:5;1357:4;1337:12;:25::i;:::-;:33;;1222:156;-1:-1:-1;;;;1222:156:0:o;56817:1108::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;56927:7:0;57010:13;;57003:4;:20;56972:886;;;57044:31;57078:17;;;:11;:17;;;;;;;;;57044:51;;;;;;;;;-1:-1:-1;;;;;57044:51:0;;;;-1:-1:-1;;;57044:51:0;;-1:-1:-1;;;;;57044:51:0;;;;;;;;-1:-1:-1;;;57044:51:0;;;;;;;;;;;;;;57114:729;;57164:14;;-1:-1:-1;;;;;57164:28:0;;57160:101;;57228:9;56817:1108;-1:-1:-1;;;56817:1108:0:o;57160:101::-;-1:-1:-1;;;57603:6:0;57648:17;;;;:11;:17;;;;;;;;;57636:29;;;;;;;;;-1:-1:-1;;;;;57636:29:0;;;;;-1:-1:-1;;;57636:29:0;;-1:-1:-1;;;;;57636:29:0;;;;;;;;-1:-1:-1;;;57636:29:0;;;;;;;;;;;;;57696:28;57692:109;;57764:9;56817:1108;-1:-1:-1;;;56817:1108:0:o;57692:109::-;57563:261;;;57025:833;56972:886;57886:31;;-1:-1:-1;;;57886:31:0;;;;;;;;;;;30601:191;30694:6;;;-1:-1:-1;;;;;30711:17:0;;;-1:-1:-1;;;;;;30711:17:0;;;;;;;30744:40;;30694:6;;;30711:17;30694:6;;30744:40;;30675:16;;30744:40;30664:128;30601:191;:::o;69958:667::-;70142:72;;-1:-1:-1;;;70142:72:0;;70121:4;;-1:-1:-1;;;;;70142:36:0;;;;;:72;;27972:10;;70193:4;;70199:7;;70208:5;;70142:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;70142:72:0;;;;;;;;-1:-1:-1;;70142:72:0;;;;;;;;;;;;:::i;:::-;;;70138:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70376:6;:13;70393:1;70376:18;70372:235;;70422:40;;-1:-1:-1;;;70422:40:0;;;;;;;;;;;70372:235;70565:6;70559:13;70550:6;70546:2;70542:15;70535:38;70138:480;-1:-1:-1;;;;;;70261:55:0;-1:-1:-1;;;70261:55:0;;-1:-1:-1;70138:480:0;69958:667;;;;;;:::o;61854:104::-;61923:27;61933:2;61937:8;61923:27;;;;;;;;;;;;:9;:27::i;77926:100::-;77978:13;78011:7;78004:14;;;;;:::i;24811:716::-;24867:13;24918:14;24935:17;24946:5;24935:10;:17::i;:::-;24955:1;24935:21;24918:38;;24971:20;25005:6;-1:-1:-1;;;;;24994:18:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24994:18:0;-1:-1:-1;24971:41:0;-1:-1:-1;25136:28:0;;;25152:2;25136:28;25193:288;-1:-1:-1;;25225:5:0;-1:-1:-1;;;25362:2:0;25351:14;;25346:30;25225:5;25333:44;25423:2;25414:11;;;-1:-1:-1;25444:21:0;25193:288;25444:21;-1:-1:-1;25502:6:0;24811:716;-1:-1:-1;;;24811:716:0:o;2021:296::-;2104:7;2147:4;2104:7;2162:118;2186:5;:12;2182:1;:16;2162:118;;;2235:33;2245:12;2259:5;2265:1;2259:8;;;;;;;;:::i;:::-;;;;;;;2235:9;:33::i;:::-;2220:48;-1:-1:-1;2200:3:0;;;;:::i;:::-;;;;2162:118;;;-1:-1:-1;2297:12:0;2021:296;-1:-1:-1;;;2021:296:0:o;62321:163::-;62444:32;62450:2;62454:8;62464:5;62471:4;62444:5;:32::i;21645:948::-;21698:7;;-1:-1:-1;;;21776:17:0;;21772:106;;-1:-1:-1;;;21814:17:0;;;-1:-1:-1;21860:2:0;21850:12;21772:106;21905:8;21896:5;:17;21892:106;;21943:8;21934:17;;;-1:-1:-1;21980:2:0;21970:12;21892:106;22025:8;22016:5;:17;22012:106;;22063:8;22054:17;;;-1:-1:-1;22100:2:0;22090:12;22012:106;22145:7;22136:5;:16;22132:103;;22182:7;22173:16;;;-1:-1:-1;22218:1:0;22208:11;22132:103;22262:7;22253:5;:16;22249:103;;22299:7;22290:16;;;-1:-1:-1;22335:1:0;22325:11;22249:103;22379:7;22370:5;:16;22366:103;;22416:7;22407:16;;;-1:-1:-1;22452:1:0;22442:11;22366:103;22496:7;22487:5;:16;22483:68;;22534:1;22524:11;22579:6;21645:948;-1:-1:-1;;21645:948:0:o;9459:149::-;9522:7;9553:1;9549;:5;:51;;9684:13;9778:15;;;9814:4;9807:15;;;9861:4;9845:21;;9549:51;;;9684:13;9778:15;;;9814:4;9807:15;;;9861:4;9845:21;;9557:20;9616:268;62743:1775;62882:20;62905:13;-1:-1:-1;;;;;62933:16:0;;62929:48;;62958:19;;-1:-1:-1;;;62958:19:0;;;;;;;;;;;62929:48;62992:8;63004:1;62992:13;62988:44;;63014:18;;-1:-1:-1;;;63014:18:0;;;;;;;;;;;62988:44;-1:-1:-1;;;;;63383:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;63442:49:0;;-1:-1:-1;;;;;63383:44:0;;;;;;;63442:49;;;;-1:-1:-1;;63383:44:0;;;;;;63442:49;;;;;;;;;;;;;;;;63508:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;63558:66:0;;;;-1:-1:-1;;;63608:15:0;63558:66;;;;;;;;;;63508:25;63705:23;;;63749:4;:23;;;;-1:-1:-1;;;;;;63757:13:0;;32568:19;:23;;63757:15;63745:641;;;63793:314;63824:38;;63849:12;;-1:-1:-1;;;;;63824:38:0;;;63841:1;;63824:38;;63841:1;;63824:38;63890:69;63929:1;63933:2;63937:14;;;;;;63953:5;63890:30;:69::i;:::-;63885:174;;63995:40;;-1:-1:-1;;;63995:40:0;;;;;;;;;;;63885:174;64102:3;64086:12;:19;63793:314;;64188:12;64171:13;;:29;64167:43;;64202:8;;;64167:43;63745:641;;;64251:120;64282:40;;64307:14;;;;;-1:-1:-1;;;;;64282:40:0;;;64299:1;;64282:40;;64299:1;;64282:40;64366:3;64350:12;:19;64251:120;;63745:641;-1:-1:-1;64400:13:0;:28;64450:60;61035:369;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:250::-;677:1;687:113;701:6;698:1;695:13;687:113;;;777:11;;;771:18;758:11;;;751:39;723:2;716:10;687:113;;;-1:-1:-1;;834:1:1;816:16;;809:27;592:250::o;847:271::-;889:3;927:5;921:12;954:6;949:3;942:19;970:76;1039:6;1032:4;1027:3;1023:14;1016:4;1009:5;1005:16;970:76;:::i;:::-;1100:2;1079:15;-1:-1:-1;;1075:29:1;1066:39;;;;1107:4;1062:50;;847:271;-1:-1:-1;;847:271:1:o;1123:220::-;1272:2;1261:9;1254:21;1235:4;1292:45;1333:2;1322:9;1318:18;1310:6;1292:45;:::i;1348:180::-;1407:6;1460:2;1448:9;1439:7;1435:23;1431:32;1428:52;;;1476:1;1473;1466:12;1428:52;-1:-1:-1;1499:23:1;;1348:180;-1:-1:-1;1348:180:1:o;1741:173::-;1809:20;;-1:-1:-1;;;;;1858:31:1;;1848:42;;1838:70;;1904:1;1901;1894:12;1838:70;1741:173;;;:::o;1919:254::-;1987:6;1995;2048:2;2036:9;2027:7;2023:23;2019:32;2016:52;;;2064:1;2061;2054:12;2016:52;2087:29;2106:9;2087:29;:::i;:::-;2077:39;2163:2;2148:18;;;;2135:32;;-1:-1:-1;;;1919:254:1:o;2178:160::-;2243:20;;2299:13;;2292:21;2282:32;;2272:60;;2328:1;2325;2318:12;2343:180;2399:6;2452:2;2440:9;2431:7;2427:23;2423:32;2420:52;;;2468:1;2465;2458:12;2420:52;2491:26;2507:9;2491:26;:::i;2710:328::-;2787:6;2795;2803;2856:2;2844:9;2835:7;2831:23;2827:32;2824:52;;;2872:1;2869;2862:12;2824:52;2895:29;2914:9;2895:29;:::i;:::-;2885:39;;2943:38;2977:2;2966:9;2962:18;2943:38;:::i;:::-;2933:48;;3028:2;3017:9;3013:18;3000:32;2990:42;;2710:328;;;;;:::o;3043:127::-;3104:10;3099:3;3095:20;3092:1;3085:31;3135:4;3132:1;3125:15;3159:4;3156:1;3149:15;3175:275;3246:2;3240:9;3311:2;3292:13;;-1:-1:-1;;3288:27:1;3276:40;;-1:-1:-1;;;;;3331:34:1;;3367:22;;;3328:62;3325:88;;;3393:18;;:::i;:::-;3429:2;3422:22;3175:275;;-1:-1:-1;3175:275:1:o;3455:712::-;3509:5;3562:3;3555:4;3547:6;3543:17;3539:27;3529:55;;3580:1;3577;3570:12;3529:55;3616:6;3603:20;3642:4;-1:-1:-1;;;;;3661:2:1;3658:26;3655:52;;;3687:18;;:::i;:::-;3733:2;3730:1;3726:10;3756:28;3780:2;3776;3772:11;3756:28;:::i;:::-;3818:15;;;3888;;;3884:24;;;3849:12;;;;3920:15;;;3917:35;;;3948:1;3945;3938:12;3917:35;3984:2;3976:6;3972:15;3961:26;;3996:142;4012:6;4007:3;4004:15;3996:142;;;4078:17;;4066:30;;4029:12;;;;4116;;;;3996:142;;;4156:5;3455:712;-1:-1:-1;;;;;;;3455:712:1:o;4172:416::-;4265:6;4273;4326:2;4314:9;4305:7;4301:23;4297:32;4294:52;;;4342:1;4339;4332:12;4294:52;4382:9;4369:23;-1:-1:-1;;;;;4407:6:1;4404:30;4401:50;;;4447:1;4444;4437:12;4401:50;4470:61;4523:7;4514:6;4503:9;4499:22;4470:61;:::i;:::-;4460:71;4578:2;4563:18;;;;4550:32;;-1:-1:-1;;;;4172:416:1:o;4593:186::-;4652:6;4705:2;4693:9;4684:7;4680:23;4676:32;4673:52;;;4721:1;4718;4711:12;4673:52;4744:29;4763:9;4744:29;:::i;4784:632::-;4955:2;5007:21;;;5077:13;;4980:18;;;5099:22;;;4926:4;;4955:2;5178:15;;;;5152:2;5137:18;;;4926:4;5221:169;5235:6;5232:1;5229:13;5221:169;;;5296:13;;5284:26;;5365:15;;;;5330:12;;;;5257:1;5250:9;5221:169;;;-1:-1:-1;5407:3:1;;4784:632;-1:-1:-1;;;;;;4784:632:1:o;5606:407::-;5671:5;-1:-1:-1;;;;;5697:6:1;5694:30;5691:56;;;5727:18;;:::i;:::-;5765:57;5810:2;5789:15;;-1:-1:-1;;5785:29:1;5816:4;5781:40;5765:57;:::i;:::-;5756:66;;5845:6;5838:5;5831:21;5885:3;5876:6;5871:3;5867:16;5864:25;5861:45;;;5902:1;5899;5892:12;5861:45;5951:6;5946:3;5939:4;5932:5;5928:16;5915:43;6005:1;5998:4;5989:6;5982:5;5978:18;5974:29;5967:40;5606:407;;;;;:::o;6018:451::-;6087:6;6140:2;6128:9;6119:7;6115:23;6111:32;6108:52;;;6156:1;6153;6146:12;6108:52;6196:9;6183:23;-1:-1:-1;;;;;6221:6:1;6218:30;6215:50;;;6261:1;6258;6251:12;6215:50;6284:22;;6337:4;6329:13;;6325:27;-1:-1:-1;6315:55:1;;6366:1;6363;6356:12;6315:55;6389:74;6455:7;6450:2;6437:16;6432:2;6428;6424:11;6389:74;:::i;6474:254::-;6539:6;6547;6600:2;6588:9;6579:7;6575:23;6571:32;6568:52;;;6616:1;6613;6606:12;6568:52;6639:29;6658:9;6639:29;:::i;:::-;6629:39;;6687:35;6718:2;6707:9;6703:18;6687:35;:::i;:::-;6677:45;;6474:254;;;;;:::o;6733:667::-;6828:6;6836;6844;6852;6905:3;6893:9;6884:7;6880:23;6876:33;6873:53;;;6922:1;6919;6912:12;6873:53;6945:29;6964:9;6945:29;:::i;:::-;6935:39;;6993:38;7027:2;7016:9;7012:18;6993:38;:::i;:::-;6983:48;;7078:2;7067:9;7063:18;7050:32;7040:42;;7133:2;7122:9;7118:18;7105:32;-1:-1:-1;;;;;7152:6:1;7149:30;7146:50;;;7192:1;7189;7182:12;7146:50;7215:22;;7268:4;7260:13;;7256:27;-1:-1:-1;7246:55:1;;7297:1;7294;7287:12;7246:55;7320:74;7386:7;7381:2;7368:16;7363:2;7359;7355:11;7320:74;:::i;:::-;7310:84;;;6733:667;;;;;;;:::o;7587:416::-;7680:6;7688;7741:2;7729:9;7720:7;7716:23;7712:32;7709:52;;;7757:1;7754;7747:12;7709:52;7793:9;7780:23;7770:33;;7854:2;7843:9;7839:18;7826:32;-1:-1:-1;;;;;7873:6:1;7870:30;7867:50;;;7913:1;7910;7903:12;7867:50;7936:61;7989:7;7980:6;7969:9;7965:22;7936:61;:::i;:::-;7926:71;;;7587:416;;;;;:::o;8008:260::-;8076:6;8084;8137:2;8125:9;8116:7;8112:23;8108:32;8105:52;;;8153:1;8150;8143:12;8105:52;8176:29;8195:9;8176:29;:::i;:::-;8166:39;;8224:38;8258:2;8247:9;8243:18;8224:38;:::i;8273:380::-;8352:1;8348:12;;;;8395;;;8416:61;;8470:4;8462:6;8458:17;8448:27;;8416:61;8523:2;8515:6;8512:14;8492:18;8489:38;8486:161;;8569:10;8564:3;8560:20;8557:1;8550:31;8604:4;8601:1;8594:15;8632:4;8629:1;8622:15;8486:161;;8273:380;;;:::o;8658:127::-;8719:10;8714:3;8710:20;8707:1;8700:31;8750:4;8747:1;8740:15;8774:4;8771:1;8764:15;8790:127;8851:10;8846:3;8842:20;8839:1;8832:31;8882:4;8879:1;8872:15;8906:4;8903:1;8896:15;8922:135;8961:3;8982:17;;;8979:43;;9002:18;;:::i;:::-;-1:-1:-1;9049:1:1;9038:13;;8922:135::o;9188:545::-;9290:2;9285:3;9282:11;9279:448;;;9326:1;9351:5;9347:2;9340:17;9396:4;9392:2;9382:19;9466:2;9454:10;9450:19;9447:1;9443:27;9437:4;9433:38;9502:4;9490:10;9487:20;9484:47;;;-1:-1:-1;9525:4:1;9484:47;9580:2;9575:3;9571:12;9568:1;9564:20;9558:4;9554:31;9544:41;;9635:82;9653:2;9646:5;9643:13;9635:82;;;9698:17;;;9679:1;9668:13;9635:82;;;9639:3;;;9188:545;;;:::o;9909:1352::-;10035:3;10029:10;-1:-1:-1;;;;;10054:6:1;10051:30;10048:56;;;10084:18;;:::i;:::-;10113:97;10203:6;10163:38;10195:4;10189:11;10163:38;:::i;:::-;10157:4;10113:97;:::i;:::-;10265:4;;10329:2;10318:14;;10346:1;10341:663;;;;11048:1;11065:6;11062:89;;;-1:-1:-1;11117:19:1;;;11111:26;11062:89;-1:-1:-1;;9866:1:1;9862:11;;;9858:24;9854:29;9844:40;9890:1;9886:11;;;9841:57;11164:81;;10311:944;;10341:663;9135:1;9128:14;;;9172:4;9159:18;;-1:-1:-1;;10377:20:1;;;10495:236;10509:7;10506:1;10503:14;10495:236;;;10598:19;;;10592:26;10577:42;;10690:27;;;;10658:1;10646:14;;;;10525:19;;10495:236;;;10499:3;10759:6;10750:7;10747:19;10744:201;;;10820:19;;;10814:26;-1:-1:-1;;10903:1:1;10899:14;;;10915:3;10895:24;10891:37;10887:42;10872:58;10857:74;;10744:201;-1:-1:-1;;;;;10991:1:1;10975:14;;;10971:22;10958:36;;-1:-1:-1;9909:1352:1:o;11266:351::-;11468:2;11450:21;;;11507:2;11487:18;;;11480:30;11546:29;11541:2;11526:18;;11519:57;11608:2;11593:18;;11266:351::o;11622:125::-;11687:9;;;11708:10;;;11705:36;;;11721:18;;:::i;11752:406::-;11954:2;11936:21;;;11993:2;11973:18;;;11966:30;12032:34;12027:2;12012:18;;12005:62;-1:-1:-1;;;12098:2:1;12083:18;;12076:40;12148:3;12133:19;;11752:406::o;12163:348::-;12365:2;12347:21;;;12404:2;12384:18;;;12377:30;12443:26;12438:2;12423:18;;12416:54;12502:2;12487:18;;12163:348::o;12922:663::-;13202:3;13240:6;13234:13;13256:66;13315:6;13310:3;13303:4;13295:6;13291:17;13256:66;:::i;:::-;13385:13;;13344:16;;;;13407:70;13385:13;13344:16;13454:4;13442:17;;13407:70;:::i;:::-;-1:-1:-1;;;13499:20:1;;13528:22;;;13577:1;13566:13;;12922:663;-1:-1:-1;;;;12922:663:1:o;13590:411::-;13792:2;13774:21;;;13831:2;13811:18;;;13804:30;13870:34;13865:2;13850:18;;13843:62;-1:-1:-1;;;13936:2:1;13921:18;;13914:45;13991:3;13976:19;;13590:411::o;14006:416::-;14208:2;14190:21;;;14247:2;14227:18;;;14220:30;14286:34;14281:2;14266:18;;14259:62;-1:-1:-1;;;14352:2:1;14337:18;;14330:50;14412:3;14397:19;;14006:416::o;15422:168::-;15495:9;;;15526;;15543:15;;;15537:22;;15523:37;15513:71;;15564:18;;:::i;17074:489::-;-1:-1:-1;;;;;17343:15:1;;;17325:34;;17395:15;;17390:2;17375:18;;17368:43;17442:2;17427:18;;17420:34;;;17490:3;17485:2;17470:18;;17463:31;;;17268:4;;17511:46;;17537:19;;17529:6;17511:46;:::i;:::-;17503:54;17074:489;-1:-1:-1;;;;;;17074:489:1:o;17568:249::-;17637:6;17690:2;17678:9;17669:7;17665:23;17661:32;17658:52;;;17706:1;17703;17696:12;17658:52;17738:9;17732:16;17757:30;17781:5;17757:30;:::i
Swarm Source
ipfs://18c3d49b5216a8ab962c4f042643d7620e15030873eea967bf15f842055883a8
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.