ERC-20
Overview
Max Total Supply
1,000,000,000 NUMBER
Holders
168
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 18 Decimals)
Balance
2,109,659.09981377555662242 NUMBERValue
$0.00Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
NumberGame
Compiler Version
v0.8.21+commit.d9974bed
Optimization Enabled:
No with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT /* Telegram - https://t.me/the_number_game Twitter - https://twitter.com/numberscoin Website - https://numberscoin.info _______ _ _ _ _ _____ |__ __| | | \ | | | | / ____| | | | |__ ___ | \| |_ _ _ __ ___ | |__ ___ _ __ | | __ __ _ _ __ ___ ___ | | | '_ \ / _ \ | . ` | | | | '_ ` _ \| '_ \ / _ \ '__| | | |_ |/ _` | '_ ` _ \ / _ \ | | | | | | __/ | |\ | |_| | | | | | | |_) | __/ | | |__| | (_| | | | | | | __/ |_| |_| |_|\___| |_| \_|\__,_|_| |_| |_|_.__/ \___|_| \_____|\__,_|_| |_| |_|\___| Welcome to The Number Game. Here are the rules: ▶ There are 10 levels. Each level gets 10x harder to guess the number correctly than the last. For example, on level 1 the chances of guessing correctly are 1/10. On level 2 the chances of guessing correctly are 1/100. On level 3 the chances of guessing correctly are 1/1000. And so on... ▶ Anyone can guess a number using the guessNumber() function. Each player's guesses are unique to their public address, so MEV is not an issue. ▶ If a player guesses the number correctly, the player will be able to successfully claim 1% of the total supply of tokens. The game will then proceed to the next level each time a prize is claimed until the game is over after level 10. ▶ Finally, in order to claim the prize a player must own at least 0.1% of the total supply. Good luck! */ pragma solidity ^0.8.21; interface IUniswapV2Factory { event PairCreated(address indexed token0, address indexed token1, address pair, uint256); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint256) external view returns (address pair); function allPairsLength() external view returns (uint256); function createPair(address tokenA, address tokenB) external returns (address pair); function setFeeTo(address) external; function setFeeToSetter(address) external; } pragma solidity ^0.8.21; interface IUniswapV2Router02 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity); function addLiquidityETH( address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline ) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external; } pragma solidity ^0.8.21; library SafeMath { 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); } } function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } function add(uint256 a, uint256 b) internal pure returns (uint256) { return a + b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return a - b; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { return a * b; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return a % b; } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a / b; } } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a % b; } } } pragma solidity ^0.8.4; /// @notice Library for converting numbers into strings and other string operations. /// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibString.sol) /// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol) library LibString { /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* CUSTOM ERRORS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev The `length` of the output is too small to contain all the hex digits. error HexLengthInsufficient(); /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* CONSTANTS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev The constant returned when the `search` is not found in the string. uint256 internal constant NOT_FOUND = type(uint256).max; /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* DECIMAL OPERATIONS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev Returns the base 10 decimal representation of `value`. function toString(uint256 value) internal pure returns (string memory str) { /// @solidity memory-safe-assembly assembly { // The maximum value of a uint256 contains 78 digits (1 byte per digit), but // we allocate 0xa0 bytes to keep the free memory pointer 32-byte word aligned. // We will need 1 word for the trailing zeros padding, 1 word for the length, // and 3 words for a maximum of 78 digits. str := add(mload(0x40), 0x80) // Update the free memory pointer to allocate. mstore(0x40, add(str, 0x20)) // Zeroize the slot after the string. mstore(str, 0) // Cache the end of the memory to calculate the length later. let end := str let w := not(0) // Tsk. // We write the string from rightmost digit to leftmost digit. // The following is essentially a do-while loop that also handles the zero case. for { let temp := value } 1 {} { str := add(str, w) // `sub(str, 1)`. // Write the character to the pointer. // The ASCII index of the '0' character is 48. mstore8(str, add(48, mod(temp, 10))) // Keep dividing `temp` until zero. temp := div(temp, 10) if iszero(temp) { break } } let length := sub(end, str) // Move the pointer 32 bytes leftwards to make room for the length. str := sub(str, 0x20) // Store the length. mstore(str, length) } } /// @dev Returns the base 10 decimal representation of `value`. function toString(int256 value) internal pure returns (string memory str) { if (value >= 0) { return toString(uint256(value)); } unchecked { str = toString(uint256(-value)); } /// @solidity memory-safe-assembly assembly { // We still have some spare memory space on the left, // as we have allocated 3 words (96 bytes) for up to 78 digits. let length := mload(str) // Load the string length. mstore(str, 0x2d) // Store the '-' character. str := sub(str, 1) // Move back the string pointer by a byte. mstore(str, add(length, 1)) // Update the string length. } } /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* HEXADECIMAL OPERATIONS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev Returns the hexadecimal representation of `value`, /// left-padded to an input length of `length` bytes. /// The output is prefixed with "0x" encoded using 2 hexadecimal digits per byte, /// giving a total length of `length * 2 + 2` bytes. /// Reverts if `length` is too small for the output to contain all the digits. function toHexString(uint256 value, uint256 length) internal pure returns (string memory str) { str = toHexStringNoPrefix(value, length); /// @solidity memory-safe-assembly assembly { let strLength := add(mload(str), 2) // Compute the length. mstore(str, 0x3078) // Write the "0x" prefix. str := sub(str, 2) // Move the pointer. mstore(str, strLength) // Write the length. } } /// @dev Returns the hexadecimal representation of `value`, /// left-padded to an input length of `length` bytes. /// The output is prefixed with "0x" encoded using 2 hexadecimal digits per byte, /// giving a total length of `length * 2` bytes. /// Reverts if `length` is too small for the output to contain all the digits. function toHexStringNoPrefix(uint256 value, uint256 length) internal pure returns (string memory str) { /// @solidity memory-safe-assembly assembly { // We need 0x20 bytes for the trailing zeros padding, `length * 2` bytes // for the digits, 0x02 bytes for the prefix, and 0x20 bytes for the length. // We add 0x20 to the total and round down to a multiple of 0x20. // (0x20 + 0x20 + 0x02 + 0x20) = 0x62. str := add(mload(0x40), and(add(shl(1, length), 0x42), not(0x1f))) // Allocate the memory. mstore(0x40, add(str, 0x20)) // Zeroize the slot after the string. mstore(str, 0) // Cache the end to calculate the length later. let end := str // Store "0123456789abcdef" in scratch space. mstore(0x0f, 0x30313233343536373839616263646566) let start := sub(str, add(length, length)) let w := not(1) // Tsk. let temp := value // We write the string from rightmost digit to leftmost digit. // The following is essentially a do-while loop that also handles the zero case. for {} 1 {} { str := add(str, w) // `sub(str, 2)`. mstore8(add(str, 1), mload(and(temp, 15))) mstore8(str, mload(and(shr(4, temp), 15))) temp := shr(8, temp) if iszero(xor(str, start)) { break } } if temp { // Store the function selector of `HexLengthInsufficient()`. mstore(0x00, 0x2194895a) // Revert with (offset, size). revert(0x1c, 0x04) } // Compute the string's length. let strLength := sub(end, str) // Move the pointer and write the length. str := sub(str, 0x20) mstore(str, strLength) } } /// @dev Returns the hexadecimal representation of `value`. /// The output is prefixed with "0x" and encoded using 2 hexadecimal digits per byte. /// As address are 20 bytes long, the output will left-padded to have /// a length of `20 * 2 + 2` bytes. function toHexString(uint256 value) internal pure returns (string memory str) { str = toHexStringNoPrefix(value); /// @solidity memory-safe-assembly assembly { let strLength := add(mload(str), 2) // Compute the length. mstore(str, 0x3078) // Write the "0x" prefix. str := sub(str, 2) // Move the pointer. mstore(str, strLength) // Write the length. } } /// @dev Returns the hexadecimal representation of `value`. /// The output is prefixed with "0x". /// The output excludes leading "0" from the `toHexString` output. /// `0x00: "0x0", 0x01: "0x1", 0x12: "0x12", 0x123: "0x123"`. function toMinimalHexString(uint256 value) internal pure returns (string memory str) { str = toHexStringNoPrefix(value); /// @solidity memory-safe-assembly assembly { let o := eq(byte(0, mload(add(str, 0x20))), 0x30) // Whether leading zero is present. let strLength := add(mload(str), 2) // Compute the length. mstore(add(str, o), 0x3078) // Write the "0x" prefix, accounting for leading zero. str := sub(add(str, o), 2) // Move the pointer, accounting for leading zero. mstore(str, sub(strLength, o)) // Write the length, accounting for leading zero. } } /// @dev Returns the hexadecimal representation of `value`. /// The output excludes leading "0" from the `toHexStringNoPrefix` output. /// `0x00: "0", 0x01: "1", 0x12: "12", 0x123: "123"`. function toMinimalHexStringNoPrefix(uint256 value) internal pure returns (string memory str) { str = toHexStringNoPrefix(value); /// @solidity memory-safe-assembly assembly { let o := eq(byte(0, mload(add(str, 0x20))), 0x30) // Whether leading zero is present. let strLength := mload(str) // Get the length. str := add(str, o) // Move the pointer, accounting for leading zero. mstore(str, sub(strLength, o)) // Write the length, accounting for leading zero. } } /// @dev Returns the hexadecimal representation of `value`. /// The output is encoded using 2 hexadecimal digits per byte. /// As address are 20 bytes long, the output will left-padded to have /// a length of `20 * 2` bytes. function toHexStringNoPrefix(uint256 value) internal pure returns (string memory str) { /// @solidity memory-safe-assembly assembly { // We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length, // 0x02 bytes for the prefix, and 0x40 bytes for the digits. // The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x40) is 0xa0. str := add(mload(0x40), 0x80) // Allocate the memory. mstore(0x40, add(str, 0x20)) // Zeroize the slot after the string. mstore(str, 0) // Cache the end to calculate the length later. let end := str // Store "0123456789abcdef" in scratch space. mstore(0x0f, 0x30313233343536373839616263646566) let w := not(1) // Tsk. // We write the string from rightmost digit to leftmost digit. // The following is essentially a do-while loop that also handles the zero case. for { let temp := value } 1 {} { str := add(str, w) // `sub(str, 2)`. mstore8(add(str, 1), mload(and(temp, 15))) mstore8(str, mload(and(shr(4, temp), 15))) temp := shr(8, temp) if iszero(temp) { break } } // Compute the string's length. let strLength := sub(end, str) // Move the pointer and write the length. str := sub(str, 0x20) mstore(str, strLength) } } /// @dev Returns the hexadecimal representation of `value`. /// The output is prefixed with "0x", encoded using 2 hexadecimal digits per byte, /// and the alphabets are capitalized conditionally according to /// https://eips.ethereum.org/EIPS/eip-55 function toHexStringChecksummed(address value) internal pure returns (string memory str) { str = toHexString(value); /// @solidity memory-safe-assembly assembly { let mask := shl(6, div(not(0), 255)) // `0b010000000100000000 ...` let o := add(str, 0x22) let hashed := and(keccak256(o, 40), mul(34, mask)) // `0b10001000 ... ` let t := shl(240, 136) // `0b10001000 << 240` for { let i := 0 } 1 {} { mstore(add(i, i), mul(t, byte(i, hashed))) i := add(i, 1) if eq(i, 20) { break } } mstore(o, xor(mload(o), shr(1, and(mload(0x00), and(mload(o), mask))))) o := add(o, 0x20) mstore(o, xor(mload(o), shr(1, and(mload(0x20), and(mload(o), mask))))) } } /// @dev Returns the hexadecimal representation of `value`. /// The output is prefixed with "0x" and encoded using 2 hexadecimal digits per byte. function toHexString(address value) internal pure returns (string memory str) { str = toHexStringNoPrefix(value); /// @solidity memory-safe-assembly assembly { let strLength := add(mload(str), 2) // Compute the length. mstore(str, 0x3078) // Write the "0x" prefix. str := sub(str, 2) // Move the pointer. mstore(str, strLength) // Write the length. } } /// @dev Returns the hexadecimal representation of `value`. /// The output is encoded using 2 hexadecimal digits per byte. function toHexStringNoPrefix(address value) internal pure returns (string memory str) { /// @solidity memory-safe-assembly assembly { str := mload(0x40) // Allocate the memory. // We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length, // 0x02 bytes for the prefix, and 0x28 bytes for the digits. // The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x28) is 0x80. mstore(0x40, add(str, 0x80)) // Store "0123456789abcdef" in scratch space. mstore(0x0f, 0x30313233343536373839616263646566) str := add(str, 2) mstore(str, 40) let o := add(str, 0x20) mstore(add(o, 40), 0) value := shl(96, value) // We write the string from rightmost digit to leftmost digit. // The following is essentially a do-while loop that also handles the zero case. for { let i := 0 } 1 {} { let p := add(o, add(i, i)) let temp := byte(i, value) mstore8(add(p, 1), mload(and(temp, 15))) mstore8(p, mload(shr(4, temp))) i := add(i, 1) if eq(i, 20) { break } } } } /// @dev Returns the hex encoded string from the raw bytes. /// The output is encoded using 2 hexadecimal digits per byte. function toHexString(bytes memory raw) internal pure returns (string memory str) { str = toHexStringNoPrefix(raw); /// @solidity memory-safe-assembly assembly { let strLength := add(mload(str), 2) // Compute the length. mstore(str, 0x3078) // Write the "0x" prefix. str := sub(str, 2) // Move the pointer. mstore(str, strLength) // Write the length. } } /// @dev Returns the hex encoded string from the raw bytes. /// The output is encoded using 2 hexadecimal digits per byte. function toHexStringNoPrefix(bytes memory raw) internal pure returns (string memory str) { /// @solidity memory-safe-assembly assembly { let length := mload(raw) str := add(mload(0x40), 2) // Skip 2 bytes for the optional prefix. mstore(str, add(length, length)) // Store the length of the output. // Store "0123456789abcdef" in scratch space. mstore(0x0f, 0x30313233343536373839616263646566) let o := add(str, 0x20) let end := add(raw, length) for {} iszero(eq(raw, end)) {} { raw := add(raw, 1) mstore8(add(o, 1), mload(and(mload(raw), 15))) mstore8(o, mload(and(shr(4, mload(raw)), 15))) o := add(o, 2) } mstore(o, 0) // Zeroize the slot after the string. mstore(0x40, add(o, 0x20)) // Allocate the memory. } } /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* RUNE STRING OPERATIONS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ /// @dev Returns the number of UTF characters in the string. function runeCount(string memory s) internal pure returns (uint256 result) { /// @solidity memory-safe-assembly assembly { if mload(s) { mstore(0x00, div(not(0), 255)) mstore(0x20, 0x0202020202020202020202020202020202020202020202020303030304040506) let o := add(s, 0x20) let end := add(o, mload(s)) for { result := 1 } 1 { result := add(result, 1) } { o := add(o, byte(0, mload(shr(250, mload(o))))) if iszero(lt(o, end)) { break } } } } } /// @dev Returns if this string is a 7-bit ASCII string. /// (i.e. all characters codes are in [0..127]) function is7BitASCII(string memory s) internal pure returns (bool result) { /// @solidity memory-safe-assembly assembly { let mask := shl(7, div(not(0), 255)) result := 1 let n := mload(s) if n { let o := add(s, 0x20) let end := add(o, n) let last := mload(end) mstore(end, 0) for {} 1 {} { if and(mask, mload(o)) { result := 0 break } o := add(o, 0x20) if iszero(lt(o, end)) { break } } mstore(end, last) } } } /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/ /* BYTE STRING OPERATIONS */ /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/ // For performance and bytecode compactness, all indices of the following operations // are byte (ASCII) offsets, not UTF character offsets. /// @dev Returns `subject` all occurrences of `search` replaced with `replacement`. function replace(string memory subject, string memory search, string memory replacement) internal pure returns (string memory result) { /// @solidity memory-safe-assembly assembly { let subjectLength := mload(subject) let searchLength := mload(search) let replacementLength := mload(replacement) subject := add(subject, 0x20) search := add(search, 0x20) replacement := add(replacement, 0x20) result := add(mload(0x40), 0x20) let subjectEnd := add(subject, subjectLength) if iszero(gt(searchLength, subjectLength)) { let subjectSearchEnd := add(sub(subjectEnd, searchLength), 1) let h := 0 if iszero(lt(searchLength, 0x20)) { h := keccak256(search, searchLength) } let m := shl(3, sub(0x20, and(searchLength, 0x1f))) let s := mload(search) for {} 1 {} { let t := mload(subject) // Whether the first `searchLength % 32` bytes of // `subject` and `search` matches. if iszero(shr(m, xor(t, s))) { if h { if iszero(eq(keccak256(subject, searchLength), h)) { mstore(result, t) result := add(result, 1) subject := add(subject, 1) if iszero(lt(subject, subjectSearchEnd)) { break } continue } } // Copy the `replacement` one word at a time. for { let o := 0 } 1 {} { mstore(add(result, o), mload(add(replacement, o))) o := add(o, 0x20) if iszero(lt(o, replacementLength)) { break } } result := add(result, replacementLength) subject := add(subject, searchLength) if searchLength { if iszero(lt(subject, subjectSearchEnd)) { break } continue } } mstore(result, t) result := add(result, 1) subject := add(subject, 1) if iszero(lt(subject, subjectSearchEnd)) { break } } } let resultRemainder := result result := add(mload(0x40), 0x20) let k := add(sub(resultRemainder, result), sub(subjectEnd, subject)) // Copy the rest of the string one word at a time. for {} lt(subject, subjectEnd) {} { mstore(resultRemainder, mload(subject)) resultRemainder := add(resultRemainder, 0x20) subject := add(subject, 0x20) } result := sub(result, 0x20) let last := add(add(result, 0x20), k) // Zeroize the slot after the string. mstore(last, 0) mstore(0x40, add(last, 0x20)) // Allocate the memory. mstore(result, k) // Store the length. } } /// @dev Returns the byte index of the first location of `search` in `subject`, /// searching from left to right, starting from `from`. /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found. function indexOf(string memory subject, string memory search, uint256 from) internal pure returns (uint256 result) { /// @solidity memory-safe-assembly assembly { for { let subjectLength := mload(subject) } 1 {} { if iszero(mload(search)) { if iszero(gt(from, subjectLength)) { result := from break } result := subjectLength break } let searchLength := mload(search) let subjectStart := add(subject, 0x20) result := not(0) // Initialize to `NOT_FOUND`. subject := add(subjectStart, from) let end := add(sub(add(subjectStart, subjectLength), searchLength), 1) let m := shl(3, sub(0x20, and(searchLength, 0x1f))) let s := mload(add(search, 0x20)) if iszero(and(lt(subject, end), lt(from, subjectLength))) { break } if iszero(lt(searchLength, 0x20)) { for { let h := keccak256(add(search, 0x20), searchLength) } 1 {} { if iszero(shr(m, xor(mload(subject), s))) { if eq(keccak256(subject, searchLength), h) { result := sub(subject, subjectStart) break } } subject := add(subject, 1) if iszero(lt(subject, end)) { break } } break } for {} 1 {} { if iszero(shr(m, xor(mload(subject), s))) { result := sub(subject, subjectStart) break } subject := add(subject, 1) if iszero(lt(subject, end)) { break } } break } } } /// @dev Returns the byte index of the first location of `search` in `subject`, /// searching from left to right. /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found. function indexOf(string memory subject, string memory search) internal pure returns (uint256 result) { result = indexOf(subject, search, 0); } /// @dev Returns the byte index of the first location of `search` in `subject`, /// searching from right to left, starting from `from`. /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found. function lastIndexOf(string memory subject, string memory search, uint256 from) internal pure returns (uint256 result) { /// @solidity memory-safe-assembly assembly { for {} 1 {} { result := not(0) // Initialize to `NOT_FOUND`. let searchLength := mload(search) if gt(searchLength, mload(subject)) { break } let w := result let fromMax := sub(mload(subject), searchLength) if iszero(gt(fromMax, from)) { from := fromMax } let end := add(add(subject, 0x20), w) subject := add(add(subject, 0x20), from) if iszero(gt(subject, end)) { break } // As this function is not too often used, // we shall simply use keccak256 for smaller bytecode size. for { let h := keccak256(add(search, 0x20), searchLength) } 1 {} { if eq(keccak256(subject, searchLength), h) { result := sub(subject, add(end, 1)) break } subject := add(subject, w) // `sub(subject, 1)`. if iszero(gt(subject, end)) { break } } break } } } /// @dev Returns the byte index of the first location of `search` in `subject`, /// searching from right to left. /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found. function lastIndexOf(string memory subject, string memory search) internal pure returns (uint256 result) { result = lastIndexOf(subject, search, uint256(int256(-1))); } /// @dev Returns whether `subject` starts with `search`. function startsWith(string memory subject, string memory search) internal pure returns (bool result) { /// @solidity memory-safe-assembly assembly { let searchLength := mload(search) // Just using keccak256 directly is actually cheaper. // forgefmt: disable-next-item result := and( iszero(gt(searchLength, mload(subject))), eq( keccak256(add(subject, 0x20), searchLength), keccak256(add(search, 0x20), searchLength) ) ) } } /// @dev Returns whether `subject` ends with `search`. function endsWith(string memory subject, string memory search) internal pure returns (bool result) { /// @solidity memory-safe-assembly assembly { let searchLength := mload(search) let subjectLength := mload(subject) // Whether `search` is not longer than `subject`. let withinRange := iszero(gt(searchLength, subjectLength)) // Just using keccak256 directly is actually cheaper. // forgefmt: disable-next-item result := and( withinRange, eq( keccak256( // `subject + 0x20 + max(subjectLength - searchLength, 0)`. add(add(subject, 0x20), mul(withinRange, sub(subjectLength, searchLength))), searchLength ), keccak256(add(search, 0x20), searchLength) ) ) } } /// @dev Returns `subject` repeated `times`. function repeat(string memory subject, uint256 times) internal pure returns (string memory result) { /// @solidity memory-safe-assembly assembly { let subjectLength := mload(subject) if iszero(or(iszero(times), iszero(subjectLength))) { subject := add(subject, 0x20) result := mload(0x40) let output := add(result, 0x20) for {} 1 {} { // Copy the `subject` one word at a time. for { let o := 0 } 1 {} { mstore(add(output, o), mload(add(subject, o))) o := add(o, 0x20) if iszero(lt(o, subjectLength)) { break } } output := add(output, subjectLength) times := sub(times, 1) if iszero(times) { break } } mstore(output, 0) // Zeroize the slot after the string. let resultLength := sub(output, add(result, 0x20)) mstore(result, resultLength) // Store the length. // Allocate the memory. mstore(0x40, add(result, add(resultLength, 0x20))) } } } /// @dev Returns a copy of `subject` sliced from `start` to `end` (exclusive). /// `start` and `end` are byte offsets. function slice(string memory subject, uint256 start, uint256 end) internal pure returns (string memory result) { /// @solidity memory-safe-assembly assembly { let subjectLength := mload(subject) if iszero(gt(subjectLength, end)) { end := subjectLength } if iszero(gt(subjectLength, start)) { start := subjectLength } if lt(start, end) { result := mload(0x40) let resultLength := sub(end, start) mstore(result, resultLength) subject := add(subject, start) let w := not(0x1f) // Copy the `subject` one word at a time, backwards. for { let o := and(add(resultLength, 0x1f), w) } 1 {} { mstore(add(result, o), mload(add(subject, o))) o := add(o, w) // `sub(o, 0x20)`. if iszero(o) { break } } // Zeroize the slot after the string. mstore(add(add(result, 0x20), resultLength), 0) // Allocate memory for the length and the bytes, // rounded up to a multiple of 32. mstore(0x40, add(result, and(add(resultLength, 0x3f), w))) } } } /// @dev Returns a copy of `subject` sliced from `start` to the end of the string. /// `start` is a byte offset. function slice(string memory subject, uint256 start) internal pure returns (string memory result) { result = slice(subject, start, uint256(int256(-1))); } /// @dev Returns all the indices of `search` in `subject`. /// The indices are byte offsets. function indicesOf(string memory subject, string memory search) internal pure returns (uint256[] memory result) { /// @solidity memory-safe-assembly assembly { let subjectLength := mload(subject) let searchLength := mload(search) if iszero(gt(searchLength, subjectLength)) { subject := add(subject, 0x20) search := add(search, 0x20) result := add(mload(0x40), 0x20) let subjectStart := subject let subjectSearchEnd := add(sub(add(subject, subjectLength), searchLength), 1) let h := 0 if iszero(lt(searchLength, 0x20)) { h := keccak256(search, searchLength) } let m := shl(3, sub(0x20, and(searchLength, 0x1f))) let s := mload(search) for {} 1 {} { let t := mload(subject) // Whether the first `searchLength % 32` bytes of // `subject` and `search` matches. if iszero(shr(m, xor(t, s))) { if h { if iszero(eq(keccak256(subject, searchLength), h)) { subject := add(subject, 1) if iszero(lt(subject, subjectSearchEnd)) { break } continue } } // Append to `result`. mstore(result, sub(subject, subjectStart)) result := add(result, 0x20) // Advance `subject` by `searchLength`. subject := add(subject, searchLength) if searchLength { if iszero(lt(subject, subjectSearchEnd)) { break } continue } } subject := add(subject, 1) if iszero(lt(subject, subjectSearchEnd)) { break } } let resultEnd := result // Assign `result` to the free memory pointer. result := mload(0x40) // Store the length of `result`. mstore(result, shr(5, sub(resultEnd, add(result, 0x20)))) // Allocate memory for result. // We allocate one more word, so this array can be recycled for {split}. mstore(0x40, add(resultEnd, 0x20)) } } } /// @dev Returns a arrays of strings based on the `delimiter` inside of the `subject` string. function split(string memory subject, string memory delimiter) internal pure returns (string[] memory result) { uint256[] memory indices = indicesOf(subject, delimiter); /// @solidity memory-safe-assembly assembly { let w := not(0x1f) let indexPtr := add(indices, 0x20) let indicesEnd := add(indexPtr, shl(5, add(mload(indices), 1))) mstore(add(indicesEnd, w), mload(subject)) mstore(indices, add(mload(indices), 1)) let prevIndex := 0 for {} 1 {} { let index := mload(indexPtr) mstore(indexPtr, 0x60) if iszero(eq(index, prevIndex)) { let element := mload(0x40) let elementLength := sub(index, prevIndex) mstore(element, elementLength) // Copy the `subject` one word at a time, backwards. for { let o := and(add(elementLength, 0x1f), w) } 1 {} { mstore(add(element, o), mload(add(add(subject, prevIndex), o))) o := add(o, w) // `sub(o, 0x20)`. if iszero(o) { break } } // Zeroize the slot after the string. mstore(add(add(element, 0x20), elementLength), 0) // Allocate memory for the length and the bytes, // rounded up to a multiple of 32. mstore(0x40, add(element, and(add(elementLength, 0x3f), w))) // Store the `element` into the array. mstore(indexPtr, element) } prevIndex := add(index, mload(delimiter)) indexPtr := add(indexPtr, 0x20) if iszero(lt(indexPtr, indicesEnd)) { break } } result := indices if iszero(mload(delimiter)) { result := add(indices, 0x20) mstore(result, sub(mload(indices), 2)) } } } /// @dev Returns a concatenated string of `a` and `b`. /// Cheaper than `string.concat()` and does not de-align the free memory pointer. function concat(string memory a, string memory b) internal pure returns (string memory result) { /// @solidity memory-safe-assembly assembly { let w := not(0x1f) result := mload(0x40) let aLength := mload(a) // Copy `a` one word at a time, backwards. for { let o := and(add(aLength, 0x20), w) } 1 {} { mstore(add(result, o), mload(add(a, o))) o := add(o, w) // `sub(o, 0x20)`. if iszero(o) { break } } let bLength := mload(b) let output := add(result, aLength) // Copy `b` one word at a time, backwards. for { let o := and(add(bLength, 0x20), w) } 1 {} { mstore(add(output, o), mload(add(b, o))) o := add(o, w) // `sub(o, 0x20)`. if iszero(o) { break } } let totalLength := add(aLength, bLength) let last := add(add(result, 0x20), totalLength) // Zeroize the slot after the string. mstore(last, 0) // Stores the length. mstore(result, totalLength) // Allocate memory for the length and the bytes, // rounded up to a multiple of 32. mstore(0x40, and(add(last, 0x1f), w)) } } /// @dev Returns a copy of the string in either lowercase or UPPERCASE. /// WARNING! This function is only compatible with 7-bit ASCII strings. function toCase(string memory subject, bool toUpper) internal pure returns (string memory result) { /// @solidity memory-safe-assembly assembly { let length := mload(subject) if length { result := add(mload(0x40), 0x20) subject := add(subject, 1) let flags := shl(add(70, shl(5, toUpper)), 0x3ffffff) let w := not(0) for { let o := length } 1 {} { o := add(o, w) let b := and(0xff, mload(add(subject, o))) mstore8(add(result, o), xor(b, and(shr(b, flags), 0x20))) if iszero(o) { break } } result := mload(0x40) mstore(result, length) // Store the length. let last := add(add(result, 0x20), length) mstore(last, 0) // Zeroize the slot after the string. mstore(0x40, add(last, 0x20)) // Allocate the memory. } } } /// @dev Returns a lowercased copy of the string. /// WARNING! This function is only compatible with 7-bit ASCII strings. function lower(string memory subject) internal pure returns (string memory result) { result = toCase(subject, false); } /// @dev Returns an UPPERCASED copy of the string. /// WARNING! This function is only compatible with 7-bit ASCII strings. function upper(string memory subject) internal pure returns (string memory result) { result = toCase(subject, true); } /// @dev Escapes the string to be used within HTML tags. function escapeHTML(string memory s) internal pure returns (string memory result) { /// @solidity memory-safe-assembly assembly { for { let end := add(s, mload(s)) result := add(mload(0x40), 0x20) // Store the bytes of the packed offsets and strides into the scratch space. // `packed = (stride << 5) | offset`. Max offset is 20. Max stride is 6. mstore(0x1f, 0x900094) mstore(0x08, 0xc0000000a6ab) // Store ""&'<>" into the scratch space. mstore(0x00, shl(64, 0x2671756f743b26616d703b262333393b266c743b2667743b)) } iszero(eq(s, end)) {} { s := add(s, 1) let c := and(mload(s), 0xff) // Not in `["\"","'","&","<",">"]`. if iszero(and(shl(c, 1), 0x500000c400000000)) { mstore8(result, c) result := add(result, 1) continue } let t := shr(248, mload(c)) mstore(result, mload(and(t, 0x1f))) result := add(result, shr(5, t)) } let last := result mstore(last, 0) // Zeroize the slot after the string. result := mload(0x40) mstore(result, sub(last, add(result, 0x20))) // Store the length. mstore(0x40, add(last, 0x20)) // Allocate the memory. } } /// @dev Escapes the string to be used within double-quotes in a JSON. function escapeJSON(string memory s) internal pure returns (string memory result) { /// @solidity memory-safe-assembly assembly { for { let end := add(s, mload(s)) result := add(mload(0x40), 0x20) // Store "\\u0000" in scratch space. // Store "0123456789abcdef" in scratch space. // Also, store `{0x08:"b", 0x09:"t", 0x0a:"n", 0x0c:"f", 0x0d:"r"}`. // into the scratch space. mstore(0x15, 0x5c75303030303031323334353637383961626364656662746e006672) // Bitmask for detecting `["\"","\\"]`. let e := or(shl(0x22, 1), shl(0x5c, 1)) } iszero(eq(s, end)) {} { s := add(s, 1) let c := and(mload(s), 0xff) if iszero(lt(c, 0x20)) { if iszero(and(shl(c, 1), e)) { // Not in `["\"","\\"]`. mstore8(result, c) result := add(result, 1) continue } mstore8(result, 0x5c) // "\\". mstore8(add(result, 1), c) result := add(result, 2) continue } if iszero(and(shl(c, 1), 0x3700)) { // Not in `["\b","\t","\n","\f","\d"]`. mstore8(0x1d, mload(shr(4, c))) // Hex value. mstore8(0x1e, mload(and(c, 15))) // Hex value. mstore(result, mload(0x19)) // "\\u00XX". result := add(result, 6) continue } mstore8(result, 0x5c) // "\\". mstore8(add(result, 1), mload(add(c, 8))) result := add(result, 2) } let last := result mstore(last, 0) // Zeroize the slot after the string. result := mload(0x40) mstore(result, sub(last, add(result, 0x20))) // Store the length. mstore(0x40, add(last, 0x20)) // Allocate the memory. } } /// @dev Returns whether `a` equals `b`. function eq(string memory a, string memory b) internal pure returns (bool result) { assembly { result := eq(keccak256(add(a, 0x20), mload(a)), keccak256(add(b, 0x20), mload(b))) } } /// @dev Packs a single string with its length into a single word. /// Returns `bytes32(0)` if the length is zero or greater than 31. function packOne(string memory a) internal pure returns (bytes32 result) { /// @solidity memory-safe-assembly assembly { // We don't need to zero right pad the string, // since this is our own custom non-standard packing scheme. result := mul( // Load the length and the bytes. mload(add(a, 0x1f)), // `length != 0 && length < 32`. Abuses underflow. // Assumes that the length is valid and within the block gas limit. lt(sub(mload(a), 1), 0x1f) ) } } /// @dev Unpacks a string packed using {packOne}. /// Returns the empty string if `packed` is `bytes32(0)`. /// If `packed` is not an output of {packOne}, the output behaviour is undefined. function unpackOne(bytes32 packed) internal pure returns (string memory result) { /// @solidity memory-safe-assembly assembly { // Grab the free memory pointer. result := mload(0x40) // Allocate 2 words (1 for the length, 1 for the bytes). mstore(0x40, add(result, 0x40)) // Zeroize the length slot. mstore(result, 0) // Store the length and bytes. mstore(add(result, 0x1f), packed) // Right pad with zeroes. mstore(add(add(result, 0x20), mload(result)), 0) } } /// @dev Packs two strings with their lengths into a single word. /// Returns `bytes32(0)` if combined length is zero or greater than 30. function packTwo(string memory a, string memory b) internal pure returns (bytes32 result) { /// @solidity memory-safe-assembly assembly { let aLength := mload(a) // We don't need to zero right pad the strings, // since this is our own custom non-standard packing scheme. result := mul( // Load the length and the bytes of `a` and `b`. or( shl(shl(3, sub(0x1f, aLength)), mload(add(a, aLength))), mload(sub(add(b, 0x1e), aLength)) ), // `totalLength != 0 && totalLength < 31`. Abuses underflow. // Assumes that the lengths are valid and within the block gas limit. lt(sub(add(aLength, mload(b)), 1), 0x1e) ) } } /// @dev Unpacks strings packed using {packTwo}. /// Returns the empty strings if `packed` is `bytes32(0)`. /// If `packed` is not an output of {packTwo}, the output behaviour is undefined. function unpackTwo(bytes32 packed) internal pure returns (string memory resultA, string memory resultB) { /// @solidity memory-safe-assembly assembly { // Grab the free memory pointer. resultA := mload(0x40) resultB := add(resultA, 0x40) // Allocate 2 words for each string (1 for the length, 1 for the byte). Total 4 words. mstore(0x40, add(resultB, 0x40)) // Zeroize the length slots. mstore(resultA, 0) mstore(resultB, 0) // Store the lengths and bytes. mstore(add(resultA, 0x1f), packed) mstore(add(resultB, 0x1f), mload(add(add(resultA, 0x20), mload(resultA)))) // Right pad with zeroes. mstore(add(add(resultA, 0x20), mload(resultA)), 0) mstore(add(add(resultB, 0x20), mload(resultB)), 0) } } /// @dev Directly returns `a` without copying. function directReturn(string memory a) internal pure { assembly { // Assumes that the string does not start from the scratch space. let retStart := sub(a, 0x20) let retSize := add(mload(a), 0x40) // Right pad with zeroes. Just in case the string is produced // by a method that doesn't zero right pad. mstore(add(retStart, retSize), 0) // Store the return offset. mstore(retStart, 0x20) // End the transaction, returning the string. return(retStart, retSize) } } } pragma solidity ^0.8.21; interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } pragma solidity ^0.8.21; interface IERC20Metadata is IERC20 { function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8); } pragma solidity ^0.8.21; abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } pragma solidity ^0.8.21; abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() { _transferOwnership(_msgSender()); } function owner() public view virtual returns (address) { return _owner; } modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } pragma solidity ^0.8.21; contract ERC20 is Context, IERC20, IERC20Metadata { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } function name() public view virtual override returns (string memory) { return _name; } function symbol() public view virtual override returns (string memory) { return _symbol; } function decimals() public view virtual override returns (uint8) { return 18; } function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); uint256 currentAllowance = _allowances[sender][_msgSender()]; require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance"); unchecked { _approve(sender, _msgSender(), currentAllowance - amount); } return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { uint256 currentAllowance = _allowances[_msgSender()][spender]; require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(_msgSender(), spender, currentAllowance - subtractedValue); } return true; } function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); uint256 senderBalance = _balances[sender]; require(senderBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[sender] = senderBalance - amount; } _balances[recipient] += amount; emit Transfer(sender, recipient, amount); _afterTokenTransfer(sender, recipient, amount); } function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; _balances[account] += amount; emit Transfer(address(0), account, amount); _afterTokenTransfer(address(0), account, amount); } function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; } _totalSupply -= amount; emit Transfer(account, address(0), amount); _afterTokenTransfer(account, address(0), amount); } function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {} function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {} } pragma solidity ^0.8.21; contract NumberGame is ERC20, Ownable { using SafeMath for uint256; error ZeroValue(); error InvalidNumber(); error GameNotActive(); error TransferFailed(); error DoesntEqualTotal(); error GameNotConfigured(); error GameAlreadyStarted(); IUniswapV2Router02 public immutable uniswapV2Router; address public immutable uniswapV2Pair; address public constant deadAddress = address(0xdead); bool private swapping; bool public gameActive; address private marketingWallet; address private devWallet; uint256 public maxTransactionAmount; uint256 public swapTokensAtAmount; uint256 public maxWallet; bool public limitsInEffect = true; bool public tradingActive = false; bool public swapEnabled = false; uint256 private launchedAt; uint256 private launchedTime; uint256 public deadBlocks; uint256 public buyTotalFees; uint256 public sellTotalFees; uint256 public numberGuessBalance; uint256 public currentLevel; uint256 public totalLevels; uint256 public minGuessHoldings; mapping(uint256 => uint256) public payoutPerLevel; mapping(address => bool) private _isExcludedFromFees; mapping(address => bool) public _isExcludedMaxTransactionAmount; mapping(address => bool) public automatedMarketMakerPairs; event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress); event ExcludeFromFees(address indexed account, bool isExcluded); event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value); event marketingWalletUpdated(address indexed newWallet, address indexed oldWallet); event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity); event GameStarted(); event GameEnded(); event CorrectGuess(address indexed guesser, uint256 indexed level, uint256 indexed number); constructor() ERC20("Number Game", "NUMBER") { IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D ); excludeFromMaxTransaction(address(_uniswapV2Router), true); uniswapV2Router = _uniswapV2Router; uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH()); excludeFromMaxTransaction(address(uniswapV2Pair), true); _setAutomatedMarketMakerPair(address(uniswapV2Pair), true); uint256 totalSupply = 1_000_000_000 * 1e18; // TODO: Manually define numberGuessSupply uint256 numberGuessSupply = 100_000_000 * 1e18; minGuessHoldings = 1_000_000 * 1e18; maxTransactionAmount = 5_000_000 * 1e18; maxWallet = 5_000_000 * 1e18; swapTokensAtAmount = 150_000 * 1e18; // 0.015% * 20 = 0.3% marketingWallet = msg.sender; devWallet = msg.sender; excludeFromFees(owner(), true); excludeFromFees(address(this), true); excludeFromFees(address(0xdead), true); excludeFromMaxTransaction(owner(), true); excludeFromMaxTransaction(address(this), true); excludeFromMaxTransaction(address(0xdead), true); // Adjusted supply mints to account for numberGuessSupply being stored in contract _mint(msg.sender, totalSupply - numberGuessSupply); _mint(address(this), numberGuessSupply); // Store the tokens allocated to number guess game for proper accounting numberGuessBalance = numberGuessSupply; } receive() external payable {} function updateMinimumTokenHoldings(uint256 _newMin) external onlyOwner { minGuessHoldings = _newMin * 1e18; } // Configure number guess game by specifying number of levels and the payout per level function configureGuessGame(uint256[] calldata _payouts) external onlyOwner { // Prevent reconfiguration if game has already started if (gameActive) { revert GameAlreadyStarted(); } // Store each level's payout value and tally payouts to prevent exceeding allocation uint256 totalPayout; for (uint256 i; i < _payouts.length;) { if (_payouts[i] == 0) { revert ZeroValue(); } payoutPerLevel[i + 1] = _payouts[i]; unchecked { totalPayout += _payouts[i]; ++i; } } if (totalPayout != numberGuessBalance) { revert DoesntEqualTotal(); } // Set totalLevels to _payouts length so mapping doesn't have to be iterable totalLevels = _payouts.length; } // One-way switch to activate the game function activateGame() external onlyOwner { if (gameActive) { revert GameAlreadyStarted(); } if (totalLevels == 0) { revert GameNotConfigured(); } gameActive = true; currentLevel += 1; emit GameStarted(); } // Calculate sender+block-specific hash for any given number function hashNum(uint256 _num) public view returns (bytes32) { return keccak256(abi.encodePacked(msg.sender, _num)); } // Guess the number for a particular level (starts at 1) function guessNumber(uint256 _num) external { // Player must hold 1m tokens (0.1%) require(balanceOf(msg.sender) >= minGuessHoldings); // Confirm game is active uint256 level = currentLevel; if (level == 0) { revert GameNotActive(); } // Calculate address + number hash bytes memory numHash = abi.encodePacked(hashNum(_num)); // Convert bytes32 to string string memory numHashString = LibString.toHexStringNoPrefix(numHash); // Determine difficulty by calculating repeating "0" prefix based on current level string memory difficultyPrefix = LibString.repeat("0", level); // Verify number hash starts with the difficulty prefix bool confirmed = LibString.startsWith(numHashString, difficultyPrefix); if (!confirmed) { revert InvalidNumber(); } else { uint256 payout = payoutPerLevel[level]; // Adjust internal accounting numberGuessBalance -= payout; currentLevel += 1; // Check msg.sender's balance beforehand uint256 balance = balanceOf(msg.sender); // Call pre-override ERC20 _transfer function to avoid tax logic ERC20._transfer(address(this), msg.sender, payout); // Confirm transfer was successful as _transfer doesn't perform completion checks if (balanceOf(msg.sender) - payout != balance) { revert TransferFailed(); } emit CorrectGuess(msg.sender, level, _num); // If final level win, end game if (level == totalLevels) { // Setting currentLevel to zero prevents guessNumber from being callable currentLevel = 0; emit GameEnded(); // gameActive is not set to false as it would allow for a theoretical rerun with no tokens } } } function enableTrading(uint256 _deadBlocks) external onlyOwner { deadBlocks = _deadBlocks; tradingActive = true; swapEnabled = true; launchedAt = block.number; launchedTime = block.timestamp; } function removeLimits() external onlyOwner returns (bool) { limitsInEffect = false; return true; } function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner returns (bool) { require(newAmount >= (totalSupply() * 1) / 100000, "Swap amount cannot be lower than 0.001% total supply."); require(newAmount <= (totalSupply() * 5) / 1000, "Swap amount cannot be higher than 0.5% total supply."); swapTokensAtAmount = newAmount; return true; } function updateMaxTxnAmount(uint256 newNum) external onlyOwner { require(newNum >= ((totalSupply() * 1) / 1000) / 1e18, "Cannot set maxTransactionAmount lower than 0.1%"); maxTransactionAmount = newNum * (10 ** 18); } function updateMaxWalletAmount(uint256 newNum) external onlyOwner { require(newNum >= ((totalSupply() * 5) / 1000) / 1e18, "Cannot set maxWallet lower than 0.5%"); maxWallet = newNum * (10 ** 18); } function whitelistContract(address _whitelist, bool isWL) public onlyOwner { _isExcludedMaxTransactionAmount[_whitelist] = isWL; _isExcludedFromFees[_whitelist] = isWL; } function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner { _isExcludedMaxTransactionAmount[updAds] = isEx; } // only use to disable contract sales if absolutely necessary (emergency use only) function updateSwapEnabled(bool enabled) external onlyOwner { swapEnabled = enabled; } function excludeFromFees(address account, bool excluded) public onlyOwner { _isExcludedFromFees[account] = excluded; emit ExcludeFromFees(account, excluded); } function manualswap(uint256 amount) external { require(_msgSender() == marketingWallet); // Corrected require statement to account for number guess game allocation require(amount <= (balanceOf(address(this)) - numberGuessBalance) && amount > 0, "Wrong amount"); swapTokensForEth(amount); } function manualsend() external { bool success; (success,) = address(devWallet).call{value: address(this).balance}(""); } function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner { require(pair != uniswapV2Pair, "The pair cannot be removed from automatedMarketMakerPairs"); _setAutomatedMarketMakerPair(pair, value); } function _setAutomatedMarketMakerPair(address pair, bool value) private { automatedMarketMakerPairs[pair] = value; emit SetAutomatedMarketMakerPair(pair, value); } function updateBuyFees(uint256 _marketingFee) external onlyOwner { buyTotalFees = _marketingFee; require(buyTotalFees <= 5, "Must keep fees at 5% or less"); } function updateSellFees(uint256 _marketingFee) external onlyOwner { sellTotalFees = _marketingFee; require(sellTotalFees <= 5, "Must keep fees at 5% or less"); } function updateMarketingWallet(address newMarketingWallet) external onlyOwner { emit marketingWalletUpdated(newMarketingWallet, marketingWallet); marketingWallet = newMarketingWallet; } function airdrop(address[] calldata addresses, uint256[] calldata amounts) external { require(addresses.length > 0 && amounts.length == addresses.length); address from = msg.sender; for (uint256 i = 0; i < addresses.length; i++) { _transfer(from, addresses[i], amounts[i] * (10 ** 18)); } } function _transfer(address from, address to, uint256 amount) internal override { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); if (amount == 0) { super._transfer(from, to, 0); return; } if (limitsInEffect) { if (from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !swapping) { if ((launchedAt + deadBlocks) >= block.number) { buyTotalFees = 35; sellTotalFees = 35; } else if (block.number <= launchedAt + 5) { buyTotalFees = 25; sellTotalFees = 25; } else if (block.number <= launchedAt + 10) { buyTotalFees = 10; sellTotalFees = 10; } else { buyTotalFees = 3; sellTotalFees = 3; } if (!tradingActive) { require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active."); } //when buy if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) { require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount."); require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded"); } //when sell else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) { require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount."); } else if (!_isExcludedMaxTransactionAmount[to]) { require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded"); } } } // Corrected to account for number guess game allocation uint256 contractTokenBalance = balanceOf(address(this)) - numberGuessBalance; bool canSwap = contractTokenBalance >= swapTokensAtAmount; if ( canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to] ) { swapping = true; swapBack(); swapping = false; } bool takeFee = !swapping; // if any account belongs to _isExcludedFromFee account then remove the fee if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) { takeFee = false; } uint256 fees = 0; // only take fees on buys/sells, do not take on wallet transfers if (takeFee) { // on sell if (automatedMarketMakerPairs[to] && sellTotalFees > 0) { fees = amount.mul(sellTotalFees).div(100); } // on buy else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) { fees = amount.mul(buyTotalFees).div(100); } if (fees > 0) { super._transfer(from, address(this), fees); } amount -= fees; } super._transfer(from, to, amount); } function swapTokensForEth(uint256 tokenAmount) private { // generate the uniswap pair path of token -> weth address[] memory path = new address[](2); path[0] = address(this); path[1] = uniswapV2Router.WETH(); _approve(address(this), address(uniswapV2Router), tokenAmount); // make the swap uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens( tokenAmount, 0, // accept any amount of ETH path, address(this), block.timestamp ); } function swapBack() private { // Corrected to account for number guess game allocation uint256 contractBalance = balanceOf(address(this)) - numberGuessBalance; bool success; if (contractBalance == 0) { return; } if (contractBalance > swapTokensAtAmount * 20) { contractBalance = swapTokensAtAmount * 20; } // Halve the amount of liquidity tokens uint256 amountToSwapForETH = contractBalance; swapTokensForEth(amountToSwapForETH); uint256 ethForDev = (address(this).balance).div(5); uint256 ethforMarketing = address(this).balance; (success,) = address(devWallet).call{value: ethForDev}(""); (success,) = address(marketingWallet).call{value: ethforMarketing}(""); } }
{ "optimizer": { "enabled": false, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"DoesntEqualTotal","type":"error"},{"inputs":[],"name":"GameAlreadyStarted","type":"error"},{"inputs":[],"name":"GameNotActive","type":"error"},{"inputs":[],"name":"GameNotConfigured","type":"error"},{"inputs":[],"name":"InvalidNumber","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"inputs":[],"name":"ZeroValue","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":"address","name":"guesser","type":"address"},{"indexed":true,"internalType":"uint256","name":"level","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"number","type":"uint256"}],"name":"CorrectGuess","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"ExcludeFromFees","type":"event"},{"anonymous":false,"inputs":[],"name":"GameEnded","type":"event"},{"anonymous":false,"inputs":[],"name":"GameStarted","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":"pair","type":"address"},{"indexed":true,"internalType":"bool","name":"value","type":"bool"}],"name":"SetAutomatedMarketMakerPair","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokensSwapped","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethReceived","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tokensIntoLiquidity","type":"uint256"}],"name":"SwapAndLiquify","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"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newAddress","type":"address"},{"indexed":true,"internalType":"address","name":"oldAddress","type":"address"}],"name":"UpdateUniswapV2Router","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newWallet","type":"address"},{"indexed":true,"internalType":"address","name":"oldWallet","type":"address"}],"name":"marketingWalletUpdated","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_isExcludedMaxTransactionAmount","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"activateGame","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"airdrop","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":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"automatedMarketMakerPairs","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyTotalFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_payouts","type":"uint256[]"}],"name":"configureGuessGame","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"currentLevel","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deadAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deadBlocks","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_deadBlocks","type":"uint256"}],"name":"enableTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"excluded","type":"bool"}],"name":"excludeFromFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"updAds","type":"address"},{"internalType":"bool","name":"isEx","type":"bool"}],"name":"excludeFromMaxTransaction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"gameActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_num","type":"uint256"}],"name":"guessNumber","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_num","type":"uint256"}],"name":"hashNum","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"limitsInEffect","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"manualsend","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"manualswap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxTransactionAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minGuessHoldings","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numberGuessBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"payoutPerLevel","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"removeLimits","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sellTotalFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"name":"setAutomatedMarketMakerPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapTokensAtAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalLevels","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradingActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","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"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_marketingFee","type":"uint256"}],"name":"updateBuyFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newMarketingWallet","type":"address"}],"name":"updateMarketingWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newNum","type":"uint256"}],"name":"updateMaxTxnAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newNum","type":"uint256"}],"name":"updateMaxWalletAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newMin","type":"uint256"}],"name":"updateMinimumTokenHoldings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_marketingFee","type":"uint256"}],"name":"updateSellFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"enabled","type":"bool"}],"name":"updateSwapEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newAmount","type":"uint256"}],"name":"updateSwapTokensAtAmount","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_whitelist","type":"address"},{"internalType":"bool","name":"isWL","type":"bool"}],"name":"whitelistContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Deployed Bytecode
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
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.