文件 1 的 1：FruitTownGremlinsWTFruit.sol
pragma solidity ^0.8.0;
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.0;
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.0;
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, 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 from,
address to,
uint256 amount
) external returns (bool);
}
pragma solidity ^0.8.0;
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.0;
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 to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, 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) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, 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;
unchecked {
_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 _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - 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.0;
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
_spendAllowance(account, _msgSender(), amount);
_burn(account, amount);
}
}
pragma solidity ^0.8.0;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
function verifyCalldata(
bytes32[] calldata proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
return processProofCalldata(proof, leaf) == root;
}
function processProof(bytes32[] memory proof, bytes32 leaf)
internal
pure
returns (bytes32)
{
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
function processProofCalldata(bytes32[] calldata proof, bytes32 leaf)
internal
pure
returns (bytes32)
{
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
function multiProofVerify(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProof(proof, proofFlags, leaves) == root;
}
function multiProofVerifyCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProofCalldata(proof, proofFlags, leaves) == root;
}
function processMultiProof(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
uint256 leavesLen = leaves.length;
uint256 totalHashes = proofFlags.length;
require(
leavesLen + proof.length - 1 == totalHashes,
"MerkleProof: invalid multiproof"
);
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen
? leaves[leafPos++]
: hashes[hashPos++];
bytes32 b = proofFlags[i]
? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]
: proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
return hashes[totalHashes - 1];
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
function processMultiProofCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
uint256 leavesLen = leaves.length;
uint256 totalHashes = proofFlags.length;
require(
leavesLen + proof.length - 1 == totalHashes,
"MerkleProof: invalid multiproof"
);
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen
? leaves[leafPos++]
: hashes[hashPos++];
bytes32 b = proofFlags[i]
? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]
: proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
return hashes[totalHashes - 1];
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
}
function _efficientHash(bytes32 a, bytes32 b)
private
pure
returns (bytes32 value)
{
assembly {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length)
internal
pure
returns (string memory)
{
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
pragma solidity ^0.8.0;
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
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.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(
address(this).balance >= amount,
"Address: insufficient balance"
);
(bool success, ) = recipient.call{value: amount}("");
require(
success,
"Address: unable to send value, recipient may have reverted"
);
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return
functionCallWithValue(
target,
data,
value,
"Address: low-level call with value failed"
);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(
address(this).balance >= value,
"Address: insufficient balance for call"
);
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(
data
);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
return
functionStaticCall(
target,
data,
"Address: low-level static call failed"
);
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return
functionDelegateCall(
target,
data,
"Address: low-level delegate call failed"
);
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
return interfaceId == type(IERC165).interfaceId;
}
}
pragma solidity ^0.8.0;
interface IERC721 is IERC165 {
event Transfer(
address indexed from,
address indexed to,
uint256 indexed tokenId
);
event Approval(
address indexed owner,
address indexed approved,
uint256 indexed tokenId
);
event ApprovalForAll(
address indexed owner,
address indexed operator,
bool approved
);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId)
external
view
returns (address operator);
function isApprovedForAll(address owner, address operator)
external
view
returns (bool);
}
pragma solidity ^0.8.0;
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
returns (uint256);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity ^0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.8.0;
contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable
{
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 private currentIndex = 0;
uint256 internal immutable collectionSize;
uint256 internal immutable maxBatchSize;
string private _name;
string private _symbol;
mapping(uint256 => TokenOwnership) private _ownerships;
mapping(address => AddressData) private _addressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_,
uint256 collectionSize_
) {
require(
collectionSize_ > 0,
"ERC721A: collection must have a nonzero supply"
);
require(maxBatchSize_ > 0, "ERC721A: max batch size must be nonzero");
_name = name_;
_symbol = symbol_;
maxBatchSize = maxBatchSize_;
collectionSize = collectionSize_;
}
function totalSupply() public view override returns (uint256) {
return currentIndex;
}
function tokenByIndex(uint256 index)
public
view
override
returns (uint256)
{
require(index < totalSupply(), "ERC721A: global index out of bounds");
return index;
}
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
override
returns (uint256)
{
require(index < balanceOf(owner), "ERC721A: owner index out of bounds");
uint256 numMintedSoFar = totalSupply();
uint256 tokenIdsIdx = 0;
address currOwnershipAddr = address(0);
for (uint256 i = 0; i < numMintedSoFar; i++) {
TokenOwnership memory ownership = _ownerships[i];
if (ownership.addr != address(0)) {
currOwnershipAddr = ownership.addr;
}
if (currOwnershipAddr == owner) {
if (tokenIdsIdx == index) {
return i;
}
tokenIdsIdx++;
}
}
revert("ERC721A: unable to get token of owner by index");
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
interfaceId == type(IERC721Enumerable).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view override returns (uint256) {
require(
owner != address(0),
"ERC721A: balance query for the zero address"
);
return uint256(_addressData[owner].balance);
}
function _numberMinted(address owner) internal view returns (uint256) {
require(
owner != address(0),
"ERC721A: number minted query for the zero address"
);
return uint256(_addressData[owner].numberMinted);
}
function ownershipOf(uint256 tokenId)
internal
view
returns (TokenOwnership memory)
{
require(_exists(tokenId), "ERC721A: owner query for nonexistent token");
uint256 lowestTokenToCheck;
if (tokenId >= maxBatchSize) {
lowestTokenToCheck = tokenId - maxBatchSize + 1;
}
for (uint256 curr = tokenId; curr >= lowestTokenToCheck; curr--) {
TokenOwnership memory ownership = _ownerships[curr];
if (ownership.addr != address(0)) {
return ownership;
}
}
revert("ERC721A: unable to determine the owner of token");
}
function ownerOf(uint256 tokenId) public view override returns (address) {
return ownershipOf(tokenId).addr;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
require(
_exists(tokenId),
"ERC721Metadata: URI query for nonexistent token"
);
string memory baseURI = _baseURI();
return
bytes(baseURI).length > 0
? string(abi.encodePacked(baseURI, tokenId.toString()))
: "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public override {
address owner = ERC721A.ownerOf(tokenId);
require(to != owner, "ERC721A: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721A: approve caller is not owner nor approved for all"
);
_approve(to, tokenId, owner);
}
function getApproved(uint256 tokenId)
public
view
override
returns (address)
{
require(
_exists(tokenId),
"ERC721A: approved query for nonexistent token"
);
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved)
public
override
{
require(operator != _msgSender(), "ERC721A: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
return _operatorApprovals[owner][operator];
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
_transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
_transfer(from, to, tokenId);
require(
_checkOnERC721Received(from, to, tokenId, _data),
"ERC721A: transfer to non ERC721Receiver implementer"
);
}
function _exists(uint256 tokenId) internal view returns (bool) {
return tokenId < currentIndex;
}
function _safeMint(address to, uint256 quantity) internal {
_safeMint(to, quantity, "");
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
uint256 startTokenId = currentIndex;
require(to != address(0), "ERC721A: mint to the zero address");
require(!_exists(startTokenId), "ERC721A: token already minted");
require(quantity <= maxBatchSize, "ERC721A: quantity to mint too high");
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
AddressData memory addressData = _addressData[to];
_addressData[to] = AddressData(
addressData.balance + uint128(quantity),
addressData.numberMinted + uint128(quantity)
);
_ownerships[startTokenId] = TokenOwnership(to, uint64(block.timestamp));
uint256 updatedIndex = startTokenId;
for (uint256 i = 0; i < quantity; i++) {
emit Transfer(address(0), to, updatedIndex);
require(
_checkOnERC721Received(address(0), to, updatedIndex, _data),
"ERC721A: transfer to non ERC721Receiver implementer"
);
updatedIndex++;
}
currentIndex = updatedIndex;
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
function _transfer(
address from,
address to,
uint256 tokenId
) private {
TokenOwnership memory prevOwnership = ownershipOf(tokenId);
bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
getApproved(tokenId) == _msgSender() ||
isApprovedForAll(prevOwnership.addr, _msgSender()));
require(
isApprovedOrOwner,
"ERC721A: transfer caller is not owner nor approved"
);
require(
prevOwnership.addr == from,
"ERC721A: transfer from incorrect owner"
);
require(to != address(0), "ERC721A: transfer to the zero address");
_beforeTokenTransfers(from, to, tokenId, 1);
_approve(address(0), tokenId, prevOwnership.addr);
_addressData[from].balance -= 1;
_addressData[to].balance += 1;
_ownerships[tokenId] = TokenOwnership(to, uint64(block.timestamp));
uint256 nextTokenId = tokenId + 1;
if (_ownerships[nextTokenId].addr == address(0)) {
if (_exists(nextTokenId)) {
_ownerships[nextTokenId] = TokenOwnership(
prevOwnership.addr,
prevOwnership.startTimestamp
);
}
}
emit Transfer(from, to, tokenId);
_afterTokenTransfers(from, to, tokenId, 1);
}
function _approve(
address to,
uint256 tokenId,
address owner
) private {
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
uint256 public nextOwnerToExplicitlySet = 0;
function _setOwnersExplicit(uint256 quantity) internal {
uint256 oldNextOwnerToSet = nextOwnerToExplicitlySet;
require(quantity > 0, "quantity must be nonzero");
uint256 endIndex = oldNextOwnerToSet + quantity - 1;
if (endIndex > collectionSize - 1) {
endIndex = collectionSize - 1;
}
require(_exists(endIndex), "not enough minted yet for this cleanup");
for (uint256 i = oldNextOwnerToSet; i <= endIndex; i++) {
if (_ownerships[i].addr == address(0)) {
TokenOwnership memory ownership = ownershipOf(i);
_ownerships[i] = TokenOwnership(
ownership.addr,
ownership.startTimestamp
);
}
}
nextOwnerToExplicitlySet = endIndex + 1;
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try
IERC721Receiver(to).onERC721Received(
_msgSender(),
from,
tokenId,
_data
)
returns (bytes4 retval) {
return retval == IERC721Receiver(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert(
"ERC721A: transfer to non ERC721Receiver implementer"
);
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity ^0.8.11;
contract $TOON is ERC20Burnable, Ownable {
using SafeMath for uint256;
ERC721A public devilCatzNft;
uint256 public cost = 0.0005 ether;
event Bought(uint256 amount);
uint256 public maxSupply = 1235813;
uint256 public stakedNfts = 0;
uint256 public rewardsTime = 86400;
bool public nftStakingPaused = false;
bool public rewardsCollectionPaused = false;
mapping(address => mapping(uint256 => uint256)) public nftStakersWithTime;
mapping(address => uint256[]) private nftStakersWithArray;
mapping(address => uint256) public rewardsInWei;
constructor() payable ERC20("$TOON", "$TOON") {
_mint(address(this), 935813);
_mint(0x1aBC6efe814F2766003d0c4AA5496B9b0EBC6eA3, 150000);
_mint(0x4538C3d93FfdE7677EF66aB548a4Dd7f39eca785, 150000);
devilCatzNft = ERC721A(0x1c4a28690482b03F6991C8c24295016cba197C12);
}
function getUsersStakedNfts(address _staker)
public
view
returns (uint256[] memory)
{
return nftStakersWithArray[_staker];
}
function decimals() public view virtual override returns (uint8) {
return 0;
}
function circulatingSupply() public view returns (uint256) {
return (this.totalSupply() - balanceOf(address(this)));
}
function setMaxSupply(uint256 _amount) public onlyOwner {
require(
circulatingSupply() < _amount,
"Cant set new total supply less than old supply."
);
maxSupply = _amount;
}
function setNftStakingPaused(bool _b) public onlyOwner {
nftStakingPaused = _b;
}
function setRewardsCollectionPaused(bool _b) public onlyOwner {
rewardsCollectionPaused = _b;
}
function buy(uint256 _quantity) public payable {
require(_quantity > 0, "Quantity needs to be greater than 1");
require(
balanceOf(address(this)) > _quantity,
"Not enough left in contract to buy.."
);
uint256 totalCostEth = _quantity * cost;
require(msg.value >= totalCostEth, "Did not send enough ETH");
_transfer(address(this), msg.sender, _quantity);
emit Bought(_quantity);
}
function withdrawEthFromContract(uint256 _amount) public payable onlyOwner {
(bool os, ) = payable(owner()).call{value: _amount}("");
require(os);
}
function withdrawToonFromContract(uint256 _amount)
public
payable
onlyOwner
{
_transfer(address(this), owner(), _amount);
}
function sendToonFromConract(address addy, uint256 _amount)
public
payable
onlyOwner
{
_transfer(address(this), addy, _amount);
}
function setCost(uint256 _newCost) public onlyOwner {
cost = _newCost;
}
function burn(uint256 _amount) public virtual override {
_burn(_msgSender(), _amount);
maxSupply -= _amount;
}
function stakeNft(uint256 _tokenID) public {
require(!nftStakingPaused, "Staking NFTs is currently paused.");
require(
nftStakersWithTime[msg.sender][_tokenID] == 0,
"This token already staked."
);
devilCatzNft.transferFrom(msg.sender, address(this), _tokenID);
nftStakersWithTime[msg.sender][_tokenID] = block.timestamp;
stakedNfts += 1;
nftStakersWithArray[msg.sender].push(_tokenID);
}
function stakeMultipleNfts(uint256[] calldata _nftIds) public {
require(!nftStakingPaused, "Staking NFTs is currently paused.");
for (uint256 i = 0; i <= _nftIds.length - 1; i++) {
require(
devilCatzNft.ownerOf(_nftIds[i]) == msg.sender,
"Not all of those NFTs are in your current wallet."
);
devilCatzNft.transferFrom(msg.sender, address(this), _nftIds[i]);
nftStakersWithTime[msg.sender][_nftIds[i]] = block.timestamp;
stakedNfts += 1;
nftStakersWithArray[msg.sender].push(_nftIds[i]);
}
}
function potentialAllStakedNftReward(address _addy)
public
view
returns (uint256)
{
uint256[] memory nfts = getUsersStakedNfts(_addy);
uint256 intDate = 0;
uint256 subtracted = 0;
uint256 utilToken = 0;
for (uint256 i = 0; i < nfts.length; i++) {
if (nftStakersWithTime[_addy][nfts[i]] != 0) {
intDate = nftStakersWithTime[_addy][nfts[i]];
subtracted = block.timestamp - intDate;
utilToken += subtracted / rewardsTime;
}
}
return utilToken * 1;
}
function potentialStakedNftReward(address _addy, uint256 _tokenID)
public
view
returns (uint256)
{
require(
nftStakersWithTime[_addy][_tokenID] != 0,
"This token not staked."
);
uint256 intDate = nftStakersWithTime[_addy][_tokenID];
uint256 subtracted = block.timestamp - intDate;
uint256 tokens = subtracted / rewardsTime;
return tokens * 1;
}
function collectStakedNftReward(address _addy, uint256 _tokenID) public {
require(!nftStakingPaused, "Staking NFTs is currently paused.");
require(
nftStakersWithTime[_addy][_tokenID] != 0,
"This token not staked."
);
require(
potentialStakedNftReward(_addy, _tokenID) != 0,
"You dont have enough to claim."
);
uint256 tokens = potentialStakedNftReward(_addy, _tokenID);
_transfer(address(this), _addy, tokens);
nftStakersWithTime[_addy][_tokenID] = block.timestamp;
}
function collectMultipleStakedNftReward(uint256[] calldata _nftIds) public {
require(
!rewardsCollectionPaused,
"Collecting Rewards is currently paused."
);
for (uint256 i = 0; i <= _nftIds.length - 1; i++) {
require(
nftStakersWithTime[msg.sender][_nftIds[i]] != 0,
"Not all those tokens are staked."
);
collectStakedNftReward(msg.sender, _nftIds[i]);
}
}
function removeStakedNft(uint256 _stakedNFT) public {
require(
nftStakersWithTime[msg.sender][_stakedNFT] != 0,
"Cant Unstake something your not staking."
);
devilCatzNft.transferFrom(address(this), msg.sender, _stakedNFT);
nftStakersWithTime[msg.sender][_stakedNFT] = 0;
stakedNfts -= 1;
uint256[] storage tempArray = nftStakersWithArray[msg.sender];
for (uint256 i = 0; i < tempArray.length; i++) {
if (tempArray[i] == _stakedNFT) {
if (i >= tempArray.length) return;
for (uint256 j = i; j < tempArray.length - 1; j++) {
tempArray[j] = tempArray[j + 1];
}
tempArray.pop();
nftStakersWithArray[msg.sender] = tempArray;
}
}
}
function removeMultipleStakedNft(uint256[] calldata _nftIds) public {
for (uint256 k = 0; k <= _nftIds.length - 1; k++) {
require(
nftStakersWithTime[msg.sender][_nftIds[k]] != 0,
"Cant Unstake something your not staking."
);
removeStakedNft(_nftIds[k]);
}
}
}
pragma solidity ^0.8.11;
contract FruitTownGremlinsWTFruit is ERC721A, Ownable {
using Strings for uint256;
$TOON public $toon;
ERC721A public devilCatzNft;
uint256 public immutable MAX_SUPPLY = 4444;
uint256 public immutable MAX_MINT_AMOUNT = 50;
bool public isFreeMintOpen = false;
uint256 public freeMintAmount = 3;
uint256 public stakersMintAmount = 10;
uint256 public mintCost = 0.1 ether;
uint256 public toonMintMultiplier = 1;
uint256 public sellOwnerShipCostInEth = 50 ether;
uint256 public sellOwnerShipCostInToon = 1000000;
string public BASE_URI =
"https://fruittown.s3.us-east-2.amazonaws.com/json/";
string public BASE_EXTENSION = ".json";
string public NOT_REVEALED_URI =
"https://fruittown.s3.us-east-2.amazonaws.com/images/ftgbanner.png";
bool public PAUSED = false;
bool public REVEALED = true;
bool public isContractForToonSale = false;
bool public isContractForEthSale = false;
mapping(uint256 => bool) public hasCatFreeMinted;
mapping(address => bool) public hasStakerAddressFreeMinted;
mapping(address => bool) public hasPublicAddressMinted;
address public ARTIST = 0x49A6e20E7C56D526B0AE30c5B61D7FAe9c958961;
address public DEV = 0x75939FA0D2F41542F5e8634ce88E2aE9bFD48767;
constructor() ERC721A("FruitTownGremlins.WTFruit", "WTFruit", MAX_SUPPLY, MAX_MINT_AMOUNT) {
devilCatzNft = ERC721A(0x1c4a28690482b03F6991C8c24295016cba197C12);
$toon = $TOON(0x61DED8A72cDc7762D159ab46bE880BE7127A2DeF);
_safeMint(ARTIST, 355);
_safeMint(DEV, 55);
_safeMint(0x689Ee5488a551E5d67ce38D971d998ab6C0Fa6EE,40);
}
modifier onlyDev() {
require(msg.sender == DEV, "Dev only!");
_;
}
modifier onlyArtist() {
require(msg.sender == ARTIST, "Dev only!");
_;
}
modifier mintChecks(uint256 _mintAmount) {
require(_mintAmount > 0, "Mint amount has to be greater than 0.");
require(
totalSupply() + _mintAmount <= MAX_SUPPLY,
"Minting that many would go over whats available."
);
require(
_mintAmount <= MAX_MINT_AMOUNT,
"Can not exceed max mint amount."
);
_;
}
function setToonMintMultiplier(uint256 _x) public onlyOwner {
toonMintMultiplier = _x;
}
function setDev(address _address) public onlyDev {
DEV = _address;
}
function setArtist(address _address) public onlyArtist {
ARTIST = _address;
}
function setIsFreeMintOpen(bool b) public onlyOwner {
isFreeMintOpen = b;
}
function setFreeMintAmount(uint256 amount) public onlyOwner {
freeMintAmount = amount;
}
function setisContractForToonSale(bool b) public onlyOwner {
isContractForToonSale = b;
}
function setisContractForEthSale(bool b) public onlyOwner {
isContractForEthSale = b;
}
function setCost(uint256 _newCost) public onlyOwner {
mintCost = _newCost;
}
function setBaseURI(string memory _newBaseURI) public onlyArtist {
BASE_URI = _newBaseURI;
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyArtist
{
BASE_EXTENSION = _newBaseExtension;
}
function setStakersMintAmount(uint256 amount) public onlyOwner {
require(
amount <= MAX_MINT_AMOUNT,
"Cant be greater than max mint amount."
);
stakersMintAmount = amount;
}
function setSellOwnerShipInEth(uint256 cost) public onlyOwner {
sellOwnerShipCostInEth = cost;
}
function setSellOwnerShipCostInToon(uint256 cost) public onlyOwner {
sellOwnerShipCostInToon = cost;
}
function buyContractWithTOON() public payable {
require(isContractForToonSale, "Contract not for sale right now for ETH");
$toon.transferFrom(msg.sender, owner(), sellOwnerShipCostInToon);
_transferOwnership(msg.sender);
}
function catFreeMint(uint256[] calldata catsToClaimFreeMint)
public
payable
mintChecks(catsToClaimFreeMint.length)
{
uint256 numToMint = 0;
for (uint256 i = 0; i < catsToClaimFreeMint.length; i++) {
require(
!hasCatFreeMinted[catsToClaimFreeMint[i]],
"One of these cats have already claimed a FTG.Wtfruit"
);
if (devilCatzNft.ownerOf(catsToClaimFreeMint[i]) == msg.sender) {
numToMint += 1;
} else {
require(
$toon.nftStakersWithTime(
msg.sender,
catsToClaimFreeMint[i]
) > 0,
"No Cats unstaked or staked found."
);
numToMint += 1;
}
}
_safeMint(msg.sender, numToMint);
for (uint256 i = 0; i < catsToClaimFreeMint.length; i++) {
hasCatFreeMinted[catsToClaimFreeMint[i]] = true;
}
}
function stakedAddressesFreeMint()
public
payable
mintChecks(stakersMintAmount)
{
require(
$toon.getUsersStakedNfts(msg.sender).length > 0,
"No staked catz found."
);
require(
!hasStakerAddressFreeMinted[msg.sender],
"This address already claimed free staking mint."
);
_safeMint(msg.sender, stakersMintAmount);
hasStakerAddressFreeMinted[msg.sender] = true;
}
function freeMint(uint256 _mintAmount)
public
payable
mintChecks(_mintAmount)
{
require(isFreeMintOpen, "No Free Mints Right Now.");
require(freeMintAmount >= _mintAmount, "Cant mint that many.");
require(
!hasPublicAddressMinted[msg.sender],
"This address already claimed free mint."
);
_safeMint(msg.sender, _mintAmount);
hasPublicAddressMinted[msg.sender] = true;
}
function mintForEth(uint256 _mintAmount)
public
payable
mintChecks(_mintAmount)
{
if (msg.sender != owner()) {
require(
msg.value >= mintCost * _mintAmount,
"Not Enough Eth Sent."
);
_safeMint(msg.sender, _mintAmount);
} else {
_safeMint(msg.sender, _mintAmount);
}
}
function mintWithToon(uint256 _mintAmount)
public
payable
mintChecks(_mintAmount * toonMintMultiplier )
{
$toon.transferFrom(msg.sender, owner(), _mintAmount);
_safeMint(msg.sender, _mintAmount * toonMintMultiplier);
}
bool isFirstSale = true;
function buyContractWithEth() public payable {
require(isContractForEthSale, "Contract not for sale right now for ETH");
require(
msg.value >= sellOwnerShipCostInEth,
"Not Enough Eth Sent to be Owner."
);
if(isFirstSale){
uint256 teamFee = sellOwnerShipCostInEth / 2;
(bool devBool, ) = payable(DEV).call{value: teamFee}("");
require(devBool);
(bool artBool, ) = payable(ARTIST).call{value: teamFee}("");
require(artBool);
isFirstSale = false;
}else{
uint256 teamFee = sellOwnerShipCostInEth / 50;
(bool devBool, ) = payable(DEV).call{value: teamFee}("");
require(devBool);
(bool artBool, ) = payable(ARTIST).call{value: teamFee}("");
require(artBool);
uint256 result = sellOwnerShipCostInEth - teamFee - teamFee;
(bool resultBool, ) = payable(owner()).call{value: result}("");
require(resultBool);
}
_transferOwnership(msg.sender);
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
require(
_exists(_tokenId),
"ERC721Metadata: URI query for nonexistent token"
);
return
bytes(BASE_URI).length > 0
? string(
abi.encodePacked(
BASE_URI,
(_tokenId).toString(),
BASE_EXTENSION
)
)
: "";
}
function withdraw(uint256 _amount) public payable onlyOwner {
(bool resultBool, ) = payable(owner()).call{value: _amount}("");
require(resultBool);
}
}
