Feature Tip: Add private address tag to any address under My Name Tag !
ERC-20
Overview
Max Total Supply
455,624,250,000,000 GG
Holders
460
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 18 Decimals)
Balance
0.00000000000000007 GGValue
$0.00Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
OmniGh0sts
Compiler Version
v0.8.20+commit.a1b79de6
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2023-12-23 */ // File: @openzeppelin/contracts/utils/math/SignedMath.sol // OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol) pragma solidity ^0.8.20; /** * @dev Standard signed math utilities missing in the Solidity language. */ library SignedMath { /** * @dev Returns the largest of two signed numbers. */ function max(int256 a, int256 b) internal pure returns (int256) { return a > b ? a : b; } /** * @dev Returns the smallest of two signed numbers. */ function min(int256 a, int256 b) internal pure returns (int256) { return a < b ? a : b; } /** * @dev Returns the average of two signed numbers without overflow. * The result is rounded towards zero. */ function average(int256 a, int256 b) internal pure returns (int256) { // Formula from the book "Hacker's Delight" int256 x = (a & b) + ((a ^ b) >> 1); return x + (int256(uint256(x) >> 255) & (a ^ b)); } /** * @dev Returns the absolute unsigned value of a signed value. */ function abs(int256 n) internal pure returns (uint256) { unchecked { // must be unchecked in order to support `n = type(int256).min` return uint256(n >= 0 ? n : -n); } } } // File: @openzeppelin/contracts/utils/math/Math.sol // OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol) pragma solidity ^0.8.20; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { /** * @dev Muldiv operation overflow. */ error MathOverflowedMulDiv(); enum Rounding { Floor, // Toward negative infinity Ceil, // Toward positive infinity Trunc, // Toward zero Expand // Away from zero } /** * @dev Returns the addition of two unsigned integers, with an overflow flag. */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the subtraction of two unsigned integers, with an overflow flag. */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds towards infinity instead * of rounding towards zero. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { if (b == 0) { // Guarantee the same behavior as in a regular Solidity division. return a / b; } // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or * denominator == 0. * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by * Uniswap Labs also under MIT license. */ function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0 = x * y; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { // Solidity will revert if denominator == 0, unlike the div opcode on its own. // The surrounding unchecked block does not change this fact. // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic. return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. if (denominator <= prod1) { revert MathOverflowedMulDiv(); } /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. // Always >= 1. See https://cs.stackexchange.com/q/138556/92363. uint256 twos = denominator & (0 - denominator); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also // works in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded * towards zero. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2 of a positive value rounded towards zero. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10 of a positive value rounded towards zero. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10 ** 64) { value /= 10 ** 64; result += 64; } if (value >= 10 ** 32) { value /= 10 ** 32; result += 32; } if (value >= 10 ** 16) { value /= 10 ** 16; result += 16; } if (value >= 10 ** 8) { value /= 10 ** 8; result += 8; } if (value >= 10 ** 4) { value /= 10 ** 4; result += 4; } if (value >= 10 ** 2) { value /= 10 ** 2; result += 2; } if (value >= 10 ** 1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0); } } /** * @dev Return the log in base 256 of a positive value rounded towards zero. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 256, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0); } } /** * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers. */ function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) { return uint8(rounding) % 2 == 1; } } // File: @openzeppelin/contracts/utils/Strings.sol // OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol) pragma solidity ^0.8.20; /** * @dev String operations. */ library Strings { bytes16 private constant HEX_DIGITS = "0123456789abcdef"; uint8 private constant ADDRESS_LENGTH = 20; /** * @dev The `value` string doesn't fit in the specified `length`. */ error StringsInsufficientHexLength(uint256 value, uint256 length); /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), HEX_DIGITS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `int256` to its ASCII `string` decimal representation. */ function toStringSigned(int256 value) internal pure returns (string memory) { return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value))); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { uint256 localValue = value; bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = HEX_DIGITS[localValue & 0xf]; localValue >>= 4; } if (localValue != 0) { revert StringsInsufficientHexLength(value, length); } return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal * representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH); } /** * @dev Returns true if the two strings are equal. */ function equal(string memory a, string memory b) internal pure returns (bool) { return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b)); } } // File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.20; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be * reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } // File: @openzeppelin/contracts/utils/introspection/IERC165.sol // OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol) pragma solidity ^0.8.20; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: @openzeppelin/contracts/utils/introspection/ERC165.sol // OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol) pragma solidity ^0.8.20; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) { return interfaceId == type(IERC165).interfaceId; } } // File: @openzeppelin/contracts/token/ERC721/IERC721.sol // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.20; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon * a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or * {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon * a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must * understand this adds an external call which potentially creates a reentrancy vulnerability. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 tokenId) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the address zero. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); } // File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol) pragma solidity ^0.8.20; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); } // File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol) pragma solidity ^0.8.20; /** * @dev Standard ERC20 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens. */ interface IERC20Errors { /** * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. * @param balance Current balance for the interacting account. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC20InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC20InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers. * @param spender Address that may be allowed to operate on tokens without being their owner. * @param allowance Amount of tokens a `spender` is allowed to operate with. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC20InvalidApprover(address approver); /** * @dev Indicates a failure with the `spender` to be approved. Used in approvals. * @param spender Address that may be allowed to operate on tokens without being their owner. */ error ERC20InvalidSpender(address spender); } /** * @dev Standard ERC721 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens. */ interface IERC721Errors { /** * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20. * Used in balance queries. * @param owner Address of the current owner of a token. */ error ERC721InvalidOwner(address owner); /** * @dev Indicates a `tokenId` whose `owner` is the zero address. * @param tokenId Identifier number of a token. */ error ERC721NonexistentToken(uint256 tokenId); /** * @dev Indicates an error related to the ownership over a particular token. Used in transfers. * @param sender Address whose tokens are being transferred. * @param tokenId Identifier number of a token. * @param owner Address of the current owner of a token. */ error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC721InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC721InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `operator`’s approval. Used in transfers. * @param operator Address that may be allowed to operate on tokens without being their owner. * @param tokenId Identifier number of a token. */ error ERC721InsufficientApproval(address operator, uint256 tokenId); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC721InvalidApprover(address approver); /** * @dev Indicates a failure with the `operator` to be approved. Used in approvals. * @param operator Address that may be allowed to operate on tokens without being their owner. */ error ERC721InvalidOperator(address operator); } /** * @dev Standard ERC1155 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens. */ interface IERC1155Errors { /** * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. * @param balance Current balance for the interacting account. * @param needed Minimum amount required to perform a transfer. * @param tokenId Identifier number of a token. */ error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC1155InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC1155InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `operator`’s approval. Used in transfers. * @param operator Address that may be allowed to operate on tokens without being their owner. * @param owner Address of the current owner of a token. */ error ERC1155MissingApprovalForAll(address operator, address owner); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC1155InvalidApprover(address approver); /** * @dev Indicates a failure with the `operator` to be approved. Used in approvals. * @param operator Address that may be allowed to operate on tokens without being their owner. */ error ERC1155InvalidOperator(address operator); /** * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation. * Used in batch transfers. * @param idsLength Length of the array of token identifiers * @param valuesLength Length of the array of token amounts */ error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength); } // File: @openzeppelin/contracts/utils/Context.sol // OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol) pragma solidity ^0.8.20; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } function _contextSuffixLength() internal view virtual returns (uint256) { return 0; } } // File: @openzeppelin/contracts/access/Ownable.sol // OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol) pragma solidity ^0.8.20; /** * @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. * * The initial owner is set to the address provided by the deployer. 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; /** * @dev The caller account is not authorized to perform an operation. */ error OwnableUnauthorizedAccount(address account); /** * @dev The owner is not a valid owner account. (eg. `address(0)`) */ error OwnableInvalidOwner(address owner); event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the address provided by the deployer as the initial owner. */ constructor(address initialOwner) { if (initialOwner == address(0)) { revert OwnableInvalidOwner(address(0)); } _transferOwnership(initialOwner); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { if (owner() != _msgSender()) { revert OwnableUnauthorizedAccount(_msgSender()); } } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { if (newOwner == address(0)) { revert OwnableInvalidOwner(address(0)); } _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File: @openzeppelin/contracts/token/ERC721/ERC721.sol // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/ERC721.sol) pragma solidity ^0.8.20; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors { using Strings for uint256; // Token name string private _name; // Token symbol string private _symbol; mapping(uint256 tokenId => address) private _owners; mapping(address owner => uint256) private _balances; mapping(uint256 tokenId => address) private _tokenApprovals; mapping(address owner => mapping(address operator => bool)) private _operatorApprovals; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual returns (uint256) { if (owner == address(0)) { revert ERC721InvalidOwner(address(0)); } return _balances[owner]; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual returns (address) { return _requireOwned(tokenId); } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual returns (string memory) { _requireOwned(tokenId); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overridden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual { _approve(to, tokenId, _msgSender()); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual returns (address) { _requireOwned(tokenId); return _getApproved(tokenId); } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual { _setApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom(address from, address to, uint256 tokenId) public virtual { if (to == address(0)) { revert ERC721InvalidReceiver(address(0)); } // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here. address previousOwner = _update(to, tokenId, _msgSender()); if (previousOwner != from) { revert ERC721IncorrectOwner(from, tokenId, previousOwner); } } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 tokenId) public { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual { transferFrom(from, to, tokenId); _checkOnERC721Received(from, to, tokenId, data); } /** * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist * * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the * core ERC721 logic MUST be matched with the use of {_increaseBalance} to keep balances * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`. */ function _ownerOf(uint256 tokenId) internal view virtual returns (address) { return _owners[tokenId]; } /** * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted. */ function _getApproved(uint256 tokenId) internal view virtual returns (address) { return _tokenApprovals[tokenId]; } /** * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in * particular (ignoring whether it is owned by `owner`). * * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this * assumption. */ function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) { return spender != address(0) && (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender); } /** * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner. * Reverts if `spender` does not have approval from the provided `owner` for the given token or for all its assets * the `spender` for the specific `tokenId`. * * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this * assumption. */ function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual { if (!_isAuthorized(owner, spender, tokenId)) { if (owner == address(0)) { revert ERC721NonexistentToken(tokenId); } else { revert ERC721InsufficientApproval(spender, tokenId); } } } /** * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override. * * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that * a uint256 would ever overflow from increments when these increments are bounded to uint128 values. * * WARNING: Increasing an account's balance using this function tends to be paired with an override of the * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership * remain consistent with one another. */ function _increaseBalance(address account, uint128 value) internal virtual { unchecked { _balances[account] += value; } } /** * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update. * * The `auth` argument is optional. If the value passed is non 0, then this function will check that * `auth` is either the owner of the token, or approved to operate on the token (by the owner). * * Emits a {Transfer} event. * * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}. */ function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) { address from = _ownerOf(tokenId); // Perform (optional) operator check if (auth != address(0)) { _checkAuthorized(from, auth, tokenId); } // Execute the update if (from != address(0)) { // Clear approval. No need to re-authorize or emit the Approval event _approve(address(0), tokenId, address(0), false); unchecked { _balances[from] -= 1; } } if (to != address(0)) { unchecked { _balances[to] += 1; } } _owners[tokenId] = to; emit Transfer(from, to, tokenId); return from; } /** * @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 { if (to == address(0)) { revert ERC721InvalidReceiver(address(0)); } address previousOwner = _update(to, tokenId, address(0)); if (previousOwner != address(0)) { revert ERC721InvalidSender(address(0)); } } /** * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance. * * Requirements: * * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal { _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); _checkOnERC721Received(address(0), to, tokenId, data); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * This is an internal function that does not check if the sender is authorized to operate on the token. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal { address previousOwner = _update(address(0), tokenId, address(0)); if (previousOwner == address(0)) { revert ERC721NonexistentToken(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 { if (to == address(0)) { revert ERC721InvalidReceiver(address(0)); } address previousOwner = _update(to, tokenId, address(0)); if (previousOwner == address(0)) { revert ERC721NonexistentToken(tokenId); } else if (previousOwner != from) { revert ERC721IncorrectOwner(from, tokenId, previousOwner); } } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients * are aware of the ERC721 standard 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 like {safeTransferFrom} in the sense that it invokes * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `tokenId` token must exist and be owned by `from`. * - `to` cannot be the zero address. * - `from` cannot be the zero address. * - 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) internal { _safeTransfer(from, to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual { _transfer(from, to, tokenId); _checkOnERC721Received(from, to, tokenId, data); } /** * @dev Approve `to` to operate on `tokenId` * * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is * either the owner of the token, or approved to operate on all tokens held by this owner. * * Emits an {Approval} event. * * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument. */ function _approve(address to, uint256 tokenId, address auth) internal { _approve(to, tokenId, auth, true); } /** * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not * emitted in the context of transfers. */ function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual { // Avoid reading the owner unless necessary if (emitEvent || auth != address(0)) { address owner = _requireOwned(tokenId); // We do not use _isAuthorized because single-token approvals should not be able to call approve if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) { revert ERC721InvalidApprover(auth); } if (emitEvent) { emit Approval(owner, to, tokenId); } } _tokenApprovals[tokenId] = to; } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Requirements: * - operator can't be the address zero. * * Emits an {ApprovalForAll} event. */ function _setApprovalForAll(address owner, address operator, bool approved) internal virtual { if (operator == address(0)) { revert ERC721InvalidOperator(operator); } _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned). * Returns the owner. * * Overrides to ownership logic should be done to {_ownerOf}. */ function _requireOwned(uint256 tokenId) internal view returns (address) { address owner = _ownerOf(tokenId); if (owner == address(0)) { revert ERC721NonexistentToken(tokenId); } return owner; } /** * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target address. This will revert if the * recipient doesn't accept the token transfer. 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 */ function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private { if (to.code.length > 0) { try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) { if (retval != IERC721Receiver.onERC721Received.selector) { revert ERC721InvalidReceiver(to); } } catch (bytes memory reason) { if (reason.length == 0) { revert ERC721InvalidReceiver(to); } else { /// @solidity memory-safe-assembly assembly { revert(add(32, reason), mload(reason)) } } } } } } // File: @openzeppelin/contracts/token/ERC20/IERC20.sol // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.20; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the value of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the value of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves a `value` amount of tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 value) 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 a `value` amount of tokens 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 value) external returns (bool); /** * @dev Moves a `value` amount of tokens from `from` to `to` using the * allowance mechanism. `value` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 value) external returns (bool); } // File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.20; /** * @dev Interface for the optional metadata functions from the ERC20 standard. */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); } // File: @openzeppelin/contracts/token/ERC20/ERC20.sol // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol) pragma solidity ^0.8.20; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * * TIP: For a detailed writeup see our guide * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * The default value of {decimals} is 18. To change this, you should override * this function so it returns a different value. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead returning `false` on failure. This behavior is nonetheless * conventional and does not conflict with the expectations of ERC20 * applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. */ abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors { mapping(address account => uint256) private _balances; mapping(address account => mapping(address spender => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5.05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the default value returned by this function, unless * it's overridden. * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `to` cannot be the zero address. * - the caller must have a balance of at least `value`. */ function transfer(address to, uint256 value) public virtual returns (bool) { address owner = _msgSender(); _transfer(owner, to, value); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on * `transferFrom`. This is semantically equivalent to an infinite approval. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 value) public virtual returns (bool) { address owner = _msgSender(); _approve(owner, spender, value); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * NOTE: Does not update the allowance if the current allowance * is the maximum `uint256`. * * Requirements: * * - `from` and `to` cannot be the zero address. * - `from` must have a balance of at least `value`. * - the caller must have allowance for ``from``'s tokens of at least * `value`. */ function transferFrom(address from, address to, uint256 value) public virtual returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, value); _transfer(from, to, value); return true; } /** * @dev Moves a `value` amount of tokens from `from` to `to`. * * This internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * NOTE: This function is not virtual, {_update} should be overridden instead. */ function _transfer(address from, address to, uint256 value) internal { if (from == address(0)) { revert ERC20InvalidSender(address(0)); } if (to == address(0)) { revert ERC20InvalidReceiver(address(0)); } _update(from, to, value); } /** * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from` * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding * this function. * * Emits a {Transfer} event. */ function _update(address from, address to, uint256 value) internal virtual { if (from == address(0)) { // Overflow check required: The rest of the code assumes that totalSupply never overflows _totalSupply += value; } else { uint256 fromBalance = _balances[from]; if (fromBalance < value) { revert ERC20InsufficientBalance(from, fromBalance, value); } unchecked { // Overflow not possible: value <= fromBalance <= totalSupply. _balances[from] = fromBalance - value; } } if (to == address(0)) { unchecked { // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply. _totalSupply -= value; } } else { unchecked { // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256. _balances[to] += value; } } emit Transfer(from, to, value); } /** * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0). * Relies on the `_update` mechanism * * Emits a {Transfer} event with `from` set to the zero address. * * NOTE: This function is not virtual, {_update} should be overridden instead. */ function _mint(address account, uint256 value) internal { if (account == address(0)) { revert ERC20InvalidReceiver(address(0)); } _update(address(0), account, value); } /** * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply. * Relies on the `_update` mechanism. * * Emits a {Transfer} event with `to` set to the zero address. * * NOTE: This function is not virtual, {_update} should be overridden instead */ function _burn(address account, uint256 value) internal { if (account == address(0)) { revert ERC20InvalidSender(address(0)); } _update(account, address(0), value); } /** * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. * * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument. */ function _approve(address owner, address spender, uint256 value) internal { _approve(owner, spender, value, true); } /** * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event. * * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any * `Approval` event during `transferFrom` operations. * * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to * true using the following override: * ``` * function _approve(address owner, address spender, uint256 value, bool) internal virtual override { * super._approve(owner, spender, value, true); * } * ``` * * Requirements are the same as {_approve}. */ function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual { if (owner == address(0)) { revert ERC20InvalidApprover(address(0)); } if (spender == address(0)) { revert ERC20InvalidSpender(address(0)); } _allowances[owner][spender] = value; if (emitEvent) { emit Approval(owner, spender, value); } } /** * @dev Updates `owner` s allowance for `spender` based on spent `value`. * * Does not update the allowance value in case of infinite allowance. * Revert if not enough allowance is available. * * Does not emit an {Approval} event. */ function _spendAllowance(address owner, address spender, uint256 value) internal virtual { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { if (currentAllowance < value) { revert ERC20InsufficientAllowance(spender, currentAllowance, value); } unchecked { _approve(owner, spender, currentAllowance - value, false); } } } } // File: OmniGh0sts.sol /* ?]]?????????????????????]]????]]]]????]]]]????????]?]]]???]]??]]?]]]]??]]]]]??????]]]]???] ]?????????????????????]]????????????]?????????????]]]??????????]]]]??????]]?????]]]??????] ?????????????????????]??????????????]???????????]]]????????????]?????]]???????]]]]?]????]] ?????????????????]]??????????????]]]???????????]]??????????????????]]]???????????????????] ????????????????]]???????]??????]]???????????????????????????????]]]???????????????????]][ ??????????????]]]??????]???????????????????????????????????????]]]????????????]]???]]]]]]] ????????????]]]??????]???????????????????????????????????????]]]?????????????????]]?]]]??] ????]]????]]]??????]??????????????????????[{(|trvuvnf)[]???]]]?????????????????]]?]]]????] ???]?????]]??????]]????????????]{|/ruc*#Mz|>,""^^^`^,+tcu/}]??????????????????]]???????]]] ?]]]???]]]?????]]?????????????[cxrjft////ttff\}-i:,^``^"_M@#xxj???????????????????????]]]] ]]????]]?????]]???????????????xf{{-+{_~{{+;[{{{{{{{)(((M({1{{1&}?]???????????????????]]??] ]???]]]?????]]???????????????]#{{{[;>::~;>{{{{{{{{{{{{{uj{{{)fWr]????????????]]????]]???]] ??]]??????]]????????????????{*#nxjt\{1)?{11)(||\/tjjjxnj{~I,^. :ct]?????????]]????]]?????] ]]]?????]]]?????????????[/fjt){{{)(|\/ttffft/\\||tf?;`. `zn]??????]]?????????????] ]??????]]????????????)uWBMMW}^^^,;!_{|/\){{)/|-;"' .xu]]???????????????????] ??????]??????????????][{{[|\ ;fzc\" .':/B@#ul (u]???????????????????] ????]]]???]????????]????][z' ,#$$W~` `B$$$*:' /r???????????????????] ??]]]????????????]]???]]?x< .&$$$n^ `z$$c^ 'zx]]????????????????] ?]]]????????????]]???]]?(f .<B$%\. -c%$$%z-. `*j?????????????????] ]]?????????????]???????}*' "W$$@? .r$$$[ `W/????????????????] ????]]????????????????]vi ^<c$v "uz; !8{???????????????] ??]]]??????]]?????????)&. . fW}??????????????] ]]]???????????????????rc '**]?????????????] ]????????????????????]nu `I<II,^'. ..'',<?-_n{, "8j?????????????] ??????????????????????rM 'u?"i}";|#(??]c~,,/``\"z' \8[????????????] ????????????????????]?rW. >&jI[(:I+W!I;;)gggg[t*v&: ^%t]]????]?????] ??????????????????????j*. :#Bfj~`^#+,,"?z`;t`illx. tz]???????????] ?]????????????????????fz ,Mt<*(?+!ll>[1?t1[t(i ,@1???????????] ]?????????????????????/* ... .#r?]?????????] ?????]]???????????????(W. )*]??????????] ?]]?]]????????????????|&. lB1?????????][ ]]]]]?[\r/(/r|[??????]t&. 'B|??????????] ]]]]]t|` .`?n(]???]uB. .8r???]?????]] ]]]?/1 .:\r}]}8&' .*&]?]]??????] ]???j? `|j{%@&, .`^` <@x]]???????] ???]}v' ,xB@$@t` .~<;,:-\?". .j@f[???????] ??]?])r. [@{z@$@t'' {` .`>[^ !Bz]??????] ]]?]]?1r' ^Mj ;z$$[;{_` .u .:{". ;@x??????] ]?]]???\z. `Mz. /x...';}-". r' ,-1[i, .n@|?????] ?]]????{@~ ^&z' ,#'......."+[~". "M` .' "B&{????] ]]]????{B*. `M&' ,u'..........'"~}+i,` >8' j$n???][ ]]]?]??]c$` uB" /i1-``-(i'........`?B*:. u1 ]$M]?]]] ]]?]???]($, +$! "| '(&r<tM'......._Bt\8' ;B` i$M]]]?] ]]]???]?1$- ^Br )" .ff{8v-^......"*1;&$$#(II@~ l$&[]??] ?]]?????1$c. .x%` `|:. ',' ',-_+_}|[\tcW$$$$$$@{ :@B{???] */ // Name: OmniGh0sts // Ticker: GG // An omni-chain memecoin by and for the @gh0stlygh0stscommunity - the 1st 0mnichain NFT 0n @LayerZero_Labs. // gg // pragma solidity ^0.8.19; contract OmniGh0sts is ERC20, Ownable { ERC721 internal immutable nft; uint256 public immutable tokensPerClaim; event Claimed(uint256 indexed tokenId, address indexed claimer); error NotOwner(); error AlreadyRedeemed(); mapping(uint256 => bool) public hasClaimed; uint256 public maxHolding; address public uniswapV2Pair; address public ggMakerWallet; address public gh0stlygh0stsTeamWallet; mapping (address => bool) public noGgList; address public gh0stlygh0stsContractAddress = 0xA74aE2c6FCa0CEdbAef30A8CEEF834B247186bcF; constructor( address _ghostMaker, address _gh0stlygh0stsTeamAddress) ERC20("OmniGh0sts", "GG") Ownable(msg.sender) { ggMakerWallet = _ghostMaker; gh0stlygh0stsTeamWallet = _gh0stlygh0stsTeamAddress; maxHolding = 414000000000000000000000000000000; _mint(msg.sender, 414000000000000000000000000000000); // 60% of total supply goes to LP _mint(_ghostMaker, 27600000000000000000000000000000); // 4% of total supply goes to future ghost maker _mint(_gh0stlygh0stsTeamAddress, 6900000000000000000000000000000); // 1% of total supply goes to gh0stlygh0sts team nft = ERC721(gh0stlygh0stsContractAddress); // 35% of total supply goes to gh0stlygh0sts community tokensPerClaim = 24150000000000000000000000000; } // @notice Claim tokens by NFT token Id // @dev One claim per NFT token Id function claim(uint256 tokenId) external payable { if (hasClaimed[tokenId]) revert AlreadyRedeemed(); if (nft.ownerOf(tokenId) != msg.sender) revert NotOwner(); hasClaimed[tokenId] = true; emit Claimed(tokenId, msg.sender); _mint(msg.sender, tokensPerClaim); } // @notice Claim tokens by batch NFT token Ids // @dev One claim per NFT token Id function batchClaim(uint256[] memory tokenIds) external payable { for (uint256 index = 0; index < tokenIds.length; index++) { uint256 tokenId = tokenIds[index]; if (hasClaimed[tokenId]) revert AlreadyRedeemed(); if (nft.ownerOf(tokenId) != msg.sender) revert NotOwner(); hasClaimed[tokenId] = true; emit Claimed(tokenId, msg.sender); } _mint(msg.sender, tokensPerClaim * tokenIds.length); } // @notice Initialize the pair and the max holding amount // @dev Tokens cannot be transferred before first gg function firstGG(address _uniswapV2Pair, uint256 _maxHolding) external onlyOwner { uniswapV2Pair = _uniswapV2Pair; maxHolding = _maxHolding; } // @notice Can't trade if on noGgList or if pair not set // @dev Override update to check for noGgList and maxHolding function _update(address from, address to, uint256 value) override internal { require(!noGgList[from] || !noGgList[to], "GG: No ~gg~ list!"); if (uniswapV2Pair == address(0)) { require(from == owner() || to == owner() || to == ggMakerWallet || to == gh0stlygh0stsTeamWallet, "GG: You can't transfer before first gg"); } require(super.balanceOf(to) + value <= maxHolding, "GG: Exceed max holding"); super._update(from, to, value); } function addtoNoGgList(address _address) external onlyOwner { noGgList[_address] = true; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_ghostMaker","type":"address"},{"internalType":"address","name":"_gh0stlygh0stsTeamAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyRedeemed","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[],"name":"NotOwner","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":true,"internalType":"address","name":"claimer","type":"address"}],"name":"Claimed","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":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"addtoNoGgList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"batchClaim","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"claim","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_uniswapV2Pair","type":"address"},{"internalType":"uint256","name":"_maxHolding","type":"uint256"}],"name":"firstGG","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"ggMakerWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gh0stlygh0stsContractAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gh0stlygh0stsTeamWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"hasClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxHolding","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"noGgList","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokensPerClaim","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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)
0000000000000000000000001d5ad59833f7133d0aaff882e46a7bb1e50f29ec000000000000000000000000099a2da6bb4f40ecaea36ad0abe32d09f98c2a0a
-----Decoded View---------------
Arg [0] : _ghostMaker (address): 0x1D5aD59833f7133d0aAff882e46a7bB1e50F29ec
Arg [1] : _gh0stlygh0stsTeamAddress (address): 0x099a2DA6bB4F40Ecaea36aD0AbE32D09f98c2A0A
-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000001d5ad59833f7133d0aaff882e46a7bb1e50f29ec
Arg [1] : 000000000000000000000000099a2da6bb4f40ecaea36ad0abe32d09f98c2a0a
Deployed Bytecode Sourcemap
77004:3467:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63125:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65418:190;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;77378:28;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64227:99;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66186:249;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64078:84;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;77508:88;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;77311:25;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;78494:314;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;77458:41;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;77343:28;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64389:118;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38911:103;;;;;;;;;;;;;:::i;:::-;;38236:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63335:95;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;77413:38;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64712:182;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;79540:165;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;78913:493;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;77260:42;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64957:142;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39169:220;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;77085:39;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;80364:104;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;63125:91;63170:13;63203:5;63196:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63125:91;:::o;65418:190::-;65491:4;65508:13;65524:12;:10;:12::i;:::-;65508:28;;65547:31;65556:5;65563:7;65572:5;65547:8;:31::i;:::-;65596:4;65589:11;;;65418:190;;;;:::o;77378:28::-;;;;;;;;;;;;;:::o;64227:99::-;64279:7;64306:12;;64299:19;;64227:99;:::o;66186:249::-;66273:4;66290:15;66308:12;:10;:12::i;:::-;66290:30;;66331:37;66347:4;66353:7;66362:5;66331:15;:37::i;:::-;66379:26;66389:4;66395:2;66399:5;66379:9;:26::i;:::-;66423:4;66416:11;;;66186:249;;;;;:::o;64078:84::-;64127:5;64152:2;64145:9;;64078:84;:::o;77508:88::-;;;;;;;;;;;;;:::o;77311:25::-;;;;:::o;78494:314::-;78558:10;:19;78569:7;78558:19;;;;;;;;;;;;;;;;;;;;;78554:49;;;78586:17;;;;;;;;;;;;;;78554:49;78642:10;78618:34;;:3;:11;;;78630:7;78618:20;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:34;;;78614:57;;78661:10;;;;;;;;;;;;;;78614:57;78706:4;78684:10;:19;78695:7;78684:19;;;;;;;;;;;;:26;;;;;;;;;;;;;;;;;;78743:10;78726:28;;78734:7;78726:28;;;;;;;;;;78767:33;78773:10;78785:14;78767:5;:33::i;:::-;78494:314;:::o;77458:41::-;;;;;;;;;;;;;;;;;;;;;;:::o;77343:28::-;;;;;;;;;;;;;:::o;64389:118::-;64454:7;64481:9;:18;64491:7;64481:18;;;;;;;;;;;;;;;;64474:25;;64389:118;;;:::o;38911:103::-;38122:13;:11;:13::i;:::-;38976:30:::1;39003:1;38976:18;:30::i;:::-;38911:103::o:0;38236:87::-;38282:7;38309:6;;;;;;;;;;;38302:13;;38236:87;:::o;63335:95::-;63382:13;63415:7;63408:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63335:95;:::o;77413:38::-;;;;;;;;;;;;;:::o;64712:182::-;64781:4;64798:13;64814:12;:10;:12::i;:::-;64798:28;;64837:27;64847:5;64854:2;64858:5;64837:9;:27::i;:::-;64882:4;64875:11;;;64712:182;;;;:::o;79540:165::-;38122:13;:11;:13::i;:::-;79648:14:::1;79632:13;;:30;;;;;;;;;;;;;;;;;;79686:11;79673:10;:24;;;;79540:165:::0;;:::o;78913:493::-;78993:13;78988:347;79020:8;:15;79012:5;:23;78988:347;;;79061:15;79079:8;79088:5;79079:15;;;;;;;;:::i;:::-;;;;;;;;79061:33;;79115:10;:19;79126:7;79115:19;;;;;;;;;;;;;;;;;;;;;79111:49;;;79143:17;;;;;;;;;;;;;;79111:49;79203:10;79179:34;;:3;:11;;;79191:7;79179:20;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:34;;;79175:57;;79222:10;;;;;;;;;;;;;;79175:57;79271:4;79249:10;:19;79260:7;79249:19;;;;;;;;;;;;:26;;;;;;;;;;;;;;;;;;79312:10;79295:28;;79303:7;79295:28;;;;;;;;;;79046:289;79037:7;;;;;:::i;:::-;;;;78988:347;;;;79347:51;79353:10;79382:8;:15;79365:14;:32;;;;:::i;:::-;79347:5;:51::i;:::-;78913:493;:::o;77260:42::-;;;;;;;;;;;;;;;;;;;;;;:::o;64957:142::-;65037:7;65064:11;:18;65076:5;65064:18;;;;;;;;;;;;;;;:27;65083:7;65064:27;;;;;;;;;;;;;;;;65057:34;;64957:142;;;;:::o;39169:220::-;38122:13;:11;:13::i;:::-;39274:1:::1;39254:22;;:8;:22;;::::0;39250:93:::1;;39328:1;39300:31;;;;;;;;;;;:::i;:::-;;;;;;;;39250:93;39353:28;39372:8;39353:18;:28::i;:::-;39169:220:::0;:::o;77085:39::-;;;:::o;80364:104::-;38122:13;:11;:13::i;:::-;80456:4:::1;80435:8;:18;80444:8;80435:18;;;;;;;;;;;;;;;;:25;;;;;;;;;;;;;;;;;;80364:104:::0;:::o;36245:98::-;36298:7;36325:10;36318:17;;36245:98;:::o;70245:130::-;70330:37;70339:5;70346:7;70355:5;70362:4;70330:8;:37::i;:::-;70245:130;;;:::o;71961:487::-;72061:24;72088:25;72098:5;72105:7;72088:9;:25::i;:::-;72061:52;;72148:17;72128:16;:37;72124:317;;72205:5;72186:16;:24;72182:132;;;72265:7;72274:16;72292:5;72238:60;;;;;;;;;;;;;:::i;:::-;;;;;;;;72182:132;72357:57;72366:5;72373:7;72401:5;72382:16;:24;72408:5;72357:8;:57::i;:::-;72124:317;72050:398;71961:487;;;:::o;66820:308::-;66920:1;66904:18;;:4;:18;;;66900:88;;66973:1;66946:30;;;;;;;;;;;:::i;:::-;;;;;;;;66900:88;67016:1;67002:16;;:2;:16;;;66998:88;;67071:1;67042:32;;;;;;;;;;;:::i;:::-;;;;;;;;66998:88;67096:24;67104:4;67110:2;67114:5;67096:7;:24::i;:::-;66820:308;;;:::o;68940:213::-;69030:1;69011:21;;:7;:21;;;69007:93;;69085:1;69056:32;;;;;;;;;;;:::i;:::-;;;;;;;;69007:93;69110:35;69126:1;69130:7;69139:5;69110:7;:35::i;:::-;68940:213;;:::o;38401:166::-;38472:12;:10;:12::i;:::-;38461:23;;:7;:5;:7::i;:::-;:23;;;38457:103;;38535:12;:10;:12::i;:::-;38508:40;;;;;;;;;;;:::i;:::-;;;;;;;;38457:103;38401:166::o;39549:191::-;39623:16;39642:6;;;;;;;;;;;39623:25;;39668:8;39659:6;;:17;;;;;;;;;;;;;;;;;;39723:8;39692:40;;39713:8;39692:40;;;;;;;;;;;;39612:128;39549:191;:::o;71226:443::-;71356:1;71339:19;;:5;:19;;;71335:91;;71411:1;71382:32;;;;;;;;;;;:::i;:::-;;;;;;;;71335:91;71459:1;71440:21;;:7;:21;;;71436:92;;71513:1;71485:31;;;;;;;;;;;:::i;:::-;;;;;;;;71436:92;71568:5;71538:11;:18;71550:5;71538:18;;;;;;;;;;;;;;;:27;71557:7;71538:27;;;;;;;;;;;;;;;:35;;;;71588:9;71584:78;;;71635:7;71619:31;;71628:5;71619:31;;;71644:5;71619:31;;;;;;:::i;:::-;;;;;;;;71584:78;71226:443;;;;:::o;79846:510::-;79944:8;:14;79953:4;79944:14;;;;;;;;;;;;;;;;;;;;;;;;;79943:15;:32;;;;79963:8;:12;79972:2;79963:12;;;;;;;;;;;;;;;;;;;;;;;;;79962:13;79943:32;79935:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;80039:1;80014:27;;:13;;;;;;;;;;;:27;;;80010:199;;80074:7;:5;:7::i;:::-;80066:15;;:4;:15;;;:32;;;;80091:7;:5;:7::i;:::-;80085:13;;:2;:13;;;80066:32;:55;;;;80108:13;;;;;;;;;;;80102:19;;:2;:19;;;80066:55;:88;;;;80131:23;;;;;;;;;;;80125:29;;:2;:29;;;80066:88;80058:139;;;;;;;;;;;;:::i;:::-;;;;;;;;;80010:199;80260:10;;80251:5;80229:19;80245:2;80229:15;:19::i;:::-;:27;;;;:::i;:::-;:41;;80221:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;80318:30;80332:4;80338:2;80342:5;80318:13;:30::i;:::-;79846:510;;;:::o;67452:1135::-;67558:1;67542:18;;:4;:18;;;67538:552;;67696:5;67680:12;;:21;;;;;;;:::i;:::-;;;;;;;;67538:552;;;67734:19;67756:9;:15;67766:4;67756:15;;;;;;;;;;;;;;;;67734:37;;67804:5;67790:11;:19;67786:117;;;67862:4;67868:11;67881:5;67837:50;;;;;;;;;;;;;:::i;:::-;;;;;;;;67786:117;68058:5;68044:11;:19;68026:9;:15;68036:4;68026:15;;;;;;;;;;;;;;;:37;;;;67719:371;67538:552;68120:1;68106:16;;:2;:16;;;68102:435;;68288:5;68272:12;;:21;;;;;;;;;;;68102:435;;;68505:5;68488:9;:13;68498:2;68488:13;;;;;;;;;;;;;;;;:22;;;;;;;;;;;68102:435;68569:2;68554:25;;68563:4;68554:25;;;68573:5;68554:25;;;;;;:::i;:::-;;;;;;;;67452:1135;;;:::o;7:99:1:-;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:246::-;368:1;378:113;392:6;389:1;386:13;378:113;;;477:1;472:3;468:11;462:18;458:1;453:3;449:11;442:39;414:2;411:1;407:10;402:15;;378:113;;;525:1;516:6;511:3;507:16;500:27;349:184;287:246;;;:::o;539:102::-;580:6;631:2;627:7;622:2;615:5;611:14;607:28;597:38;;539:102;;;:::o;647:377::-;735:3;763:39;796:5;763:39;:::i;:::-;818:71;882:6;877:3;818:71;:::i;:::-;811:78;;898:65;956:6;951:3;944:4;937:5;933:16;898:65;:::i;:::-;988:29;1010:6;988:29;:::i;:::-;983:3;979:39;972:46;;739:285;647:377;;;;:::o;1030:313::-;1143:4;1181:2;1170:9;1166:18;1158:26;;1230:9;1224:4;1220:20;1216:1;1205:9;1201:17;1194:47;1258:78;1331:4;1322:6;1258:78;:::i;:::-;1250:86;;1030:313;;;;:::o;1349:75::-;1382:6;1415:2;1409:9;1399:19;;1349:75;:::o;1430:117::-;1539:1;1536;1529:12;1553:117;1662:1;1659;1652:12;1676:126;1713:7;1753:42;1746:5;1742:54;1731:65;;1676:126;;;:::o;1808:96::-;1845:7;1874:24;1892:5;1874:24;:::i;:::-;1863:35;;1808:96;;;:::o;1910:122::-;1983:24;2001:5;1983:24;:::i;:::-;1976:5;1973:35;1963:63;;2022:1;2019;2012:12;1963:63;1910:122;:::o;2038:139::-;2084:5;2122:6;2109:20;2100:29;;2138:33;2165:5;2138:33;:::i;:::-;2038:139;;;;:::o;2183:77::-;2220:7;2249:5;2238:16;;2183:77;;;:::o;2266:122::-;2339:24;2357:5;2339:24;:::i;:::-;2332:5;2329:35;2319:63;;2378:1;2375;2368:12;2319:63;2266:122;:::o;2394:139::-;2440:5;2478:6;2465:20;2456:29;;2494:33;2521:5;2494:33;:::i;:::-;2394:139;;;;:::o;2539:474::-;2607:6;2615;2664:2;2652:9;2643:7;2639:23;2635:32;2632:119;;;2670:79;;:::i;:::-;2632:119;2790:1;2815:53;2860:7;2851:6;2840:9;2836:22;2815:53;:::i;:::-;2805:63;;2761:117;2917:2;2943:53;2988:7;2979:6;2968:9;2964:22;2943:53;:::i;:::-;2933:63;;2888:118;2539:474;;;;;:::o;3019:90::-;3053:7;3096:5;3089:13;3082:21;3071:32;;3019:90;;;:::o;3115:109::-;3196:21;3211:5;3196:21;:::i;:::-;3191:3;3184:34;3115:109;;:::o;3230:210::-;3317:4;3355:2;3344:9;3340:18;3332:26;;3368:65;3430:1;3419:9;3415:17;3406:6;3368:65;:::i;:::-;3230:210;;;;:::o;3446:118::-;3533:24;3551:5;3533:24;:::i;:::-;3528:3;3521:37;3446:118;;:::o;3570:222::-;3663:4;3701:2;3690:9;3686:18;3678:26;;3714:71;3782:1;3771:9;3767:17;3758:6;3714:71;:::i;:::-;3570:222;;;;:::o;3798:118::-;3885:24;3903:5;3885:24;:::i;:::-;3880:3;3873:37;3798:118;;:::o;3922:222::-;4015:4;4053:2;4042:9;4038:18;4030:26;;4066:71;4134:1;4123:9;4119:17;4110:6;4066:71;:::i;:::-;3922:222;;;;:::o;4150:619::-;4227:6;4235;4243;4292:2;4280:9;4271:7;4267:23;4263:32;4260:119;;;4298:79;;:::i;:::-;4260:119;4418:1;4443:53;4488:7;4479:6;4468:9;4464:22;4443:53;:::i;:::-;4433:63;;4389:117;4545:2;4571:53;4616:7;4607:6;4596:9;4592:22;4571:53;:::i;:::-;4561:63;;4516:118;4673:2;4699:53;4744:7;4735:6;4724:9;4720:22;4699:53;:::i;:::-;4689:63;;4644:118;4150:619;;;;;:::o;4775:86::-;4810:7;4850:4;4843:5;4839:16;4828:27;;4775:86;;;:::o;4867:112::-;4950:22;4966:5;4950:22;:::i;:::-;4945:3;4938:35;4867:112;;:::o;4985:214::-;5074:4;5112:2;5101:9;5097:18;5089:26;;5125:67;5189:1;5178:9;5174:17;5165:6;5125:67;:::i;:::-;4985:214;;;;:::o;5205:329::-;5264:6;5313:2;5301:9;5292:7;5288:23;5284:32;5281:119;;;5319:79;;:::i;:::-;5281:119;5439:1;5464:53;5509:7;5500:6;5489:9;5485:22;5464:53;:::i;:::-;5454:63;;5410:117;5205:329;;;;:::o;5540:::-;5599:6;5648:2;5636:9;5627:7;5623:23;5619:32;5616:119;;;5654:79;;:::i;:::-;5616:119;5774:1;5799:53;5844:7;5835:6;5824:9;5820:22;5799:53;:::i;:::-;5789:63;;5745:117;5540:329;;;;:::o;5875:117::-;5984:1;5981;5974:12;5998:180;6046:77;6043:1;6036:88;6143:4;6140:1;6133:15;6167:4;6164:1;6157:15;6184:281;6267:27;6289:4;6267:27;:::i;:::-;6259:6;6255:40;6397:6;6385:10;6382:22;6361:18;6349:10;6346:34;6343:62;6340:88;;;6408:18;;:::i;:::-;6340:88;6448:10;6444:2;6437:22;6227:238;6184:281;;:::o;6471:129::-;6505:6;6532:20;;:::i;:::-;6522:30;;6561:33;6589:4;6581:6;6561:33;:::i;:::-;6471:129;;;:::o;6606:311::-;6683:4;6773:18;6765:6;6762:30;6759:56;;;6795:18;;:::i;:::-;6759:56;6845:4;6837:6;6833:17;6825:25;;6905:4;6899;6895:15;6887:23;;6606:311;;;:::o;6923:117::-;7032:1;7029;7022:12;7063:710;7159:5;7184:81;7200:64;7257:6;7200:64;:::i;:::-;7184:81;:::i;:::-;7175:90;;7285:5;7314:6;7307:5;7300:21;7348:4;7341:5;7337:16;7330:23;;7401:4;7393:6;7389:17;7381:6;7377:30;7430:3;7422:6;7419:15;7416:122;;;7449:79;;:::i;:::-;7416:122;7564:6;7547:220;7581:6;7576:3;7573:15;7547:220;;;7656:3;7685:37;7718:3;7706:10;7685:37;:::i;:::-;7680:3;7673:50;7752:4;7747:3;7743:14;7736:21;;7623:144;7607:4;7602:3;7598:14;7591:21;;7547:220;;;7551:21;7165:608;;7063:710;;;;;:::o;7796:370::-;7867:5;7916:3;7909:4;7901:6;7897:17;7893:27;7883:122;;7924:79;;:::i;:::-;7883:122;8041:6;8028:20;8066:94;8156:3;8148:6;8141:4;8133:6;8129:17;8066:94;:::i;:::-;8057:103;;7873:293;7796:370;;;;:::o;8172:539::-;8256:6;8305:2;8293:9;8284:7;8280:23;8276:32;8273:119;;;8311:79;;:::i;:::-;8273:119;8459:1;8448:9;8444:17;8431:31;8489:18;8481:6;8478:30;8475:117;;;8511:79;;:::i;:::-;8475:117;8616:78;8686:7;8677:6;8666:9;8662:22;8616:78;:::i;:::-;8606:88;;8402:302;8172:539;;;;:::o;8717:474::-;8785:6;8793;8842:2;8830:9;8821:7;8817:23;8813:32;8810:119;;;8848:79;;:::i;:::-;8810:119;8968:1;8993:53;9038:7;9029:6;9018:9;9014:22;8993:53;:::i;:::-;8983:63;;8939:117;9095:2;9121:53;9166:7;9157:6;9146:9;9142:22;9121:53;:::i;:::-;9111:63;;9066:118;8717:474;;;;;:::o;9197:180::-;9245:77;9242:1;9235:88;9342:4;9339:1;9332:15;9366:4;9363:1;9356:15;9383:320;9427:6;9464:1;9458:4;9454:12;9444:22;;9511:1;9505:4;9501:12;9532:18;9522:81;;9588:4;9580:6;9576:17;9566:27;;9522:81;9650:2;9642:6;9639:14;9619:18;9616:38;9613:84;;9669:18;;:::i;:::-;9613:84;9434:269;9383:320;;;:::o;9709:143::-;9766:5;9797:6;9791:13;9782:22;;9813:33;9840:5;9813:33;:::i;:::-;9709:143;;;;:::o;9858:351::-;9928:6;9977:2;9965:9;9956:7;9952:23;9948:32;9945:119;;;9983:79;;:::i;:::-;9945:119;10103:1;10128:64;10184:7;10175:6;10164:9;10160:22;10128:64;:::i;:::-;10118:74;;10074:128;9858:351;;;;:::o;10215:180::-;10263:77;10260:1;10253:88;10360:4;10357:1;10350:15;10384:4;10381:1;10374:15;10401:180;10449:77;10446:1;10439:88;10546:4;10543:1;10536:15;10570:4;10567:1;10560:15;10587:233;10626:3;10649:24;10667:5;10649:24;:::i;:::-;10640:33;;10695:66;10688:5;10685:77;10682:103;;10765:18;;:::i;:::-;10682:103;10812:1;10805:5;10801:13;10794:20;;10587:233;;;:::o;10826:410::-;10866:7;10889:20;10907:1;10889:20;:::i;:::-;10884:25;;10923:20;10941:1;10923:20;:::i;:::-;10918:25;;10978:1;10975;10971:9;11000:30;11018:11;11000:30;:::i;:::-;10989:41;;11179:1;11170:7;11166:15;11163:1;11160:22;11140:1;11133:9;11113:83;11090:139;;11209:18;;:::i;:::-;11090:139;10874:362;10826:410;;;;:::o;11242:442::-;11391:4;11429:2;11418:9;11414:18;11406:26;;11442:71;11510:1;11499:9;11495:17;11486:6;11442:71;:::i;:::-;11523:72;11591:2;11580:9;11576:18;11567:6;11523:72;:::i;:::-;11605;11673:2;11662:9;11658:18;11649:6;11605:72;:::i;:::-;11242:442;;;;;;:::o;11690:167::-;11830:19;11826:1;11818:6;11814:14;11807:43;11690:167;:::o;11863:366::-;12005:3;12026:67;12090:2;12085:3;12026:67;:::i;:::-;12019:74;;12102:93;12191:3;12102:93;:::i;:::-;12220:2;12215:3;12211:12;12204:19;;11863:366;;;:::o;12235:419::-;12401:4;12439:2;12428:9;12424:18;12416:26;;12488:9;12482:4;12478:20;12474:1;12463:9;12459:17;12452:47;12516:131;12642:4;12516:131;:::i;:::-;12508:139;;12235:419;;;:::o;12660:225::-;12800:34;12796:1;12788:6;12784:14;12777:58;12869:8;12864:2;12856:6;12852:15;12845:33;12660:225;:::o;12891:366::-;13033:3;13054:67;13118:2;13113:3;13054:67;:::i;:::-;13047:74;;13130:93;13219:3;13130:93;:::i;:::-;13248:2;13243:3;13239:12;13232:19;;12891:366;;;:::o;13263:419::-;13429:4;13467:2;13456:9;13452:18;13444:26;;13516:9;13510:4;13506:20;13502:1;13491:9;13487:17;13480:47;13544:131;13670:4;13544:131;:::i;:::-;13536:139;;13263:419;;;:::o;13688:191::-;13728:3;13747:20;13765:1;13747:20;:::i;:::-;13742:25;;13781:20;13799:1;13781:20;:::i;:::-;13776:25;;13824:1;13821;13817:9;13810:16;;13845:3;13842:1;13839:10;13836:36;;;13852:18;;:::i;:::-;13836:36;13688:191;;;;:::o;13885:172::-;14025:24;14021:1;14013:6;14009:14;14002:48;13885:172;:::o;14063:366::-;14205:3;14226:67;14290:2;14285:3;14226:67;:::i;:::-;14219:74;;14302:93;14391:3;14302:93;:::i;:::-;14420:2;14415:3;14411:12;14404:19;;14063:366;;;:::o;14435:419::-;14601:4;14639:2;14628:9;14624:18;14616:26;;14688:9;14682:4;14678:20;14674:1;14663:9;14659:17;14652:47;14716:131;14842:4;14716:131;:::i;:::-;14708:139;;14435:419;;;:::o
Swarm Source
ipfs://1e0cd1e4a371021c0cefcd7af6bbc80a1f8186d1e341812b2b2213388935ab46
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.