Source Code
Overview
POL Balance
More Info
ContractCreator
TokenTracker
Multichain Info
N/A
Latest 16 from a total of 16 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Burn | 18228786 | 11 hrs ago | IN | 0 POL | 0.00320338 | ||||
Update Burn Peri... | 18228574 | 11 hrs ago | IN | 0 POL | 0.00104907 | ||||
Update Burn Peri... | 18228442 | 11 hrs ago | IN | 0 POL | 0.00088458 | ||||
Burn | 18054201 | 4 days ago | IN | 0 POL | 0.0033769 | ||||
Burn | 17708044 | 13 days ago | IN | 0 POL | 0.00495369 | ||||
Burn | 17707984 | 13 days ago | IN | 0 POL | 0.00147015 | ||||
Burn | 17707964 | 13 days ago | IN | 0 POL | 0.00114345 | ||||
Flip Burn State | 17465109 | 19 days ago | IN | 0 POL | 0.00092627 | ||||
Set Base URI | 16641045 | 40 days ago | IN | 0 POL | 0.00142621 | ||||
Set Gem Category | 16609106 | 41 days ago | IN | 0 POL | 0.00332216 | ||||
Safe Transfer Fr... | 16609036 | 41 days ago | IN | 0 POL | 0.00411859 | ||||
Set Base URI | 16608997 | 41 days ago | IN | 0 POL | 0.001529 | ||||
Set Base URI | 16573584 | 42 days ago | IN | 0 POL | 0.00460395 | ||||
Set Minting Addr... | 16573371 | 42 days ago | IN | 0 POL | 0.00138537 | ||||
Set Gem Category | 16573296 | 42 days ago | IN | 0 POL | 0.00474475 | ||||
Flip Contract St... | 16573275 | 42 days ago | IN | 0 POL | 0.00103111 |
Loading...
Loading
Contract Source Code Verified (Exact Match)
Contract Name:
GEMNFTs
Compiler Version
v0.8.26+commit.8a97fa7a
Contract Source Code (Solidity Multiple files format)
// SPDX-License-Identifier: MIT /** * * @title: GEM NFTs * @date: 07-January-2025 * @version: 2.5 * @author: IPMB Dev Team */ 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 GSN 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 memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } } // File: @openzeppelin/contracts/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 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`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 tokenId) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @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 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); /** * @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; } // File: @openzeppelin/contracts/token/ERC721/IERC721Metadata.sol pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); } // File: @openzeppelin/contracts/token/ERC721/IERC721Enumerable.sol pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); } // File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`. */ function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4); } // File: @openzeppelin/contracts/introspection/ERC165.sol pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts may inherit from this and call {_registerInterface} to declare * their support of an interface. */ abstract contract ERC165 is IERC165 { /* * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7 */ bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7; /** * @dev Mapping of interface ids to whether or not it's supported. */ mapping(bytes4 => bool) private _supportedInterfaces; constructor () internal { // Derived contracts need only register support for their own interfaces, // we register support for ERC165 itself here _registerInterface(_INTERFACE_ID_ERC165); } /** * @dev See {IERC165-supportsInterface}. * * Time complexity O(1), guaranteed to always use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return _supportedInterfaces[interfaceId]; } /** * @dev Registers the contract as an implementer of the interface defined by * `interfaceId`. Support of the actual ERC165 interface is automatic and * registering its interface id is not required. * * See {IERC165-supportsInterface}. * * Requirements: * * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`). */ function _registerInterface(bytes4 interfaceId) internal virtual { require(interfaceId != 0xffffffff, "ERC165: invalid interface id"); _supportedInterfaces[interfaceId] = true; } } // File: @openzeppelin/contracts/math/SafeMath.sol pragma solidity ^0.8.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ 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) { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { 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) { // 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) { 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) { 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) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @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) { require(b <= a, "SafeMath: subtraction overflow"); 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) { if (a == 0) return 0; uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @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. 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) internal pure returns (uint256) { require(b > 0, "SafeMath: division by zero"); 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) { require(b > 0, "SafeMath: modulo by zero"); 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) { 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. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryDiv}. * * 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) { 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) { require(b > 0, errorMessage); return a % b; } } // File: @openzeppelin/contracts/utils/Address.sol pragma solidity ^0.8.0; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File: @openzeppelin/contracts/utils/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. */ 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; // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement. 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] = toDeleteIndex + 1; // All indexes are 1-based // 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) { require(set._values.length > index, "EnumerableSet: index out of bounds"); return set._values[index]; } // 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); } // 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)))); } // 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)); } } // File: @openzeppelin/contracts/utils/EnumerableMap.sol 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; * } * ``` * * As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are * supported. */ library EnumerableMap { // 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 MapEntry { bytes32 _key; bytes32 _value; } struct Map { // Storage of map keys and values MapEntry[] _entries; // Position of the entry defined by a key in the `entries` array, plus 1 // because index 0 means a key is not in the map. mapping (bytes32 => uint256) _indexes; } /** * @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(Map storage map, bytes32 key, bytes32 value) private returns (bool) { // We read and store the key's index to prevent multiple reads from the same storage slot uint256 keyIndex = map._indexes[key]; if (keyIndex == 0) { // Equivalent to !contains(map, key) map._entries.push(MapEntry({ _key: key, _value: value })); // The entry is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value map._indexes[key] = map._entries.length; return true; } else { map._entries[keyIndex - 1]._value = value; return false; } } /** * @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(Map storage map, bytes32 key) private returns (bool) { // We read and store the key's index to prevent multiple reads from the same storage slot uint256 keyIndex = map._indexes[key]; if (keyIndex != 0) { // Equivalent to contains(map, key) // To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one // in the array, and then remove the last entry (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = keyIndex - 1; uint256 lastIndex = map._entries.length - 1; // When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement. MapEntry storage lastEntry = map._entries[lastIndex]; // Move the last entry to the index where the entry to delete is map._entries[toDeleteIndex] = lastEntry; // Update the index for the moved entry map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based // Delete the slot where the moved entry was stored map._entries.pop(); // Delete the index for the deleted slot delete map._indexes[key]; return true; } else { return false; } } /** * @dev Returns true if the key is in the map. O(1). */ function _contains(Map storage map, bytes32 key) private view returns (bool) { return map._indexes[key] != 0; } /** * @dev Returns the number of key-value pairs in the map. O(1). */ function _length(Map storage map) private view returns (uint256) { return map._entries.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(Map storage map, uint256 index) private view returns (bytes32, bytes32) { require(map._entries.length > index, "EnumerableMap: index out of bounds"); MapEntry storage entry = map._entries[index]; return (entry._key, entry._value); } /** * @dev Tries to returns the value associated with `key`. O(1). * Does not revert if `key` is not in the map. */ function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) { uint256 keyIndex = map._indexes[key]; if (keyIndex == 0) return (false, 0); // Equivalent to contains(map, key) return (true, map._entries[keyIndex - 1]._value); // All indexes are 1-based } /** * @dev Returns the value associated with `key`. O(1). * * Requirements: * * - `key` must be in the map. */ function _get(Map storage map, bytes32 key) private view returns (bytes32) { uint256 keyIndex = map._indexes[key]; require(keyIndex != 0, "EnumerableMap: nonexistent key"); // Equivalent to contains(map, key) return map._entries[keyIndex - 1]._value; // All indexes are 1-based } /** * @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(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) { uint256 keyIndex = map._indexes[key]; require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key) return map._entries[keyIndex - 1]._value; // All indexes are 1-based } // UintToAddressMap struct UintToAddressMap { Map _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. * * _Available since v3.4._ */ 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)))); } } // File: @openzeppelin/contracts/utils/math/Math.sol pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { // Solidity will revert if denominator == 0, unlike the div opcode on its own. // The surrounding unchecked block does not change this fact. // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic. return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1, "Math: mulDiv overflow"); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10 ** 64) { value /= 10 ** 64; result += 64; } if (value >= 10 ** 32) { value /= 10 ** 32; result += 32; } if (value >= 10 ** 16) { value /= 10 ** 16; result += 16; } if (value >= 10 ** 8) { value /= 10 ** 8; result += 8; } if (value >= 10 ** 4) { value /= 10 ** 4; result += 4; } if (value >= 10 ** 2) { value /= 10 ** 2; result += 2; } if (value >= 10 ** 1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 256, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0); } } } // File: @openzeppelin/contracts/utils/math/SignedMath.sol pragma solidity ^0.8.0; /** * @dev Standard signed math utilities missing in the Solidity language. */ library SignedMath { /** * @dev Returns the largest of two signed numbers. */ function max(int256 a, int256 b) internal pure returns (int256) { return a > b ? a : b; } /** * @dev Returns the smallest of two signed numbers. */ function min(int256 a, int256 b) internal pure returns (int256) { return a < b ? a : b; } /** * @dev Returns the average of two signed numbers without overflow. * The result is rounded towards zero. */ function average(int256 a, int256 b) internal pure returns (int256) { // Formula from the book "Hacker's Delight" int256 x = (a & b) + ((a ^ b) >> 1); return x + (int256(uint256(x) >> 255) & (a ^ b)); } /** * @dev Returns the absolute unsigned value of a signed value. */ function abs(int256 n) internal pure returns (uint256) { unchecked { // must be unchecked in order to support `n = type(int256).min` return uint256(n >= 0 ? n : -n); } } } // File: @openzeppelin/contracts/utils/Strings.sol pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `int256` to its ASCII `string` decimal representation. */ function toString(int256 value) internal pure returns (string memory) { return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value)))); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } /** * @dev Returns true if the two strings are equal. */ function equal(string memory a, string memory b) internal pure returns (bool) { return keccak256(bytes(a)) == keccak256(bytes(b)); } } // File: @openzeppelin/contracts/token/ERC721/ERC721.sol pragma solidity ^0.8.0; /** * @title ERC721 Non-Fungible Token Standard basic implementation * @dev see https://eips.ethereum.org/EIPS/eip-721 */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable { using SafeMath for uint256; using Address for address; using EnumerableSet for EnumerableSet.UintSet; using EnumerableMap for EnumerableMap.UintToAddressMap; using Strings for uint256; // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector` bytes4 private constant _ERC721_RECEIVED = 0x150b7a02; // Mapping from holder address to their (enumerable) set of owned tokens mapping (address => EnumerableSet.UintSet) private _holderTokens; // Enumerable mapping from token ids to their owners EnumerableMap.UintToAddressMap private _tokenOwners; // Mapping from token ID to approved address mapping (uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping (address => mapping (address => bool)) private _operatorApprovals; // Token name string private _name; // Token symbol string private _symbol; // Optional mapping for token URIs mapping (uint256 => string) private _tokenURIs; // Base URI string private _baseURI; /* * bytes4(keccak256('balanceOf(address)')) == 0x70a08231 * bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e * bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3 * bytes4(keccak256('getApproved(uint256)')) == 0x081812fc * bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465 * bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5 * bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd * bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e * bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde * * => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^ * 0xa22cb465 ^ 0xe985e9c5 ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd */ bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd; /* * bytes4(keccak256('name()')) == 0x06fdde03 * bytes4(keccak256('symbol()')) == 0x95d89b41 * bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd * * => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f */ bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f; /* * bytes4(keccak256('totalSupply()')) == 0x18160ddd * bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59 * bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7 * * => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63 */ bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor (string memory name_, string memory symbol_) public { _name = name_; _symbol = symbol_; // register the supported interfaces to conform to ERC721 via ERC165 _registerInterface(_INTERFACE_ID_ERC721); _registerInterface(_INTERFACE_ID_ERC721_METADATA); _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: balance query for the zero address"); return _holderTokens[owner].length(); } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token"); } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token"); string memory _tokenURI = _tokenURIs[tokenId]; string memory base = baseURI(); // If there is no base URI, return the token URI. if (bytes(base).length == 0) { return _tokenURI; } // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked). if (bytes(_tokenURI).length > 0) { return string(abi.encodePacked(base, _tokenURI)); } // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI. return string(abi.encodePacked(base, tokenId.toString())); } /** * @dev Returns the base URI set via {_setBaseURI}. This will be * automatically added as a prefix in {tokenURI} to each token's URI, or * to the token ID if no specific URI is set for that token ID. */ function baseURI() public view virtual returns (string memory) { return _baseURI; } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) { return _holderTokens[owner].at(index); } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds return _tokenOwners.length(); } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view virtual override returns (uint256) { (uint256 tokenId, ) = _tokenOwners.at(index); return tokenId; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require(_msgSender() == owner || ERC721.isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not owner nor approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { require(_exists(tokenId), "ERC721: approved query for nonexistent token"); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { require(operator != _msgSender(), "ERC721: approve to caller"); _operatorApprovals[_msgSender()][operator] = approved; emit ApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom(address from, address to, uint256 tokenId) public virtual override { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved"); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved"); _safeTransfer(from, to, tokenId, _data); } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * `_data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual { _transfer(from, to, tokenId); require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return _tokenOwners.contains(tokenId); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { require(_exists(tokenId), "ERC721: operator query for nonexistent token"); address owner = ERC721.ownerOf(tokenId); return (spender == owner || getApproved(tokenId) == spender || ERC721.isApprovedForAll(owner, spender)); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: d* * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual { _mint(to, tokenId); require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId); _holderTokens[to].add(tokenId); _tokenOwners.set(tokenId, to); emit Transfer(address(0), to, tokenId); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ERC721.ownerOf(tokenId); // internal owner _beforeTokenTransfer(owner, address(0), tokenId); // Clear approvals _approve(address(0), tokenId); // Clear metadata (if any) if (bytes(_tokenURIs[tokenId]).length != 0) { delete _tokenURIs[tokenId]; } _holderTokens[owner].remove(tokenId); _tokenOwners.remove(tokenId); emit Transfer(owner, address(0), tokenId); } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer(address from, address to, uint256 tokenId) internal virtual { require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own"); // internal owner require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId); // Clear approvals from the previous owner _approve(address(0), tokenId); _holderTokens[from].remove(tokenId); _holderTokens[to].add(tokenId); _tokenOwners.set(tokenId, to); emit Transfer(from, to, tokenId); } /** * @dev Sets `_tokenURI` as the tokenURI of `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual { require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token"); _tokenURIs[tokenId] = _tokenURI; } /** * @dev Internal function to set the base URI for all token IDs. It is * automatically added as a prefix to the value returned in {tokenURI}, * or to the token ID if {tokenURI} is empty. */ function _setBaseURI(string memory baseURI_) internal virtual { _baseURI = baseURI_; } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param _data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) private returns (bool) { if (!to.isContract()) { return true; } bytes memory returndata = to.functionCall(abi.encodeWithSelector( IERC721Receiver(to).onERC721Received.selector, _msgSender(), from, tokenId, _data ), "ERC721: transfer to non ERC721Receiver implementer"); bytes4 retval = abi.decode(returndata, (bytes4)); return (retval == _ERC721_RECEIVED); } /** * @dev Approve `to` to operate on `tokenId` * * Emits an {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.ownerOf(tokenId), to, tokenId); // internal owner } /** * @dev Hook that is called before any token transfer. This includes minting * and burning. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be * transferred to `to`. * - When `from` is zero, `tokenId` will be minted for `to`. * - When `to` is zero, ``from``'s `tokenId` will be burned. * - `from` cannot be the zero address. * - `to` cannot be the zero address. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { } } // File: @openzeppelin/contracts/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 () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = 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"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } /** * * @title IERC20 */ pragma solidity ^0.8.5; /** * @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); } /** * @title GEM NFTs Smart Contract */ pragma solidity ^0.8.25; import "./IStaking.sol"; contract GEMNFTs is ERC721, Ownable { // use of libraries using SafeMath for uint256; using Strings for uint256; // struct struct gemCat { uint256 price; uint256 counter; uint256 supply; uint256 fee; bool status; } // declaration of variables bool public contractIsActive = false; bool public burnIsActive = false; uint256 circSupply; uint256 burnPeriod; uint256 public burnFee; address public mintingAddress; IStaking public stakingAddress; // declaration of mappings mapping(string => gemCat) gemCategories; mapping(uint256 => string) public tCategory; mapping(address => bool) public adminPermissions; mapping(uint256 => address) public burnAddressForToken; mapping(uint256 => uint256) public mintedDate; mapping (address => mapping (uint256 => bool) ) public alreadyClaimDiscount; address public burnAddr; // declaration of modifiers modifier adminRequired { require((adminPermissions[msg.sender] == true) || (msg.sender == owner()), "User is not an admin"); _; } // constructor constructor(string memory name, string memory symbol, address _stakingAddress, uint256 _burnPeriod) ERC721(name, symbol) { adminPermissions[msg.sender] = true; stakingAddress = IStaking(_stakingAddress); burnAddr = 0x000000000000000000000000000000000000dEaD; burnPeriod = _burnPeriod; } /* * Withdraw POL funds sent to the smart contract */ function withdraw(address _to) public onlyOwner { uint balance = address(this).balance; payable(_to).transfer(balance); } /* * Withdraw any ERC20 funds sent to the smart contract */ function withdrawERC20(address _contractAddress, address _to) public onlyOwner { uint amount = IERC20(_contractAddress).balanceOf(address(this)); IERC20(_contractAddress).transfer(_to, amount); } /* * Set Base URI */ function setBaseURI(string memory baseURI) public adminRequired { _setBaseURI(baseURI); } /* * Update burning period */ function updateBurnPeriod(uint256 _burnPeriod) public adminRequired { burnPeriod = _burnPeriod; } /* * Pause contract if active, make active if paused */ function flipContractState() public onlyOwner { contractIsActive = !contractIsActive; } /* * Pause burn if active, make active if paused */ function flipBurnState() public onlyOwner { burnIsActive = !burnIsActive; } /** * Allows GPRO holders to mint an NFT from a minting smart contract */ function mintGEMNFTAUTH(string memory _id, address _receiver) public { require(msg.sender == mintingAddress, "No external Minting"); uint256 mintIndex = circSupply; tCategory[mintIndex] = _id; mintedDate[mintIndex] = block.timestamp; gemCategories[_id].counter = gemCategories[_id].counter + 1; circSupply = circSupply + 1; _safeMint(_receiver, mintIndex); } /** * Set Staking contract address */ function setStakingAddress(address _staking) public onlyOwner { stakingAddress = IStaking(_staking); } /** * Set Minting Address */ function setMintingAddress(address _minting) public onlyOwner { mintingAddress = _minting; } /** * Burn the NFT (only KYC verified users can burn an NFT) */ function burn(uint256 tokenId) public payable { require(burnIsActive, "Burn not active"); require(msg.value == burnFee, "Fee error"); require (msg.sender == ownerOf(tokenId), "Address is not the owner"); require(stakingAddress.retrieveKYCStatus(msg.sender) == true, "Address has not passed KYC"); require(stakingAddress.retrieveBlackListStatus(msg.sender) == false, "Address is blacklisted"); require(block.timestamp >= mintedDate[tokenId] + burnPeriod, "Burn Period has not passed"); _burn(tokenId); burnAddressForToken[tokenId] = msg.sender; } /** * Function to register Admin */ function registerAdmin(address _admin, bool _status) public onlyOwner { adminPermissions[_admin] = _status; } /** * Function to create a GeM NFT category */ function setGemCategory(string memory _id, uint256 _price, uint256 _supply, uint256 _fee) public adminRequired { require(gemCategories[_id].status == false); gemCategories[_id].price = _price; gemCategories[_id].supply = _supply; gemCategories[_id].fee = _fee; gemCategories[_id].status = true; } /** * Function to change the status of a category */ function updateCategoryStatus(string memory _id) public adminRequired { gemCategories[_id].status = false; } /** * Function to update the fee of a category */ function updateCategoryFee(string memory _id, uint256 _fee) public adminRequired { gemCategories[_id].fee = _fee; } /** * Function to update the burn fee */ function updateBurnFee(uint256 _fee) public adminRequired { burnFee = _fee; } /** * Function to retrieve the data of a category */ function retrieveCategoryData(string memory _id) public view returns (uint256, uint256, uint256, uint256, bool) { return (gemCategories[_id].price, gemCategories[_id].counter, gemCategories[_id].supply, gemCategories[_id].fee, gemCategories[_id].status); } /** * Function to return the category price */ function retrieveCategoryPrice(string memory _id) public view returns (uint256) { return (gemCategories[_id].price); } /** * Function to return the burning period */ function retrieveBurnPeriod() public view returns (uint256) { return (burnPeriod); } /** * Function to return the burning status */ function retrieveBurnStatus(uint256 _tokenId) public view returns (bool) { return (block.timestamp >= mintedDate[_tokenId] + burnPeriod); } /** * Function to return the tokenURI for a specific token */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token"); return bytes(baseURI()).length > 0 ? string(abi.encodePacked(baseURI(), tokenId.toString())) : ""; } }
// SPDX-License-Identifier: MIT /** * * @title Interface of the Staking contract */ pragma solidity ^0.8.5; interface IStaking { function getDiscount(uint256 _poolID, address _address, uint256 _index) external view returns (uint256); function poolStatus(uint256 _poolID) external view returns (bool); function poolAmountPerAddress(uint256 _poolID, address _address, uint256 _index) external view returns (uint256); function updateAddressPool(address _address, uint256 _poolID, uint256 _index) external; function poolDataPerAddress(uint256 _poolID, address _address, uint256 _index) external view returns (uint256, uint256, uint256, uint256, uint256); function poolGPROPricePerAddress(uint256 _poolID, address _address, uint256 _index) external view returns (uint256); function poolGoldPricePerAddress(uint256 _poolID, address _address, uint256 _index) external view returns (uint256); function poolEpochPerAddress(uint256 _poolID, address _address, uint256 _index) external view returns (uint256); function poolPrice(uint256 _poolID) external view returns (uint256); function retrieveKYCStatus(address _address) external view returns (bool); function retrieveBlackListStatus(address _address) external view returns (bool); function withdrawalPool(uint256 _poolID, uint256 _index) external; function depositPool(uint256 _poolID) external; function poolDiscount(uint256 _poolID) external view returns (uint256); }
[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"address","name":"_stakingAddress","type":"address"},{"internalType":"uint256","name":"_burnPeriod","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"adminPermissions","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"alreadyClaimDiscount","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"burnAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"burnAddressForToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"flipBurnState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"flipContractState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_id","type":"string"},{"internalType":"address","name":"_receiver","type":"address"}],"name":"mintGEMNFTAUTH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"mintedDate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintingAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_admin","type":"address"},{"internalType":"bool","name":"_status","type":"bool"}],"name":"registerAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"retrieveBurnPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"retrieveBurnStatus","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_id","type":"string"}],"name":"retrieveCategoryData","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_id","type":"string"}],"name":"retrieveCategoryPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_id","type":"string"},{"internalType":"uint256","name":"_price","type":"uint256"},{"internalType":"uint256","name":"_supply","type":"uint256"},{"internalType":"uint256","name":"_fee","type":"uint256"}],"name":"setGemCategory","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_minting","type":"address"}],"name":"setMintingAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_staking","type":"address"}],"name":"setStakingAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakingAddress","outputs":[{"internalType":"contract IStaking","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"tCategory","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_fee","type":"uint256"}],"name":"updateBurnFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_burnPeriod","type":"uint256"}],"name":"updateBurnPeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_id","type":"string"},{"internalType":"uint256","name":"_fee","type":"uint256"}],"name":"updateCategoryFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_id","type":"string"}],"name":"updateCategoryStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_contractAddress","type":"address"},{"internalType":"address","name":"_to","type":"address"}],"name":"withdrawERC20","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)
000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000db886f0a75dfd735118b201c3426a1fa40180e2d0000000000000000000000000000000000000000000000000000000000000e10000000000000000000000000000000000000000000000000000000000000000a47454d204e465473205400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000447454d5400000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : name (string): GEM NFTs T
Arg [1] : symbol (string): GEMT
Arg [2] : _stakingAddress (address): 0xdB886f0a75DFd735118B201C3426a1fA40180e2d
Arg [3] : _burnPeriod (uint256): 3600
-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 000000000000000000000000db886f0a75dfd735118b201c3426a1fa40180e2d
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000e10
Arg [4] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [5] : 47454d204e465473205400000000000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [7] : 47454d5400000000000000000000000000000000000000000000000000000000
Deployed Bytecode Sourcemap
85620:6815:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10206:150;;;;;;;;;;-1:-1:-1;10206:150:0;;;;;:::i;:::-;-1:-1:-1;;;;;;10315:33:0;10291:4;10315:33;;;;;;;;;;;;;;10206:150;;;;565:14:2;;558:22;540:41;;528:2;513:18;10206:150:0;;;;;;;;67522:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;70308:221::-;;;;;;;;;;-1:-1:-1;70308:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1528:32:2;;;1510:51;;1498:2;1483:18;70308:221:0;1364:203:2;69838:404:0;;;;;;;;;;-1:-1:-1;69838:404:0;;;;;:::i;:::-;;:::i;:::-;;85964:36;;;;;;;;;;-1:-1:-1;85964:36:0;;;;-1:-1:-1;;;85964:36:0;;;;;;69316:211;;;;;;;;;;;;;:::i;:::-;;;2201:25:2;;;2189:2;2174:18;69316:211:0;2055:177:2;91525:132:0;;;;;;;;;;-1:-1:-1;91525:132:0;;;;;:::i;:::-;;:::i;71198:305::-;;;;;;;;;;-1:-1:-1;71198:305:0;;;;;:::i;:::-;;:::i;69078:162::-;;;;;;;;;;-1:-1:-1;69078:162:0;;;;;:::i;:::-;;:::i;86385:54::-;;;;;;;;;;-1:-1:-1;86385:54:0;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;86385:54:0;;;89125:106;;;;;;;;;;-1:-1:-1;89125:106:0;;;;;:::i;:::-;;:::i;90198:346::-;;;;;;;;;;-1:-1:-1;90198:346:0;;;;;:::i;:::-;;:::i;71574:151::-;;;;;;;;;;-1:-1:-1;71574:151:0;;;;;:::i;:::-;;:::i;89320:622::-;;;;;;:::i;:::-;;:::i;69604:172::-;;;;;;;;;;-1:-1:-1;69604:172:0;;;;;:::i;:::-;;:::i;87234:144::-;;;;;;;;;;-1:-1:-1;87234:144:0;;;;;:::i;:::-;;:::i;87750:103::-;;;;;;;;;;-1:-1:-1;87750:103:0;;;;;:::i;:::-;;:::i;67278:177::-;;;;;;;;;;-1:-1:-1;67278:177:0;;;;;:::i;:::-;;:::i;86007:32::-;;;;;;;;;;-1:-1:-1;86007:32:0;;;;-1:-1:-1;;;86007:32:0;;;;;;68897:97;;;;;;;;;;;;;:::i;66995:221::-;;;;;;;;;;-1:-1:-1;66995:221:0;;;;;:::i;:::-;;:::i;82221:148::-;;;;;;;;;;;;;:::i;91014:91::-;;;;;;;;;;-1:-1:-1;91014:91:0;;;;;:::i;:::-;;:::i;81570:87::-;;;;;;;;;;-1:-1:-1;81643:6:0;;-1:-1:-1;;;;;81643:6:0;81570:87;;91729:98;;;;;;;;;;-1:-1:-1;91808:10:0;;91729:98;;86280:43;;;;;;;;;;-1:-1:-1;86280:43:0;;;;;:::i;:::-;;:::i;86330:48::-;;;;;;;;;;-1:-1:-1;86330:48:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;91899:153;;;;;;;;;;-1:-1:-1;91899:153:0;;;;;:::i;:::-;;:::i;87468:231::-;;;;;;;;;;-1:-1:-1;87468:231:0;;;;;:::i;:::-;;:::i;67691:104::-;;;;;;;;;;;;;:::i;70601:295::-;;;;;;;;;;-1:-1:-1;70601:295:0;;;;;:::i;:::-;;:::i;88278:89::-;;;;;;;;;;;;;:::i;90622:122::-;;;;;;;;;;-1:-1:-1;90622:122:0;;;;;:::i;:::-;;:::i;91183:270::-;;;;;;;;;;-1:-1:-1;91183:270:0;;;;;:::i;:::-;;:::i;:::-;;;;5857:25:2;;;5913:2;5898:18;;5891:34;;;;5941:18;;;5934:34;;;;5999:2;5984:18;;5977:34;6055:14;6048:22;6042:3;6027:19;;6020:51;5844:3;5829:19;91183:270:0;5604:473:2;71796:285:0;;;;;;;;;;-1:-1:-1;71796:285:0;;;;;:::i;:::-;;:::i;86446:45::-;;;;;;;;;;-1:-1:-1;86446:45:0;;;;;:::i;:::-;;;;;;;;;;;;;;87908:111;;;;;;;;;;-1:-1:-1;87908:111:0;;;;;:::i;:::-;;:::i;92139:291::-;;;;;;;;;;-1:-1:-1;92139:291:0;;;;;:::i;:::-;;:::i;88466:426::-;;;;;;;;;;-1:-1:-1;88466:426:0;;;;;:::i;:::-;;:::i;90819:129::-;;;;;;;;;;-1:-1:-1;90819:129:0;;;;;:::i;:::-;;:::i;86580:23::-;;;;;;;;;;-1:-1:-1;86580:23:0;;;;-1:-1:-1;;;;;86580:23:0;;;86161:30;;;;;;;;;;-1:-1:-1;86161:30:0;;;;-1:-1:-1;;;;;86161:30:0;;;88100:101;;;;;;;;;;;;;:::i;90003:123::-;;;;;;;;;;-1:-1:-1;90003:123:0;;;;;:::i;:::-;;:::i;70967:164::-;;;;;;;;;;-1:-1:-1;70967:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;71088:25:0;;;71064:4;71088:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;70967:164;82524:244;;;;;;;;;;-1:-1:-1;82524:244:0;;;;;:::i;:::-;;:::i;88955:116::-;;;;;;;;;;-1:-1:-1;88955:116:0;;;;;:::i;:::-;;:::i;86498:75::-;;;;;;;;;;-1:-1:-1;86498:75:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;86096:22;;;;;;;;;;;;;;;;86125:29;;;;;;;;;;-1:-1:-1;86125:29:0;;;;-1:-1:-1;;;;;86125:29:0;;;67522:100;67576:13;67609:5;67602:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67522:100;:::o;70308:221::-;70384:7;70412:16;70420:7;70412;:16::i;:::-;70404:73;;;;-1:-1:-1;;;70404:73:0;;8454:2:2;70404:73:0;;;8436:21:2;8493:2;8473:18;;;8466:30;8532:34;8512:18;;;8505:62;-1:-1:-1;;;8583:18:2;;;8576:42;8635:19;;70404:73:0;;;;;;;;;-1:-1:-1;70497:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;70497:24:0;;70308:221::o;69838:404::-;69919:13;69935:23;69950:7;69935:14;:23::i;:::-;69919:39;;69983:5;-1:-1:-1;;;;;69977:11:0;:2;-1:-1:-1;;;;;69977:11:0;;69969:57;;;;-1:-1:-1;;;69969:57:0;;8867:2:2;69969:57:0;;;8849:21:2;8906:2;8886:18;;;8879:30;8945:34;8925:18;;;8918:62;-1:-1:-1;;;8996:18:2;;;8989:31;9037:19;;69969:57:0;8665:397:2;69969:57:0;798:10;-1:-1:-1;;;;;70047:21:0;;;;:69;;-1:-1:-1;70072:44:0;70096:5;798:10;70967:164;:::i;70072:44::-;70039:161;;;;-1:-1:-1;;;70039:161:0;;9269:2:2;70039:161:0;;;9251:21:2;9308:2;9288:18;;;9281:30;9347:34;9327:18;;;9320:62;9418:26;9398:18;;;9391:54;9462:19;;70039:161:0;9067:420:2;70039:161:0;70213:21;70222:2;70226:7;70213:8;:21::i;:::-;69908:334;69838:404;;:::o;69316:211::-;69377:7;69498:21;:12;:19;:21::i;:::-;69491:28;;69316:211;:::o;91525:132::-;91596:7;91624:13;91638:3;91624:18;;;;;;:::i;:::-;;;;;;;;;;;;;;:24;;91525:132;-1:-1:-1;;91525:132:0:o;71198:305::-;71359:41;798:10;71392:7;71359:18;:41::i;:::-;71351:103;;;;-1:-1:-1;;;71351:103:0;;;;;;;:::i;:::-;71467:28;71477:4;71483:2;71487:7;71467:9;:28::i;69078:162::-;-1:-1:-1;;;;;69202:20:0;;69175:7;69202:20;;;:13;:20;;;;;:30;;69226:5;69202:23;:30::i;:::-;69195:37;;69078:162;;;;;:::o;89125:106::-;81643:6;;-1:-1:-1;;;;;81643:6:0;798:10;81790:23;81782:68;;;;-1:-1:-1;;;81782:68:0;;;;;;;:::i;:::-;89198:14:::1;:25:::0;;-1:-1:-1;;;;;;89198:25:0::1;-1:-1:-1::0;;;;;89198:25:0;;;::::1;::::0;;;::::1;::::0;;89125:106::o;90198:346::-;86705:10;86688:28;;;;:16;:28;;;;;;;;:36;;:28;:36;;86687:65;;-1:-1:-1;81643:6:0;;-1:-1:-1;;;;;81643:6:0;86730:10;:21;86687:65;86679:98;;;;-1:-1:-1;;;86679:98:0;;;;;;;:::i;:::-;90328:13:::1;90342:3;90328:18;;;;;;:::i;:::-;::::0;;;::::1;::::0;;;;;::::1;::::0;;;:25:::1;;::::0;::::1;;:34;90320:43;;;::::0;::::1;;90401:6;90374:13;90388:3;90374:18;;;;;;:::i;:::-;::::0;;;::::1;::::0;;;;;::::1;::::0;;;:33;;;;90446:7;;90418:13:::1;::::0;:18:::1;::::0;90432:3;;90418:18:::1;:::i;:::-;;;;;;;;;;;;;:25;;:35;;;;90489:4;90464:13;90478:3;90464:18;;;;;;:::i;:::-;;;;;;;;;;;;;:22;;:29;;;;90532:4;90504:13;90518:3;90504:18;;;;;;:::i;:::-;::::0;;;::::1;::::0;;;;;::::1;::::0;;;:25:::1;;:32:::0;;;::::1;;-1:-1:-1::0;;90504:32:0;;::::1;::::0;;;::::1;::::0;;-1:-1:-1;;;;90198:346:0:o;71574:151::-;71678:39;71695:4;71701:2;71705:7;71678:39;;;;;;;;;;;;:16;:39::i;89320:622::-;89385:12;;-1:-1:-1;;;89385:12:0;;;;89377:40;;;;-1:-1:-1;;;89377:40:0;;11236:2:2;89377:40:0;;;11218:21:2;11275:2;11255:18;;;11248:30;-1:-1:-1;;;11294:18:2;;;11287:45;11349:18;;89377:40:0;11034:339:2;89377:40:0;89449:7;;89436:9;:20;89428:42;;;;-1:-1:-1;;;89428:42:0;;11580:2:2;89428:42:0;;;11562:21:2;11619:1;11599:18;;;11592:29;-1:-1:-1;;;11637:18:2;;;11630:39;11686:18;;89428:42:0;11378:332:2;89428:42:0;89504:16;89512:7;89504;:16::i;:::-;-1:-1:-1;;;;;89490:30:0;:10;-1:-1:-1;;;;;89490:30:0;;89481:68;;;;-1:-1:-1;;;89481:68:0;;11917:2:2;89481:68:0;;;11899:21:2;11956:2;11936:18;;;11929:30;11995:26;11975:18;;;11968:54;12039:18;;89481:68:0;11715:348:2;89481:68:0;89568:14;;:44;;-1:-1:-1;;;89568:44:0;;89601:10;89568:44;;;1510:51:2;-1:-1:-1;;;;;89568:14:0;;;;:32;;1483:18:2;;89568:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:52;;89616:4;89568:52;89560:91;;;;-1:-1:-1;;;89560:91:0;;12520:2:2;89560:91:0;;;12502:21:2;12559:2;12539:18;;;12532:30;12598:28;12578:18;;;12571:56;12644:18;;89560:91:0;12318:350:2;89560:91:0;89670:14;;:50;;-1:-1:-1;;;89670:50:0;;89709:10;89670:50;;;1510:51:2;-1:-1:-1;;;;;89670:14:0;;;;:38;;1483:18:2;;89670:50:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:59;89662:94;;;;-1:-1:-1;;;89662:94:0;;12875:2:2;89662:94:0;;;12857:21:2;12914:2;12894:18;;;12887:30;-1:-1:-1;;;12933:18:2;;;12926:52;12995:18;;89662:94:0;12673:346:2;89662:94:0;89816:10;;89794:19;;;;:10;:19;;;;;;:32;;89816:10;89794:32;:::i;:::-;89775:15;:51;;89767:90;;;;-1:-1:-1;;;89767:90:0;;13488:2:2;89767:90:0;;;13470:21:2;13527:2;13507:18;;;13500:30;13566:28;13546:18;;;13539:56;13612:18;;89767:90:0;13286:350:2;89767:90:0;89868:14;89874:7;89868:5;:14::i;:::-;89893:28;;;;:19;:28;;;;;:41;;-1:-1:-1;;;;;;89893:41:0;89924:10;89893:41;;;89320:622::o;69604:172::-;69679:7;;69721:22;:12;69737:5;69721:15;:22::i;:::-;-1:-1:-1;69699:44:0;69604:172;-1:-1:-1;;;69604:172:0:o;87234:144::-;81643:6;;-1:-1:-1;;;;;81643:6:0;798:10;81790:23;81782:68;;;;-1:-1:-1;;;81782:68:0;;;;;;;:::i;:::-;87340:30:::1;::::0;87308:21:::1;::::0;-1:-1:-1;;;;;87340:21:0;::::1;::::0;:30;::::1;;;::::0;87308:21;;87293:12:::1;87340:30:::0;87293:12;87340:30;87308:21;87340;:30;::::1;;;;;;;;;;;;;::::0;::::1;;;;87750:103:::0;86705:10;86688:28;;;;:16;:28;;;;;;;;:36;;:28;:36;;86687:65;;-1:-1:-1;81643:6:0;;-1:-1:-1;;;;;81643:6:0;86730:10;:21;86687:65;86679:98;;;;-1:-1:-1;;;86679:98:0;;;;;;;:::i;:::-;87825:20:::1;87837:7;87825:11;:20::i;:::-;87750:103:::0;:::o;67278:177::-;67350:7;67377:70;67394:7;67377:70;;;;;;;;;;;;;;;;;:12;;:70;:16;:70::i;68897:97::-;68945:13;68978:8;68971:15;;;;;:::i;66995:221::-;67067:7;-1:-1:-1;;;;;67095:19:0;;67087:74;;;;-1:-1:-1;;;67087:74:0;;13843:2:2;67087:74:0;;;13825:21:2;13882:2;13862:18;;;13855:30;13921:34;13901:18;;;13894:62;-1:-1:-1;;;13972:18:2;;;13965:40;14022:19;;67087:74:0;13641:406:2;67087:74:0;-1:-1:-1;;;;;67179:20:0;;;;;;:13;:20;;;;;:29;;:27;:29::i;82221:148::-;81643:6;;-1:-1:-1;;;;;81643:6:0;798:10;81790:23;81782:68;;;;-1:-1:-1;;;81782:68:0;;;;;;;:::i;:::-;82312:6:::1;::::0;82291:40:::1;::::0;82328:1:::1;::::0;-1:-1:-1;;;;;82312:6:0::1;::::0;82291:40:::1;::::0;82328:1;;82291:40:::1;82342:6;:19:::0;;-1:-1:-1;;;;;;82342:19:0::1;::::0;;82221:148::o;91014:91::-;86705:10;86688:28;;;;:16;:28;;;;;;;;:36;;:28;:36;;86687:65;;-1:-1:-1;81643:6:0;;-1:-1:-1;;;;;81643:6:0;86730:10;:21;86687:65;86679:98;;;;-1:-1:-1;;;86679:98:0;;;;;;;:::i;:::-;91083:7:::1;:14:::0;91014:91::o;86280:43::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;91899:153::-;92033:10;;91966:4;92010:20;;;:10;:20;;;;;;91966:4;;92010:33;;;:::i;:::-;91991:15;:52;;;91899:153;-1:-1:-1;;91899:153:0:o;87468:231::-;81643:6;;-1:-1:-1;;;;;81643:6:0;798:10;81790:23;81782:68;;;;-1:-1:-1;;;81782:68:0;;;;;;;:::i;:::-;87572:49:::1;::::0;-1:-1:-1;;;87572:49:0;;87615:4:::1;87572:49;::::0;::::1;1510:51:2::0;87558:11:0::1;::::0;-1:-1:-1;;;;;87572:34:0;::::1;::::0;::::1;::::0;1483:18:2;;87572:49:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;87632:46;::::0;-1:-1:-1;;;87632:46:0;;-1:-1:-1;;;;;14433:32:2;;;87632:46:0::1;::::0;::::1;14415:51:2::0;14482:18;;;14475:34;;;87558:63:0;;-1:-1:-1;87632:33:0;;::::1;::::0;::::1;::::0;14388:18:2;;87632:46:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;87547:152;87468:231:::0;;:::o;67691:104::-;67747:13;67780:7;67773:14;;;;;:::i;70601:295::-;798:10;-1:-1:-1;;;;;70704:24:0;;;70696:62;;;;-1:-1:-1;;;70696:62:0;;14722:2:2;70696:62:0;;;14704:21:2;14761:2;14741:18;;;14734:30;14800:27;14780:18;;;14773:55;14845:18;;70696:62:0;14520:349:2;70696:62:0;798:10;70771:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;70771:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;70771:53:0;;;;;;;;;;70840:48;;540:41:2;;;70771:42:0;;798:10;70840:48;;513:18:2;70840:48:0;;;;;;;70601:295;;:::o;88278:89::-;81643:6;;-1:-1:-1;;;;;81643:6:0;798:10;81790:23;81782:68;;;;-1:-1:-1;;;81782:68:0;;;;;;;:::i;:::-;88347:12:::1;::::0;;-1:-1:-1;;;;88331:28:0;::::1;-1:-1:-1::0;;;88347:12:0;;;::::1;;;88346:13;88331:28:::0;;::::1;;::::0;;88278:89::o;90622:122::-;86705:10;86688:28;;;;:16;:28;;;;;;;;:36;;:28;:36;;86687:65;;-1:-1:-1;81643:6:0;;-1:-1:-1;;;;;81643:6:0;86730:10;:21;86687:65;86679:98;;;;-1:-1:-1;;;86679:98:0;;;;;;;:::i;:::-;90731:5:::1;90703:13;90717:3;90703:18;;;;;;:::i;:::-;::::0;;;::::1;::::0;;;;;::::1;::::0;;;:25:::1;;:33:::0;;;::::1;;-1:-1:-1::0;;90703:33:0;;::::1;::::0;;;::::1;::::0;;-1:-1:-1;90622:122:0:o;91183:270::-;91253:7;91262;91271;91280;91289:4;91314:13;91328:3;91314:18;;;;;;:::i;:::-;;;;;;;;;;;;;;:24;;91340:13;;:18;;91354:3;;91340:18;:::i;:::-;;;;;;;;;;;;;:26;;;91368:13;91382:3;91368:18;;;;;;:::i;:::-;;;;;;;;;;;;;:25;;;91395:13;91409:3;91395:18;;;;;;:::i;:::-;;;;;;;;;;;;;:22;;;91419:13;91433:3;91419:18;;;;;;:::i;:::-;;;;;;;;;;;;;;:25;;;91306:139;;-1:-1:-1;91306:139:0;;-1:-1:-1;91306:139:0;-1:-1:-1;91306:139:0;-1:-1:-1;91419:25:0;;;-1:-1:-1;91183:270:0;;;;;;;:::o;71796:285::-;71928:41;798:10;71961:7;71928:18;:41::i;:::-;71920:103;;;;-1:-1:-1;;;71920:103:0;;;;;;;:::i;:::-;72034:39;72048:4;72054:2;72058:7;72067:5;72034:13;:39::i;87908:111::-;86705:10;86688:28;;;;:16;:28;;;;;;;;:36;;:28;:36;;86687:65;;-1:-1:-1;81643:6:0;;-1:-1:-1;;;;;81643:6:0;86730:10;:21;86687:65;86679:98;;;;-1:-1:-1;;;86679:98:0;;;;;;;:::i;:::-;87987:10:::1;:24:::0;87908:111::o;92139:291::-;92212:13;92246:16;92254:7;92246;:16::i;:::-;92238:76;;;;-1:-1:-1;;;92238:76:0;;15076:2:2;92238:76:0;;;15058:21:2;15115:2;15095:18;;;15088:30;15154:34;15134:18;;;15127:62;-1:-1:-1;;;15205:18:2;;;15198:45;15260:19;;92238:76:0;14874:411:2;92238:76:0;92358:1;92338:9;:7;:9::i;:::-;92332:23;:27;:90;;;;;;;;;;;;;;;;;92386:9;:7;:9::i;:::-;92397:18;:7;:16;:18::i;:::-;92369:47;;;;;;;;;:::i;:::-;;;;;;;;;;;;;92325:97;92139:291;-1:-1:-1;;92139:291:0:o;88466:426::-;88568:14;;-1:-1:-1;;;;;88568:14:0;88554:10;:28;88546:60;;;;-1:-1:-1;;;88546:60:0;;15764:2:2;88546:60:0;;;15746:21:2;15803:2;15783:18;;;15776:30;-1:-1:-1;;;15822:18:2;;;15815:49;15881:18;;88546:60:0;15562:343:2;88546:60:0;88637:10;;88617:17;88658:20;;;:9;:20;;;;;:26;88681:3;88658:20;:26;:::i;:::-;-1:-1:-1;88695:21:0;;;;:10;:21;;;;;;;88719:15;88695:39;;88774:18;:13;;:18;;88788:3;;88774:18;:::i;:::-;;;;;;;;;;;;;:26;;;88803:1;88774:30;;;;:::i;:::-;88745:13;88759:3;88745:18;;;;;;:::i;:::-;;;;;;;;;;;;;:26;;:59;;;;88828:10;;88841:1;88828:14;;;;:::i;:::-;88815:10;:27;88853:31;88863:9;88874;88853;:31::i;90819:129::-;86705:10;86688:28;;;;:16;:28;;;;;;;;:36;;:28;:36;;86687:65;;-1:-1:-1;81643:6:0;;-1:-1:-1;;;;;81643:6:0;86730:10;:21;86687:65;86679:98;;;;-1:-1:-1;;;86679:98:0;;;;;;;:::i;:::-;90936:4:::1;90911:13;90925:3;90911:18;;;;;;:::i;:::-;::::0;;;::::1;::::0;;;;;::::1;::::0;;;:22:::1;;:29:::0;-1:-1:-1;;90819:129:0:o;88100:101::-;81643:6;;-1:-1:-1;;;;;81643:6:0;798:10;81790:23;81782:68;;;;-1:-1:-1;;;81782:68:0;;;;;;;:::i;:::-;88177:16:::1;::::0;;-1:-1:-1;;;;88157:36:0;::::1;-1:-1:-1::0;;;88177:16:0;;;::::1;;;88176:17;88157:36:::0;;::::1;;::::0;;88100:101::o;90003:123::-;81643:6;;-1:-1:-1;;;;;81643:6:0;798:10;81790:23;81782:68;;;;-1:-1:-1;;;81782:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;90084:24:0;;;::::1;;::::0;;;:16:::1;:24;::::0;;;;:34;;-1:-1:-1;;90084:34:0::1;::::0;::::1;;::::0;;;::::1;::::0;;90003:123::o;82524:244::-;81643:6;;-1:-1:-1;;;;;81643:6:0;798:10;81790:23;81782:68;;;;-1:-1:-1;;;81782:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;82613:22:0;::::1;82605:73;;;::::0;-1:-1:-1;;;82605:73:0;;18236:2:2;82605:73:0::1;::::0;::::1;18218:21:2::0;18275:2;18255:18;;;18248:30;18314:34;18294:18;;;18287:62;-1:-1:-1;;;18365:18:2;;;18358:36;18411:19;;82605:73:0::1;18034:402:2::0;82605:73:0::1;82715:6;::::0;82694:38:::1;::::0;-1:-1:-1;;;;;82694:38:0;;::::1;::::0;82715:6:::1;::::0;82694:38:::1;::::0;82715:6:::1;::::0;82694:38:::1;82743:6;:17:::0;;-1:-1:-1;;;;;;82743:17:0::1;-1:-1:-1::0;;;;;82743:17:0;;;::::1;::::0;;;::::1;::::0;;82524:244::o;88955:116::-;81643:6;;-1:-1:-1;;;;;81643:6:0;798:10;81790:23;81782:68;;;;-1:-1:-1;;;81782:68:0;;;;;;;:::i;:::-;89028:14:::1;:35:::0;;-1:-1:-1;;;;;;89028:35:0::1;-1:-1:-1::0;;;;;89028:35:0;;;::::1;::::0;;;::::1;::::0;;88955:116::o;73548:127::-;73613:4;73637:30;:12;73659:7;73637:21;:30::i;79566:192::-;79641:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;79641:29:0;-1:-1:-1;;;;;79641:29:0;;;;;;;;:24;;79695:23;79641:24;79695:14;:23::i;:::-;-1:-1:-1;;;;;79686:46:0;;;;;;;;;;;79566:192;;:::o;44201:123::-;44270:7;44297:19;44305:3;40863:19;;40780:110;73842:355;73935:4;73960:16;73968:7;73960;:16::i;:::-;73952:73;;;;-1:-1:-1;;;73952:73:0;;18643:2:2;73952:73:0;;;18625:21:2;18682:2;18662:18;;;18655:30;18721:34;18701:18;;;18694:62;-1:-1:-1;;;18772:18:2;;;18765:42;18824:19;;73952:73:0;18441:408:2;73952:73:0;74036:13;74052:23;74067:7;74052:14;:23::i;:::-;74036:39;;74105:5;-1:-1:-1;;;;;74094:16:0;:7;-1:-1:-1;;;;;74094:16:0;;:51;;;;74138:7;-1:-1:-1;;;;;74114:31:0;:20;74126:7;74114:11;:20::i;:::-;-1:-1:-1;;;;;74114:31:0;;74094:51;:94;;;-1:-1:-1;;;;;;71088:25:0;;;71064:4;71088:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;74149:39;74086:103;73842:355;-1:-1:-1;;;;73842:355:0:o;76978:599::-;77103:4;-1:-1:-1;;;;;77076:31:0;:23;77091:7;77076:14;:23::i;:::-;-1:-1:-1;;;;;77076:31:0;;77068:85;;;;-1:-1:-1;;;77068:85:0;;19056:2:2;77068:85:0;;;19038:21:2;19095:2;19075:18;;;19068:30;19134:34;19114:18;;;19107:62;-1:-1:-1;;;19185:18:2;;;19178:39;19234:19;;77068:85:0;18854:405:2;77068:85:0;-1:-1:-1;;;;;77190:16:0;;77182:65;;;;-1:-1:-1;;;77182:65:0;;19466:2:2;77182:65:0;;;19448:21:2;19505:2;19485:18;;;19478:30;19544:34;19524:18;;;19517:62;-1:-1:-1;;;19595:18:2;;;19588:34;19639:19;;77182:65:0;19264:400:2;77182:65:0;77364:29;77381:1;77385:7;77364:8;:29::i;:::-;-1:-1:-1;;;;;77406:19:0;;;;;;:13;:19;;;;;:35;;77433:7;77406:26;:35::i;:::-;-1:-1:-1;;;;;;77452:17:0;;;;;;:13;:17;;;;;:30;;77474:7;77452:21;:30::i;:::-;-1:-1:-1;77495:29:0;:12;77512:7;77521:2;77495:16;:29::i;:::-;;77561:7;77557:2;-1:-1:-1;;;;;77542:27:0;77551:4;-1:-1:-1;;;;;77542:27:0;;;;;;;;;;;76978:599;;;:::o;36004:137::-;36075:7;36110:22;36114:3;36126:5;36110:3;:22::i;76096:545::-;76156:13;76172:23;76187:7;76172:14;:23::i;:::-;76156:39;;76315:29;76332:1;76336:7;76315:8;:29::i;:::-;76403:19;;;;:10;:19;;;;;76397:33;;;;;:::i;:::-;:38;;-1:-1:-1;76393:97:0;;76459:19;;;;:10;:19;;;;;76452:26;;;:::i;:::-;-1:-1:-1;;;;;76502:20:0;;;;;;:13;:20;;;;;:36;;76530:7;76502:27;:36::i;:::-;-1:-1:-1;76551:28:0;:12;76571:7;76551:19;:28::i;:::-;-1:-1:-1;76597:36:0;;76625:7;;76621:1;;-1:-1:-1;;;;;76597:36:0;;;;;76621:1;;76597:36;76145:496;76096:545;:::o;44663:236::-;44743:7;;;;44803:22;44807:3;44819:5;44803:3;:22::i;:::-;44772:53;;;;-1:-1:-1;44663:236:0;-1:-1:-1;;;;;44663:236:0:o;78178:100::-;78251:8;:19;78262:8;78251;:19;:::i;:::-;;78178:100;:::o;45949:213::-;46056:7;46107:44;46112:3;46132;46138:12;46107:4;:44::i;:::-;46099:53;-1:-1:-1;45949:213:0;;;;;;:::o;72963:272::-;73077:28;73087:4;73093:2;73097:7;73077:9;:28::i;:::-;73124:48;73147:4;73153:2;73157:7;73166:5;73124:22;:48::i;:::-;73116:111;;;;-1:-1:-1;;;73116:111:0;;;;;;;:::i;60858:716::-;60914:13;60965:14;60982:17;60993:5;60982:10;:17::i;:::-;61002:1;60982:21;60965:38;;61018:20;61052:6;61041:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;61041:18:0;-1:-1:-1;61018:41:0;-1:-1:-1;61183:28:0;;;61199:2;61183:28;61240:288;-1:-1:-1;;61272:5:0;-1:-1:-1;;;61409:2:0;61398:14;;61393:30;61272:5;61380:44;61470:2;61461:11;;;-1:-1:-1;61491:21:0;61240:288;61491:21;-1:-1:-1;61549:6:0;60858:716;-1:-1:-1;;;60858:716:0:o;74540:110::-;74616:26;74626:2;74630:7;74616:26;;;;;;;;;;;;:9;:26::i;43962:151::-;44046:4;40655:17;;;:12;;;:17;;;;;;:22;;44070:35;40560:125;35091:137;35161:4;35185:35;35193:3;35213:5;35185:7;:35::i;34784:131::-;34851:4;34875:32;34880:3;34900:5;34875:4;:32::i;43385:185::-;43474:4;43498:64;43503:3;43523;-1:-1:-1;;;;;43537:23:0;;43498:4;:64::i;31042:204::-;31137:18;;31109:7;;31137:26;-1:-1:-1;31129:73:0;;;;-1:-1:-1;;;31129:73:0;;20422:2:2;31129:73:0;;;20404:21:2;20461:2;20441:18;;;20434:30;20500:34;20480:18;;;20473:62;-1:-1:-1;;;20551:18:2;;;20544:32;20593:19;;31129:73:0;20220:398:2;31129:73:0;31220:3;:11;;31232:5;31220:18;;;;;;;;:::i;:::-;;;;;;;;;31213:25;;31042:204;;;;:::o;43736:142::-;43813:4;43837:33;43845:3;43865;43837:7;:33::i;41245:279::-;41349:19;;41312:7;;;;41349:27;-1:-1:-1;41341:74:0;;;;-1:-1:-1;;;41341:74:0;;20957:2:2;41341:74:0;;;20939:21:2;20996:2;20976:18;;;20969:30;21035:34;21015:18;;;21008:62;-1:-1:-1;;;21086:18:2;;;21079:32;21128:19;;41341:74:0;20755:398:2;41341:74:0;41428:22;41453:3;:12;;41466:5;41453:19;;;;;;;;:::i;:::-;;;;;;;;;;;41428:44;;41491:5;:10;;;41503:5;:12;;;41483:33;;;;;41245:279;;;;;:::o;42742:319::-;42836:7;42875:17;;;:12;;;:17;;;;;;42926:12;42911:13;42903:36;;;;-1:-1:-1;;;42903:36:0;;;;;;;;:::i;:::-;-1:-1:-1;42993:3:0;43006:12;43017:1;43006:8;:12;:::i;:::-;42993:26;;;;;;;;:::i;:::-;;;;;;;;;;;:33;;;42986:40;;;42742:319;;;;;:::o;78843:604::-;78964:4;-1:-1:-1;;;;;78991:13:0;;19552:20;78986:60;;-1:-1:-1;79030:4:0;79023:11;;78986:60;79056:23;79082:252;-1:-1:-1;;;798:10:0;79222:4;79241:7;79263:5;79098:181;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;;;;79098:181:0;;;;;;;-1:-1:-1;;;;;79098:181:0;;;;;;;;;;;79082:252;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;79082:15:0;;;:252;:15;:252::i;:::-;79056:278;;79345:13;79372:10;79361:32;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;79412:26:0;-1:-1:-1;;;79412:26:0;;-1:-1:-1;;;78843:604:0;;;;;;:::o;56509:948::-;56562:7;;-1:-1:-1;;;56640:17:0;;56636:106;;-1:-1:-1;;;56678:17:0;;;-1:-1:-1;56724:2:0;56714:12;56636:106;56769:8;56760:5;:17;56756:106;;56807:8;56798:17;;;-1:-1:-1;56844:2:0;56834:12;56756:106;56889:8;56880:5;:17;56876:106;;56927:8;56918:17;;;-1:-1:-1;56964:2:0;56954:12;56876:106;57009:7;57000:5;:16;56996:103;;57046:7;57037:16;;;-1:-1:-1;57082:1:0;57072:11;56996:103;57126:7;57117:5;:16;57113:103;;57163:7;57154:16;;;-1:-1:-1;57199:1:0;57189:11;57113:103;57243:7;57234:5;:16;57230:103;;57280:7;57271:16;;;-1:-1:-1;57316:1:0;57306:11;57230:103;57360:7;57351:5;:16;57347:68;;57398:1;57388:11;57443:6;56509:948;-1:-1:-1;;56509:948:0:o;74877:250::-;74973:18;74979:2;74983:7;74973:5;:18::i;:::-;75010:54;75041:1;75045:2;75049:7;75058:5;75010:22;:54::i;:::-;75002:117;;;;-1:-1:-1;;;75002:117:0;;;;;;;:::i;28744:1544::-;28810:4;28949:19;;;:12;;;:19;;;;;;28985:15;;28981:1300;;29347:21;29371:14;29384:1;29371:10;:14;:::i;:::-;29420:18;;29347:38;;-1:-1:-1;29400:17:0;;29420:22;;29441:1;;29420:22;:::i;:::-;29400:42;;29687:17;29707:3;:11;;29719:9;29707:22;;;;;;;;:::i;:::-;;;;;;;;;29687:42;;29853:9;29824:3;:11;;29836:13;29824:26;;;;;;;;:::i;:::-;;;;;;;;;;:38;29956:17;:13;29972:1;29956:17;:::i;:::-;29930:23;;;;:12;;;:23;;;;;:43;30082:17;;29930:3;;30082:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;30177:3;:12;;:19;30190:5;30177:19;;;;;;;;;;;30170:26;;;30220:4;30213:11;;;;;;;;28981:1300;30264:5;30257:12;;;;;28154:414;28217:4;40655:17;;;:12;;;:17;;;;;;28234:327;;-1:-1:-1;28277:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;28460:18;;28438:19;;;:12;;;:19;;;;;;:40;;;;28493:11;;28234:327;-1:-1:-1;28544:5:0;28537:12;;38060:692;38136:4;38271:17;;;:12;;;:17;;;;;;38305:13;;;38301:444;;-1:-1:-1;;38390:38:0;;;;;;;;;;;;;;;;;;38372:57;;;;;;;;:12;:57;;;;;;;;;;;;;;;;;;;;;;;;38587:19;;38567:17;;;:12;;;:17;;;;;;;:39;38621:11;;38301:444;38701:5;38665:3;38678:12;38689:1;38678:8;:12;:::i;:::-;38665:26;;;;;;;;:::i;:::-;;;;;;;;;;;:33;;:41;;;;38728:5;38721:12;;;;;38927:1549;38991:4;39126:17;;;:12;;;:17;;;;;;39160:13;;39156:1313;;39521:21;39545:12;39556:1;39545:8;:12;:::i;:::-;39592:19;;39521:36;;-1:-1:-1;39572:17:0;;39592:23;;39614:1;;39592:23;:::i;:::-;39572:43;;39860:26;39889:3;:12;;39902:9;39889:23;;;;;;;;:::i;:::-;;;;;;;;;;;39860:52;;40037:9;40007:3;:12;;40020:13;40007:27;;;;;;;;:::i;:::-;;;;;;;;;:39;;:27;;;;;:39;;;;;;;;;;;;40145:17;;:13;;:17;:::i;:::-;40127:14;;40114:28;;;;:12;;;:28;;;;;:48;40271:18;;40114:3;;40271:18;;;;;:::i;:::-;;;;;;;;;;-1:-1:-1;;40271:18:0;;;;;;;;;;;;;;;;;;;;;40367:17;;;:12;;;:17;;;;;;40360:24;;;;40271:18;-1:-1:-1;40401:11:0;;-1:-1:-1;;;;40401:11:0;22103:195;22206:12;22238:52;22260:6;22268:4;22274:1;22277:12;22238:21;:52::i;75463:404::-;-1:-1:-1;;;;;75543:16:0;;75535:61;;;;-1:-1:-1;;;75535:61:0;;22380:2:2;75535:61:0;;;22362:21:2;;;22399:18;;;22392:30;22458:34;22438:18;;;22431:62;22510:18;;75535:61:0;22178:356:2;75535:61:0;75616:16;75624:7;75616;:16::i;:::-;75615:17;75607:58;;;;-1:-1:-1;;;75607:58:0;;22741:2:2;75607:58:0;;;22723:21:2;22780:2;22760:18;;;22753:30;22819;22799:18;;;22792:58;22867:18;;75607:58:0;22539:352:2;75607:58:0;-1:-1:-1;;;;;75736:17:0;;;;;;:13;:17;;;;;:30;;75758:7;75736:21;:30::i;:::-;-1:-1:-1;75779:29:0;:12;75796:7;75805:2;75779:16;:29::i;:::-;-1:-1:-1;75826:33:0;;75851:7;;-1:-1:-1;;;;;75826:33:0;;;75843:1;;75826:33;;75843:1;;75826:33;75463:404;;:::o;23155:530::-;23282:12;23340:5;23315:21;:30;;23307:81;;;;-1:-1:-1;;;23307:81:0;;23098:2:2;23307:81:0;;;23080:21:2;23137:2;23117:18;;;23110:30;23176:34;23156:18;;;23149:62;-1:-1:-1;;;23227:18:2;;;23220:36;23273:19;;23307:81:0;22896:402:2;23307:81:0;19552:20;;23399:60;;;;-1:-1:-1;;;23399:60:0;;23505:2:2;23399:60:0;;;23487:21:2;23544:2;23524:18;;;23517:30;23583:31;23563:18;;;23556:59;23632:18;;23399:60:0;23303:353:2;23399:60:0;23533:12;23547:23;23574:6;-1:-1:-1;;;;;23574:11:0;23594:5;23602:4;23574:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23532:75;;;;23625:52;23643:7;23652:10;23664:12;23625:17;:52::i;:::-;23618:59;23155:530;-1:-1:-1;;;;;;;23155:530:0:o;25695:742::-;25810:12;25839:7;25835:595;;;-1:-1:-1;25870:10:0;25863:17;;25835:595;25984:17;;:21;25980:439;;26247:10;26241:17;26308:15;26295:10;26291:2;26287:19;26280:44;25980:439;26390:12;26383:20;;-1:-1:-1;;;26383:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:131:2:-;-1:-1:-1;;;;;;88:32:2;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:300::-;645:3;683:5;677:12;710:6;705:3;698:19;766:6;759:4;752:5;748:16;741:4;736:3;732:14;726:47;818:1;811:4;802:6;797:3;793:16;789:27;782:38;881:4;874:2;870:7;865:2;857:6;853:15;849:29;844:3;840:39;836:50;829:57;;;592:300;;;;:::o;897:231::-;1046:2;1035:9;1028:21;1009:4;1066:56;1118:2;1107:9;1103:18;1095:6;1066:56;:::i;1133:226::-;1192:6;1245:2;1233:9;1224:7;1220:23;1216:32;1213:52;;;1261:1;1258;1251:12;1213:52;-1:-1:-1;1306:23:2;;1133:226;-1:-1:-1;1133:226:2:o;1572:173::-;1640:20;;-1:-1:-1;;;;;1689:31:2;;1679:42;;1669:70;;1735:1;1732;1725:12;1669:70;1572:173;;;:::o;1750:300::-;1818:6;1826;1879:2;1867:9;1858:7;1854:23;1850:32;1847:52;;;1895:1;1892;1885:12;1847:52;1918:29;1937:9;1918:29;:::i;:::-;1908:39;2016:2;2001:18;;;;1988:32;;-1:-1:-1;;;1750:300:2:o;2237:127::-;2298:10;2293:3;2289:20;2286:1;2279:31;2329:4;2326:1;2319:15;2353:4;2350:1;2343:15;2369:716;2434:5;2466:1;2490:18;2482:6;2479:30;2476:56;;;2512:18;;:::i;:::-;-1:-1:-1;2667:2:2;2661:9;-1:-1:-1;;2580:2:2;2559:15;;2555:29;;2725:2;2713:15;2709:29;2697:42;;2790:22;;;2769:18;2754:34;;2751:62;2748:88;;;2816:18;;:::i;:::-;2852:2;2845:22;2900;;;2885:6;-1:-1:-1;2885:6:2;2937:16;;;2934:25;-1:-1:-1;2931:45:2;;;2972:1;2969;2962:12;2931:45;3022:6;3017:3;3010:4;3002:6;2998:17;2985:44;3077:1;3070:4;3061:6;3053;3049:19;3045:30;3038:41;;2369:716;;;;;:::o;3090:222::-;3133:5;3186:3;3179:4;3171:6;3167:17;3163:27;3153:55;;3204:1;3201;3194:12;3153:55;3226:80;3302:3;3293:6;3280:20;3273:4;3265:6;3261:17;3226:80;:::i;3317:322::-;3386:6;3439:2;3427:9;3418:7;3414:23;3410:32;3407:52;;;3455:1;3452;3445:12;3407:52;3495:9;3482:23;3528:18;3520:6;3517:30;3514:50;;;3560:1;3557;3550:12;3514:50;3583;3625:7;3616:6;3605:9;3601:22;3583:50;:::i;3644:374::-;3721:6;3729;3737;3790:2;3778:9;3769:7;3765:23;3761:32;3758:52;;;3806:1;3803;3796:12;3758:52;3829:29;3848:9;3829:29;:::i;:::-;3819:39;;3877:38;3911:2;3900:9;3896:18;3877:38;:::i;:::-;3644:374;;3867:48;;-1:-1:-1;;;3984:2:2;3969:18;;;;3956:32;;3644:374::o;4023:186::-;4082:6;4135:2;4123:9;4114:7;4110:23;4106:32;4103:52;;;4151:1;4148;4141:12;4103:52;4174:29;4193:9;4174:29;:::i;4214:677::-;4310:6;4318;4326;4334;4387:3;4375:9;4366:7;4362:23;4358:33;4355:53;;;4404:1;4401;4394:12;4355:53;4444:9;4431:23;4477:18;4469:6;4466:30;4463:50;;;4509:1;4506;4499:12;4463:50;4532;4574:7;4565:6;4554:9;4550:22;4532:50;:::i;:::-;4522:60;4651:2;4636:18;;4623:32;;-1:-1:-1;4752:2:2;4737:18;;4724:32;;4855:2;4840:18;4827:32;;-1:-1:-1;4214:677:2;-1:-1:-1;;;;4214:677:2:o;4896:260::-;4964:6;4972;5025:2;5013:9;5004:7;5000:23;4996:32;4993:52;;;5041:1;5038;5031:12;4993:52;5064:29;5083:9;5064:29;:::i;:::-;5054:39;;5112:38;5146:2;5135:9;5131:18;5112:38;:::i;:::-;5102:48;;4896:260;;;;;:::o;5161:118::-;5247:5;5240:13;5233:21;5226:5;5223:32;5213:60;;5269:1;5266;5259:12;5284:315;5349:6;5357;5410:2;5398:9;5389:7;5385:23;5381:32;5378:52;;;5426:1;5423;5416:12;5378:52;5449:29;5468:9;5449:29;:::i;:::-;5439:39;;5528:2;5517:9;5513:18;5500:32;5541:28;5563:5;5541:28;:::i;:::-;5588:5;5578:15;;;5284:315;;;;;:::o;6082:713::-;6177:6;6185;6193;6201;6254:3;6242:9;6233:7;6229:23;6225:33;6222:53;;;6271:1;6268;6261:12;6222:53;6294:29;6313:9;6294:29;:::i;:::-;6284:39;;6342:38;6376:2;6365:9;6361:18;6342:38;:::i;:::-;6332:48;-1:-1:-1;6449:2:2;6434:18;;6421:32;;-1:-1:-1;6528:2:2;6513:18;;6500:32;6555:18;6544:30;;6541:50;;;6587:1;6584;6577:12;6541:50;6610:22;;6663:4;6655:13;;6651:27;-1:-1:-1;6641:55:2;;6692:1;6689;6682:12;6641:55;6715:74;6781:7;6776:2;6763:16;6758:2;6754;6750:11;6715:74;:::i;:::-;6705:84;;;6082:713;;;;;;;:::o;6800:396::-;6878:6;6886;6939:2;6927:9;6918:7;6914:23;6910:32;6907:52;;;6955:1;6952;6945:12;6907:52;6995:9;6982:23;7028:18;7020:6;7017:30;7014:50;;;7060:1;7057;7050:12;7014:50;7083;7125:7;7116:6;7105:9;7101:22;7083:50;:::i;:::-;7073:60;;;7152:38;7186:2;7175:9;7171:18;7152:38;:::i;7201:436::-;7279:6;7287;7340:2;7328:9;7319:7;7315:23;7311:32;7308:52;;;7356:1;7353;7346:12;7308:52;7396:9;7383:23;7429:18;7421:6;7418:30;7415:50;;;7461:1;7458;7451:12;7415:50;7484;7526:7;7517:6;7506:9;7502:22;7484:50;:::i;:::-;7474:60;7603:2;7588:18;;;;7575:32;;-1:-1:-1;;;;7201:436:2:o;7867:380::-;7946:1;7942:12;;;;7989;;;8010:61;;8064:4;8056:6;8052:17;8042:27;;8010:61;8117:2;8109:6;8106:14;8086:18;8083:38;8080:161;;8163:10;8158:3;8154:20;8151:1;8144:31;8198:4;8195:1;8188:15;8226:4;8223:1;8216:15;8080:161;;7867:380;;;:::o;9492:212::-;9534:3;9572:5;9566:12;9616:6;9609:4;9602:5;9598:16;9593:3;9587:36;9678:1;9642:16;;9667:13;;;-1:-1:-1;9642:16:2;;9492:212;-1:-1:-1;9492:212:2:o;9709:192::-;9840:3;9865:30;9891:3;9883:6;9865:30;:::i;9906:413::-;10108:2;10090:21;;;10147:2;10127:18;;;10120:30;10186:34;10181:2;10166:18;;10159:62;-1:-1:-1;;;10252:2:2;10237:18;;10230:47;10309:3;10294:19;;9906:413::o;10324:356::-;10526:2;10508:21;;;10545:18;;;10538:30;10604:34;10599:2;10584:18;;10577:62;10671:2;10656:18;;10324:356::o;10685:344::-;10887:2;10869:21;;;10926:2;10906:18;;;10899:30;-1:-1:-1;;;10960:2:2;10945:18;;10938:50;11020:2;11005:18;;10685:344::o;12068:245::-;12135:6;12188:2;12176:9;12167:7;12163:23;12159:32;12156:52;;;12204:1;12201;12194:12;12156:52;12236:9;12230:16;12255:28;12277:5;12255:28;:::i;13024:127::-;13085:10;13080:3;13076:20;13073:1;13066:31;13116:4;13113:1;13106:15;13140:4;13137:1;13130:15;13156:125;13221:9;;;13242:10;;;13239:36;;;13255:18;;:::i;14052:184::-;14122:6;14175:2;14163:9;14154:7;14150:23;14146:32;14143:52;;;14191:1;14188;14181:12;14143:52;-1:-1:-1;14214:16:2;;14052:184;-1:-1:-1;14052:184:2:o;15290:267::-;15469:3;15494:57;15520:30;15546:3;15538:6;15520:30;:::i;:::-;15512:6;15494:57;:::i;16036:518::-;16138:2;16133:3;16130:11;16127:421;;;16174:5;16171:1;16164:16;16218:4;16215:1;16205:18;16288:2;16276:10;16272:19;16269:1;16265:27;16259:4;16255:38;16324:4;16312:10;16309:20;16306:47;;;-1:-1:-1;16347:4:2;16306:47;16402:2;16397:3;16393:12;16390:1;16386:20;16380:4;16376:31;16366:41;;16457:81;16475:2;16468:5;16465:13;16457:81;;;16534:1;16520:16;;16501:1;16490:13;16457:81;;;16461:3;;16036:518;;;:::o;16730:1299::-;16856:3;16850:10;16883:18;16875:6;16872:30;16869:56;;;16905:18;;:::i;:::-;16934:97;17024:6;16984:38;17016:4;17010:11;16984:38;:::i;:::-;16978:4;16934:97;:::i;:::-;17080:4;17111:2;17100:14;;17128:1;17123:649;;;;17816:1;17833:6;17830:89;;;-1:-1:-1;17885:19:2;;;17879:26;17830:89;-1:-1:-1;;16687:1:2;16683:11;;;16679:24;16675:29;16665:40;16711:1;16707:11;;;16662:57;17932:81;;17093:930;;17123:649;15983:1;15976:14;;;16020:4;16007:18;;-1:-1:-1;;17159:20:2;;;17277:222;17291:7;17288:1;17285:14;17277:222;;;17373:19;;;17367:26;17352:42;;17480:4;17465:20;;;;17433:1;17421:14;;;;17307:12;17277:222;;;17281:3;17527:6;17518:7;17515:19;17512:201;;;17588:19;;;17582:26;-1:-1:-1;;17671:1:2;17667:14;;;17683:3;17663:24;17659:37;17655:42;17640:58;17625:74;;17512:201;-1:-1:-1;;;;17759:1:2;17743:14;;;17739:22;17726:36;;-1:-1:-1;16730:1299:2:o;19669:414::-;19871:2;19853:21;;;19910:2;19890:18;;;19883:30;19949:34;19944:2;19929:18;;19922:62;-1:-1:-1;;;20015:2:2;20000:18;;19993:48;20073:3;20058:19;;19669:414::o;20623:127::-;20684:10;20679:3;20675:20;20672:1;20665:31;20715:4;20712:1;20705:15;20739:4;20736:1;20729:15;21158:128;21225:9;;;21246:11;;;21243:37;;;21260:18;;:::i;21291:496::-;-1:-1:-1;;;;;21522:32:2;;;21504:51;;21591:32;;21586:2;21571:18;;21564:60;21655:2;21640:18;;21633:34;;;21703:3;21698:2;21683:18;;21676:31;;;-1:-1:-1;;21724:57:2;;21761:19;;21753:6;21724:57;:::i;:::-;21716:65;21291:496;-1:-1:-1;;;;;;21291:496:2:o;21792:249::-;21861:6;21914:2;21902:9;21893:7;21889:23;21885:32;21882:52;;;21930:1;21927;21920:12;21882:52;21962:9;21956:16;21981:30;22005:5;21981:30;:::i;22046:127::-;22107:10;22102:3;22098:20;22095:1;22088:31;22138:4;22135:1;22128:15;22162:4;22159:1;22152:15
Swarm Source
ipfs://54c5d95535cb64941073956e17507fa3b06b068f2ebe1a7034a29d872284c11c
Loading...
Loading
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.