Feature Tip: Add private address tag to any address under My Name Tag !
Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 13 from a total of 13 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Open Lucky Bag | 16948446 | 519 days ago | IN | 0 ETH | 0.00524563 | ||||
Open Lucky Bag | 16763250 | 545 days ago | IN | 0 ETH | 0.00356647 | ||||
Open Lucky Bag | 16763247 | 545 days ago | IN | 0 ETH | 0.00335298 | ||||
Open Lucky Bag | 16224573 | 620 days ago | IN | 0 ETH | 0.00162157 | ||||
Open Lucky Bag | 16224567 | 620 days ago | IN | 0 ETH | 0.00178103 | ||||
Open Lucky Bag | 16224560 | 620 days ago | IN | 0 ETH | 0.0018347 | ||||
Open Lucky Bag | 16212227 | 622 days ago | IN | 0 ETH | 0.00187751 | ||||
Open Lucky Bag | 16212204 | 622 days ago | IN | 0 ETH | 0.00198155 | ||||
Open Lucky Bag | 16211965 | 622 days ago | IN | 0 ETH | 0.0019822 | ||||
Open Lucky Bag | 16211646 | 622 days ago | IN | 0 ETH | 0.00201466 | ||||
Add Lucky NFT | 16209518 | 622 days ago | IN | 0 ETH | 0.00098585 | ||||
Add Lucky NFT | 16209290 | 622 days ago | IN | 0 ETH | 0.01878258 | ||||
0x61010060 | 16209140 | 622 days ago | IN | 0 ETH | 0.03221632 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
HypeLuckyBag
Compiler Version
v0.8.17+commit.8df45f5f
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2022-12-18 */ // 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/structs/EnumerableMap.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableMap.sol) // This file was procedurally generated from scripts/generate/templates/EnumerableMap.js. pragma solidity ^0.8.0; /** * @dev Library for managing an enumerable variant of Solidity's * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`] * type. * * Maps have the following properties: * * - Entries are added, removed, and checked for existence in constant time * (O(1)). * - Entries are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableMap for EnumerableMap.UintToAddressMap; * * // Declare a set state variable * EnumerableMap.UintToAddressMap private myMap; * } * ``` * * The following map types are supported: * * - `uint256 -> address` (`UintToAddressMap`) since v3.0.0 * - `address -> uint256` (`AddressToUintMap`) since v4.6.0 * - `bytes32 -> bytes32` (`Bytes32ToBytes32Map`) since v4.6.0 * - `uint256 -> uint256` (`UintToUintMap`) since v4.7.0 * - `bytes32 -> uint256` (`Bytes32ToUintMap`) since v4.7.0 * * [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 EnumerableMap, you can either remove all elements one by one or create a fresh instance using an * array of EnumerableMap. * ==== */ library EnumerableMap { using EnumerableSet for EnumerableSet.Bytes32Set; // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Map type with // bytes32 keys and values. // The Map implementation uses private functions, and user-facing // implementations (such as Uint256ToAddressMap) are just wrappers around // the underlying Map. // This means that we can only create new EnumerableMaps for types that fit // in bytes32. struct Bytes32ToBytes32Map { // Storage of keys EnumerableSet.Bytes32Set _keys; mapping(bytes32 => bytes32) _values; } /** * @dev Adds a key-value pair to a map, or updates the value for an existing * key. O(1). * * Returns true if the key was added to the map, that is if it was not * already present. */ function set( Bytes32ToBytes32Map storage map, bytes32 key, bytes32 value ) internal returns (bool) { map._values[key] = value; return map._keys.add(key); } /** * @dev Removes a key-value pair from a map. O(1). * * Returns true if the key was removed from the map, that is if it was present. */ function remove(Bytes32ToBytes32Map storage map, bytes32 key) internal returns (bool) { delete map._values[key]; return map._keys.remove(key); } /** * @dev Returns true if the key is in the map. O(1). */ function contains(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool) { return map._keys.contains(key); } /** * @dev Returns the number of key-value pairs in the map. O(1). */ function length(Bytes32ToBytes32Map storage map) internal view returns (uint256) { return map._keys.length(); } /** * @dev Returns the key-value pair stored at position `index` in the map. O(1). * * Note that there are no guarantees on the ordering of entries inside the * array, and it may change when more entries are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32ToBytes32Map storage map, uint256 index) internal view returns (bytes32, bytes32) { bytes32 key = map._keys.at(index); return (key, map._values[key]); } /** * @dev Tries to returns the value associated with `key`. O(1). * Does not revert if `key` is not in the map. */ function tryGet(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool, bytes32) { bytes32 value = map._values[key]; if (value == bytes32(0)) { return (contains(map, key), bytes32(0)); } else { return (true, value); } } /** * @dev Returns the value associated with `key`. O(1). * * Requirements: * * - `key` must be in the map. */ function get(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bytes32) { bytes32 value = map._values[key]; require(value != 0 || contains(map, key), "EnumerableMap: nonexistent key"); return value; } /** * @dev Same as {get}, with a custom error message when `key` is not in the map. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryGet}. */ function get( Bytes32ToBytes32Map storage map, bytes32 key, string memory errorMessage ) internal view returns (bytes32) { bytes32 value = map._values[key]; require(value != 0 || contains(map, key), errorMessage); return value; } // UintToUintMap struct UintToUintMap { Bytes32ToBytes32Map _inner; } /** * @dev Adds a key-value pair to a map, or updates the value for an existing * key. O(1). * * Returns true if the key was added to the map, that is if it was not * already present. */ function set( UintToUintMap storage map, uint256 key, uint256 value ) internal returns (bool) { return set(map._inner, bytes32(key), bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the key was removed from the map, that is if it was present. */ function remove(UintToUintMap storage map, uint256 key) internal returns (bool) { return remove(map._inner, bytes32(key)); } /** * @dev Returns true if the key is in the map. O(1). */ function contains(UintToUintMap storage map, uint256 key) internal view returns (bool) { return contains(map._inner, bytes32(key)); } /** * @dev Returns the number of elements in the map. O(1). */ function length(UintToUintMap storage map) internal view returns (uint256) { return length(map._inner); } /** * @dev Returns the element 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(UintToUintMap storage map, uint256 index) internal view returns (uint256, uint256) { (bytes32 key, bytes32 value) = at(map._inner, index); return (uint256(key), uint256(value)); } /** * @dev Tries to returns the value associated with `key`. O(1). * Does not revert if `key` is not in the map. */ function tryGet(UintToUintMap storage map, uint256 key) internal view returns (bool, uint256) { (bool success, bytes32 value) = tryGet(map._inner, bytes32(key)); return (success, uint256(value)); } /** * @dev Returns the value associated with `key`. O(1). * * Requirements: * * - `key` must be in the map. */ function get(UintToUintMap storage map, uint256 key) internal view returns (uint256) { return uint256(get(map._inner, bytes32(key))); } /** * @dev Same as {get}, with a custom error message when `key` is not in the map. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryGet}. */ function get( UintToUintMap storage map, uint256 key, string memory errorMessage ) internal view returns (uint256) { return uint256(get(map._inner, bytes32(key), errorMessage)); } // UintToAddressMap struct UintToAddressMap { Bytes32ToBytes32Map _inner; } /** * @dev Adds a key-value pair to a map, or updates the value for an existing * key. O(1). * * Returns true if the key was added to the map, that is if it was not * already present. */ function set( UintToAddressMap storage map, uint256 key, address value ) internal returns (bool) { return set(map._inner, bytes32(key), bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the key was removed from the map, that is if it was present. */ function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) { return remove(map._inner, bytes32(key)); } /** * @dev Returns true if the key is in the map. O(1). */ function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) { return contains(map._inner, bytes32(key)); } /** * @dev Returns the number of elements in the map. O(1). */ function length(UintToAddressMap storage map) internal view returns (uint256) { return length(map._inner); } /** * @dev Returns the element 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(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) { (bytes32 key, bytes32 value) = at(map._inner, index); return (uint256(key), address(uint160(uint256(value)))); } /** * @dev Tries to returns the value associated with `key`. O(1). * Does not revert if `key` is not in the map. */ function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) { (bool success, bytes32 value) = tryGet(map._inner, bytes32(key)); return (success, address(uint160(uint256(value)))); } /** * @dev Returns the value associated with `key`. O(1). * * Requirements: * * - `key` must be in the map. */ function get(UintToAddressMap storage map, uint256 key) internal view returns (address) { return address(uint160(uint256(get(map._inner, bytes32(key))))); } /** * @dev Same as {get}, with a custom error message when `key` is not in the map. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryGet}. */ function get( UintToAddressMap storage map, uint256 key, string memory errorMessage ) internal view returns (address) { return address(uint160(uint256(get(map._inner, bytes32(key), errorMessage)))); } // AddressToUintMap struct AddressToUintMap { Bytes32ToBytes32Map _inner; } /** * @dev Adds a key-value pair to a map, or updates the value for an existing * key. O(1). * * Returns true if the key was added to the map, that is if it was not * already present. */ function set( AddressToUintMap storage map, address key, uint256 value ) internal returns (bool) { return set(map._inner, bytes32(uint256(uint160(key))), bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the key was removed from the map, that is if it was present. */ function remove(AddressToUintMap storage map, address key) internal returns (bool) { return remove(map._inner, bytes32(uint256(uint160(key)))); } /** * @dev Returns true if the key is in the map. O(1). */ function contains(AddressToUintMap storage map, address key) internal view returns (bool) { return contains(map._inner, bytes32(uint256(uint160(key)))); } /** * @dev Returns the number of elements in the map. O(1). */ function length(AddressToUintMap storage map) internal view returns (uint256) { return length(map._inner); } /** * @dev Returns the element 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(AddressToUintMap storage map, uint256 index) internal view returns (address, uint256) { (bytes32 key, bytes32 value) = at(map._inner, index); return (address(uint160(uint256(key))), uint256(value)); } /** * @dev Tries to returns the value associated with `key`. O(1). * Does not revert if `key` is not in the map. */ function tryGet(AddressToUintMap storage map, address key) internal view returns (bool, uint256) { (bool success, bytes32 value) = tryGet(map._inner, bytes32(uint256(uint160(key)))); return (success, uint256(value)); } /** * @dev Returns the value associated with `key`. O(1). * * Requirements: * * - `key` must be in the map. */ function get(AddressToUintMap storage map, address key) internal view returns (uint256) { return uint256(get(map._inner, bytes32(uint256(uint160(key))))); } /** * @dev Same as {get}, with a custom error message when `key` is not in the map. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryGet}. */ function get( AddressToUintMap storage map, address key, string memory errorMessage ) internal view returns (uint256) { return uint256(get(map._inner, bytes32(uint256(uint160(key))), errorMessage)); } // Bytes32ToUintMap struct Bytes32ToUintMap { Bytes32ToBytes32Map _inner; } /** * @dev Adds a key-value pair to a map, or updates the value for an existing * key. O(1). * * Returns true if the key was added to the map, that is if it was not * already present. */ function set( Bytes32ToUintMap storage map, bytes32 key, uint256 value ) internal returns (bool) { return set(map._inner, key, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the key was removed from the map, that is if it was present. */ function remove(Bytes32ToUintMap storage map, bytes32 key) internal returns (bool) { return remove(map._inner, key); } /** * @dev Returns true if the key is in the map. O(1). */ function contains(Bytes32ToUintMap storage map, bytes32 key) internal view returns (bool) { return contains(map._inner, key); } /** * @dev Returns the number of elements in the map. O(1). */ function length(Bytes32ToUintMap storage map) internal view returns (uint256) { return length(map._inner); } /** * @dev Returns the element 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(Bytes32ToUintMap storage map, uint256 index) internal view returns (bytes32, uint256) { (bytes32 key, bytes32 value) = at(map._inner, index); return (key, uint256(value)); } /** * @dev Tries to returns the value associated with `key`. O(1). * Does not revert if `key` is not in the map. */ function tryGet(Bytes32ToUintMap storage map, bytes32 key) internal view returns (bool, uint256) { (bool success, bytes32 value) = tryGet(map._inner, key); return (success, uint256(value)); } /** * @dev Returns the value associated with `key`. O(1). * * Requirements: * * - `key` must be in the map. */ function get(Bytes32ToUintMap storage map, bytes32 key) internal view returns (uint256) { return uint256(get(map._inner, key)); } /** * @dev Same as {get}, with a custom error message when `key` is not in the map. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryGet}. */ function get( Bytes32ToUintMap storage map, bytes32 key, string memory errorMessage ) internal view returns (uint256) { return uint256(get(map._inner, key, errorMessage)); } } // File: @openzeppelin/contracts/token/ERC20/IERC20.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `from` to `to` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 amount ) external returns (bool); } // File: @openzeppelin/contracts/interfaces/IERC20.sol // OpenZeppelin Contracts v4.4.1 (interfaces/IERC20.sol) pragma solidity ^0.8.0; // File: @openzeppelin/contracts/utils/introspection/IERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: @openzeppelin/contracts/token/ERC721/IERC721.sol // OpenZeppelin Contracts (last updated v4.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/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/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/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: @chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol pragma solidity ^0.8.4; /** **************************************************************************** * @notice Interface for contracts using VRF randomness * ***************************************************************************** * @dev PURPOSE * * @dev Reggie the Random Oracle (not his real job) wants to provide randomness * @dev to Vera the verifier in such a way that Vera can be sure he's not * @dev making his output up to suit himself. Reggie provides Vera a public key * @dev to which he knows the secret key. Each time Vera provides a seed to * @dev Reggie, he gives back a value which is computed completely * @dev deterministically from the seed and the secret key. * * @dev Reggie provides a proof by which Vera can verify that the output was * @dev correctly computed once Reggie tells it to her, but without that proof, * @dev the output is indistinguishable to her from a uniform random sample * @dev from the output space. * * @dev The purpose of this contract is to make it easy for unrelated contracts * @dev to talk to Vera the verifier about the work Reggie is doing, to provide * @dev simple access to a verifiable source of randomness. It ensures 2 things: * @dev 1. The fulfillment came from the VRFCoordinator * @dev 2. The consumer contract implements fulfillRandomWords. * ***************************************************************************** * @dev USAGE * * @dev Calling contracts must inherit from VRFConsumerBase, and can * @dev initialize VRFConsumerBase's attributes in their constructor as * @dev shown: * * @dev contract VRFConsumer { * @dev constructor(<other arguments>, address _vrfCoordinator, address _link) * @dev VRFConsumerBase(_vrfCoordinator) public { * @dev <initialization with other arguments goes here> * @dev } * @dev } * * @dev The oracle will have given you an ID for the VRF keypair they have * @dev committed to (let's call it keyHash). Create subscription, fund it * @dev and your consumer contract as a consumer of it (see VRFCoordinatorInterface * @dev subscription management functions). * @dev Call requestRandomWords(keyHash, subId, minimumRequestConfirmations, * @dev callbackGasLimit, numWords), * @dev see (VRFCoordinatorInterface for a description of the arguments). * * @dev Once the VRFCoordinator has received and validated the oracle's response * @dev to your request, it will call your contract's fulfillRandomWords method. * * @dev The randomness argument to fulfillRandomWords is a set of random words * @dev generated from your requestId and the blockHash of the request. * * @dev If your contract could have concurrent requests open, you can use the * @dev requestId returned from requestRandomWords to track which response is associated * @dev with which randomness request. * @dev See "SECURITY CONSIDERATIONS" for principles to keep in mind, * @dev if your contract could have multiple requests in flight simultaneously. * * @dev Colliding `requestId`s are cryptographically impossible as long as seeds * @dev differ. * * ***************************************************************************** * @dev SECURITY CONSIDERATIONS * * @dev A method with the ability to call your fulfillRandomness method directly * @dev could spoof a VRF response with any random value, so it's critical that * @dev it cannot be directly called by anything other than this base contract * @dev (specifically, by the VRFConsumerBase.rawFulfillRandomness method). * * @dev For your users to trust that your contract's random behavior is free * @dev from malicious interference, it's best if you can write it so that all * @dev behaviors implied by a VRF response are executed *during* your * @dev fulfillRandomness method. If your contract must store the response (or * @dev anything derived from it) and use it later, you must ensure that any * @dev user-significant behavior which depends on that stored value cannot be * @dev manipulated by a subsequent VRF request. * * @dev Similarly, both miners and the VRF oracle itself have some influence * @dev over the order in which VRF responses appear on the blockchain, so if * @dev your contract could have multiple VRF requests in flight simultaneously, * @dev you must ensure that the order in which the VRF responses arrive cannot * @dev be used to manipulate your contract's user-significant behavior. * * @dev Since the block hash of the block which contains the requestRandomness * @dev call is mixed into the input to the VRF *last*, a sufficiently powerful * @dev miner could, in principle, fork the blockchain to evict the block * @dev containing the request, forcing the request to be included in a * @dev different block with a different hash, and therefore a different input * @dev to the VRF. However, such an attack would incur a substantial economic * @dev cost. This cost scales with the number of blocks the VRF oracle waits * @dev until it calls responds to a request. It is for this reason that * @dev that you can signal to an oracle you'd like them to wait longer before * @dev responding to the request (however this is not enforced in the contract * @dev and so remains effective only in the case of unmodified oracle software). */ abstract contract VRFConsumerBaseV2 { error OnlyCoordinatorCanFulfill(address have, address want); address private immutable vrfCoordinator; /** * @param _vrfCoordinator address of VRFCoordinator contract */ constructor(address _vrfCoordinator) { vrfCoordinator = _vrfCoordinator; } /** * @notice fulfillRandomness handles the VRF response. Your contract must * @notice implement it. See "SECURITY CONSIDERATIONS" above for important * @notice principles to keep in mind when implementing your fulfillRandomness * @notice method. * * @dev VRFConsumerBaseV2 expects its subcontracts to have a method with this * @dev signature, and will call it once it has verified the proof * @dev associated with the randomness. (It is triggered via a call to * @dev rawFulfillRandomness, below.) * * @param requestId The Id initially returned by requestRandomness * @param randomWords the VRF output expanded to the requested number of words */ function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) internal virtual; // rawFulfillRandomness is called by VRFCoordinator when it receives a valid VRF // proof. rawFulfillRandomness then calls fulfillRandomness, after validating // the origin of the call function rawFulfillRandomWords(uint256 requestId, uint256[] memory randomWords) external { if (msg.sender != vrfCoordinator) { revert OnlyCoordinatorCanFulfill(msg.sender, vrfCoordinator); } fulfillRandomWords(requestId, randomWords); } } // File: @chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol pragma solidity ^0.8.0; interface VRFCoordinatorV2Interface { /** * @notice Get configuration relevant for making requests * @return minimumRequestConfirmations global min for request confirmations * @return maxGasLimit global max for request gas limit * @return s_provingKeyHashes list of registered key hashes */ function getRequestConfig() external view returns ( uint16, uint32, bytes32[] memory ); /** * @notice Request a set of random words. * @param keyHash - Corresponds to a particular oracle job which uses * that key for generating the VRF proof. Different keyHash's have different gas price * ceilings, so you can select a specific one to bound your maximum per request cost. * @param subId - The ID of the VRF subscription. Must be funded * with the minimum subscription balance required for the selected keyHash. * @param minimumRequestConfirmations - How many blocks you'd like the * oracle to wait before responding to the request. See SECURITY CONSIDERATIONS * for why you may want to request more. The acceptable range is * [minimumRequestBlockConfirmations, 200]. * @param callbackGasLimit - How much gas you'd like to receive in your * fulfillRandomWords callback. Note that gasleft() inside fulfillRandomWords * may be slightly less than this amount because of gas used calling the function * (argument decoding etc.), so you may need to request slightly more than you expect * to have inside fulfillRandomWords. The acceptable range is * [0, maxGasLimit] * @param numWords - The number of uint256 random values you'd like to receive * in your fulfillRandomWords callback. Note these numbers are expanded in a * secure way by the VRFCoordinator from a single random value supplied by the oracle. * @return requestId - A unique identifier of the request. Can be used to match * a request to a response in fulfillRandomWords. */ function requestRandomWords( bytes32 keyHash, uint64 subId, uint16 minimumRequestConfirmations, uint32 callbackGasLimit, uint32 numWords ) external returns (uint256 requestId); /** * @notice Create a VRF subscription. * @return subId - A unique subscription id. * @dev You can manage the consumer set dynamically with addConsumer/removeConsumer. * @dev Note to fund the subscription, use transferAndCall. For example * @dev LINKTOKEN.transferAndCall( * @dev address(COORDINATOR), * @dev amount, * @dev abi.encode(subId)); */ function createSubscription() external returns (uint64 subId); /** * @notice Get a VRF subscription. * @param subId - ID of the subscription * @return balance - LINK balance of the subscription in juels. * @return reqCount - number of requests for this subscription, determines fee tier. * @return owner - owner of the subscription. * @return consumers - list of consumer address which are able to use this subscription. */ function getSubscription(uint64 subId) external view returns ( uint96 balance, uint64 reqCount, address owner, address[] memory consumers ); /** * @notice Request subscription owner transfer. * @param subId - ID of the subscription * @param newOwner - proposed new owner of the subscription */ function requestSubscriptionOwnerTransfer(uint64 subId, address newOwner) external; /** * @notice Request subscription owner transfer. * @param subId - ID of the subscription * @dev will revert if original owner of subId has * not requested that msg.sender become the new owner. */ function acceptSubscriptionOwnerTransfer(uint64 subId) external; /** * @notice Add a consumer to a VRF subscription. * @param subId - ID of the subscription * @param consumer - New consumer which can use the subscription */ function addConsumer(uint64 subId, address consumer) external; /** * @notice Remove a consumer from a VRF subscription. * @param subId - ID of the subscription * @param consumer - Consumer to remove from the subscription */ function removeConsumer(uint64 subId, address consumer) external; /** * @notice Cancel a subscription * @param subId - ID of the subscription * @param to - Where to send the remaining LINK to */ function cancelSubscription(uint64 subId, address to) external; /* * @notice Check to see if there exists a request commitment consumers * for all consumers and keyhashes for a given sub. * @param subId - ID of the subscription * @return true if there exists at least one unfulfilled request for the subscription, false * otherwise. */ function pendingRequestExists(uint64 subId) external view returns (bool); } // File: @chainlink/contracts/src/v0.8/interfaces/LinkTokenInterface.sol pragma solidity ^0.8.0; interface LinkTokenInterface { function allowance(address owner, address spender) external view returns (uint256 remaining); function approve(address spender, uint256 value) external returns (bool success); function balanceOf(address owner) external view returns (uint256 balance); function decimals() external view returns (uint8 decimalPlaces); function decreaseApproval(address spender, uint256 addedValue) external returns (bool success); function increaseApproval(address spender, uint256 subtractedValue) external; function name() external view returns (string memory tokenName); function symbol() external view returns (string memory tokenSymbol); function totalSupply() external view returns (uint256 totalTokensIssued); function transfer(address to, uint256 value) external returns (bool success); function transferAndCall( address to, uint256 value, bytes calldata data ) external returns (bool success); function transferFrom( address from, address to, uint256 value ) external returns (bool success); } // 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/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: @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/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/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: contracts/HypeLuckyBag.sol pragma solidity ^0.8.17; //@author PZ //@title HypeLuckyBag contract HypeLuckyBag is Ownable, VRFConsumerBaseV2, ReentrancyGuard { using SafeMath for uint256; using EnumerableSet for EnumerableSet.UintSet; using EnumerableMap for EnumerableMap.UintToUintMap; uint256 private bagsCount; IERC721 immutable HYPE_SAINTS; //IERC20 immutable GMT; VRFCoordinatorV2Interface immutable COORDINATOR; LinkTokenInterface immutable LINKTOKEN; mapping(uint256=>uint256) luckyReward; EnumerableSet.UintSet private nftSet; mapping(uint256=>uint256) requestIdNFT; mapping(uint256=>address) requestIdAddress; uint256[] public LUCKY_BAG; struct RequestConfig { bytes32 keyHash; uint64 subId; uint32 callbackGasLimit; uint16 requestConfirmations; } RequestConfig public requestConfig; event NftRequestId(uint256 indexed requestId,uint256 indexed nftId, address indexed sender); event LuckyBag(address indexed sender,uint256 indexed nftId,uint256 indexed reward); constructor(address _hypeSaints, address _VRFCoordinator, address _LINKToken, bytes32 _keyHash, uint64 _subId) VRFConsumerBaseV2(_VRFCoordinator) { HYPE_SAINTS = IERC721(_hypeSaints); COORDINATOR = VRFCoordinatorV2Interface(_VRFCoordinator); LINKTOKEN = LinkTokenInterface(_LINKToken); requestConfig = RequestConfig({ keyHash: _keyHash, subId: _subId, callbackGasLimit: 2500000, requestConfirmations: 3 }); LUCKY_BAG = [50,50,50,50,50,50,50,50,50,50,100,100,100,100,100,100,100,100,100,100,150,150,150,150,150,150,150,150,150,150,200,200,200]; } // chainlink config setters function setSubId(uint64 _subId) external onlyOwner { requestConfig.subId = _subId; } function setCallbackGasLimit(uint32 _callbackGasLimit) external onlyOwner { requestConfig.callbackGasLimit = _callbackGasLimit; } function setRequestConfirmations(uint16 _requestConfirmations) external onlyOwner { requestConfig.requestConfirmations = _requestConfirmations; } function setKeyHash(bytes32 _keyHash) external onlyOwner { requestConfig.keyHash = _keyHash; } function openLuckyBag(uint256 _tokenId) external nonReentrant returns (uint256) { require(nftSet.contains(_tokenId),"This NFT is not lucky"); require(luckyReward[_tokenId]==0,"This LuckyBag has been opened!"); require(msg.sender == HYPE_SAINTS.ownerOf(_tokenId),"you do not have this HypeSaints!"); RequestConfig memory rc = requestConfig; uint256 requestId = COORDINATOR.requestRandomWords(rc.keyHash, rc.subId, rc.requestConfirmations, rc.callbackGasLimit, 1); requestIdAddress[requestId] = msg.sender; requestIdNFT[requestId] = _tokenId; emit NftRequestId(requestId,_tokenId,msg.sender); return requestId; } // VRF callback function function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) internal override { uint256 bagId = randomWords[0]%LUCKY_BAG.length; address holder = requestIdAddress[requestId]; uint256 nftId = requestIdNFT[requestId]; uint256 reward = LUCKY_BAG[bagId]; luckyReward[nftId] = reward; removeBag(bagId); emit LuckyBag(holder,nftId,reward); } //add lucky nft ids function addLuckyNFT(uint256[] memory nftIds) external onlyOwner { for(uint256 i = 0; i < nftIds.length; i++) { nftSet.add(nftIds[i]); luckyReward[nftIds[i]] = 0; } } //show lucky NFT ids function getLuckyNFT() public view returns (uint256[] memory) { return nftSet.values(); } function getReward(uint256 _tokenId) public view returns (uint256) { return luckyReward[_tokenId]; } function getLuckyBags() public view returns(uint256[] memory) { return LUCKY_BAG; } function removeBag(uint256 index) private { LUCKY_BAG[index] = LUCKY_BAG[LUCKY_BAG.length - 1]; LUCKY_BAG.pop(); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_hypeSaints","type":"address"},{"internalType":"address","name":"_VRFCoordinator","type":"address"},{"internalType":"address","name":"_LINKToken","type":"address"},{"internalType":"bytes32","name":"_keyHash","type":"bytes32"},{"internalType":"uint64","name":"_subId","type":"uint64"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"have","type":"address"},{"internalType":"address","name":"want","type":"address"}],"name":"OnlyCoordinatorCanFulfill","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"uint256","name":"nftId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"LuckyBag","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"requestId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"nftId","type":"uint256"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"NftRequestId","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"LUCKY_BAG","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"nftIds","type":"uint256[]"}],"name":"addLuckyNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getLuckyBags","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLuckyNFT","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"getReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"openLuckyBag","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"requestId","type":"uint256"},{"internalType":"uint256[]","name":"randomWords","type":"uint256[]"}],"name":"rawFulfillRandomWords","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"requestConfig","outputs":[{"internalType":"bytes32","name":"keyHash","type":"bytes32"},{"internalType":"uint64","name":"subId","type":"uint64"},{"internalType":"uint32","name":"callbackGasLimit","type":"uint32"},{"internalType":"uint16","name":"requestConfirmations","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"_callbackGasLimit","type":"uint32"}],"name":"setCallbackGasLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_keyHash","type":"bytes32"}],"name":"setKeyHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"_requestConfirmations","type":"uint16"}],"name":"setRequestConfirmations","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"_subId","type":"uint64"}],"name":"setSubId","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000004af790223169a8621095871375f79425725d22c9000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909000000000000000000000000514910771af9ca656af840dff83e8264ecf986ca8af398995b04c28e9951adb9721ef74c74f93e6a478f39e7e0777be13527e7ef0000000000000000000000000000000000000000000000000000000000000251
-----Decoded View---------------
Arg [0] : _hypeSaints (address): 0x4aF790223169a8621095871375f79425725d22C9
Arg [1] : _VRFCoordinator (address): 0x271682DEB8C4E0901D1a1550aD2e64D568E69909
Arg [2] : _LINKToken (address): 0x514910771AF9Ca656af840dff83E8264EcF986CA
Arg [3] : _keyHash (bytes32): 0x8af398995b04c28e9951adb9721ef74c74f93e6a478f39e7e0777be13527e7ef
Arg [4] : _subId (uint64): 593
-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000004af790223169a8621095871375f79425725d22c9
Arg [1] : 000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909
Arg [2] : 000000000000000000000000514910771af9ca656af840dff83e8264ecf986ca
Arg [3] : 8af398995b04c28e9951adb9721ef74c74f93e6a478f39e7e0777be13527e7ef
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000251
Deployed Bytecode Sourcemap
81638:4563:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83996:946;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;85830:114;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53364:261;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;83455:99;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;85458:215;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;82459:34;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;70891:103;;;:::i;:::-;;83713:159;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;70243:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;83880:108;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;82268:26;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;83562:143;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;85952:97;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71149:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;85709:113;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;83996:946;84067:7;73520:1;74118:7;;:19;74110:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;73520:1;74251:7;:18;;;;84097:25:::1;84113:8;84097:6;:15;;:25;;;;:::i;:::-;84089:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;84189:1;84166:11;:21;84178:8;84166:21;;;;;;;;;;;;:24;84158:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;84257:11;:19;;;84277:8;84257:29;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;84243:43;;:10;:43;;;84235:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;84335:23;84361:13;84335:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;84385:17;84405:11;:30;;;84436:2;:10;;;84508:2;:8;;;84578:2;:23;;;84663:2;:19;;;84744:1;84405:341;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;84385:361;;84789:10;84759:16;:27;84776:9;84759:27;;;;;;;;;;;;:40;;;;;;;;;;;;;;;;;;84836:8;84810:12;:23;84823:9;84810:23;;;;;;;;;;;:34;;;;84892:10;84860:43;;84883:8;84873:9;84860:43;;;;;;;;;;84923:9;84916:16;;;;73476:1:::0;74430:7;:22;;;;83996:946;;;:::o;85830:114::-;85888:7;85915:11;:21;85927:8;85915:21;;;;;;;;;;;;85908:28;;85830:114;;;:::o;53364:261::-;53478:14;53464:28;;:10;:28;;;53460:111;;53536:10;53548:14;53510:53;;;;;;;;;;;;:::i;:::-;;;;;;;;53460:111;53577:42;53596:9;53607:11;53577:18;:42::i;:::-;53364:261;;:::o;83455:99::-;70129:13;:11;:13::i;:::-;83540:6:::1;83518:13;:19;;;:28;;;;;;;;;;;;;;;;;;83455:99:::0;:::o;85458:215::-;70129:13;:11;:13::i;:::-;85538:9:::1;85534:132;85557:6;:13;85553:1;:17;85534:132;;;85592:21;85603:6;85610:1;85603:9;;;;;;;;:::i;:::-;;;;;;;;85592:6;:10;;:21;;;;:::i;:::-;;85653:1;85628:11;:22;85640:6;85647:1;85640:9;;;;;;;;:::i;:::-;;;;;;;;85628:22;;;;;;;;;;;:26;;;;85572:3;;;;;:::i;:::-;;;;85534:132;;;;85458:215:::0;:::o;82459:34::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;70891:103::-;70129:13;:11;:13::i;:::-;70956:30:::1;70983:1;70956:18;:30::i;:::-;70891:103::o:0;83713:159::-;70129:13;:11;:13::i;:::-;83843:21:::1;83806:13;:34;;;:58;;;;;;;;;;;;;;;;;;83713:159:::0;:::o;70243:87::-;70289:7;70316:6;;;;;;;;;;;70309:13;;70243:87;:::o;83880:108::-;70129:13;:11;:13::i;:::-;83972:8:::1;83948:13;:21;;:32;;;;83880:108:::0;:::o;82268:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;83562:143::-;70129:13;:11;:13::i;:::-;83680:17:::1;83647:13;:30;;;:50;;;;;;;;;;;;;;;;;;83562:143:::0;:::o;85952:97::-;85996:16;86032:9;86025:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85952:97;:::o;71149:201::-;70129:13;:11;:13::i;:::-;71258:1:::1;71238:22;;:8;:22;;::::0;71230:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;71314:28;71333:8;71314:18;:28::i;:::-;71149:201:::0;:::o;85709:113::-;85753:16;85789:15;:6;:13;:15::i;:::-;85782:22;;85709:113;:::o;11388:146::-;11465:4;11489:37;11499:3;:10;;11519:5;11511:14;;11489:9;:37::i;:::-;11482:44;;11388:146;;;;:::o;84982:439::-;85088:13;85119:9;:16;;;;85104:11;85116:1;85104:14;;;;;;;;:::i;:::-;;;;;;;;:31;;;;:::i;:::-;85088:47;;85148:14;85165:16;:27;85182:9;85165:27;;;;;;;;;;;;;;;;;;;;;85148:44;;85205:13;85221:12;:23;85234:9;85221:23;;;;;;;;;;;;85205:39;;85257:14;85274:9;85284:5;85274:16;;;;;;;;:::i;:::-;;;;;;;;;;85257:33;;85324:6;85303:11;:18;85315:5;85303:18;;;;;;;;;;;:27;;;;85343:16;85353:5;85343:9;:16::i;:::-;85406:6;85400:5;85393:6;85384:29;;;;;;;;;;;;85077:344;;;;84982:439;;:::o;70408:132::-;70483:12;:10;:12::i;:::-;70472:23;;:7;:5;:7::i;:::-;:23;;;70464:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70408:132::o;10858:131::-;10925:4;10949:32;10954:3;:10;;10974:5;10966:14;;10949:4;:32::i;:::-;10942:39;;10858:131;;;;:::o;71510:191::-;71584:16;71603:6;;;;;;;;;;;71584:25;;71629:8;71620:6;;:17;;;;;;;;;;;;;;;;;;71684:8;71653:40;;71674:8;71653:40;;;;;;;;;;;;71573:128;71510:191;:::o;12775:307::-;12835:16;12864:22;12889:19;12897:3;:10;;12889:7;:19::i;:::-;12864:44;;12919:23;13033:5;13023:15;;13068:6;13061:13;;;;12775:307;;;:::o;4307:129::-;4380:4;4427:1;4404:3;:12;;:19;4417:5;4404:19;;;;;;;;;;;;:24;;4397:31;;4307:129;;;;:::o;86057:137::-;86129:9;86158:1;86139:9;:16;;;;:20;;;;:::i;:::-;86129:31;;;;;;;;:::i;:::-;;;;;;;;;;86110:9;86120:5;86110:16;;;;;;;;:::i;:::-;;;;;;;;;:50;;;;86171:9;:15;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;86057:137;:::o;60535:98::-;60588:7;60615:10;60608:17;;60535:98;:::o;2211:414::-;2274:4;2296:21;2306:3;2311:5;2296:9;:21::i;:::-;2291:327;;2334:3;:11;;2351:5;2334:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2517:3;:11;;:18;;;;2495:3;:12;;:19;2508:5;2495:19;;;;;;;;;;;:40;;;;2557:4;2550:11;;;;2291:327;2601:5;2594:12;;2211:414;;;;;:::o;5655:111::-;5711:16;5747:3;:11;;5740:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5655:111;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:77;371:7;400:5;389:16;;334:77;;;:::o;417:122::-;490:24;508:5;490:24;:::i;:::-;483:5;480:35;470:63;;529:1;526;519:12;470:63;417:122;:::o;545:139::-;591:5;629:6;616:20;607:29;;645:33;672:5;645:33;:::i;:::-;545:139;;;;:::o;690:329::-;749:6;798:2;786:9;777:7;773:23;769:32;766:119;;;804:79;;:::i;:::-;766:119;924:1;949:53;994:7;985:6;974:9;970:22;949:53;:::i;:::-;939:63;;895:117;690:329;;;;:::o;1025:118::-;1112:24;1130:5;1112:24;:::i;:::-;1107:3;1100:37;1025:118;;:::o;1149:222::-;1242:4;1280:2;1269:9;1265:18;1257:26;;1293:71;1361:1;1350:9;1346:17;1337:6;1293:71;:::i;:::-;1149:222;;;;:::o;1377:117::-;1486:1;1483;1476:12;1500:102;1541:6;1592:2;1588:7;1583:2;1576:5;1572:14;1568:28;1558:38;;1500:102;;;:::o;1608:180::-;1656:77;1653:1;1646:88;1753:4;1750:1;1743:15;1777:4;1774:1;1767:15;1794:281;1877:27;1899:4;1877:27;:::i;:::-;1869:6;1865:40;2007:6;1995:10;1992:22;1971:18;1959:10;1956:34;1953:62;1950:88;;;2018:18;;:::i;:::-;1950:88;2058:10;2054:2;2047:22;1837:238;1794:281;;:::o;2081:129::-;2115:6;2142:20;;:::i;:::-;2132:30;;2171:33;2199:4;2191:6;2171:33;:::i;:::-;2081:129;;;:::o;2216:311::-;2293:4;2383:18;2375:6;2372:30;2369:56;;;2405:18;;:::i;:::-;2369:56;2455:4;2447:6;2443:17;2435:25;;2515:4;2509;2505:15;2497:23;;2216:311;;;:::o;2533:117::-;2642:1;2639;2632:12;2673:710;2769:5;2794:81;2810:64;2867:6;2810:64;:::i;:::-;2794:81;:::i;:::-;2785:90;;2895:5;2924:6;2917:5;2910:21;2958:4;2951:5;2947:16;2940:23;;3011:4;3003:6;2999:17;2991:6;2987:30;3040:3;3032:6;3029:15;3026:122;;;3059:79;;:::i;:::-;3026:122;3174:6;3157:220;3191:6;3186:3;3183:15;3157:220;;;3266:3;3295:37;3328:3;3316:10;3295:37;:::i;:::-;3290:3;3283:50;3362:4;3357:3;3353:14;3346:21;;3233:144;3217:4;3212:3;3208:14;3201:21;;3157:220;;;3161:21;2775:608;;2673:710;;;;;:::o;3406:370::-;3477:5;3526:3;3519:4;3511:6;3507:17;3503:27;3493:122;;3534:79;;:::i;:::-;3493:122;3651:6;3638:20;3676:94;3766:3;3758:6;3751:4;3743:6;3739:17;3676:94;:::i;:::-;3667:103;;3483:293;3406:370;;;;:::o;3782:684::-;3875:6;3883;3932:2;3920:9;3911:7;3907:23;3903:32;3900:119;;;3938:79;;:::i;:::-;3900:119;4058:1;4083:53;4128:7;4119:6;4108:9;4104:22;4083:53;:::i;:::-;4073:63;;4029:117;4213:2;4202:9;4198:18;4185:32;4244:18;4236:6;4233:30;4230:117;;;4266:79;;:::i;:::-;4230:117;4371:78;4441:7;4432:6;4421:9;4417:22;4371:78;:::i;:::-;4361:88;;4156:303;3782:684;;;;;:::o;4472:101::-;4508:7;4548:18;4541:5;4537:30;4526:41;;4472:101;;;:::o;4579:120::-;4651:23;4668:5;4651:23;:::i;:::-;4644:5;4641:34;4631:62;;4689:1;4686;4679:12;4631:62;4579:120;:::o;4705:137::-;4750:5;4788:6;4775:20;4766:29;;4804:32;4830:5;4804:32;:::i;:::-;4705:137;;;;:::o;4848:327::-;4906:6;4955:2;4943:9;4934:7;4930:23;4926:32;4923:119;;;4961:79;;:::i;:::-;4923:119;5081:1;5106:52;5150:7;5141:6;5130:9;5126:22;5106:52;:::i;:::-;5096:62;;5052:116;4848:327;;;;:::o;5181:539::-;5265:6;5314:2;5302:9;5293:7;5289:23;5285:32;5282:119;;;5320:79;;:::i;:::-;5282:119;5468:1;5457:9;5453:17;5440:31;5498:18;5490:6;5487:30;5484:117;;;5520:79;;:::i;:::-;5484:117;5625:78;5695:7;5686:6;5675:9;5671:22;5625:78;:::i;:::-;5615:88;;5411:302;5181:539;;;;:::o;5726:77::-;5763:7;5792:5;5781:16;;5726:77;;;:::o;5809:118::-;5896:24;5914:5;5896:24;:::i;:::-;5891:3;5884:37;5809:118;;:::o;5933:115::-;6018:23;6035:5;6018:23;:::i;:::-;6013:3;6006:36;5933:115;;:::o;6054:93::-;6090:7;6130:10;6123:5;6119:22;6108:33;;6054:93;;;:::o;6153:115::-;6238:23;6255:5;6238:23;:::i;:::-;6233:3;6226:36;6153:115;;:::o;6274:89::-;6310:7;6350:6;6343:5;6339:18;6328:29;;6274:89;;;:::o;6369:115::-;6454:23;6471:5;6454:23;:::i;:::-;6449:3;6442:36;6369:115;;:::o;6490:541::-;6661:4;6699:3;6688:9;6684:19;6676:27;;6713:71;6781:1;6770:9;6766:17;6757:6;6713:71;:::i;:::-;6794:70;6860:2;6849:9;6845:18;6836:6;6794:70;:::i;:::-;6874;6940:2;6929:9;6925:18;6916:6;6874:70;:::i;:::-;6954;7020:2;7009:9;7005:18;6996:6;6954:70;:::i;:::-;6490:541;;;;;;;:::o;7037:120::-;7109:23;7126:5;7109:23;:::i;:::-;7102:5;7099:34;7089:62;;7147:1;7144;7137:12;7089:62;7037:120;:::o;7163:137::-;7208:5;7246:6;7233:20;7224:29;;7262:32;7288:5;7262:32;:::i;:::-;7163:137;;;;:::o;7306:327::-;7364:6;7413:2;7401:9;7392:7;7388:23;7384:32;7381:119;;;7419:79;;:::i;:::-;7381:119;7539:1;7564:52;7608:7;7599:6;7588:9;7584:22;7564:52;:::i;:::-;7554:62;;7510:116;7306:327;;;;:::o;7639:126::-;7676:7;7716:42;7709:5;7705:54;7694:65;;7639:126;;;:::o;7771:96::-;7808:7;7837:24;7855:5;7837:24;:::i;:::-;7826:35;;7771:96;;;:::o;7873:118::-;7960:24;7978:5;7960:24;:::i;:::-;7955:3;7948:37;7873:118;;:::o;7997:222::-;8090:4;8128:2;8117:9;8113:18;8105:26;;8141:71;8209:1;8198:9;8194:17;8185:6;8141:71;:::i;:::-;7997:222;;;;:::o;8225:122::-;8298:24;8316:5;8298:24;:::i;:::-;8291:5;8288:35;8278:63;;8337:1;8334;8327:12;8278:63;8225:122;:::o;8353:139::-;8399:5;8437:6;8424:20;8415:29;;8453:33;8480:5;8453:33;:::i;:::-;8353:139;;;;:::o;8498:329::-;8557:6;8606:2;8594:9;8585:7;8581:23;8577:32;8574:119;;;8612:79;;:::i;:::-;8574:119;8732:1;8757:53;8802:7;8793:6;8782:9;8778:22;8757:53;:::i;:::-;8747:63;;8703:117;8498:329;;;;:::o;8833:120::-;8905:23;8922:5;8905:23;:::i;:::-;8898:5;8895:34;8885:62;;8943:1;8940;8933:12;8885:62;8833:120;:::o;8959:137::-;9004:5;9042:6;9029:20;9020:29;;9058:32;9084:5;9058:32;:::i;:::-;8959:137;;;;:::o;9102:327::-;9160:6;9209:2;9197:9;9188:7;9184:23;9180:32;9177:119;;;9215:79;;:::i;:::-;9177:119;9335:1;9360:52;9404:7;9395:6;9384:9;9380:22;9360:52;:::i;:::-;9350:62;;9306:116;9102:327;;;;:::o;9435:114::-;9502:6;9536:5;9530:12;9520:22;;9435:114;;;:::o;9555:184::-;9654:11;9688:6;9683:3;9676:19;9728:4;9723:3;9719:14;9704:29;;9555:184;;;;:::o;9745:132::-;9812:4;9835:3;9827:11;;9865:4;9860:3;9856:14;9848:22;;9745:132;;;:::o;9883:108::-;9960:24;9978:5;9960:24;:::i;:::-;9955:3;9948:37;9883:108;;:::o;9997:179::-;10066:10;10087:46;10129:3;10121:6;10087:46;:::i;:::-;10165:4;10160:3;10156:14;10142:28;;9997:179;;;;:::o;10182:113::-;10252:4;10284;10279:3;10275:14;10267:22;;10182:113;;;:::o;10331:732::-;10450:3;10479:54;10527:5;10479:54;:::i;:::-;10549:86;10628:6;10623:3;10549:86;:::i;:::-;10542:93;;10659:56;10709:5;10659:56;:::i;:::-;10738:7;10769:1;10754:284;10779:6;10776:1;10773:13;10754:284;;;10855:6;10849:13;10882:63;10941:3;10926:13;10882:63;:::i;:::-;10875:70;;10968:60;11021:6;10968:60;:::i;:::-;10958:70;;10814:224;10801:1;10798;10794:9;10789:14;;10754:284;;;10758:14;11054:3;11047:10;;10455:608;;;10331:732;;;;:::o;11069:373::-;11212:4;11250:2;11239:9;11235:18;11227:26;;11299:9;11293:4;11289:20;11285:1;11274:9;11270:17;11263:47;11327:108;11430:4;11421:6;11327:108;:::i;:::-;11319:116;;11069:373;;;;:::o;11448:122::-;11521:24;11539:5;11521:24;:::i;:::-;11514:5;11511:35;11501:63;;11560:1;11557;11550:12;11501:63;11448:122;:::o;11576:139::-;11622:5;11660:6;11647:20;11638:29;;11676:33;11703:5;11676:33;:::i;:::-;11576:139;;;;:::o;11721:329::-;11780:6;11829:2;11817:9;11808:7;11804:23;11800:32;11797:119;;;11835:79;;:::i;:::-;11797:119;11955:1;11980:53;12025:7;12016:6;12005:9;12001:22;11980:53;:::i;:::-;11970:63;;11926:117;11721:329;;;;:::o;12056:169::-;12140:11;12174:6;12169:3;12162:19;12214:4;12209:3;12205:14;12190:29;;12056:169;;;;:::o;12231:181::-;12371:33;12367:1;12359:6;12355:14;12348:57;12231:181;:::o;12418:366::-;12560:3;12581:67;12645:2;12640:3;12581:67;:::i;:::-;12574:74;;12657:93;12746:3;12657:93;:::i;:::-;12775:2;12770:3;12766:12;12759:19;;12418:366;;;:::o;12790:419::-;12956:4;12994:2;12983:9;12979:18;12971:26;;13043:9;13037:4;13033:20;13029:1;13018:9;13014:17;13007:47;13071:131;13197:4;13071:131;:::i;:::-;13063:139;;12790:419;;;:::o;13215:171::-;13355:23;13351:1;13343:6;13339:14;13332:47;13215:171;:::o;13392:366::-;13534:3;13555:67;13619:2;13614:3;13555:67;:::i;:::-;13548:74;;13631:93;13720:3;13631:93;:::i;:::-;13749:2;13744:3;13740:12;13733:19;;13392:366;;;:::o;13764:419::-;13930:4;13968:2;13957:9;13953:18;13945:26;;14017:9;14011:4;14007:20;14003:1;13992:9;13988:17;13981:47;14045:131;14171:4;14045:131;:::i;:::-;14037:139;;13764:419;;;:::o;14189:180::-;14329:32;14325:1;14317:6;14313:14;14306:56;14189:180;:::o;14375:366::-;14517:3;14538:67;14602:2;14597:3;14538:67;:::i;:::-;14531:74;;14614:93;14703:3;14614:93;:::i;:::-;14732:2;14727:3;14723:12;14716:19;;14375:366;;;:::o;14747:419::-;14913:4;14951:2;14940:9;14936:18;14928:26;;15000:9;14994:4;14990:20;14986:1;14975:9;14971:17;14964:47;15028:131;15154:4;15028:131;:::i;:::-;15020:139;;14747:419;;;:::o;15172:143::-;15229:5;15260:6;15254:13;15245:22;;15276:33;15303:5;15276:33;:::i;:::-;15172:143;;;;:::o;15321:351::-;15391:6;15440:2;15428:9;15419:7;15415:23;15411:32;15408:119;;;15446:79;;:::i;:::-;15408:119;15566:1;15591:64;15647:7;15638:6;15627:9;15623:22;15591:64;:::i;:::-;15581:74;;15537:128;15321:351;;;;:::o;15678:182::-;15818:34;15814:1;15806:6;15802:14;15795:58;15678:182;:::o;15866:366::-;16008:3;16029:67;16093:2;16088:3;16029:67;:::i;:::-;16022:74;;16105:93;16194:3;16105:93;:::i;:::-;16223:2;16218:3;16214:12;16207:19;;15866:366;;;:::o;16238:419::-;16404:4;16442:2;16431:9;16427:18;16419:26;;16491:9;16485:4;16481:20;16477:1;16466:9;16462:17;16455:47;16519:131;16645:4;16519:131;:::i;:::-;16511:139;;16238:419;;;:::o;16663:85::-;16708:7;16737:5;16726:16;;16663:85;;;:::o;16754:60::-;16782:3;16803:5;16796:12;;16754:60;;;:::o;16820:156::-;16877:9;16910:60;16927:42;16936:32;16962:5;16936:32;:::i;:::-;16927:42;:::i;:::-;16910:60;:::i;:::-;16897:73;;16820:156;;;:::o;16982:145::-;17076:44;17114:5;17076:44;:::i;:::-;17071:3;17064:57;16982:145;;:::o;17133:666::-;17339:4;17377:3;17366:9;17362:19;17354:27;;17391:71;17459:1;17448:9;17444:17;17435:6;17391:71;:::i;:::-;17472:70;17538:2;17527:9;17523:18;17514:6;17472:70;:::i;:::-;17552;17618:2;17607:9;17603:18;17594:6;17552:70;:::i;:::-;17632;17698:2;17687:9;17683:18;17674:6;17632:70;:::i;:::-;17712:80;17787:3;17776:9;17772:19;17763:6;17712:80;:::i;:::-;17133:666;;;;;;;;:::o;17805:143::-;17862:5;17893:6;17887:13;17878:22;;17909:33;17936:5;17909:33;:::i;:::-;17805:143;;;;:::o;17954:351::-;18024:6;18073:2;18061:9;18052:7;18048:23;18044:32;18041:119;;;18079:79;;:::i;:::-;18041:119;18199:1;18224:64;18280:7;18271:6;18260:9;18256:22;18224:64;:::i;:::-;18214:74;;18170:128;17954:351;;;;:::o;18311:332::-;18432:4;18470:2;18459:9;18455:18;18447:26;;18483:71;18551:1;18540:9;18536:17;18527:6;18483:71;:::i;:::-;18564:72;18632:2;18621:9;18617:18;18608:6;18564:72;:::i;:::-;18311:332;;;;;:::o;18649:180::-;18697:77;18694:1;18687:88;18794:4;18791:1;18784:15;18818:4;18815:1;18808:15;18835:180;18883:77;18880:1;18873:88;18980:4;18977:1;18970:15;19004:4;19001:1;18994:15;19021:233;19060:3;19083:24;19101:5;19083:24;:::i;:::-;19074:33;;19129:66;19122:5;19119:77;19116:103;;19199:18;;:::i;:::-;19116:103;19246:1;19239:5;19235:13;19228:20;;19021:233;;;:::o;19260:225::-;19400:34;19396:1;19388:6;19384:14;19377:58;19469:8;19464:2;19456:6;19452:15;19445:33;19260:225;:::o;19491:366::-;19633:3;19654:67;19718:2;19713:3;19654:67;:::i;:::-;19647:74;;19730:93;19819:3;19730:93;:::i;:::-;19848:2;19843:3;19839:12;19832:19;;19491:366;;;:::o;19863:419::-;20029:4;20067:2;20056:9;20052:18;20044:26;;20116:9;20110:4;20106:20;20102:1;20091:9;20087:17;20080:47;20144:131;20270:4;20144:131;:::i;:::-;20136:139;;19863:419;;;:::o;20288:180::-;20336:77;20333:1;20326:88;20433:4;20430:1;20423:15;20457:4;20454:1;20447:15;20474:176;20506:1;20523:20;20541:1;20523:20;:::i;:::-;20518:25;;20557:20;20575:1;20557:20;:::i;:::-;20552:25;;20596:1;20586:35;;20601:18;;:::i;:::-;20586:35;20642:1;20639;20635:9;20630:14;;20474:176;;;;:::o;20656:182::-;20796:34;20792:1;20784:6;20780:14;20773:58;20656:182;:::o;20844:366::-;20986:3;21007:67;21071:2;21066:3;21007:67;:::i;:::-;21000:74;;21083:93;21172:3;21083:93;:::i;:::-;21201:2;21196:3;21192:12;21185:19;;20844:366;;;:::o;21216:419::-;21382:4;21420:2;21409:9;21405:18;21397:26;;21469:9;21463:4;21459:20;21455:1;21444:9;21440:17;21433:47;21497:131;21623:4;21497:131;:::i;:::-;21489:139;;21216:419;;;:::o;21641:194::-;21681:4;21701:20;21719:1;21701:20;:::i;:::-;21696:25;;21735:20;21753:1;21735:20;:::i;:::-;21730:25;;21779:1;21776;21772:9;21764:17;;21803:1;21797:4;21794:11;21791:37;;;21808:18;;:::i;:::-;21791:37;21641:194;;;;:::o;21841:180::-;21889:77;21886:1;21879:88;21986:4;21983:1;21976:15;22010:4;22007:1;22000:15
Swarm Source
ipfs://3f3960c878fe3b77ba6b97f1b53683353612280c6ed112dcef7f6a02d34b5f76
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.