ERC-721
Overview
Max Total Supply
89 HA
Holders
80
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Balance
1 HALoading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
HypeAliens
Compiler Version
v0.8.17+commit.8df45f5f
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2023-02-28 */ // File: contracts/lib/Constants.sol pragma solidity ^0.8.13; address constant CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS = 0x000000000000AAeB6D7670E522A718067333cd4E; address constant CANONICAL_CORI_SUBSCRIPTION = 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6; // File: contracts/IOperatorFilterRegistry.sol pragma solidity ^0.8.13; interface IOperatorFilterRegistry { /** * @notice Returns true if operator is not filtered for a given token, either by address or codeHash. Also returns * true if supplied registrant address is not registered. */ function isOperatorAllowed(address registrant, address operator) external view returns (bool); /** * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner. */ function register(address registrant) external; /** * @notice Registers an address with the registry and "subscribes" to another address's filtered operators and codeHashes. */ function registerAndSubscribe(address registrant, address subscription) external; /** * @notice Registers an address with the registry and copies the filtered operators and codeHashes from another * address without subscribing. */ function registerAndCopyEntries(address registrant, address registrantToCopy) external; /** * @notice Unregisters an address with the registry and removes its subscription. May be called by address itself or by EIP-173 owner. * Note that this does not remove any filtered addresses or codeHashes. * Also note that any subscriptions to this registrant will still be active and follow the existing filtered addresses and codehashes. */ function unregister(address addr) external; /** * @notice Update an operator address for a registered address - when filtered is true, the operator is filtered. */ function updateOperator(address registrant, address operator, bool filtered) external; /** * @notice Update multiple operators for a registered address - when filtered is true, the operators will be filtered. Reverts on duplicates. */ function updateOperators(address registrant, address[] calldata operators, bool filtered) external; /** * @notice Update a codeHash for a registered address - when filtered is true, the codeHash is filtered. */ function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external; /** * @notice Update multiple codeHashes for a registered address - when filtered is true, the codeHashes will be filtered. Reverts on duplicates. */ function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external; /** * @notice Subscribe an address to another registrant's filtered operators and codeHashes. Will remove previous * subscription if present. * Note that accounts with subscriptions may go on to subscribe to other accounts - in this case, * subscriptions will not be forwarded. Instead the former subscription's existing entries will still be * used. */ function subscribe(address registrant, address registrantToSubscribe) external; /** * @notice Unsubscribe an address from its current subscribed registrant, and optionally copy its filtered operators and codeHashes. */ function unsubscribe(address registrant, bool copyExistingEntries) external; /** * @notice Get the subscription address of a given registrant, if any. */ function subscriptionOf(address addr) external returns (address registrant); /** * @notice Get the set of addresses subscribed to a given registrant. * Note that order is not guaranteed as updates are made. */ function subscribers(address registrant) external returns (address[] memory); /** * @notice Get the subscriber at a given index in the set of addresses subscribed to a given registrant. * Note that order is not guaranteed as updates are made. */ function subscriberAt(address registrant, uint256 index) external returns (address); /** * @notice Copy filtered operators and codeHashes from a different registrantToCopy to addr. */ function copyEntriesOf(address registrant, address registrantToCopy) external; /** * @notice Returns true if operator is filtered by a given address or its subscription. */ function isOperatorFiltered(address registrant, address operator) external returns (bool); /** * @notice Returns true if the hash of an address's code is filtered by a given address or its subscription. */ function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool); /** * @notice Returns true if a codeHash is filtered by a given address or its subscription. */ function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool); /** * @notice Returns a list of filtered operators for a given address or its subscription. */ function filteredOperators(address addr) external returns (address[] memory); /** * @notice Returns the set of filtered codeHashes for a given address or its subscription. * Note that order is not guaranteed as updates are made. */ function filteredCodeHashes(address addr) external returns (bytes32[] memory); /** * @notice Returns the filtered operator at the given index of the set of filtered operators for a given address or * its subscription. * Note that order is not guaranteed as updates are made. */ function filteredOperatorAt(address registrant, uint256 index) external returns (address); /** * @notice Returns the filtered codeHash at the given index of the list of filtered codeHashes for a given address or * its subscription. * Note that order is not guaranteed as updates are made. */ function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32); /** * @notice Returns true if an address has registered */ function isRegistered(address addr) external returns (bool); /** * @dev Convenience method to compute the code hash of an arbitrary contract */ function codeHashOf(address addr) external returns (bytes32); } // File: contracts/OperatorFilterer.sol pragma solidity ^0.8.13; /** * @title OperatorFilterer * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another * registrant's entries in the OperatorFilterRegistry. * @dev This smart contract is meant to be inherited by token contracts so they can use the following: * - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods. * - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods. * Please note that if your token contract does not provide an owner with EIP-173, it must provide * administration methods on the contract itself to interact with the registry otherwise the subscription * will be locked to the options set during construction. */ abstract contract OperatorFilterer { /// @dev Emitted when an operator is not allowed. error OperatorNotAllowed(address operator); bool public operatorFilteringEnabled = true; IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY = IOperatorFilterRegistry(CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS); /// @dev The constructor that is called when the contract is being deployed. constructor(address subscriptionOrRegistrantToCopy, bool subscribe) { // If an inheriting token contract is deployed to a network without the registry deployed, the modifier // will not revert, but the contract will need to be registered with the registry once it is deployed in // order for the modifier to filter addresses. if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) { if (subscribe) { OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy); } else { if (subscriptionOrRegistrantToCopy != address(0)) { OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy); } else { OPERATOR_FILTER_REGISTRY.register(address(this)); } } } } modifier onlyAllowedOperator(address from) virtual { // Check registry code length to facilitate testing in environments without a deployed registry. if (address(OPERATOR_FILTER_REGISTRY).code.length > 0 && operatorFilteringEnabled) { // Allow spending tokens from addresses with balance // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred // from an EOA. if (from == msg.sender) { _; return; } if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), msg.sender)) { revert OperatorNotAllowed(msg.sender); } } _; } modifier onlyAllowedOperatorApproval(address operator) virtual { // Check registry code length to facilitate testing in environments without a deployed registry. if (address(OPERATOR_FILTER_REGISTRY).code.length > 0 && operatorFilteringEnabled) { if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) { revert OperatorNotAllowed(operator); } } _; } } // File: contracts/DefaultOperatorFilterer.sol pragma solidity ^0.8.13; /** * @title DefaultOperatorFilterer * @notice Inherits from OperatorFilterer and automatically subscribes to the default OpenSea subscription. */ abstract contract DefaultOperatorFilterer is OperatorFilterer { address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6); constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {} } // File: @openzeppelin/contracts/utils/structs/EnumerableSet.sol // OpenZeppelin Contracts (last updated v4.7.0) (utils/structs/EnumerableSet.sol) pragma solidity ^0.8.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. * * [WARNING] * ==== * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure unusable. * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info. * * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an array of EnumerableSet. * ==== */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping(bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; if (lastIndex != toDeleteIndex) { bytes32 lastValue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastValue; // Update the index for the moved value set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex } // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { return set._values[index]; } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function _values(Set storage set) private view returns (bytes32[] memory) { return set._values; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(Bytes32Set storage set) internal view returns (bytes32[] memory) { return _values(set._inner); } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(AddressSet storage set) internal view returns (address[] memory) { bytes32[] memory store = _values(set._inner); address[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values on the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(UintSet storage set) internal view returns (uint256[] memory) { bytes32[] memory store = _values(set._inner); uint256[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } } // File: @openzeppelin/contracts/utils/cryptography/MerkleProof.sol // OpenZeppelin Contracts (last updated v4.7.0) (utils/cryptography/MerkleProof.sol) pragma solidity ^0.8.0; /** * @dev These functions deal with verification of Merkle Tree proofs. * * The proofs can be generated using the JavaScript library * https://github.com/miguelmota/merkletreejs[merkletreejs]. * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled. * * See `test/utils/cryptography/MerkleProof.test.js` for some examples. * * 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. */ 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 proved to be a part of a Merkle tree defined by * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}. * * _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} * * _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 the sibling nodes in `proof`, * consuming from one or the other at each step according to the instructions given by * `proofFlags`. * * _Available since v4.7._ */ function processMultiProof( bytes32[] memory proof, bool[] memory proofFlags, bytes32[] memory leaves ) internal pure returns (bytes32 merkleRoot) { // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of // the merkle tree. uint256 leavesLen = leaves.length; uint256 totalHashes = proofFlags.length; // Check proof validity. require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof"); // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop". bytes32[] memory hashes = new bytes32[](totalHashes); uint256 leafPos = 0; uint256 hashPos = 0; uint256 proofPos = 0; // At each step, we compute the next hash using two values: // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we // get the next hash. // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the // `proof` array. for (uint256 i = 0; i < totalHashes; i++) { bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]; bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++]; hashes[i] = _hashPair(a, b); } if (totalHashes > 0) { return hashes[totalHashes - 1]; } else if (leavesLen > 0) { return leaves[0]; } else { return proof[0]; } } /** * @dev Calldata version of {processMultiProof} * * _Available since v4.7._ */ function processMultiProofCalldata( bytes32[] calldata proof, bool[] calldata proofFlags, bytes32[] memory leaves ) internal pure returns (bytes32 merkleRoot) { // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of // the merkle tree. uint256 leavesLen = leaves.length; uint256 totalHashes = proofFlags.length; // Check proof validity. require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof"); // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop". bytes32[] memory hashes = new bytes32[](totalHashes); uint256 leafPos = 0; uint256 hashPos = 0; uint256 proofPos = 0; // At each step, we compute the next hash using two values: // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we // get the next hash. // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the // `proof` array. for (uint256 i = 0; i < totalHashes; i++) { bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]; bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++]; hashes[i] = _hashPair(a, b); } if (totalHashes > 0) { return hashes[totalHashes - 1]; } else if (leavesLen > 0) { return leaves[0]; } else { return proof[0]; } } function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) { return a < b ? _efficientHash(a, b) : _efficientHash(b, a); } function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) { /// @solidity memory-safe-assembly assembly { mstore(0x00, a) mstore(0x20, b) value := keccak256(0x00, 0x40) } } } // File: @openzeppelin/contracts/utils/Counters.sol // OpenZeppelin Contracts v4.4.1 (utils/Counters.sol) pragma solidity ^0.8.0; /** * @title Counters * @author Matt Condon (@shrugs) * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number * of elements in a mapping, issuing ERC721 ids, or counting request ids. * * Include with `using Counters for Counters.Counter;` */ library Counters { struct Counter { // This variable should never be directly accessed by users of the library: interactions must be restricted to // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add // this feature: see https://github.com/ethereum/solidity/issues/4637 uint256 _value; // default: 0 } function current(Counter storage counter) internal view returns (uint256) { return counter._value; } function increment(Counter storage counter) internal { unchecked { counter._value += 1; } } function decrement(Counter storage counter) internal { uint256 value = counter._value; require(value > 0, "Counter: decrement overflow"); unchecked { counter._value = value - 1; } } function reset(Counter storage counter) internal { counter._value = 0; } } // File: @openzeppelin/contracts/utils/math/SafeMath.sol // OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol) pragma solidity ^0.8.0; // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. /** * @dev Wrappers over Solidity's arithmetic operations. * * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler * now has built in overflow checking. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the subtraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { return a + b; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { return a * b; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a / b; } } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a % b; } } } // File: @openzeppelin/contracts/security/ReentrancyGuard.sol // OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor() { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } } // File: @openzeppelin/contracts/utils/Address.sol // OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @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/token/ERC1155/IERC1155.sol // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol) pragma solidity ^0.8.0; /** * @dev Required interface of an ERC1155 compliant contract, as defined in the * https://eips.ethereum.org/EIPS/eip-1155[EIP]. * * _Available since v3.1._ */ interface IERC1155 is IERC165 { /** * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`. */ event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value); /** * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all * transfers. */ event TransferBatch( address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values ); /** * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to * `approved`. */ event ApprovalForAll(address indexed account, address indexed operator, bool approved); /** * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI. * * If an {URI} event was emitted for `id`, the standard * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value * returned by {IERC1155MetadataURI-uri}. */ event URI(string value, uint256 indexed id); /** * @dev Returns the amount of tokens of token type `id` owned by `account`. * * Requirements: * * - `account` cannot be the zero address. */ function balanceOf(address account, uint256 id) external view returns (uint256); /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. * * Requirements: * * - `accounts` and `ids` must have the same length. */ function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory); /** * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, * * Emits an {ApprovalForAll} event. * * Requirements: * * - `operator` cannot be the caller. */ function setApprovalForAll(address operator, bool approved) external; /** * @dev Returns true if `operator` is approved to transfer ``account``'s tokens. * * See {setApprovalForAll}. */ function isApprovedForAll(address account, address operator) external view returns (bool); /** * @dev Transfers `amount` tokens of token type `id` from `from` to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. * - `from` must have a balance of tokens of type `id` of at least `amount`. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function safeTransferFrom( address from, address to, uint256 id, uint256 amount, bytes calldata data ) external; /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. * * Emits a {TransferBatch} event. * * Requirements: * * - `ids` and `amounts` must have the same length. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function safeBatchTransferFrom( address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data ) external; } // File: @openzeppelin/contracts/interfaces/IERC1155.sol // OpenZeppelin Contracts v4.4.1 (interfaces/IERC1155.sol) pragma solidity ^0.8.0; // File: contracts/ICoin.sol pragma solidity ^0.8.17; interface ICoin is IERC1155{ function burn(address account,uint256 id,uint256 value) external ; } // File: @openzeppelin/contracts/interfaces/IERC2981.sol // OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol) pragma solidity ^0.8.0; /** * @dev Interface for the NFT Royalty Standard. * * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal * support for royalty payments across all NFT marketplaces and ecosystem participants. * * _Available since v4.5._ */ interface IERC2981 is IERC165 { /** * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of * exchange. The royalty amount is denominated and should be paid in that same unit of exchange. */ function royaltyInfo(uint256 tokenId, uint256 salePrice) external view returns (address receiver, uint256 royaltyAmount); } // File: @openzeppelin/contracts/token/ERC721/IERC721.sol // OpenZeppelin Contracts (last updated v4.7.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: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); } // File: @openzeppelin/contracts/token/ERC721/extensions/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: @openzeppelin/contracts/interfaces/IERC721.sol // OpenZeppelin Contracts v4.4.1 (interfaces/IERC721.sol) pragma solidity ^0.8.0; // 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/common/ERC2981.sol // OpenZeppelin Contracts (last updated v4.7.0) (token/common/ERC2981.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information. * * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first. * * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the * fee is specified in basis points by default. * * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported. * * _Available since v4.5._ */ abstract contract ERC2981 is IERC2981, ERC165 { struct RoyaltyInfo { address receiver; uint96 royaltyFraction; } RoyaltyInfo private _defaultRoyaltyInfo; mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo; /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) { return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId); } /** * @inheritdoc IERC2981 */ function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256) { RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId]; if (royalty.receiver == address(0)) { royalty = _defaultRoyaltyInfo; } uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator(); return (royalty.receiver, royaltyAmount); } /** * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an * override. */ function _feeDenominator() internal pure virtual returns (uint96) { return 10000; } /** * @dev Sets the royalty information that all ids in this contract will default to. * * Requirements: * * - `receiver` cannot be the zero address. * - `feeNumerator` cannot be greater than the fee denominator. */ function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual { require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice"); require(receiver != address(0), "ERC2981: invalid receiver"); _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator); } /** * @dev Removes default royalty information. */ function _deleteDefaultRoyalty() internal virtual { delete _defaultRoyaltyInfo; } /** * @dev Sets the royalty information for a specific token id, overriding the global default. * * Requirements: * * - `receiver` cannot be the zero address. * - `feeNumerator` cannot be greater than the fee denominator. */ function _setTokenRoyalty( uint256 tokenId, address receiver, uint96 feeNumerator ) internal virtual { require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice"); require(receiver != address(0), "ERC2981: Invalid parameters"); _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator); } /** * @dev Resets royalty information for the token id back to the global default. */ function _resetTokenRoyalty(uint256 tokenId) internal virtual { delete _tokenRoyaltyInfo[tokenId]; } } // File: @openzeppelin/contracts/utils/Strings.sol // OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _HEX_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) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } return string(buffer); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { if (value == 0) { return "0x00"; } uint256 temp = value; uint256 length = 0; while (temp != 0) { length++; temp >>= 8; } return toHexString(value, length); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _HEX_SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } } // File: @openzeppelin/contracts/utils/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.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File: @openzeppelin/contracts/token/ERC721/ERC721.sol // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/ERC721.sol) pragma solidity ^0.8.0; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata { using Address for address; using Strings for uint256; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) private _owners; // Mapping owner address to token count mapping(address => uint256) private _balances; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: address zero is not a valid owner"); return _balances[owner]; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { address owner = _owners[tokenId]; require(owner != address(0), "ERC721: invalid token ID"); return owner; } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { _requireMinted(tokenId); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overridden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not token owner nor approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { _requireMinted(tokenId); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { _setApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom( address from, address to, uint256 tokenId ) public virtual override { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner nor approved"); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId ) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory data ) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner nor approved"); _safeTransfer(from, to, tokenId, data); } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * `data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer( address from, address to, uint256 tokenId, bytes memory data ) internal virtual { _transfer(from, to, tokenId); require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return _owners[tokenId] != address(0); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { address owner = ERC721.ownerOf(tokenId); return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: * * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint( address to, uint256 tokenId, bytes memory data ) internal virtual { _mint(to, tokenId); require( _checkOnERC721Received(address(0), to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId); _balances[to] += 1; _owners[tokenId] = to; emit Transfer(address(0), to, tokenId); _afterTokenTransfer(address(0), to, tokenId); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ERC721.ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId); // Clear approvals _approve(address(0), tokenId); _balances[owner] -= 1; delete _owners[tokenId]; emit Transfer(owner, address(0), tokenId); _afterTokenTransfer(owner, address(0), tokenId); } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint256 tokenId ) internal virtual { require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId); // Clear approvals from the previous owner _approve(address(0), tokenId); _balances[from] -= 1; _balances[to] += 1; _owners[tokenId] = to; emit Transfer(from, to, tokenId); _afterTokenTransfer(from, to, tokenId); } /** * @dev Approve `to` to operate on `tokenId` * * Emits an {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.ownerOf(tokenId), to, tokenId); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits an {ApprovalForAll} event. */ function _setApprovalForAll( address owner, address operator, bool approved ) internal virtual { require(owner != operator, "ERC721: approve to caller"); _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Reverts if the `tokenId` has not been minted yet. */ function _requireMinted(uint256 tokenId) internal view virtual { require(_exists(tokenId), "ERC721: invalid token ID"); } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 tokenId, bytes memory data ) private returns (bool) { if (to.isContract()) { try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) { return retval == IERC721Receiver.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721: transfer to non ERC721Receiver implementer"); } else { /// @solidity memory-safe-assembly assembly { revert(add(32, reason), mload(reason)) } } } } else { return true; } } /** * @dev Hook that is called before any token transfer. This includes minting * and burning. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be * transferred to `to`. * - When `from` is zero, `tokenId` will be minted for `to`. * - When `to` is zero, ``from``'s `tokenId` will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal virtual {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 tokenId ) internal virtual {} } // File: @openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Enumerable.sol) pragma solidity ^0.8.0; /** * @dev This implements an optional extension of {ERC721} defined in the EIP that adds * enumerability of all the token ids in the contract as well as all token ids owned by each * account. */ abstract contract ERC721Enumerable is ERC721, IERC721Enumerable { // Mapping from owner to list of owned token IDs mapping(address => mapping(uint256 => uint256)) private _ownedTokens; // Mapping from token ID to index of the owner tokens list mapping(uint256 => uint256) private _ownedTokensIndex; // Array with all token ids, used for enumeration uint256[] private _allTokens; // Mapping from token id to position in the allTokens array mapping(uint256 => uint256) private _allTokensIndex; /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) { return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) { require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds"); return _ownedTokens[owner][index]; } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _allTokens.length; } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view virtual override returns (uint256) { require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds"); return _allTokens[index]; } /** * @dev Hook that is called before any token transfer. This includes minting * and burning. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be * transferred to `to`. * - When `from` is zero, `tokenId` will be minted for `to`. * - When `to` is zero, ``from``'s `tokenId` will be burned. * - `from` cannot be the zero address. * - `to` cannot be the zero address. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal virtual override { super._beforeTokenTransfer(from, to, tokenId); if (from == address(0)) { _addTokenToAllTokensEnumeration(tokenId); } else if (from != to) { _removeTokenFromOwnerEnumeration(from, tokenId); } if (to == address(0)) { _removeTokenFromAllTokensEnumeration(tokenId); } else if (to != from) { _addTokenToOwnerEnumeration(to, tokenId); } } /** * @dev Private function to add a token to this extension's ownership-tracking data structures. * @param to address representing the new owner of the given token ID * @param tokenId uint256 ID of the token to be added to the tokens list of the given address */ function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private { uint256 length = ERC721.balanceOf(to); _ownedTokens[to][length] = tokenId; _ownedTokensIndex[tokenId] = length; } /** * @dev Private function to add a token to this extension's token tracking data structures. * @param tokenId uint256 ID of the token to be added to the tokens list */ function _addTokenToAllTokensEnumeration(uint256 tokenId) private { _allTokensIndex[tokenId] = _allTokens.length; _allTokens.push(tokenId); } /** * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for * gas optimizations e.g. when performing a transfer operation (avoiding double writes). * This has O(1) time complexity, but alters the order of the _ownedTokens array. * @param from address representing the previous owner of the given token ID * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address */ function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private { // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = ERC721.balanceOf(from) - 1; uint256 tokenIndex = _ownedTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary if (tokenIndex != lastTokenIndex) { uint256 lastTokenId = _ownedTokens[from][lastTokenIndex]; _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index } // This also deletes the contents at the last position of the array delete _ownedTokensIndex[tokenId]; delete _ownedTokens[from][lastTokenIndex]; } /** * @dev Private function to remove a token from this extension's token tracking data structures. * This has O(1) time complexity, but alters the order of the _allTokens array. * @param tokenId uint256 ID of the token to be removed from the tokens list */ function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private { // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = _allTokens.length - 1; uint256 tokenIndex = _allTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding // an 'if' statement (like in _removeTokenFromOwnerEnumeration) uint256 lastTokenId = _allTokens[lastTokenIndex]; _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index // This also deletes the contents at the last position of the array delete _allTokensIndex[tokenId]; _allTokens.pop(); } } // File: @openzeppelin/contracts/access/IAccessControl.sol // OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol) pragma solidity ^0.8.0; /** * @dev External interface of AccessControl declared to support ERC165 detection. */ interface IAccessControl { /** * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` * * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite * {RoleAdminChanged} not being emitted signaling this. * * _Available since v3.1._ */ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); /** * @dev Emitted when `account` is granted `role`. * * `sender` is the account that originated the contract call, an admin role * bearer except when using {AccessControl-_setupRole}. */ event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Emitted when `account` is revoked `role`. * * `sender` is the account that originated the contract call: * - if using `revokeRole`, it is the admin role bearer * - if using `renounceRole`, it is the role bearer (i.e. `account`) */ event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) external view returns (bool); /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {AccessControl-_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) external view returns (bytes32); /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) external; /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) external; /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been granted `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) external; } // File: @openzeppelin/contracts/access/AccessControl.sol // OpenZeppelin Contracts (last updated v4.7.0) (access/AccessControl.sol) pragma solidity ^0.8.0; /** * @dev Contract module that allows children to implement role-based access * control mechanisms. This is a lightweight version that doesn't allow enumerating role * members except through off-chain means by accessing the contract event logs. Some * applications may benefit from on-chain enumerability, for those cases see * {AccessControlEnumerable}. * * Roles are referred to by their `bytes32` identifier. These should be exposed * in the external API and be unique. The best way to achieve this is by * using `public constant` hash digests: * * ``` * bytes32 public constant MY_ROLE = keccak256("MY_ROLE"); * ``` * * Roles can be used to represent a set of permissions. To restrict access to a * function call, use {hasRole}: * * ``` * function foo() public { * require(hasRole(MY_ROLE, msg.sender)); * ... * } * ``` * * Roles can be granted and revoked dynamically via the {grantRole} and * {revokeRole} functions. Each role has an associated admin role, and only * accounts that have a role's admin role can call {grantRole} and {revokeRole}. * * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means * that only accounts with this role will be able to grant or revoke other * roles. More complex role relationships can be created by using * {_setRoleAdmin}. * * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to * grant and revoke this role. Extra precautions should be taken to secure * accounts that have been granted it. */ abstract contract AccessControl is Context, IAccessControl, ERC165 { struct RoleData { mapping(address => bool) members; bytes32 adminRole; } mapping(bytes32 => RoleData) private _roles; bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00; /** * @dev Modifier that checks that an account has a specific role. Reverts * with a standardized message including the required role. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ * * _Available since v4.1._ */ modifier onlyRole(bytes32 role) { _checkRole(role); _; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId); } /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) public view virtual override returns (bool) { return _roles[role].members[account]; } /** * @dev Revert with a standard message if `_msgSender()` is missing `role`. * Overriding this function changes the behavior of the {onlyRole} modifier. * * Format of the revert message is described in {_checkRole}. * * _Available since v4.6._ */ function _checkRole(bytes32 role) internal view virtual { _checkRole(role, _msgSender()); } /** * @dev Revert with a standard message if `account` is missing `role`. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ */ function _checkRole(bytes32 role, address account) internal view virtual { if (!hasRole(role, account)) { revert( string( abi.encodePacked( "AccessControl: account ", Strings.toHexString(uint160(account), 20), " is missing role ", Strings.toHexString(uint256(role), 32) ) ) ); } } /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) { return _roles[role].adminRole; } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleGranted} event. */ function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _grantRole(role, account); } /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleRevoked} event. */ function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _revokeRole(role, account); } /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been revoked `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. * * May emit a {RoleRevoked} event. */ function renounceRole(bytes32 role, address account) public virtual override { require(account == _msgSender(), "AccessControl: can only renounce roles for self"); _revokeRole(role, account); } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. Note that unlike {grantRole}, this function doesn't perform any * checks on the calling account. * * May emit a {RoleGranted} event. * * [WARNING] * ==== * This function should only be called from the constructor when setting * up the initial roles for the system. * * Using this function in any other way is effectively circumventing the admin * system imposed by {AccessControl}. * ==== * * NOTE: This function is deprecated in favor of {_grantRole}. */ function _setupRole(bytes32 role, address account) internal virtual { _grantRole(role, account); } /** * @dev Sets `adminRole` as ``role``'s admin role. * * Emits a {RoleAdminChanged} event. */ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual { bytes32 previousAdminRole = getRoleAdmin(role); _roles[role].adminRole = adminRole; emit RoleAdminChanged(role, previousAdminRole, adminRole); } /** * @dev Grants `role` to `account`. * * Internal function without access restriction. * * May emit a {RoleGranted} event. */ function _grantRole(bytes32 role, address account) internal virtual { if (!hasRole(role, account)) { _roles[role].members[account] = true; emit RoleGranted(role, account, _msgSender()); } } /** * @dev Revokes `role` from `account`. * * Internal function without access restriction. * * May emit a {RoleRevoked} event. */ function _revokeRole(bytes32 role, address account) internal virtual { if (hasRole(role, account)) { _roles[role].members[account] = false; emit RoleRevoked(role, account, _msgSender()); } } } // File: contracts/HypeAliens.sol //@author PZ //@title HypeAliens pragma solidity 0.8.17; contract HypeAliens is ERC721Enumerable, IERC721Receiver, ReentrancyGuard, Ownable,ERC2981,DefaultOperatorFilterer{ using Strings for uint256; using Counters for Counters.Counter; using EnumerableSet for EnumerableSet.Bytes32Set; bool public transformActive; bool public stepnActive; string private baseUri; mapping(uint256=>string) private baseUrlMap; mapping(uint256=>uint256) private coinIdMap; mapping(uint256=>uint256) private alienCoinId; mapping(uint256=>uint256) private alien_hs_map; mapping(uint256=>uint256) private hs_alien_map; Counters.Counter private coinId; Counters.Counter private alienId; Counters.Counter private stenpId; bytes32 private _merkleRoot; IERC721 immutable HYPE_SAINTS; ICoin immutable HYPE_COIN; EnumerableSet.Bytes32Set private stepnSet; uint256 public constant HA = 1; uint256 public constant HAC = 2; uint256 public constant STEPN = 3; uint256 public constant COIN_ID = 0; uint256 public constant DEFORMABLE_ALIEN = 3333; uint256 private _royaltyBps; address payable private _royaltyRecipient; modifier tokenExists(uint256 tokenId) { require(_exists(tokenId), "Token does not exist."); _; } modifier callerIsUser() { require(tx.origin == msg.sender, "The caller is another contract"); _; } constructor(address _Saints, address _coin, string memory _baseUri, address royalty_, uint96 royaltyFee_) ERC721("HypeAliens", "HA") { HYPE_SAINTS = IERC721(_Saints); HYPE_COIN = ICoin(_coin); baseUri = _baseUri; _setDefaultRoyalty(royalty_, royaltyFee_); } function setBaseURIMap(string memory uri,uint256 id) external onlyOwner { baseUrlMap[id] = uri; } function getBaseURIMap(uint256 id) public view onlyOwner returns (string memory) { return baseUrlMap[id]; } function setBaseURI(string memory _baseUri) external onlyOwner { baseUri = _baseUri; } function setTransformActive(bool _transformActive) external onlyOwner { transformActive = _transformActive; } function setStepnActive(bool _stepnActive) external onlyOwner { stepnActive = _stepnActive; } function getCoinMap(uint256 tokenId) public view onlyOwner returns (uint256) { return coinIdMap[tokenId]; } function getCoinId(uint256 tokenId) public view onlyOwner returns (uint256) { return alienCoinId[tokenId]; } function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require(_exists(tokenId), "Token does not exist."); if(alienCoinId[tokenId] > 0) { string memory baseURI = baseUrlMap[HAC]; return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, alienCoinId[tokenId].toString())) : baseUri; } else if(tokenId > DEFORMABLE_ALIEN) { string memory baseURI = baseUrlMap[STEPN]; uint256 _tokenId = tokenId - DEFORMABLE_ALIEN; return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, _tokenId.toString())) : baseUri; } else { string memory baseURI = baseUrlMap[HA]; return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : baseUri; } } function getAlien(uint256 _hsId) public view returns(uint256) { return hs_alien_map[_hsId]; } function getSaints(uint256 _alienId) public view returns(uint256) { return alien_hs_map[_alienId]; } function _createAlien(address to, uint256 tokenId) internal { _safeMint(to, tokenId); } function onERC721Received(address, address from, uint256 tokenId, bytes memory data) public virtual override nonReentrant returns (bytes4) { if (msg.sender == address(HYPE_SAINTS)) { require(transformActive, "Transform is not allowed at this time."); if (!_exists(hs_alien_map[tokenId])) { alienId.increment(); require(alienId.current() <= DEFORMABLE_ALIEN,"The number of aliens exceeds the maximum value"); _createAlien(from, alienId.current()); if(coinIdMap[tokenId] > 0) { HYPE_COIN.burn(from,0,1); coinId.increment(); alienCoinId[alienId.current()] = coinId.current(); } alien_hs_map[alienId.current()] = tokenId; hs_alien_map[tokenId] = alienId.current(); } else { _safeTransfer(address(this), from, hs_alien_map[tokenId], ""); } } else if (msg.sender == address(this)) { require(transformActive, "Transform is not allowed at this time."); HYPE_SAINTS.safeTransferFrom(address(this), from, alien_hs_map[tokenId]); } else { revert("Only HypeSaints and HypeAliens are supported."); } return this.onERC721Received.selector; } function transformAlien(uint256 hypeSaintId,bool useCoin) external callerIsUser { if (useCoin) { require(!_exists(hs_alien_map[hypeSaintId]),"This HypeSaint is not the first time to transform,so you can not use coin"); require(HYPE_COIN.balanceOf(msg.sender, COIN_ID) > 0,"This address does not have hype coin"); coinIdMap[hypeSaintId] = 1; } HYPE_SAINTS.safeTransferFrom(msg.sender, address(this), hypeSaintId, "transform to Alien"); } function transformSaints(uint256 _alienId) external callerIsUser { require(alien_hs_map[_alienId] > 0,"Sorry,this hypealien cant not transform"); safeTransferFrom(msg.sender, address(this), _alienId); } function stepnMint(bytes32[] calldata _proof,bytes32 emailCode) external callerIsUser nonReentrant{ require(stepnActive,"stenp activity does not start!"); require(isWhiteListed(emailCode, _proof), "Not whitelisted"); require(!stepnSet.contains(emailCode),"You have minted NFT"); stenpId.increment(); _createAlien(msg.sender, DEFORMABLE_ALIEN+stenpId.current()); stepnSet.add(emailCode); } function getHypeSaints(address to, uint256 tokenId) external onlyOwner { if (!_exists(tokenId) || ownerOf(tokenId) == address(this)) { HYPE_SAINTS.safeTransferFrom(address(this), to, tokenId); } else if (ownerOf(tokenId) == address(HYPE_SAINTS)) { // space doodle stuck in doodle contract _safeTransfer(address(HYPE_SAINTS), to, tokenId, ""); } else { revert("Only allowed in rescue scenarios."); } } //Whitelist function setMerkleRoot(bytes32 merkleRoot_) external onlyOwner { _merkleRoot = merkleRoot_; } function isWhiteListed(bytes32 emailCode, bytes32[] calldata _proof) internal view returns(bool) { return _verify(leaf(emailCode), _proof); } function leaf(bytes32 emailCode) internal pure returns(bytes32) { return keccak256(abi.encodePacked(emailCode)); } function _verify(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) { return MerkleProof.verify(_proof, _merkleRoot, _leaf); } function supportsInterface(bytes4 interfaceId) public view override(ERC2981,ERC721Enumerable) returns (bool) { return super.supportsInterface(interfaceId); } //set Default Royalty._feeNumerator 500 = 5% Royalty function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) external virtual onlyOwner { _setDefaultRoyalty(_receiver, _feeNumerator); } /** * @notice Set the state of the OpenSea operator filter * @param value Flag indicating if the operator filter should be applied to transfers and approvals */ function setOperatorFilteringEnabled(bool value) external onlyOwner { operatorFilteringEnabled = value; } function setApprovalForAll(address operator, bool approved) public override(ERC721,IERC721) onlyAllowedOperatorApproval(operator) { super.setApprovalForAll(operator, approved); } function approve(address operator, uint256 tokenId) public override(ERC721,IERC721) onlyAllowedOperatorApproval(operator) { super.approve(operator, tokenId); } function transferFrom(address from, address to, uint256 tokenId) public override(ERC721,IERC721) onlyAllowedOperator(from) { super.transferFrom(from, to, tokenId); } function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721,IERC721) onlyAllowedOperator(from) { super.safeTransferFrom(from, to, tokenId); } function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override(ERC721,IERC721) onlyAllowedOperator(from) { super.safeTransferFrom(from, to, tokenId, data); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_Saints","type":"address"},{"internalType":"address","name":"_coin","type":"address"},{"internalType":"string","name":"_baseUri","type":"string"},{"internalType":"address","name":"royalty_","type":"address"},{"internalType":"uint96","name":"royaltyFee_","type":"uint96"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","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":[],"name":"COIN_ID","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFORMABLE_ALIEN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"HA","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"HAC","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"STEPN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_hsId","type":"uint256"}],"name":"getAlien","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"getBaseURIMap","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getCoinId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getCoinMap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getHypeSaints","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_alienId","type":"uint256"}],"name":"getSaints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"operatorFilteringEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"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":"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":"_baseUri","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"uri","type":"string"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"setBaseURIMap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"uint96","name":"_feeNumerator","type":"uint96"}],"name":"setDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"merkleRoot_","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"value","type":"bool"}],"name":"setOperatorFilteringEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_stepnActive","type":"bool"}],"name":"setStepnActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_transformActive","type":"bool"}],"name":"setTransformActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stepnActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"},{"internalType":"bytes32","name":"emailCode","type":"bytes32"}],"name":"stepnMint","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":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[],"name":"transformActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"hypeSaintId","type":"uint256"},{"internalType":"bool","name":"useCoin","type":"bool"}],"name":"transformAlien","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_alienId","type":"uint256"}],"name":"transformSaints","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000004af790223169a8621095871375f79425725d22c9000000000000000000000000509a4d150036fe9b0cb83594d44bdd21ad8cfdf200000000000000000000000000000000000000000000000000000000000000a00000000000000000000000009dada93ef24cfeb2cfc7ee87db12bcf2f3a7950700000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : _Saints (address): 0x4aF790223169a8621095871375f79425725d22C9
Arg [1] : _coin (address): 0x509A4d150036fE9b0Cb83594D44BdD21AD8CFdf2
Arg [2] : _baseUri (string):
Arg [3] : royalty_ (address): 0x9DADA93ef24Cfeb2cfC7Ee87DB12BcF2f3a79507
Arg [4] : royaltyFee_ (uint96): 80
-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000004af790223169a8621095871375f79425725d22c9
Arg [1] : 000000000000000000000000509a4d150036fe9b0cb83594d44bdd21ad8cfdf2
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [3] : 0000000000000000000000009dada93ef24cfeb2cfc7ee87db12bcf2f3a79507
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000050
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000000
Deployed Bytecode Sourcemap
110959:9380:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;118614:171;;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;118614:171:0;;;;;;;;118851:158;;;;;;:::i;:::-;;:::i;:::-;;116808:225;;;;;;:::i;:::-;;:::i;80114:100::-;;;:::i;:::-;;;;;;;:::i;114669:114::-;;;;;;:::i;:::-;114726:7;114753:22;;;:12;:22;;;;;;;114669:114;;;;2228:25:1;;;2216:2;2201:18;114669:114:0;2082:177:1;81627:171:0;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2428:32:1;;;2410:51;;2398:2;2383:18;81627:171:0;2264:203:1;119529:173:0;;;;;;:::i;:::-;;:::i;114900:1371::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;;4332:33:1;;;4314:52;;4302:2;4287:18;114900:1371:0;4170:202:1;94020:113:0;94108:10;:17;94020:113;;112920:121;;;;;;:::i;:::-;;:::i;111865:30::-;;111894:1;111865:30;;119710:179;;;;;;:::i;:::-;;:::i;117514:493::-;;;;;;:::i;:::-;;:::i;69193:442::-;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;5155:32:1;;;5137:51;;5219:2;5204:18;;5197:34;;;;5110:18;69193:442:0;4963:274:1;93688:256:0;;;;;;:::i;:::-;;:::i;116279:521::-;;;;;;:::i;:::-;;:::i;7724:143::-;;132:42;7724:143;;119897:187;;;;;;:::i;:::-;;:::i;94210:233::-;;;;;;:::i;:::-;;:::i;113053:100::-;;;;;;:::i;:::-;;:::i;111251:23::-;;;;;;;;;;;;79825:222;;;;;;:::i;:::-;;:::i;113536:122::-;;;;;;:::i;:::-;;:::i;79556:207::-;;;;;;:::i;:::-;;:::i;76963:103::-;;;:::i;118032:109::-;;;;;;:::i;:::-;;:::i;76315:87::-;76388:6;;-1:-1:-1;;;;;76388:6:0;76315:87;;80283:104;;;:::i;111980:35::-;;112014:1;111980:35;;117043:453;;;;;;:::i;:::-;;:::i;111940:33::-;;111972:1;111940:33;;119329:192;;;;;;:::i;:::-;;:::i;111215:27::-;;;;;;;;;;;;119202:119;;;;;;:::i;:::-;;:::i;120092:244::-;;;;;;:::i;:::-;;:::i;114554:107::-;;;;;;:::i;:::-;114607:7;114634:19;;;:12;:19;;;;;;;114554:107;112801:111;;;;;;:::i;:::-;;:::i;113666:878::-;;;;;;:::i;:::-;;:::i;113292:107::-;;;;;;:::i;:::-;;:::i;111902:31::-;;111932:1;111902:31;;113407:121;;;;;;:::i;:::-;;:::i;82096:164::-;;;;;;:::i;:::-;-1:-1:-1;;;;;82217:25:0;;;82193:4;82217:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;82096:164;112022:47;;112065:4;112022:47;;113161:123;;;;;;:::i;:::-;;:::i;77221:201::-;;;;;;:::i;:::-;;:::i;7672:43::-;;;;;;;;;118614:171;118717:4;118741:36;118765:11;118741:23;:36::i;:::-;118734:43;118614:171;-1:-1:-1;;118614:171:0:o;118851:158::-;76201:13;:11;:13::i;:::-;118957:44:::1;118976:9;118987:13;118957:18;:44::i;:::-;118851:158:::0;;:::o;116808:225::-;112337:9;112350:10;112337:23;112329:66;;;;-1:-1:-1;;;112329:66:0;;;;;;;:::i;:::-;;;;;;;;;116917:1:::1;116892:22:::0;;;:12:::1;:22;::::0;;;;;116884:77:::1;;;::::0;-1:-1:-1;;;116884:77:0;;9328:2:1;116884:77:0::1;::::0;::::1;9310:21:1::0;9367:2;9347:18;;;9340:30;9406:34;9386:18;;;9379:62;-1:-1:-1;;;9457:18:1;;;9450:37;9504:19;;116884:77:0::1;9126:403:1::0;116884:77:0::1;116972:53;116989:10;117009:4;117016:8;116972:16;:53::i;:::-;116808:225:::0;:::o;80114:100::-;80168:13;80201:5;80194:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80114:100;:::o;81627:171::-;81703:7;81723:23;81738:7;81723:14;:23::i;:::-;-1:-1:-1;81766:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;81766:24:0;;81627:171::o;119529:173::-;119641:8;132:42;9828:45;:49;;;;:77;;-1:-1:-1;9881:24:0;;;;9828:77;9824:253;;;9927:67;;-1:-1:-1;;;9927:67:0;;9978:4;9927:67;;;10131:34:1;-1:-1:-1;;;;;10201:15:1;;10181:18;;;10174:43;132:42:0;;9927;;10066:18:1;;9927:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9922:144;;10022:28;;-1:-1:-1;;;10022:28:0;;-1:-1:-1;;;;;2428:32:1;;10022:28:0;;;2410:51:1;2383:18;;10022:28:0;2264:203:1;9922:144:0;119662:32:::1;119676:8;119686:7;119662:13;:32::i;:::-;119529:173:::0;;;:::o;114900:1371::-;115031:6;42713:1;43311:7;;:19;43303:63;;;;-1:-1:-1;;;43303:63:0;;10680:2:1;43303:63:0;;;10662:21:1;10719:2;10699:18;;;10692:30;10758:33;10738:18;;;10731:61;10809:18;;43303:63:0;10478:355:1;43303:63:0;42713:1;43444:7;:18;-1:-1:-1;;;;;115076:11:0::1;115054:34;:10;:34:::0;115050:1164:::1;;115113:15;::::0;::::1;::::0;::::1;;;115105:66;;;;-1:-1:-1::0;;;115105:66:0::1;;;;;;;:::i;:::-;115201:21;::::0;;;:12:::1;:21;::::0;;;;;115193:30:::1;::::0;:7:::1;:30::i;:::-;115188:708;;115244:19;:7;33478:19:::0;;33496:1;33478:19;;;33389:127;115244:19:::1;112065:4;115290:17;:7;33359:14:::0;;33267:114;115290:17:::1;:37;;115282:95;;;::::0;-1:-1:-1;;;115282:95:0;;11447:2:1;115282:95:0::1;::::0;::::1;11429:21:1::0;11486:2;11466:18;;;11459:30;11525:34;11505:18;;;11498:62;-1:-1:-1;;;11576:18:1;;;11569:44;11630:19;;115282:95:0::1;11245:410:1::0;115282:95:0::1;115396:37;115409:4;115415:17;:7;33359:14:::0;;33267:114;115415:17:::1;115396:12;:37::i;:::-;115476:1;115455:18:::0;;;:9:::1;:18;::::0;;;;;:22;115452:207:::1;;115502:24;::::0;-1:-1:-1;;;115502:24:0;;-1:-1:-1;;;;;11896:32:1;;;115502:24:0::1;::::0;::::1;11878:51:1::0;115522:1:0::1;11945:18:1::0;;;11938:34;115524:1:0::1;11988:18:1::0;;;11981:34;115502:9:0::1;:14;::::0;::::1;::::0;11851:18:1;;115502:24:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;115549:18;:6;33478:19:::0;;33496:1;33478:19;;;33389:127;115549:18:::1;115623:6;33359:14:::0;115590:11:::1;:30;115602:17;:7;33359:14:::0;;33267:114;115602:17:::1;115590:30:::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;115590:30:0;:49;115452:207:::1;115711:7;115677:12;:31;115690:17;:7;33359:14:::0;;33267:114;115690:17:::1;115677:31:::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;115677:31:0;:41;115761:7:::1;33359:14:::0;115737:21:::1;::::0;;;:12:::1;:21;::::0;;;;:41;115050:1164:::1;;115188:708;115819:61;115841:4;115848;115854:12;:21;115867:7;115854:21;;;;;;;;;;;;115819:61;;;;;;;;;;;::::0;:13:::1;:61::i;:::-;115050:1164;;;115939:4;115917:10;:27:::0;115913:301:::1;;115969:15;::::0;::::1;::::0;::::1;;;115961:66;;;;-1:-1:-1::0;;;115961:66:0::1;;;;;;;:::i;:::-;116092:21;::::0;;;:12:::1;:21;::::0;;;;;;;116042:72;;-1:-1:-1;;;116042:72:0;;116079:4:::1;116042:72;::::0;::::1;12266:34:1::0;-1:-1:-1;;;;;12336:15:1;;;12316:18;;;12309:43;12368:18;;;12361:34;;;;116042:11:0::1;:28:::0;;::::1;::::0;::::1;::::0;12201:18:1;;116042:72:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;115913:301;;;116147:55;::::0;-1:-1:-1;;;116147:55:0;;12608:2:1;116147:55:0::1;::::0;::::1;12590:21:1::0;12647:2;12627:18;;;12620:30;12686:34;12666:18;;;12659:62;-1:-1:-1;;;12737:18:1;;;12730:43;12790:19;;116147:55:0::1;12406:409:1::0;115913:301:0::1;-1:-1:-1::0;;;;42669:1:0;43623:7;:22;114900:1371;;-1:-1:-1;;;;114900:1371:0:o;112920:121::-;112986:13;76201;:11;:13::i;:::-;113019:14:::1;::::0;;;:10:::1;:14;::::0;;;;113012:21;;::::1;::::0;::::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76225:1;112920:121:::0;;;:::o;119710:179::-;119827:4;132:42;9054:45;:49;;;;:77;;-1:-1:-1;9107:24:0;;;;9054:77;9050:567;;;9371:10;-1:-1:-1;;;;;9363:18:0;;;9359:85;;119844:37:::1;119863:4;119869:2;119873:7;119844:18;:37::i;:::-;9422:7:::0;;9359:85;9463:69;;-1:-1:-1;;;9463:69:0;;9514:4;9463:69;;;10131:34:1;9521:10:0;10181:18:1;;;10174:43;132:42:0;;9463;;10066:18:1;;9463:69:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9458:148;;9560:30;;-1:-1:-1;;;9560:30:0;;9579:10;9560:30;;;2410:51:1;2383:18;;9560:30:0;2264:203:1;9458:148:0;119844:37:::1;119863:4;119869:2;119873:7;119844:18;:37::i;:::-;119710:179:::0;;;;:::o;117514:493::-;76201:13;:11;:13::i;:::-;117601:16:::1;117609:7;117601;:16::i;:::-;117600:17;:54;;;-1:-1:-1::0;117649:4:0::1;117621:16;117629:7:::0;117621::::1;:16::i;:::-;-1:-1:-1::0;;;;;117621:33:0::1;;117600:54;117596:404;;;117671:56;::::0;-1:-1:-1;;;117671:56:0;;117708:4:::1;117671:56;::::0;::::1;12266:34:1::0;-1:-1:-1;;;;;12336:15:1;;;12316:18;;;12309:43;12368:18;;;12361:34;;;117671:11:0::1;:28;::::0;::::1;::::0;12201:18:1;;117671:56:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;118851:158:::0;;:::o;117596:404::-:1;117777:11;-1:-1:-1::0;;;;;117749:40:0::1;:16;117757:7;117749;:16::i;:::-;-1:-1:-1::0;;;;;117749:40:0::1;::::0;117745:255:::1;;117860:52;117882:11;117896:2;117900:7;117860:52;;;;;;;;;;;::::0;:13:::1;:52::i;117745:255::-;117945:43;::::0;-1:-1:-1;;;117945:43:0;;13022:2:1;117945:43:0::1;::::0;::::1;13004:21:1::0;13061:2;13041:18;;;13034:30;13100:34;13080:18;;;13073:62;-1:-1:-1;;;13151:18:1;;;13144:31;13192:19;;117945:43:0::1;12820:397:1::0;69193:442:0;69290:7;69348:27;;;:17;:27;;;;;;;;69319:56;;;;;;;;;-1:-1:-1;;;;;69319:56:0;;;;;-1:-1:-1;;;69319:56:0;;;-1:-1:-1;;;;;69319:56:0;;;;;;;;69290:7;;69388:92;;-1:-1:-1;69439:29:0;;;;;;;;;69449:19;69439:29;-1:-1:-1;;;;;69439:29:0;;;;-1:-1:-1;;;69439:29:0;;-1:-1:-1;;;;;69439:29:0;;;;;69388:92;69530:23;;;;69492:21;;70001:5;;69517:36;;-1:-1:-1;;;;;69517:36:0;:10;:36;:::i;:::-;69516:58;;;;:::i;:::-;69595:16;;;;;-1:-1:-1;69193:442:0;;-1:-1:-1;;;;69193:442:0:o;93688:256::-;93785:7;93821:23;93838:5;93821:16;:23::i;:::-;93813:5;:31;93805:87;;;;-1:-1:-1;;;93805:87:0;;13986:2:1;93805:87:0;;;13968:21:1;14025:2;14005:18;;;13998:30;14064:34;14044:18;;;14037:62;-1:-1:-1;;;14115:18:1;;;14108:41;14166:19;;93805:87:0;13784:407:1;93805:87:0;-1:-1:-1;;;;;;93910:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;93688:256::o;116279:521::-;112337:9;112350:10;112337:23;112329:66;;;;-1:-1:-1;;;112329:66:0;;;;;;;:::i;:::-;116374:7:::1;116370:322;;;116415:25;::::0;;;:12:::1;:25;::::0;;;;;116407:34:::1;::::0;:7:::1;:34::i;:::-;116406:35;116398:120;;;::::0;-1:-1:-1;;;116398:120:0;;14398:2:1;116398:120:0::1;::::0;::::1;14380:21:1::0;14437:2;14417:18;;;14410:30;14476:34;14456:18;;;14449:62;14547:34;14527:18;;;14520:62;-1:-1:-1;;;14598:19:1;;;14591:40;14648:19;;116398:120:0::1;14196:477:1::0;116398:120:0::1;116541:40;::::0;-1:-1:-1;;;116541:40:0;;116561:10:::1;116541:40;::::0;::::1;5137:51:1::0;116584:1:0::1;5204:18:1::0;;;5197:34;;;116584:1:0;116541:9:::1;-1:-1:-1::0;;;;;116541:19:0::1;::::0;::::1;::::0;5110:18:1;;116541:40:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;116533:92;;;::::0;-1:-1:-1;;;116533:92:0;;15069:2:1;116533:92:0::1;::::0;::::1;15051:21:1::0;15108:2;15088:18;;;15081:30;15147:34;15127:18;;;15120:62;-1:-1:-1;;;15198:18:1;;;15191:34;15242:19;;116533:92:0::1;14867:400:1::0;116533:92:0::1;116640:22;::::0;;;:9:::1;:22;::::0;;;;116665:1:::1;116640:26:::0;;116370:322:::1;116702:90;::::0;-1:-1:-1;;;116702:90:0;;116731:10:::1;116702:90;::::0;::::1;15577:34:1::0;116751:4:0::1;15627:18:1::0;;;15620:43;15679:18;;;15672:34;;;15742:3;15722:18;;;15715:31;15783:2;15762:19;;;15755:31;-1:-1:-1;;;15802:19:1;;;15795:49;116702:11:0::1;-1:-1:-1::0;;;;;116702:28:0::1;::::0;::::1;::::0;15861:19:1;;116702:90:0::1;15272:614:1::0;119897:187:0;120018:4;132:42;9054:45;:49;;;;:77;;-1:-1:-1;9107:24:0;;;;9054:77;9050:567;;;9371:10;-1:-1:-1;;;;;9363:18:0;;;9359:85;;120035:41:::1;120058:4;120064:2;120068:7;120035:22;:41::i;9359:85::-:0;9463:69;;-1:-1:-1;;;9463:69:0;;9514:4;9463:69;;;10131:34:1;9521:10:0;10181:18:1;;;10174:43;132:42:0;;9463;;10066:18:1;;9463:69:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9458:148;;9560:30;;-1:-1:-1;;;9560:30:0;;9579:10;9560:30;;;2410:51:1;2383:18;;9560:30:0;2264:203:1;9458:148:0;120035:41:::1;120058:4;120064:2;120068:7;120035:22;:41::i;94210:233::-:0;94285:7;94321:30;94108:10;:17;;94020:113;94321:30;94313:5;:38;94305:95;;;;-1:-1:-1;;;94305:95:0;;16093:2:1;94305:95:0;;;16075:21:1;16132:2;16112:18;;;16105:30;16171:34;16151:18;;;16144:62;-1:-1:-1;;;16222:18:1;;;16215:42;16274:19;;94305:95:0;15891:408:1;94305:95:0;94418:10;94429:5;94418:17;;;;;;;;:::i;:::-;;;;;;;;;94411:24;;94210:233;;;:::o;113053:100::-;76201:13;:11;:13::i;:::-;113127:7:::1;:18;113137:8:::0;113127:7;:18:::1;:::i;79825:222::-:0;79897:7;79933:16;;;:7;:16;;;;;;-1:-1:-1;;;;;79933:16:0;;79960:56;;;;-1:-1:-1;;;79960:56:0;;18842:2:1;79960:56:0;;;18824:21:1;18881:2;18861:18;;;18854:30;-1:-1:-1;;;18900:18:1;;;18893:54;18964:18;;79960:56:0;18640:348:1;113536:122:0;113603:7;76201:13;:11;:13::i;:::-;-1:-1:-1;113630:20:0::1;::::0;;;:11:::1;:20;::::0;;;;;;113536:122::o;79556:207::-;79628:7;-1:-1:-1;;;;;79656:19:0;;79648:73;;;;-1:-1:-1;;;79648:73:0;;19195:2:1;79648:73:0;;;19177:21:1;19234:2;19214:18;;;19207:30;19273:34;19253:18;;;19246:62;-1:-1:-1;;;19324:18:1;;;19317:39;19373:19;;79648:73:0;18993:405:1;79648:73:0;-1:-1:-1;;;;;;79739:16:0;;;;;:9;:16;;;;;;;79556:207::o;76963:103::-;76201:13;:11;:13::i;:::-;77028:30:::1;77055:1;77028:18;:30::i;:::-;76963:103::o:0;118032:109::-;76201:13;:11;:13::i;:::-;118106:11:::1;:25:::0;118032:109::o;80283:104::-;80339:13;80372:7;80365:14;;;;;:::i;117043:453::-;112337:9;112350:10;112337:23;112329:66;;;;-1:-1:-1;;;112329:66:0;;;;;;;:::i;:::-;42713:1:::1;43311:7;;:19:::0;43303:63:::1;;;::::0;-1:-1:-1;;;43303:63:0;;10680:2:1;43303:63:0::1;::::0;::::1;10662:21:1::0;10719:2;10699:18;;;10692:30;10758:33;10738:18;;;10731:61;10809:18;;43303:63:0::1;10478:355:1::0;43303:63:0::1;42713:1;43444:7;:18:::0;117160:11:::2;::::0;;;::::2;;;117152:53;;;::::0;-1:-1:-1;;;117152:53:0;;19605:2:1;117152:53:0::2;::::0;::::2;19587:21:1::0;19644:2;19624:18;;;19617:30;19683:32;19663:18;;;19656:60;19733:18;;117152:53:0::2;19403:354:1::0;117152:53:0::2;117224:32;117238:9;117249:6;;117224:13;:32::i;:::-;117216:60;;;::::0;-1:-1:-1;;;117216:60:0;;19964:2:1;117216:60:0::2;::::0;::::2;19946:21:1::0;20003:2;19983:18;;;19976:30;-1:-1:-1;;;20022:18:1;;;20015:45;20077:18;;117216:60:0::2;19762:339:1::0;117216:60:0::2;117296:28;:8;117314:9:::0;117296:17:::2;:28::i;:::-;117295:29;117287:60;;;::::0;-1:-1:-1;;;117287:60:0;;20308:2:1;117287:60:0::2;::::0;::::2;20290:21:1::0;20347:2;20327:18;;;20320:30;-1:-1:-1;;;20366:18:1;;;20359:49;20425:18;;117287:60:0::2;20106:343:1::0;117287:60:0::2;117360:19;:7;33478:19:::0;;33496:1;33478:19;;;33389:127;117360:19:::2;117392:60;117405:10;117434:17;:7;33359:14:::0;;33267:114;117434:17:::2;117417:34;::::0;112065:4:::2;117417:34;:::i;117392:60::-;117465:23;:8;117478:9:::0;117465:12:::2;:23::i;:::-;-1:-1:-1::0;;42669:1:0::1;43623:7;:22:::0;-1:-1:-1;;117043:453:0:o;119329:192::-;119449:8;132:42;9828:45;:49;;;;:77;;-1:-1:-1;9881:24:0;;;;9828:77;9824:253;;;9927:67;;-1:-1:-1;;;9927:67:0;;9978:4;9927:67;;;10131:34:1;-1:-1:-1;;;;;10201:15:1;;10181:18;;;10174:43;132:42:0;;9927;;10066:18:1;;9927:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9922:144;;10022:28;;-1:-1:-1;;;10022:28:0;;-1:-1:-1;;;;;2428:32:1;;10022:28:0;;;2410:51:1;2383:18;;10022:28:0;2264:203:1;9922:144:0;119470:43:::1;119494:8;119504;119470:23;:43::i;119202:119::-:0;76201:13;:11;:13::i;:::-;119281:24:::1;:32:::0;;-1:-1:-1;;119281:32:0::1;::::0;::::1;;::::0;;;::::1;::::0;;119202:119::o;120092:244::-;120259:4;132:42;9054:45;:49;;;;:77;;-1:-1:-1;9107:24:0;;;;9054:77;9050:567;;;9371:10;-1:-1:-1;;;;;9363:18:0;;;9359:85;;120281:47:::1;120304:4;120310:2;120314:7;120323:4;120281:22;:47::i;:::-;9422:7:::0;;9359:85;9463:69;;-1:-1:-1;;;9463:69:0;;9514:4;9463:69;;;10131:34:1;9521:10:0;10181:18:1;;;10174:43;132:42:0;;9463;;10066:18:1;;9463:69:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9458:148;;9560:30;;-1:-1:-1;;;9560:30:0;;9579:10;9560:30;;;2410:51:1;2383:18;;9560:30:0;2264:203:1;9458:148:0;120281:47:::1;120304:4;120310:2;120314:7;120323:4;120281:22;:47::i;:::-;120092:244:::0;;;;;:::o;112801:111::-;76201:13;:11;:13::i;:::-;112884:14:::1;::::0;;;:10:::1;:14;::::0;;;;:20:::1;112901:3:::0;112884:14;:20:::1;:::i;113666:878::-:0;113739:13;113775:16;113783:7;113775;:16::i;:::-;113767:50;;;;-1:-1:-1;;;113767:50:0;;20786:2:1;113767:50:0;;;20768:21:1;20825:2;20805:18;;;20798:30;-1:-1:-1;;;20844:18:1;;;20837:51;20905:18;;113767:50:0;20584:345:1;113767:50:0;113856:1;113833:20;;;:11;:20;;;;;;:24;113830:697;;111932:1;113874:21;113898:15;;;:10;:15;;;113874:39;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;113959:1;113941:7;113935:21;:25;:104;;114032:7;113935:104;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;113996:20;;;;:11;:20;;;;;;113987:7;;113996:31;;:29;:31::i;:::-;113970:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;113935:104;113928:111;113666:878;-1:-1:-1;;;113666:878:0:o;113830:697::-;112065:4;114073:7;:26;114070:457;;;111972:1;114116:21;114140:17;;;:10;:17;;;114116:41;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;114172:16;112065:4;114191:7;:26;;;;:::i;:::-;114172:45;;114263:1;114245:7;114239:21;:25;:92;;114324:7;114239:92;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;114291:7;114300:19;:8;:17;:19::i;:::-;114274:46;;;;;;;;;:::i;:::-;;;;;;;;;;;;;114239:92;114232:99;113666:878;-1:-1:-1;;;;113666:878:0:o;114070:457::-;111894:1;114364:21;114388:14;;;:10;:14;;;114364:38;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;114448:1;114430:7;114424:21;:25;:91;;114508:7;114424:91;;;;;:::i;:::-;114476:7;114485:18;:7;:16;:18::i;113292:107::-;76201:13;:11;:13::i;:::-;113365:11:::1;:26:::0;;;::::1;;::::0;::::1;-1:-1:-1::0;;113365:26:0;;::::1;::::0;;;::::1;::::0;;113292:107::o;113407:121::-;113475:7;76201:13;:11;:13::i;:::-;-1:-1:-1;113502:18:0::1;::::0;;;:9:::1;:18;::::0;;;;;;113407:121::o;113161:123::-;76201:13;:11;:13::i;:::-;113242:15:::1;:34:::0;;;::::1;;;;-1:-1:-1::0;;113242:34:0;;::::1;::::0;;;::::1;::::0;;113161:123::o;77221:201::-;76201:13;:11;:13::i;:::-;-1:-1:-1;;;;;77310:22:0;::::1;77302:73;;;::::0;-1:-1:-1;;;77302:73:0;;21770:2:1;77302:73:0::1;::::0;::::1;21752:21:1::0;21809:2;21789:18;;;21782:30;21848:34;21828:18;;;21821:62;-1:-1:-1;;;21899:18:1;;;21892:36;21945:19;;77302:73:0::1;21568:402:1::0;77302:73:0::1;77386:28;77405:8;77386:18;:28::i;68923:215::-:0;69025:4;-1:-1:-1;;;;;;69049:41:0;;-1:-1:-1;;;69049:41:0;;:81;;;69094:36;69118:11;69094:23;:36::i;76480:132::-;76388:6;;-1:-1:-1;;;;;76388:6:0;74946:10;76544:23;76536:68;;;;-1:-1:-1;;;76536:68:0;;22177:2:1;76536:68:0;;;22159:21:1;;;22196:18;;;22189:30;22255:34;22235:18;;;22228:62;22307:18;;76536:68:0;21975:356:1;70285:332:0;70001:5;-1:-1:-1;;;;;70388:33:0;;;;70380:88;;;;-1:-1:-1;;;70380:88:0;;22538:2:1;70380:88:0;;;22520:21:1;22577:2;22557:18;;;22550:30;22616:34;22596:18;;;22589:62;-1:-1:-1;;;22667:18:1;;;22660:40;22717:19;;70380:88:0;22336:406:1;70380:88:0;-1:-1:-1;;;;;70487:22:0;;70479:60;;;;-1:-1:-1;;;70479:60:0;;22949:2:1;70479:60:0;;;22931:21:1;22988:2;22968:18;;;22961:30;23027:27;23007:18;;;23000:55;23072:18;;70479:60:0;22747:349:1;70479:60:0;70574:35;;;;;;;;;-1:-1:-1;;;;;70574:35:0;;;;;;-1:-1:-1;;;;;70574:35:0;;;;;;;;;;-1:-1:-1;;;70552:57:0;;;;:19;:57;70285:332::o;89602:135::-;89684:16;89692:7;89684;:16::i;:::-;89676:53;;;;-1:-1:-1;;;89676:53:0;;18842:2:1;89676:53:0;;;18824:21:1;18881:2;18861:18;;;18854:30;-1:-1:-1;;;18900:18:1;;;18893:54;18964:18;;89676:53:0;18640:348:1;81144:417:0;81225:13;81241:23;81256:7;81241:14;:23::i;:::-;81225:39;;81289:5;-1:-1:-1;;;;;81283:11:0;:2;-1:-1:-1;;;;;81283:11:0;;81275:57;;;;-1:-1:-1;;;81275:57:0;;23303:2:1;81275:57:0;;;23285:21:1;23342:2;23322:18;;;23315:30;23381:34;23361:18;;;23354:62;-1:-1:-1;;;23432:18:1;;;23425:31;23473:19;;81275:57:0;23101:397:1;81275:57:0;74946:10;-1:-1:-1;;;;;81367:21:0;;;;:62;;-1:-1:-1;81392:37:0;81409:5;74946:10;82096:164;:::i;81392:37::-;81345:174;;;;-1:-1:-1;;;81345:174:0;;23705:2:1;81345:174:0;;;23687:21:1;23744:2;23724:18;;;23717:30;23783:34;23763:18;;;23756:62;23854:32;23834:18;;;23827:60;23904:19;;81345:174:0;23503:426:1;81345:174:0;81532:21;81541:2;81545:7;81532:8;:21::i;84820:127::-;84885:4;84909:16;;;:7;:16;;;;;;-1:-1:-1;;;;;84909:16:0;:30;;;84820:127::o;114791:101::-;114862:22;114872:2;114876:7;114862:9;:22::i;84194:313::-;84350:28;84360:4;84366:2;84370:7;84350:9;:28::i;:::-;84397:47;84420:4;84426:2;84430:7;84439:4;84397:22;:47::i;:::-;84389:110;;;;-1:-1:-1;;;84389:110:0;;;;;;;:::i;82327:336::-;82522:41;74946:10;82555:7;82522:18;:41::i;:::-;82514:100;;;;-1:-1:-1;;;82514:100:0;;;;;;;:::i;:::-;82627:28;82637:4;82643:2;82647:7;82627:9;:28::i;82734:185::-;82872:39;82889:4;82895:2;82899:7;82872:39;;;;;;;;;;;;:16;:39::i;77582:191::-;77675:6;;;-1:-1:-1;;;;;77692:17:0;;;-1:-1:-1;;;;;;77692:17:0;;;;;;;77725:40;;77675:6;;;77692:17;77675:6;;77725:40;;77656:16;;77725:40;77645:128;77582:191;:::o;118149:155::-;118240:4;118264:32;118272:15;118277:9;118272:4;:15::i;:::-;118289:6;;118264:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;118264:7:0;;-1:-1:-1;;;118264:32:0:i;17119:140::-;17199:4;14985:19;;;:12;;;:19;;;;;;:24;;17223:28;14888:129;16601:125;16671:4;16695:23;16700:3;16712:5;16695:4;:23::i;81870:155::-;81965:52;74946:10;81998:8;82008;81965:18;:52::i;82990:323::-;83164:41;74946:10;83197:7;83164:18;:41::i;:::-;83156:100;;;;-1:-1:-1;;;83156:100:0;;;;;;;:::i;:::-;83267:38;83281:4;83287:2;83291:7;83300:4;83267:13;:38::i;72120:723::-;72176:13;72397:5;72406:1;72397:10;72393:53;;-1:-1:-1;;72424:10:0;;;;;;;;;;;;-1:-1:-1;;;72424:10:0;;;;;72120:723::o;72393:53::-;72471:5;72456:12;72512:78;72519:9;;72512:78;;72545:8;;;;:::i;:::-;;-1:-1:-1;72568:10:0;;-1:-1:-1;72576:2:0;72568:10;;:::i;:::-;;;72512:78;;;72600:19;72632:6;72622:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;72622:17:0;;72600:39;;72650:154;72657:10;;72650:154;;72684:11;72694:1;72684:11;;:::i;:::-;;-1:-1:-1;72753:10:0;72761:2;72753:5;:10;:::i;:::-;72740:24;;:2;:24;:::i;:::-;72727:39;;72710:6;72717;72710:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;72710:56:0;;;;;;;;-1:-1:-1;72781:11:0;72790:2;72781:11;;:::i;:::-;;;72650:154;;93380:224;93482:4;-1:-1:-1;;;;;;93506:50:0;;-1:-1:-1;;;93506:50:0;;:90;;;93560:36;93584:11;93560:23;:36::i;88881:174::-;88956:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;88956:29:0;-1:-1:-1;;;;;88956:29:0;;;;;;;;:24;;89010:23;88956:24;89010:14;:23::i;:::-;-1:-1:-1;;;;;89001:46:0;;;;;;;;;;;88881:174;;:::o;85720:110::-;85796:26;85806:2;85810:7;85796:26;;;;;;;;;;;;:9;:26::i;88137:625::-;88296:4;-1:-1:-1;;;;;88269:31:0;:23;88284:7;88269:14;:23::i;:::-;-1:-1:-1;;;;;88269:31:0;;88261:81;;;;-1:-1:-1;;;88261:81:0;;25227:2:1;88261:81:0;;;25209:21:1;25266:2;25246:18;;;25239:30;25305:34;25285:18;;;25278:62;-1:-1:-1;;;25356:18:1;;;25349:35;25401:19;;88261:81:0;25025:401:1;88261:81:0;-1:-1:-1;;;;;88361:16:0;;88353:65;;;;-1:-1:-1;;;88353:65:0;;25633:2:1;88353:65:0;;;25615:21:1;25672:2;25652:18;;;25645:30;25711:34;25691:18;;;25684:62;-1:-1:-1;;;25762:18:1;;;25755:34;25806:19;;88353:65:0;25431:400:1;88353:65:0;88431:39;88452:4;88458:2;88462:7;88431:20;:39::i;:::-;88535:29;88552:1;88556:7;88535:8;:29::i;:::-;-1:-1:-1;;;;;88577:15:0;;;;;;:9;:15;;;;;:20;;88596:1;;88577:15;:20;;88596:1;;88577:20;:::i;:::-;;;;-1:-1:-1;;;;;;;88608:13:0;;;;;;:9;:13;;;;;:18;;88625:1;;88608:13;:18;;88625:1;;88608:18;:::i;:::-;;;;-1:-1:-1;;88637:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;88637:21:0;-1:-1:-1;;;;;88637:21:0;;;;;;;;;88676:27;;88637:16;;88676:27;;;;;;;119529:173;;;:::o;90301:853::-;90455:4;-1:-1:-1;;;;;90476:13:0;;45188:19;:23;90472:675;;90512:71;;-1:-1:-1;;;90512:71:0;;-1:-1:-1;;;;;90512:36:0;;;;;:71;;74946:10;;90563:4;;90569:7;;90578:4;;90512:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;90512:71:0;;;;;;;;-1:-1:-1;;90512:71:0;;;;;;;;;;;;:::i;:::-;;;90508:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;90753:6;:13;90770:1;90753:18;90749:328;;90796:60;;-1:-1:-1;;;90796:60:0;;;;;;;:::i;90749:328::-;91027:6;91021:13;91012:6;91008:2;91004:15;90997:38;90508:584;-1:-1:-1;;;;;;90634:51:0;-1:-1:-1;;;90634:51:0;;-1:-1:-1;90627:58:0;;90472:675;-1:-1:-1;91131:4:0;90301:853;;;;;;:::o;85114:264::-;85207:4;85224:13;85240:23;85255:7;85240:14;:23::i;:::-;85224:39;;85293:5;-1:-1:-1;;;;;85282:16:0;:7;-1:-1:-1;;;;;85282:16:0;;:52;;;-1:-1:-1;;;;;;82217:25:0;;;82193:4;82217:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;85302:32;85282:87;;;;85362:7;-1:-1:-1;;;;;85338:31:0;:20;85350:7;85338:11;:20::i;:::-;-1:-1:-1;;;;;85338:31:0;;85274:96;85114:264;-1:-1:-1;;;;85114:264:0:o;118312:128::-;118367:7;118421:9;118404:27;;;;;;26713:19:1;;26757:2;26748:12;;26584:182;118404:27:0;;;;;;;;;;;;;118394:38;;;;;;118387:45;;118312:128;;;:::o;118448:157::-;118527:4;118551:46;118570:6;118578:11;;118591:5;118551:18;:46::i;12792:414::-;12855:4;14985:19;;;:12;;;:19;;;;;;12872:327;;-1:-1:-1;12915:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;13098:18;;13076:19;;;:12;;;:19;;;;;;:40;;;;13131:11;;12872:327;-1:-1:-1;13182:5:0;13175:12;;89198:315;89353:8;-1:-1:-1;;;;;89344:17:0;:5;-1:-1:-1;;;;;89344:17:0;;89336:55;;;;-1:-1:-1;;;89336:55:0;;26973:2:1;89336:55:0;;;26955:21:1;27012:2;26992:18;;;26985:30;27051:27;27031:18;;;27024:55;27096:18;;89336:55:0;26771:349:1;89336:55:0;-1:-1:-1;;;;;89402:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;89402:46:0;;;;;;;;;;89464:41;;540::1;;;89464::0;;513:18:1;89464:41:0;;;;;;;89198:315;;;:::o;79187:305::-;79289:4;-1:-1:-1;;;;;;79326:40:0;;-1:-1:-1;;;79326:40:0;;:105;;-1:-1:-1;;;;;;;79383:48:0;;-1:-1:-1;;;79383:48:0;79326:105;:158;;;-1:-1:-1;;;;;;;;;;67482:40:0;;;79448:36;67373:157;86057:319;86186:18;86192:2;86196:7;86186:5;:18::i;:::-;86237:53;86268:1;86272:2;86276:7;86285:4;86237:22;:53::i;:::-;86215:153;;;;-1:-1:-1;;;86215:153:0;;;;;;;:::i;95056:589::-;-1:-1:-1;;;;;95262:18:0;;95258:187;;95297:40;95329:7;96472:10;:17;;96445:24;;;;:15;:24;;;;;:44;;;96500:24;;;;;;;;;;;;96368:164;95297:40;95258:187;;;95367:2;-1:-1:-1;;;;;95359:10:0;:4;-1:-1:-1;;;;;95359:10:0;;95355:90;;95386:47;95419:4;95425:7;95386:32;:47::i;:::-;-1:-1:-1;;;;;95459:16:0;;95455:183;;95492:45;95529:7;95492:36;:45::i;95455:183::-;95565:4;-1:-1:-1;;;;;95559:10:0;:2;-1:-1:-1;;;;;95559:10:0;;95555:83;;95586:40;95614:2;95618:7;95586:27;:40::i;24889:190::-;25014:4;25067;25038:25;25051:5;25058:4;25038:12;:25::i;:::-;:33;;24889:190;-1:-1:-1;;;;24889:190:0:o;86712:439::-;-1:-1:-1;;;;;86792:16:0;;86784:61;;;;-1:-1:-1;;;86784:61:0;;27327:2:1;86784:61:0;;;27309:21:1;;;27346:18;;;27339:30;27405:34;27385:18;;;27378:62;27457:18;;86784:61:0;27125:356:1;86784:61:0;86865:16;86873:7;86865;:16::i;:::-;86864:17;86856:58;;;;-1:-1:-1;;;86856:58:0;;27688:2:1;86856:58:0;;;27670:21:1;27727:2;27707:18;;;27700:30;27766;27746:18;;;27739:58;27814:18;;86856:58:0;27486:352:1;86856:58:0;86927:45;86956:1;86960:2;86964:7;86927:20;:45::i;:::-;-1:-1:-1;;;;;86985:13:0;;;;;;:9;:13;;;;;:18;;87002:1;;86985:13;:18;;87002:1;;86985:18;:::i;:::-;;;;-1:-1:-1;;87014:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;87014:21:0;-1:-1:-1;;;;;87014:21:0;;;;;;;;87053:33;;87014:16;;;87053:33;;87014:16;;87053:33;118851:158;;:::o;97159:988::-;97425:22;97475:1;97450:22;97467:4;97450:16;:22::i;:::-;:26;;;;:::i;:::-;97487:18;97508:26;;;:17;:26;;;;;;97425:51;;-1:-1:-1;97641:28:0;;;97637:328;;-1:-1:-1;;;;;97708:18:0;;97686:19;97708:18;;;:12;:18;;;;;;;;:34;;;;;;;;;97759:30;;;;;;:44;;;97876:30;;:17;:30;;;;;:43;;;97637:328;-1:-1:-1;98061:26:0;;;;:17;:26;;;;;;;;98054:33;;;-1:-1:-1;;;;;98105:18:0;;;;;:12;:18;;;;;:34;;;;;;;98098:41;97159:988::o;98442:1079::-;98720:10;:17;98695:22;;98720:21;;98740:1;;98720:21;:::i;:::-;98752:18;98773:24;;;:15;:24;;;;;;99146:10;:26;;98695:46;;-1:-1:-1;98773:24:0;;98695:46;;99146:26;;;;;;:::i;:::-;;;;;;;;;99124:48;;99210:11;99185:10;99196;99185:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;99290:28;;;:15;:28;;;;;;;:41;;;99462:24;;;;;99455:31;99497:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;98513:1008;;;98442:1079;:::o;95946:221::-;96031:14;96048:20;96065:2;96048:16;:20::i;:::-;-1:-1:-1;;;;;96079:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;96124:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;95946:221:0:o;25756:296::-;25839:7;25882:4;25839:7;25897:118;25921:5;:12;25917:1;:16;25897:118;;;25970:33;25980:12;25994:5;26000:1;25994:8;;;;;;;;:::i;:::-;;;;;;;25970:9;:33::i;:::-;25955:48;-1:-1:-1;25935:3:0;;;;:::i;:::-;;;;25897:118;;;-1:-1:-1;26032:12:0;25756:296;-1:-1:-1;;;25756:296:0:o;31963:149::-;32026:7;32057:1;32053;:5;:51;;32188:13;32282:15;;;32318:4;32311:15;;;32365:4;32349:21;;32053:51;;;32188:13;32282:15;;;32318:4;32311:15;;;32365:4;32349:21;;32061:20;32120:268;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:173::-;660:20;;-1:-1:-1;;;;;709:31:1;;699:42;;689:70;;755:1;752;745:12;770:366;837:6;845;898:2;886:9;877:7;873:23;869:32;866:52;;;914:1;911;904:12;866:52;937:29;956:9;937:29;:::i;:::-;927:39;;1016:2;1005:9;1001:18;988:32;-1:-1:-1;;;;;1053:5:1;1049:38;1042:5;1039:49;1029:77;;1102:1;1099;1092:12;1029:77;1125:5;1115:15;;;770:366;;;;;:::o;1141:180::-;1200:6;1253:2;1241:9;1232:7;1228:23;1224:32;1221:52;;;1269:1;1266;1259:12;1221:52;-1:-1:-1;1292:23:1;;1141:180;-1:-1:-1;1141:180:1:o;1326:250::-;1411:1;1421:113;1435:6;1432:1;1429:13;1421:113;;;1511:11;;;1505:18;1492:11;;;1485:39;1457:2;1450:10;1421:113;;;-1:-1:-1;;1568:1:1;1550:16;;1543:27;1326:250::o;1581:271::-;1623:3;1661:5;1655:12;1688:6;1683:3;1676:19;1704:76;1773:6;1766:4;1761:3;1757:14;1750:4;1743:5;1739:16;1704:76;:::i;:::-;1834:2;1813:15;-1:-1:-1;;1809:29:1;1800:39;;;;1841:4;1796:50;;1581:271;-1:-1:-1;;1581:271:1:o;1857:220::-;2006:2;1995:9;1988:21;1969:4;2026:45;2067:2;2056:9;2052:18;2044:6;2026:45;:::i;2472:254::-;2540:6;2548;2601:2;2589:9;2580:7;2576:23;2572:32;2569:52;;;2617:1;2614;2607:12;2569:52;2640:29;2659:9;2640:29;:::i;:::-;2630:39;2716:2;2701:18;;;;2688:32;;-1:-1:-1;;;2472:254:1:o;2731:127::-;2792:10;2787:3;2783:20;2780:1;2773:31;2823:4;2820:1;2813:15;2847:4;2844:1;2837:15;2863:631;2927:5;2957:18;2998:2;2990:6;2987:14;2984:40;;;3004:18;;:::i;:::-;3079:2;3073:9;3047:2;3133:15;;-1:-1:-1;;3129:24:1;;;3155:2;3125:33;3121:42;3109:55;;;3179:18;;;3199:22;;;3176:46;3173:72;;;3225:18;;:::i;:::-;3265:10;3261:2;3254:22;3294:6;3285:15;;3324:6;3316;3309:22;3364:3;3355:6;3350:3;3346:16;3343:25;3340:45;;;3381:1;3378;3371:12;3340:45;3431:6;3426:3;3419:4;3411:6;3407:17;3394:44;3486:1;3479:4;3470:6;3462;3458:19;3454:30;3447:41;;;;2863:631;;;;;:::o;3499:666::-;3594:6;3602;3610;3618;3671:3;3659:9;3650:7;3646:23;3642:33;3639:53;;;3688:1;3685;3678:12;3639:53;3711:29;3730:9;3711:29;:::i;:::-;3701:39;;3759:38;3793:2;3782:9;3778:18;3759:38;:::i;:::-;3749:48;;3844:2;3833:9;3829:18;3816:32;3806:42;;3899:2;3888:9;3884:18;3871:32;3926:18;3918:6;3915:30;3912:50;;;3958:1;3955;3948:12;3912:50;3981:22;;4034:4;4026:13;;4022:27;-1:-1:-1;4012:55:1;;4063:1;4060;4053:12;4012:55;4086:73;4151:7;4146:2;4133:16;4128:2;4124;4120:11;4086:73;:::i;:::-;4076:83;;;3499:666;;;;;;;:::o;4377:328::-;4454:6;4462;4470;4523:2;4511:9;4502:7;4498:23;4494:32;4491:52;;;4539:1;4536;4529:12;4491:52;4562:29;4581:9;4562:29;:::i;:::-;4552:39;;4610:38;4644:2;4633:9;4629:18;4610:38;:::i;:::-;4600:48;;4695:2;4684:9;4680:18;4667:32;4657:42;;4377:328;;;;;:::o;4710:248::-;4778:6;4786;4839:2;4827:9;4818:7;4814:23;4810:32;4807:52;;;4855:1;4852;4845:12;4807:52;-1:-1:-1;;4878:23:1;;;4948:2;4933:18;;;4920:32;;-1:-1:-1;4710:248:1:o;5242:118::-;5328:5;5321:13;5314:21;5307:5;5304:32;5294:60;;5350:1;5347;5340:12;5365:309;5430:6;5438;5491:2;5479:9;5470:7;5466:23;5462:32;5459:52;;;5507:1;5504;5497:12;5459:52;5543:9;5530:23;5520:33;;5603:2;5592:9;5588:18;5575:32;5616:28;5638:5;5616:28;:::i;5918:221::-;5961:5;6014:3;6007:4;5999:6;5995:17;5991:27;5981:55;;6032:1;6029;6022:12;5981:55;6054:79;6129:3;6120:6;6107:20;6100:4;6092:6;6088:17;6054:79;:::i;6144:322::-;6213:6;6266:2;6254:9;6245:7;6241:23;6237:32;6234:52;;;6282:1;6279;6272:12;6234:52;6322:9;6309:23;6355:18;6347:6;6344:30;6341:50;;;6387:1;6384;6377:12;6341:50;6410;6452:7;6443:6;6432:9;6428:22;6410:50;:::i;6471:186::-;6530:6;6583:2;6571:9;6562:7;6558:23;6554:32;6551:52;;;6599:1;6596;6589:12;6551:52;6622:29;6641:9;6622:29;:::i;6847:689::-;6942:6;6950;6958;7011:2;6999:9;6990:7;6986:23;6982:32;6979:52;;;7027:1;7024;7017:12;6979:52;7067:9;7054:23;7096:18;7137:2;7129:6;7126:14;7123:34;;;7153:1;7150;7143:12;7123:34;7191:6;7180:9;7176:22;7166:32;;7236:7;7229:4;7225:2;7221:13;7217:27;7207:55;;7258:1;7255;7248:12;7207:55;7298:2;7285:16;7324:2;7316:6;7313:14;7310:34;;;7340:1;7337;7330:12;7310:34;7395:7;7388:4;7378:6;7375:1;7371:14;7367:2;7363:23;7359:34;7356:47;7353:67;;;7416:1;7413;7406:12;7353:67;7447:4;7439:13;;;;7471:6;;-1:-1:-1;7509:20:1;;;;7496:34;;6847:689;-1:-1:-1;;;;6847:689:1:o;7541:315::-;7606:6;7614;7667:2;7655:9;7646:7;7642:23;7638:32;7635:52;;;7683:1;7680;7673:12;7635:52;7706:29;7725:9;7706:29;:::i;:::-;7696:39;;7785:2;7774:9;7770:18;7757:32;7798:28;7820:5;7798:28;:::i;7861:241::-;7917:6;7970:2;7958:9;7949:7;7945:23;7941:32;7938:52;;;7986:1;7983;7976:12;7938:52;8025:9;8012:23;8044:28;8066:5;8044:28;:::i;8107:390::-;8185:6;8193;8246:2;8234:9;8225:7;8221:23;8217:32;8214:52;;;8262:1;8259;8252:12;8214:52;8302:9;8289:23;8335:18;8327:6;8324:30;8321:50;;;8367:1;8364;8357:12;8321:50;8390;8432:7;8423:6;8412:9;8408:22;8390:50;:::i;:::-;8380:60;8487:2;8472:18;;;;8459:32;;-1:-1:-1;;;;8107:390:1:o;8502:260::-;8570:6;8578;8631:2;8619:9;8610:7;8606:23;8602:32;8599:52;;;8647:1;8644;8637:12;8599:52;8670:29;8689:9;8670:29;:::i;:::-;8660:39;;8718:38;8752:2;8741:9;8737:18;8718:38;:::i;:::-;8708:48;;8502:260;;;;;:::o;8767:354::-;8969:2;8951:21;;;9008:2;8988:18;;;8981:30;9047:32;9042:2;9027:18;;9020:60;9112:2;9097:18;;8767:354::o;9534:380::-;9613:1;9609:12;;;;9656;;;9677:61;;9731:4;9723:6;9719:17;9709:27;;9677:61;9784:2;9776:6;9773:14;9753:18;9750:38;9747:161;;9830:10;9825:3;9821:20;9818:1;9811:31;9865:4;9862:1;9855:15;9893:4;9890:1;9883:15;9747:161;;9534:380;;;:::o;10228:245::-;10295:6;10348:2;10336:9;10327:7;10323:23;10319:32;10316:52;;;10364:1;10361;10354:12;10316:52;10396:9;10390:16;10415:28;10437:5;10415:28;:::i;10838:402::-;11040:2;11022:21;;;11079:2;11059:18;;;11052:30;11118:34;11113:2;11098:18;;11091:62;-1:-1:-1;;;11184:2:1;11169:18;;11162:36;11230:3;11215:19;;10838:402::o;13222:127::-;13283:10;13278:3;13274:20;13271:1;13264:31;13314:4;13311:1;13304:15;13338:4;13335:1;13328:15;13354:168;13427:9;;;13458;;13475:15;;;13469:22;;13455:37;13445:71;;13496:18;;:::i;13527:127::-;13588:10;13583:3;13579:20;13576:1;13569:31;13619:4;13616:1;13609:15;13643:4;13640:1;13633:15;13659:120;13699:1;13725;13715:35;;13730:18;;:::i;:::-;-1:-1:-1;13764:9:1;;13659:120::o;14678:184::-;14748:6;14801:2;14789:9;14780:7;14776:23;14772:32;14769:52;;;14817:1;14814;14807:12;14769:52;-1:-1:-1;14840:16:1;;14678:184;-1:-1:-1;14678:184:1:o;16304:127::-;16365:10;16360:3;16356:20;16353:1;16346:31;16396:4;16393:1;16386:15;16420:4;16417:1;16410:15;16562:545;16664:2;16659:3;16656:11;16653:448;;;16700:1;16725:5;16721:2;16714:17;16770:4;16766:2;16756:19;16840:2;16828:10;16824:19;16821:1;16817:27;16811:4;16807:38;16876:4;16864:10;16861:20;16858:47;;;-1:-1:-1;16899:4:1;16858:47;16954:2;16949:3;16945:12;16942:1;16938:20;16932:4;16928:31;16918:41;;17009:82;17027:2;17020:5;17017:13;17009:82;;;17072:17;;;17053:1;17042:13;17009:82;;17283:1352;17409:3;17403:10;17436:18;17428:6;17425:30;17422:56;;;17458:18;;:::i;:::-;17487:97;17577:6;17537:38;17569:4;17563:11;17537:38;:::i;:::-;17531:4;17487:97;:::i;:::-;17639:4;;17703:2;17692:14;;17720:1;17715:663;;;;18422:1;18439:6;18436:89;;;-1:-1:-1;18491:19:1;;;18485:26;18436:89;-1:-1:-1;;17240:1:1;17236:11;;;17232:24;17228:29;17218:40;17264:1;17260:11;;;17215:57;18538:81;;17685:944;;17715:663;16509:1;16502:14;;;16546:4;16533:18;;-1:-1:-1;;17751:20:1;;;17869:236;17883:7;17880:1;17877:14;17869:236;;;17972:19;;;17966:26;17951:42;;18064:27;;;;18032:1;18020:14;;;;17899:19;;17869:236;;;17873:3;18133:6;18124:7;18121:19;18118:201;;;18194:19;;;18188:26;-1:-1:-1;;18277:1:1;18273:14;;;18289:3;18269:24;18265:37;18261:42;18246:58;18231:74;;18118:201;-1:-1:-1;;;;;18365:1:1;18349:14;;;18345:22;18332:36;;-1:-1:-1;17283:1352:1:o;20454:125::-;20519:9;;;20540:10;;;20537:36;;;20553:18;;:::i;20934:496::-;21113:3;21151:6;21145:13;21167:66;21226:6;21221:3;21214:4;21206:6;21202:17;21167:66;:::i;:::-;21296:13;;21255:16;;;;21318:70;21296:13;21255:16;21365:4;21353:17;;21318:70;:::i;:::-;21404:20;;20934:496;-1:-1:-1;;;;20934:496:1:o;21435:128::-;21502:9;;;21523:11;;;21520:37;;;21537:18;;:::i;23934:414::-;24136:2;24118:21;;;24175:2;24155:18;;;24148:30;24214:34;24209:2;24194:18;;24187:62;-1:-1:-1;;;24280:2:1;24265:18;;24258:48;24338:3;24323:19;;23934:414::o;24353:410::-;24555:2;24537:21;;;24594:2;24574:18;;;24567:30;24633:34;24628:2;24613:18;;24606:62;-1:-1:-1;;;24699:2:1;24684:18;;24677:44;24753:3;24738:19;;24353:410::o;24768:135::-;24807:3;24828:17;;;24825:43;;24848:18;;:::i;:::-;-1:-1:-1;24895:1:1;24884:13;;24768:135::o;24908:112::-;24940:1;24966;24956:35;;24971:18;;:::i;:::-;-1:-1:-1;25005:9:1;;24908:112::o;25836:489::-;-1:-1:-1;;;;;26105:15:1;;;26087:34;;26157:15;;26152:2;26137:18;;26130:43;26204:2;26189:18;;26182:34;;;26252:3;26247:2;26232:18;;26225:31;;;26030:4;;26273:46;;26299:19;;26291:6;26273:46;:::i;:::-;26265:54;25836:489;-1:-1:-1;;;;;;25836:489:1:o;26330:249::-;26399:6;26452:2;26440:9;26431:7;26427:23;26423:32;26420:52;;;26468:1;26465;26458:12;26420:52;26500:9;26494:16;26519:30;26543:5;26519:30;:::i;27843:127::-;27904:10;27899:3;27895:20;27892:1;27885:31;27935:4;27932:1;27925:15;27959:4;27956:1;27949:15
Swarm Source
ipfs://6c5269e0658539844271eb7203314e9849c47538797f9cc8d24ad8ac6493a247
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.