ERC-721
Overview
Max Total Supply
7,236 FRANKLT
Holders
234
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract
Balance
58 FRANKLTLoading...
Loading
Loading...
Loading
Loading...
Loading
Contract Name:
LotteryNFT
Compiler Version
v0.6.12+commit.27d51765
Contract Source Code (Solidity)
/** *Submitted for verification at ftmscan.com on 2021-05-17 */ // File: @openzeppelin/contracts/utils/Context.sol // SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /* ███████╗██████╗ █████╗ ███╗ ██╗██╗ ██╗███████╗███╗ ██╗███████╗████████╗███████╗██╗███╗ ██╗ ██╔════╝██╔══██╗██╔══██╗████╗ ██║██║ ██╔╝██╔════╝████╗ ██║██╔════╝╚══██╔══╝██╔════╝██║████╗ ██║ █████╗ ██████╔╝███████║██╔██╗ ██║█████╔╝ █████╗ ██╔██╗ ██║███████╗ ██║ █████╗ ██║██╔██╗ ██║ ██╔══╝ ██╔══██╗██╔══██║██║╚██╗██║██╔═██╗ ██╔══╝ ██║╚██╗██║╚════██║ ██║ ██╔══╝ ██║██║╚██╗██║ ██║ ██║ ██║██║ ██║██║ ╚████║██║ ██╗███████╗██║ ╚████║███████║ ██║ ███████╗██║██║ ╚████║ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═══╝╚═╝ ╚═╝╚══════╝╚═╝ ╚═══╝╚══════╝ ╚═╝ ╚══════╝╚═╝╚═╝ ╚═══╝ Website: https://frankenstein.finance/ twitter: https://twitter.com/FrankenDefi */ /* * @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 payable) { 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.6.0 <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.6.2 <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.6.2 <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.6.2 <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.6.0 <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.6.0 <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.6.0 <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.6.2 <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.6.0 <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.6.0 <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/Strings.sol pragma solidity >=0.6.0 <0.8.0; /** * @dev String operations. */ library Strings { /** * @dev Converts a `uint256` to its ASCII `string` representation. */ function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); uint256 index = digits - 1; temp = value; while (temp != 0) { buffer[index--] = bytes1(uint8(48 + temp % 10)); temp /= 10; } return string(buffer); } } // File: @openzeppelin/contracts/token/ERC721/ERC721.sol pragma solidity >=0.6.0 <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/utils/Counters.sol pragma solidity >=0.6.0 <0.8.0; /** * @title Counters * @author Matt Condon (@shrugs) * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number * of elements in a mapping, issuing ERC721 ids, or counting request ids. * * Include with `using Counters for Counters.Counter;` * Since it is not possible to overflow a 256 bit integer with increments of one, `increment` can skip the {SafeMath} * overflow check, thereby saving gas. This does assume however correct usage, in that the underlying `_value` is never * directly accessed. */ library Counters { using SafeMath for uint256; struct Counter { // This variable should never be directly accessed by users of the library: interactions must be restricted to // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add // this feature: see https://github.com/ethereum/solidity/issues/4637 uint256 _value; // default: 0 } function current(Counter storage counter) internal view returns (uint256) { return counter._value; } function increment(Counter storage counter) internal { // The {SafeMath} overflow check can be skipped here, see the comment at the top counter._value += 1; } function decrement(Counter storage counter) internal { counter._value = counter._value.sub(1); } } // File: @openzeppelin/contracts/access/Ownable.sol pragma solidity >=0.6.0 <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; } } // File: contracts/interfaces/IBEP20.sol pragma solidity >=0.6.4; interface IBEP20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the token decimals. */ function decimals() external view returns (uint8); /** * @dev Returns the token symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the token name. */ function name() external view returns (string memory); /** * @dev Returns the bep token owner. */ function getOwner() external view returns (address); /** * @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 `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, 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 `sender` to `recipient` 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 sender, address recipient, uint256 amount) external returns (bool); /** * @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); } // File: contracts/libraries/SafeBEP20.sol pragma solidity >=0.6.0 <0.8.0; /** * @title SafeBEP20 * @dev Wrappers around BEP20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeBEP20 for IBEP20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeBEP20 { using SafeMath for uint256; using Address for address; function safeTransfer(IBEP20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IBEP20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IBEP20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove(IBEP20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeBEP20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IBEP20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IBEP20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeBEP20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IBEP20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeBEP20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed"); } } } // File: contracts/interfaces/IHelp.sol pragma solidity ^0.6.12; interface IHelp { function Bytecode_0_0_2() external view returns (bool); } // File: contracts/LotteryNFT.sol pragma solidity ^0.6.12; pragma experimental ABIEncoderV2; /* ███████╗██████╗ █████╗ ███╗ ██╗██╗ ██╗███████╗███╗ ██╗███████╗████████╗███████╗██╗███╗ ██╗ ██╔════╝██╔══██╗██╔══██╗████╗ ██║██║ ██╔╝██╔════╝████╗ ██║██╔════╝╚══██╔══╝██╔════╝██║████╗ ██║ █████╗ ██████╔╝███████║██╔██╗ ██║█████╔╝ █████╗ ██╔██╗ ██║███████╗ ██║ █████╗ ██║██╔██╗ ██║ ██╔══╝ ██╔══██╗██╔══██║██║╚██╗██║██╔═██╗ ██╔══╝ ██║╚██╗██║╚════██║ ██║ ██╔══╝ ██║██║╚██╗██║ ██║ ██║ ██║██║ ██║██║ ╚████║██║ ██╗███████╗██║ ╚████║███████║ ██║ ███████╗██║██║ ╚████║ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═══╝╚═╝ ╚═╝╚══════╝╚═╝ ╚═══╝╚══════╝ ╚═╝ ╚══════╝╚═╝╚═╝ ╚═══╝ Website: https://frankenstein.finance/ twitter: https://twitter.com/FrankenDefi */ contract LotteryNFT is ERC721, Ownable { using SafeBEP20 for IBEP20; using Counters for Counters.Counter; Counters.Counter private tokenIds; // The TOKEN IBEP20 public token; // lotteryAddress address public lottery; // admin Address address public admin; mapping (uint256 => uint8[4]) public lotteryInfo; mapping (uint256 => uint256) public lotteryAmount; mapping (uint256 => uint256) public issueIndex; mapping (uint256 => bool) public claimInfo; constructor(IBEP20 _token, string memory _name, string memory _alias) public ERC721(_name, _alias) { token = _token; admin = msg.sender; } function setLottery(address _lottery) external onlyOwner { require(lottery == address(0), "!lottery"); lottery = _lottery; token.approve(lottery, uint(~0)); } function setApprove() external { require(msg.sender == admin, "!admin"); token.approve(lottery, uint(~0)); } function newLotteryItem(address player, uint8[4] memory _lotteryNumbers, uint256 _amount, uint256 _issueIndex) external onlyOwner returns (uint256){ tokenIds.increment(); uint256 newItemId = tokenIds.current(); _mint(player, newItemId); lotteryInfo[newItemId] = _lotteryNumbers; lotteryAmount[newItemId] = _amount; issueIndex[newItemId] = _issueIndex; return newItemId; } function getLotteryNumbers(uint256 tokenId) external view returns (uint8[4] memory) { return lotteryInfo[tokenId]; } function getLotteryAmount(uint256 tokenId) external view returns (uint256) { return lotteryAmount[tokenId]; } function getLotteryIssueIndex(uint256 tokenId) external view returns (uint256) { return issueIndex[tokenId]; } function claimReward(uint256 tokenId) external onlyOwner { claimInfo[tokenId] = true; } function multiClaimReward(uint256[] memory _tokenIds) external onlyOwner { for (uint i = 0; i < _tokenIds.length; i++) { claimInfo[_tokenIds[i]] = true; } } function burn(uint256 tokenId) external onlyOwner { _burn(tokenId); } function getClaimStatus(uint256 tokenId) external view returns (bool) { return claimInfo[tokenId]; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract IBEP20","name":"_token","type":"address"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_alias","type":"string"}],"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":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"claimInfo","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"claimReward","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":"uint256","name":"tokenId","type":"uint256"}],"name":"getClaimStatus","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getLotteryAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getLotteryIssueIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getLotteryNumbers","outputs":[{"internalType":"uint8[4]","name":"","type":"uint8[4]"}],"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":"uint256","name":"","type":"uint256"}],"name":"issueIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lottery","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"lotteryAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"lotteryInfo","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"}],"name":"multiClaimReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"player","type":"address"},{"internalType":"uint8[4]","name":"_lotteryNumbers","type":"uint8[4]"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint256","name":"_issueIndex","type":"uint256"}],"name":"newLotteryItem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"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":[],"name":"setApprove","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_lottery","type":"address"}],"name":"setLottery","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IBEP20","name":"","type":"address"}],"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"}]
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)
000000000000000000000000eb86b05cfee3e48db9a44275701ed099462c8ba0000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000144652414e4b204c6f7474657279205469636b657400000000000000000000000000000000000000000000000000000000000000000000000000000000000000074652414e4b4c5400000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : _token (address): 0xeb86B05cFEE3e48DB9a44275701Ed099462c8ba0
Arg [1] : _name (string): FRANK Lottery Ticket
Arg [2] : _alias (string): FRANKLT
-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 000000000000000000000000eb86b05cfee3e48db9a44275701ed099462c8ba0
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000014
Arg [4] : 4652414e4b204c6f7474657279205469636b6574000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000007
Arg [6] : 4652414e4b4c5400000000000000000000000000000000000000000000000000
Deployed Bytecode Sourcemap
79111:2404:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12019:150;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53323:100;;;:::i;:::-;;;;;;;:::i;56109:221::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;79538:46::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;55639:404::-;;;;;;:::i;:::-;;:::i;:::-;;55117:211;;;:::i;80864:124::-;;;;;;:::i;:::-;;:::i;56999:305::-;;;;;;:::i;:::-;;:::i;54879:162::-;;;;;;:::i;:::-;;:::i;81396:114::-;;;;;;:::i;:::-;;:::i;80148:439::-;;;;;;:::i;:::-;;:::i;57375:151::-;;;;;;:::i;:::-;;:::i;81305:83::-;;;;;;:::i;:::-;;:::i;55405:172::-;;;;;;:::i;:::-;;:::i;80009:131::-;;;:::i;79591:42::-;;;;;;:::i;:::-;;:::i;80595:130::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;53079:177::-;;;;;;:::i;:::-;;:::i;79427:48::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;54698:97::-;;;:::i;52796:221::-;;;;;;:::i;:::-;;:::i;69587:148::-;;;:::i;81105:192::-;;;;;;:::i;:::-;;:::i;68936:87::-;;;:::i;53492:104::-;;;:::i;56402:295::-;;;;;;:::i;:::-;;:::i;80996:101::-;;;;;;:::i;:::-;;:::i;57597:285::-;;;;;;:::i;:::-;;:::i;79347:22::-;;;:::i;79482:49::-;;;;;;:::i;:::-;;:::i;53667:792::-;;;;;;:::i;:::-;;:::i;56768:164::-;;;;;;:::i;:::-;;:::i;79811:190::-;;;;;;:::i;:::-;;:::i;69890:244::-;;;;;;:::i;:::-;;:::i;80733:123::-;;;;;;:::i;:::-;;:::i;79398:20::-;;;:::i;79298:19::-;;;:::i;12019:150::-;-1:-1:-1;;;;;;12128:33:0;;12104:4;12128:33;;;;;;;;;;;;;12019:150;;;;:::o;53323:100::-;53410:5;53403:12;;;;;;;;-1:-1:-1;;53403:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53377:13;;53403:12;;53410:5;;53403:12;;53410:5;53403:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53323:100;:::o;56109:221::-;56185:7;56213:16;56221:7;56213;:16::i;:::-;56205:73;;;;-1:-1:-1;;;56205:73:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;56298:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;56298:24:0;;56109:221::o;79538:46::-;;;;;;;;;;;;;:::o;55639:404::-;55720:13;55736:23;55751:7;55736:14;:23::i;:::-;55720:39;;55784:5;-1:-1:-1;;;;;55778:11:0;:2;-1:-1:-1;;;;;55778:11:0;;;55770:57;;;;-1:-1:-1;;;55770:57:0;;;;;;;:::i;:::-;55864:5;-1:-1:-1;;;;;55848:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;55848:21:0;;:69;;;;55873:44;55897:5;55904:12;:10;:12::i;55873:44::-;55840:161;;;;-1:-1:-1;;;55840:161:0;;;;;;;:::i;:::-;56014:21;56023:2;56027:7;56014:8;:21::i;:::-;55639:404;;;:::o;55117:211::-;55178:7;55299:21;:12;:19;:21::i;:::-;55292:28;;55117:211;:::o;80864:124::-;80934:7;80961:19;;;:10;:19;;;;;;;80864:124::o;56999:305::-;57160:41;57179:12;:10;:12::i;:::-;57193:7;57160:18;:41::i;:::-;57152:103;;;;-1:-1:-1;;;57152:103:0;;;;;;;:::i;:::-;57268:28;57278:4;57284:2;57288:7;57268:9;:28::i;54879:162::-;-1:-1:-1;;;;;55003:20:0;;54976:7;55003:20;;;:13;:20;;;;;:30;;55027:5;55003:23;:30::i;:::-;54996:37;;54879:162;;;;;:::o;81396:114::-;81460:4;81484:18;;;:9;:18;;;;;;;;;81396:114::o;80148:439::-;80287:7;69167:12;:10;:12::i;:::-;-1:-1:-1;;;;;69156:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;69156:23:0;;69148:68;;;;-1:-1:-1;;;69148:68:0;;;;;;;:::i;:::-;80306:20:::1;:8;:18;:20::i;:::-;80337:17;80357:18;:8;:16;:18::i;:::-;80337:38;;80386:24;80392:6;80400:9;80386:5;:24::i;:::-;80421:22;::::0;;;:11:::1;:22;::::0;;;;:40:::1;::::0;80446:15;80421:40:::1;;:::i;:::-;-1:-1:-1::0;80472:24:0::1;::::0;;;:13:::1;:24;::::0;;;;;;;:34;;;80517:10:::1;:21:::0;;;;;:35;;;80486:9;-1:-1:-1;69227:1:0::1;80148:439:::0;;;;;;:::o;57375:151::-;57479:39;57496:4;57502:2;57506:7;57479:39;;;;;;;;;;;;:16;:39::i;81305:83::-;69167:12;:10;:12::i;:::-;-1:-1:-1;;;;;69156:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;69156:23:0;;69148:68;;;;-1:-1:-1;;;69148:68:0;;;;;;;:::i;:::-;81366:14:::1;81372:7;81366:5;:14::i;:::-;81305:83:::0;:::o;55405:172::-;55480:7;;55522:22;:12;55538:5;55522:15;:22::i;:::-;-1:-1:-1;55500:44:0;55405:172;-1:-1:-1;;;55405:172:0:o;80009:131::-;80073:5;;-1:-1:-1;;;;;80073:5:0;80059:10;:19;80051:38;;;;-1:-1:-1;;;80051:38:0;;;;;;;:::i;:::-;80100:5;;80114:7;;80100:32;;-1:-1:-1;;;80100:32:0;;-1:-1:-1;;;;;80100:5:0;;;;:13;;:32;;80114:7;;;-1:-1:-1;;80128:2:0;80100:32;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;79591:42::-;;;;;;;;;;;;;;;:::o;80595:130::-;80662:15;;:::i;:::-;80697:20;;;;:11;:20;;;;;;80690:27;;;;;;;;;;80697:20;;80690:27;;80697:20;;80690:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;80690:27:0;;80595:130;-1:-1:-1;;;;;;;80595:130:0:o;53079:177::-;53151:7;53178:70;53195:7;53178:70;;;;;;;;;;;;;;;;;:12;;:70;:16;:70::i;79427:48::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;79427:48:0;;-1:-1:-1;79427:48:0:o;54698:97::-;54779:8;54772:15;;;;;;;;-1:-1:-1;;54772:15:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54746:13;;54772:15;;54779:8;;54772:15;;54779:8;54772:15;;;;;;;;;;;;;;;;;;;;;;;;52796:221;52868:7;-1:-1:-1;;;;;52896:19:0;;52888:74;;;;-1:-1:-1;;;52888:74:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;52980:20:0;;;;;;:13;:20;;;;;:29;;:27;:29::i;69587:148::-;69167:12;:10;:12::i;:::-;-1:-1:-1;;;;;69156:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;69156:23:0;;69148:68;;;;-1:-1:-1;;;69148:68:0;;;;;;;:::i;:::-;69678:6:::1;::::0;69657:40:::1;::::0;69694:1:::1;::::0;-1:-1:-1;;;;;69678:6:0::1;::::0;69657:40:::1;::::0;69694:1;;69657:40:::1;69708:6;:19:::0;;-1:-1:-1;;;;;;69708:19:0::1;::::0;;69587:148::o;81105:192::-;69167:12;:10;:12::i;:::-;-1:-1:-1;;;;;69156:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;69156:23:0;;69148:68;;;;-1:-1:-1;;;69148:68:0;;;;;;;:::i;:::-;81194:6:::1;81189:101;81210:9;:16;81206:1;:20;81189:101;;;81274:4;81248:9;:23;81258:9;81268:1;81258:12;;;;;;;;;::::0;;::::1;::::0;;;;;;;81248:23;;;::::1;::::0;;;;;;-1:-1:-1;81248:23:0;:30;;-1:-1:-1;;81248:30:0::1;::::0;::::1;;::::0;;;::::1;::::0;;-1:-1:-1;81228:3:0::1;81189:101;;;;81105:192:::0;:::o;68936:87::-;69009:6;;-1:-1:-1;;;;;69009:6:0;68936:87;:::o;53492:104::-;53581:7;53574:14;;;;;;;;-1:-1:-1;;53574:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53548:13;;53574:14;;53581:7;;53574:14;;53581:7;53574:14;;;;;;;;;;;;;;;;;;;;;;;;56402:295;56517:12;:10;:12::i;:::-;-1:-1:-1;;;;;56505:24:0;:8;-1:-1:-1;;;;;56505:24:0;;;56497:62;;;;-1:-1:-1;;;56497:62:0;;;;;;;:::i;:::-;56617:8;56572:18;:32;56591:12;:10;:12::i;:::-;-1:-1:-1;;;;;56572:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;56572:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;56572:53:0;;;;;;;;;;;56656:12;:10;:12::i;:::-;-1:-1:-1;;;;;56641:48:0;;56680:8;56641:48;;;;;;:::i;:::-;;;;;;;;56402:295;;:::o;80996:101::-;69167:12;:10;:12::i;:::-;-1:-1:-1;;;;;69156:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;69156:23:0;;69148:68;;;;-1:-1:-1;;;69148:68:0;;;;;;;:::i;:::-;81064:18:::1;::::0;;;:9:::1;:18;::::0;;;;:25;;-1:-1:-1;;81064:25:0::1;81085:4;81064:25;::::0;;80996:101::o;57597:285::-;57729:41;57748:12;:10;:12::i;:::-;57762:7;57729:18;:41::i;:::-;57721:103;;;;-1:-1:-1;;;57721:103:0;;;;;;;:::i;:::-;57835:39;57849:4;57855:2;57859:7;57868:5;57835:13;:39::i;:::-;57597:285;;;;:::o;79347:22::-;;;-1:-1:-1;;;;;79347:22:0;;:::o;79482:49::-;;;;;;;;;;;;;:::o;53667:792::-;53740:13;53774:16;53782:7;53774;:16::i;:::-;53766:76;;;;-1:-1:-1;;;53766:76:0;;;;;;;:::i;:::-;53881:19;;;;:10;:19;;;;;;;;;53855:45;;;;;;-1:-1:-1;;53855:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:23;;:45;;;53881:19;53855:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53911:18;53932:9;:7;:9::i;:::-;53911:30;;54023:4;54017:18;54039:1;54017:23;54013:72;;;-1:-1:-1;54064:9:0;-1:-1:-1;54057:16:0;;54013:72;54189:23;;:27;54185:108;;54264:4;54270:9;54247:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;54233:48;;;;;;54185:108;54425:4;54431:18;:7;:16;:18::i;:::-;54408:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;54394:57;;;;53667:792;;;:::o;56768:164::-;-1:-1:-1;;;;;56889:25:0;;;56865:4;56889:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;56768:164::o;79811:190::-;69167:12;:10;:12::i;:::-;-1:-1:-1;;;;;69156:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;69156:23:0;;69148:68;;;;-1:-1:-1;;;69148:68:0;;;;;;;:::i;:::-;79887:7:::1;::::0;-1:-1:-1;;;;;79887:7:0::1;:21:::0;79879:42:::1;;;;-1:-1:-1::0;;;79879:42:0::1;;;;;;;:::i;:::-;79932:7;:18:::0;;-1:-1:-1;;;;;;79932:18:0::1;-1:-1:-1::0;;;;;79932:18:0;;::::1;::::0;;;::::1;::::0;;;;79961:5:::1;::::0;:32:::1;::::0;-1:-1:-1;;;79961:32:0;;:5;;::::1;::::0;:13:::1;::::0;:32:::1;::::0;79975:7;::::1;::::0;-1:-1:-1;;79989:2:0;79961:32:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;69890:244::-:0;69167:12;:10;:12::i;:::-;-1:-1:-1;;;;;69156:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;69156:23:0;;69148:68;;;;-1:-1:-1;;;69148:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;69979:22:0;::::1;69971:73;;;;-1:-1:-1::0;;;69971:73:0::1;;;;;;;:::i;:::-;70081:6;::::0;70060:38:::1;::::0;-1:-1:-1;;;;;70060:38:0;;::::1;::::0;70081:6:::1;::::0;70060:38:::1;::::0;70081:6:::1;::::0;70060:38:::1;70109:6;:17:::0;;-1:-1:-1;;;;;;70109:17:0::1;-1:-1:-1::0;;;;;70109:17:0;;;::::1;::::0;;;::::1;::::0;;69890:244::o;80733:123::-;80799:7;80826:22;;;:13;:22;;;;;;;80733:123::o;79398:20::-;;;-1:-1:-1;;;;;79398:20:0;;:::o;79298:19::-;;;-1:-1:-1;;;;;79298:19:0;;:::o;59349:127::-;59414:4;59438:30;:12;59460:7;59438:21;:30::i;2451:106::-;2539:10;2451:106;:::o;65367:192::-;65442:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;65442:29:0;-1:-1:-1;;;;;65442:29:0;;;;;;;;:24;;65496:23;65442:24;65496:14;:23::i;:::-;-1:-1:-1;;;;;65487:46:0;;;;;;;;;;;65367:192;;:::o;46062:123::-;46131:7;46158:19;46166:3;46158:7;:19::i;59643:355::-;59736:4;59761:16;59769:7;59761;:16::i;:::-;59753:73;;;;-1:-1:-1;;;59753:73:0;;;;;;;:::i;:::-;59837:13;59853:23;59868:7;59853:14;:23::i;:::-;59837:39;;59906:5;-1:-1:-1;;;;;59895:16:0;:7;-1:-1:-1;;;;;59895:16:0;;:51;;;;59939:7;-1:-1:-1;;;;;59915:31:0;:20;59927:7;59915:11;:20::i;:::-;-1:-1:-1;;;;;59915:31:0;;59895:51;:94;;;;59950:39;59974:5;59981:7;59950:23;:39::i;62779:599::-;62904:4;-1:-1:-1;;;;;62877:31:0;:23;62892:7;62877:14;:23::i;:::-;-1:-1:-1;;;;;62877:31:0;;62869:85;;;;-1:-1:-1;;;62869:85:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;62991:16:0;;62983:65;;;;-1:-1:-1;;;62983:65:0;;;;;;;:::i;:::-;63061:39;63082:4;63088:2;63092:7;63061:20;:39::i;:::-;63165:29;63182:1;63186:7;63165:8;:29::i;:::-;-1:-1:-1;;;;;63207:19:0;;;;;;:13;:19;;;;;:35;;63234:7;63207:26;:35::i;:::-;-1:-1:-1;;;;;;63253:17:0;;;;;;:13;:17;;;;;:30;;63275:7;63253:21;:30::i;:::-;-1:-1:-1;63296:29:0;:12;63313:7;63322:2;63296:16;:29::i;:::-;;63362:7;63358:2;-1:-1:-1;;;;;63343:27:0;63352:4;-1:-1:-1;;;;;63343:27:0;;;;;;;;;;;62779:599;;;:::o;37853:137::-;37924:7;37959:22;37963:3;37975:5;37959:3;:22::i;67519:181::-;67673:19;;67691:1;67673:19;;;67519:181::o;67397:114::-;67489:14;;67397:114::o;61264:404::-;-1:-1:-1;;;;;61344:16:0;;61336:61;;;;-1:-1:-1;;;61336:61:0;;;;;;;:::i;:::-;61417:16;61425:7;61417;:16::i;:::-;61416:17;61408:58;;;;-1:-1:-1;;;61408:58:0;;;;;;;:::i;:::-;61479:45;61508:1;61512:2;61516:7;61479:20;:45::i;:::-;-1:-1:-1;;;;;61537:17:0;;;;;;:13;:17;;;;;:30;;61559:7;61537:21;:30::i;:::-;-1:-1:-1;61580:29:0;:12;61597:7;61606:2;61580:16;:29::i;:::-;-1:-1:-1;61627:33:0;;61652:7;;-1:-1:-1;;;;;61627:33:0;;;61644:1;;61627:33;;61644:1;;61627:33;61264:404;;:::o;61897:545::-;61957:13;61973:23;61988:7;61973:14;:23::i;:::-;61957:39;;62027:48;62048:5;62063:1;62067:7;62027:20;:48::i;:::-;62116:29;62133:1;62137:7;62116:8;:29::i;:::-;62204:19;;;;:10;:19;;;;;62198:33;;-1:-1:-1;;62198:33:0;;;;;;;;;;;:38;62194:97;;62260:19;;;;:10;:19;;;;;62253:26;;;:::i;:::-;-1:-1:-1;;;;;62303:20:0;;;;;;:13;:20;;;;;:36;;62331:7;62303:27;:36::i;:::-;-1:-1:-1;62352:28:0;:12;62372:7;62352:19;:28::i;:::-;-1:-1:-1;62398:36:0;;62426:7;;62422:1;;-1:-1:-1;;;;;62398:36:0;;;;;62422:1;;62398:36;61897:545;;:::o;46524:236::-;46604:7;;;;46664:22;46668:3;46680:5;46664:3;:22::i;:::-;46633:53;;;;-1:-1:-1;46524:236:0;-1:-1:-1;;;;;46524:236:0:o;47810:213::-;47917:7;47968:44;47973:3;47993;47999:12;47968:4;:44::i;:::-;47960:53;-1:-1:-1;47810:213:0;;;;;;:::o;58764:272::-;58878:28;58888:4;58894:2;58898:7;58878:9;:28::i;:::-;58925:48;58948:4;58954:2;58958:7;58967:5;58925:22;:48::i;:::-;58917:111;;;;-1:-1:-1;;;58917:111:0;;;;;;;:::i;48274:746::-;48330:13;48551:10;48547:53;;-1:-1:-1;48578:10:0;;;;;;;;;;;;-1:-1:-1;;;48578:10:0;;;;;;48547:53;48625:5;48610:12;48666:78;48673:9;;48666:78;;48699:8;;48730:2;48722:10;;;;48666:78;;;48754:19;48786:6;48776:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;48776:17:0;-1:-1:-1;48848:5:0;;-1:-1:-1;48754:39:0;-1:-1:-1;;;48820:10:0;;48864:117;48871:9;;48864:117;;48940:2;48933:4;:9;48928:2;:14;48915:29;;48897:6;48904:7;;;;;;;48897:15;;;;;;;;;;;:47;-1:-1:-1;;;;;48897:47:0;;;;;;;;-1:-1:-1;48967:2:0;48959:10;;;;48864:117;;;-1:-1:-1;49005:6:0;48274:746;-1:-1:-1;;;;48274:746:0:o;45823:151::-;45907:4;45931:35;45941:3;45961;45931:9;:35::i;36940:137::-;37010:4;37034:35;37042:3;37062:5;37034:7;:35::i;36633:131::-;36700:4;36724:32;36729:3;36749:5;36724:4;:32::i;45246:185::-;45335:4;45359:64;45364:3;45384;-1:-1:-1;;;;;45398:23:0;;45359:4;:64::i;32891:204::-;32986:18;;32958:7;;32986:26;-1:-1:-1;32978:73:0;;;;-1:-1:-1;;;32978:73:0;;;;;;;:::i;:::-;33069:3;:11;;33081:5;33069:18;;;;;;;;;;;;;;;;33062:25;;32891:204;;;;:::o;45597:142::-;45674:4;45698:33;45706:3;45726;45698:7;:33::i;43106:279::-;43210:19;;43173:7;;;;43210:27;-1:-1:-1;43202:74:0;;;;-1:-1:-1;;;43202:74:0;;;;;;;:::i;:::-;43289:22;43314:3;:12;;43327:5;43314:19;;;;;;;;;;;;;;;;;;43289:44;;43352:5;:10;;;43364:5;:12;;;43344:33;;;;;43106:279;;;;;:::o;44603:319::-;44697:7;44736:17;;;:12;;;:17;;;;;;44787:12;44772:13;44764:36;;;;-1:-1:-1;;;44764:36:0;;;;;;;;:::i;:::-;;44854:3;:12;;44878:1;44867:8;:12;44854:26;;;;;;;;;;;;;;;;;;:33;;;44847:40;;;44603:319;;;;;:::o;64644:604::-;64765:4;64792:15;:2;-1:-1:-1;;;;;64792:13:0;;:15::i;:::-;64787:60;;-1:-1:-1;64831:4:0;64824:11;;64787:60;64857:23;64883:252;-1:-1:-1;;;64996:12:0;:10;:12::i;:::-;65023:4;65042:7;65064:5;64899:181;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;;;;64899:181:0;;;;;;;-1:-1:-1;;;;;64899:181:0;;;;;;;;;;;64883:252;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;64883:15:0;;;:252;:15;:252::i;:::-;64857:278;;65146:13;65173:10;65162:32;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;65213:26:0;-1:-1:-1;;;65213:26:0;;-1:-1:-1;;;64644:604:0;;;;;;:::o;42421:125::-;42492:4;42516:17;;;:12;;;;;:17;;;;;;:22;;;42421:125::o;30593:1544::-;30659:4;30798:19;;;:12;;;:19;;;;;;30834:15;;30830:1300;;31269:18;;-1:-1:-1;;31220:14:0;;;;31269:22;;;;31196:21;;31269:3;;:22;;31556;;;;;;;;;;;;;;31536:42;;31702:9;31673:3;:11;;31685:13;31673:26;;;;;;;;;;;;;;;;;;;:38;;;;31779:23;;;31821:1;31779:12;;;:23;;;;;;31805:17;;;31779:43;;31931:17;;31779:3;;31931:17;;;;;;;;;;;;;;;;;;;;;;32026:3;:12;;:19;32039:5;32026:19;;;;;;;;;;;32019:26;;;32069:4;32062:11;;;;;;;;30830:1300;32113:5;32106:12;;;;;30003:414;30066:4;30088:21;30098:3;30103:5;30088:9;:21::i;:::-;30083:327;;-1:-1:-1;30126:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;30309:18;;30287:19;;;:12;;;:19;;;;;;:40;;;;30342:11;;30083:327;-1:-1:-1;30393:5:0;30386:12;;39921:692;39997:4;40132:17;;;:12;;;:17;;;;;;40166:13;40162:444;;-1:-1:-1;;40251:38:0;;;;;;;;;;;;;;;;;;40233:57;;;;;;;;:12;:57;;;;;;;;;;;;;;;;;;;;;;;;40448:19;;40428:17;;;:12;;;:17;;;;;;;:39;40482:11;;40162:444;40562:5;40526:3;:12;;40550:1;40539:8;:12;40526:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;40589:5;40582:12;;;;;40788:1549;40852:4;40987:17;;;:12;;;:17;;;;;;41021:13;;41017:1313;;41453:19;;-1:-1:-1;;41406:12:0;;;;41453:23;;;;41382:21;;41453:3;;:23;;41750;;;;;;;;;;;;;;;;41721:52;;41898:9;41868:3;:12;;41881:13;41868:27;;;;;;;;;;;;;;;;:39;;:27;;;;;:39;;;;;;;;;;;;;;;41988:14;;41975:28;;:12;;;:28;;;;;42006:17;;;41975:48;;42132:18;;41975:3;;42132:18;;;;;;;;;;;;;;-1:-1:-1;;42132:18:0;;;;;;;;;;;;;;;;;;;;;42228:17;;;:12;;;:17;;;;;;42221:24;;;;42132:18;-1:-1:-1;42262:11:0;;-1:-1:-1;;;;42262:11:0;21022:422;21389:20;21428:8;;;21022:422::o;23940:195::-;24043:12;24075:52;24097:6;24105:4;24111:1;24114:12;24043;25244:18;25255:6;25244:10;:18::i;:::-;25236:60;;;;-1:-1:-1;;;25236:60:0;;;;;;;:::i;:::-;25370:12;25384:23;25411:6;-1:-1:-1;;;;;25411:11:0;25431:5;25439:4;25411:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25369:75;;;;25462:52;25480:7;25489:10;25501:12;25462:17;:52::i;:::-;25455:59;24992:530;-1:-1:-1;;;;;;;24992:530:0:o;27532:742::-;27647:12;27676:7;27672:595;;;-1:-1:-1;27707:10:0;27700:17;;27672:595;27821:17;;:21;27817:439;;28084:10;28078:17;28145:15;28132:10;28128:2;28124:19;28117:44;28032:148;28227:12;28220:20;;-1:-1:-1;;;28220:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:130;72:20;;-1:-1;;;;;34172:54;;35288:35;;35278:2;;35337:1;;35327:12;2636:126;2701:20;;34388:4;34377:16;;35774:33;;35764:2;;35821:1;;35811:12;2769:241;;2873:2;2861:9;2852:7;2848:23;2844:32;2841:2;;;-1:-1;;2879:12;2841:2;2941:53;2986:7;2962:22;2941:53;:::i;3017:366::-;;;3138:2;3126:9;3117:7;3113:23;3109:32;3106:2;;;-1:-1;;3144:12;3106:2;3206:53;3251:7;3227:22;3206:53;:::i;:::-;3196:63;;3314:53;3359:7;3296:2;3339:9;3335:22;3314:53;:::i;:::-;3304:63;;3100:283;;;;;:::o;3390:491::-;;;;3528:2;3516:9;3507:7;3503:23;3499:32;3496:2;;;-1:-1;;3534:12;3496:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;3586:63;-1:-1;3686:2;3725:22;;72:20;97:33;72:20;97:33;:::i;:::-;3490:391;;3694:63;;-1:-1;;;3794:2;3833:22;;;;2566:20;;3490:391::o;3888:721::-;;;;;4052:3;4040:9;4031:7;4027:23;4023:33;4020:2;;;-1:-1;;4059:12;4020:2;4121:53;4166:7;4142:22;4121:53;:::i;:::-;4111:63;;4211:2;4229:53;4274:7;4211:2;4254:9;4250:22;4229:53;:::i;:::-;4219:63;;4319:2;4362:9;4358:22;2566:20;4327:63;;4455:2;4444:9;4440:18;4427:32;4479:18;;4471:6;4468:30;4465:2;;;-1:-1;;4501:12;4465:2;4576:6;4565:9;4561:22;;;2152:3;2145:4;2137:6;2133:17;2129:27;2119:2;;-1:-1;;2160:12;2119:2;2207:6;2194:20;4479:18;32090:6;32087:30;32084:2;;;-1:-1;;32120:12;32084:2;2229:64;32193:9;32174:17;;-1:-1;;32170:33;32251:15;;2229:64;:::i;:::-;2220:73;;2313:6;2306:5;2299:21;2417:3;4211:2;2408:6;2341;2399:16;;2396:25;2393:2;;;-1:-1;;2424:12;2393:2;34775:6;4211:2;2341:6;2337:17;4211:2;2375:5;2371:16;34752:30;34813:16;;;;;34806:27;;;;4014:595;;;;-1:-1;4014:595;;-1:-1;;4014:595::o;4616:661::-;;;;;4792:3;4780:9;4771:7;4767:23;4763:33;4760:2;;;-1:-1;;4799:12;4760:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;4851:63;-1:-1;4951:2;986:17;;;982:27;-1:-1;972:2;;-1:-1;;1013:12;972:2;1047:4;1066:76;1081:60;1047:4;1081:60;:::i;:::-;1066:76;:::i;:::-;1148:16;4951:2;5015:9;5011:22;1236:27;5015:9;1236:27;1265:3;1236:27;1233:36;1230:2;;;-1:-1;;1272:12;1230:2;-1:-1;1292:204;1047:4;1314:1;1311:13;1292:204;;;1397:35;1428:3;1416:10;1397:35;:::i;:::-;1385:48;;1447:14;;;;1475;;;;1339:1;1332:9;1292:204;;;-1:-1;4754:523;;4959:84;;-1:-1;;2566:20;;;5189:3;5229:22;2566:20;;4754:523;-1:-1;;;;;;4754:523::o;5284:360::-;;;5402:2;5390:9;5381:7;5377:23;5373:32;5370:2;;;-1:-1;;5408:12;5370:2;5470:53;5515:7;5491:22;5470:53;:::i;:::-;5460:63;;5560:2;5600:9;5596:22;1574:20;1599:30;1623:5;1599:30;:::i;:::-;5568:60;;;;5364:280;;;;;:::o;5651:366::-;;;5772:2;5760:9;5751:7;5747:23;5743:32;5740:2;;;-1:-1;;5778:12;5740:2;5840:53;5885:7;5861:22;5840:53;:::i;:::-;5830:63;5930:2;5969:22;;;;2566:20;;-1:-1;;;5734:283::o;6024:377::-;;6153:2;;6141:9;6132:7;6128:23;6124:32;6121:2;;;-1:-1;;6159:12;6121:2;6217:17;6204:31;6255:18;6247:6;6244:30;6241:2;;;-1:-1;;6277:12;6241:2;6353:22;;270:4;258:17;;254:27;-1:-1;244:2;;-1:-1;;285:12;244:2;332:6;319:20;354:80;369:64;426:6;369:64;:::i;354:80::-;462:21;;;519:14;;;;494:17;;;608;;;599:27;;;;596:36;-1:-1;593:2;;;-1:-1;;635:12;593:2;-1:-1;661:10;;655:206;680:6;677:1;674:13;655:206;;;2566:20;;748:50;;702:1;695:9;;;;;812:14;;;;840;;655:206;;;-1:-1;6297:88;6115:286;-1:-1;;;;;;;6115:286::o;6408:257::-;;6520:2;6508:9;6499:7;6495:23;6491:32;6488:2;;;-1:-1;;6526:12;6488:2;1722:6;1716:13;1734:30;1758:5;1734:30;:::i;6672:239::-;;6775:2;6763:9;6754:7;6750:23;6746:32;6743:2;;;-1:-1;;6781:12;6743:2;1855:6;1842:20;1867:32;1893:5;1867:32;:::i;6918:261::-;;7032:2;7020:9;7011:7;7007:23;7003:32;7000:2;;;-1:-1;;7038:12;7000:2;1994:6;1988:13;2006:32;2032:5;2006:32;:::i;7186:241::-;;7290:2;7278:9;7269:7;7265:23;7261:32;7258:2;;;-1:-1;;7296:12;7258:2;-1:-1;2566:20;;7252:175;-1:-1;7252:175::o;7434:366::-;;;7555:2;7543:9;7534:7;7530:23;7526:32;7523:2;;;-1:-1;;7561:12;7523:2;-1:-1;;2566:20;;;7713:2;7752:22;;;2566:20;;-1:-1;7517:283::o;9037:343::-;;9179:5;32585:12;33128:6;33123:3;33116:19;9272:52;9317:6;33165:4;33160:3;33156:14;33165:4;9298:5;9294:16;9272:52;:::i;:::-;32193:9;35192:14;-1:-1;;35188:28;9336:39;;;;33165:4;9336:39;;9127:253;-1:-1;;9127:253::o;18723:271::-;;9547:5;32585:12;9658:52;9703:6;9698:3;9691:4;9684:5;9680:16;9658:52;:::i;:::-;9722:16;;;;;18857:137;-1:-1;;18857:137::o;19001:436::-;;9547:5;32585:12;9658:52;9703:6;9698:3;9691:4;9684:5;9680:16;9658:52;:::i;:::-;32585:12;;9722:16;;;;9658:52;32585:12;9722:16;9691:4;9680:16;;9658:52;:::i;:::-;9722:16;;19185:252;-1:-1;;;;19185:252::o;19444:222::-;-1:-1;;;;;34172:54;;;;8068:45;;19571:2;19556:18;;19542:124::o;19673:672::-;-1:-1;;;;;34172:54;;;8068:45;;34172:54;;20099:2;20084:18;;8068:45;20182:2;20167:18;;18456:37;;;19918:3;20219:2;20204:18;;20197:48;;;19673:672;;20259:76;;19903:19;;20321:6;20259:76;:::i;:::-;20251:84;19889:456;-1:-1;;;;;;19889:456::o;20352:333::-;-1:-1;;;;;34172:54;;;;8068:45;;20671:2;20656:18;;18456:37;20507:2;20492:18;;20478:207::o;20692:307::-;20861:3;20846:19;;20850:9;8627:21;20692:307;8654:252;32477:4;8676:1;8673:13;8654:252;;;8740:13;;34388:4;34377:16;18562:35;;7962:4;7953:14;;;;32840;;;;8701:1;8694:9;8654:252;;;8658:14;;;20832:167;;;;:::o;21006:210::-;33933:13;;33926:21;8991:34;;21127:2;21112:18;;21098:118::o;21482:310::-;;21629:2;21650:17;21643:47;21704:78;21629:2;21618:9;21614:18;21768:6;21704:78;:::i;21799:416::-;21999:2;22013:47;;;10859:2;21984:18;;;33116:19;10895:34;33156:14;;;10875:55;-1:-1;;;10950:12;;;10943:26;10988:12;;;21970:245::o;22222:416::-;22422:2;22436:47;;;11239:2;22407:18;;;33116:19;11275:34;33156:14;;;11255:55;-1:-1;;;11330:12;;;11323:42;11384:12;;;22393:245::o;22645:416::-;22845:2;22859:47;;;11635:2;22830:18;;;33116:19;11671:34;33156:14;;;11651:55;-1:-1;;;11726:12;;;11719:30;11768:12;;;22816:245::o;23068:416::-;23268:2;23282:47;;;12019:2;23253:18;;;33116:19;12055:30;33156:14;;;12035:51;12105:12;;;23239:245::o;23491:416::-;23691:2;23705:47;;;12356:2;23676:18;;;33116:19;12392:34;33156:14;;;12372:55;-1:-1;;;12447:12;;;12440:28;12487:12;;;23662:245::o;23914:416::-;24114:2;24128:47;;;12738:2;24099:18;;;33116:19;12774:27;33156:14;;;12754:48;12821:12;;;24085:245::o;24760:416::-;24960:2;24974:47;;;13456:2;24945:18;;;33116:19;13492:34;33156:14;;;13472:55;-1:-1;;;13547:12;;;13540:36;13595:12;;;24931:245::o;25183:416::-;25383:2;25397:47;;;13846:1;25368:18;;;33116:19;-1:-1;;;33156:14;;;13861:29;13909:12;;;25354:245::o;25606:416::-;25806:2;25820:47;;;14160:2;25791:18;;;33116:19;14196:34;33156:14;;;14176:55;14265:26;14251:12;;;14244:48;14311:12;;;25777:245::o;26029:416::-;26229:2;26243:47;;;14562:2;26214:18;;;33116:19;14598:34;33156:14;;;14578:55;-1:-1;;;14653:12;;;14646:34;14699:12;;;26200:245::o;26452:416::-;26652:2;26666:47;;;14950:1;26637:18;;;33116:19;-1:-1;;;33156:14;;;14965:31;15015:12;;;26623:245::o;26875:416::-;27075:2;27089:47;;;15266:2;27060:18;;;33116:19;15302:34;33156:14;;;15282:55;-1:-1;;;15357:12;;;15350:26;15395:12;;;27046:245::o;27298:416::-;27498:2;27512:47;;;27483:18;;;33116:19;15682:34;33156:14;;;15662:55;15736:12;;;27469:245::o;27721:416::-;27921:2;27935:47;;;15987:2;27906:18;;;33116:19;16023:34;33156:14;;;16003:55;-1:-1;;;16078:12;;;16071:36;16126:12;;;27892:245::o;28144:416::-;28344:2;28358:47;;;28329:18;;;33116:19;16413:34;33156:14;;;16393:55;16467:12;;;28315:245::o;28567:416::-;28767:2;28781:47;;;16718:2;28752:18;;;33116:19;16754:34;33156:14;;;16734:55;-1:-1;;;16809:12;;;16802:33;16854:12;;;28738:245::o;28990:416::-;29190:2;29204:47;;;17105:2;29175:18;;;33116:19;17141:34;33156:14;;;17121:55;-1:-1;;;17196:12;;;17189:39;17247:12;;;29161:245::o;29413:416::-;29613:2;29627:47;;;17498:2;29598:18;;;33116:19;17534:34;33156:14;;;17514:55;-1:-1;;;17589:12;;;17582:25;17626:12;;;29584:245::o;29836:416::-;30036:2;30050:47;;;17877:2;30021:18;;;33116:19;17913:34;33156:14;;;17893:55;-1:-1;;;17968:12;;;17961:41;18021:12;;;30007:245::o;30259:416::-;30459:2;30473:47;;;18272:2;30444:18;;;33116:19;18308:31;33156:14;;;18288:52;18359:12;;;30430:245::o;30682:222::-;18456:37;;;30809:2;30794:18;;30780:124::o;30911:214::-;34388:4;34377:16;;;;18562:35;;31034:2;31019:18;;31005:120::o;31132:256::-;31194:2;31188:9;31220:17;;;31295:18;31280:34;;31316:22;;;31277:62;31274:2;;;31352:1;;31342:12;31274:2;31194;31361:22;31172:216;;-1:-1;31172:216::o;31395:304::-;;31554:18;31546:6;31543:30;31540:2;;;-1:-1;;31576:12;31540:2;-1:-1;31621:4;31609:17;;;31674:15;;31477:222::o;31706:242::-;;31861:18;31853:6;31850:30;31847:2;;;-1:-1;;31883:12;31847:2;-1:-1;31928:4;31916:17;;31784:164::o;34848:268::-;34913:1;34920:101;34934:6;34931:1;34928:13;34920:101;;;35001:11;;;34995:18;34982:11;;;34975:39;34956:2;34949:10;34920:101;;;35036:6;35033:1;35030:13;35027:2;;;-1:-1;;34913:1;35083:16;;35076:27;34897:219::o;35229:117::-;-1:-1;;;;;34172:54;;35288:35;;35278:2;;35337:1;;35327:12;35353:111;35434:5;33933:13;33926:21;35412:5;35409:32;35399:2;;35455:1;;35445:12;35471:115;-1:-1;;;;;;34020:78;;35529:34;;35519:2;;35577:1;;35567:12
Swarm Source
ipfs://b862b77eabe838e537a8c08c6ddb1cb74fbec552c90059143c3ff5d9529f764e
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.