文件 1 的 1：illogics.sol
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
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
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
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);
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 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);
}
}
}
}
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);
}
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
address[] internal _owners;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
uint256 count;
for (uint256 i; i < _owners.length; ++i) {
if (owner == _owners[i]) ++count;
}
return count;
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not owner nor approved for all");
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
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 virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
_approve(address(0), tokenId);
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
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.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
contract VRFRequestIDBase {
function makeVRFInputSeed(
bytes32 _keyHash,
uint256 _userSeed,
address _requester,
uint256 _nonce
) internal pure returns (uint256) {
return uint256(keccak256(abi.encode(_keyHash, _userSeed, _requester, _nonce)));
}
function makeRequestId(bytes32 _keyHash, uint256 _vRFInputSeed) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(_keyHash, _vRFInputSeed));
}
}
interface LinkTokenInterface {
function allowance(address owner, address spender) external view returns (uint256 remaining);
function approve(address spender, uint256 value) external returns (bool success);
function balanceOf(address owner) external view returns (uint256 balance);
function decimals() external view returns (uint8 decimalPlaces);
function decreaseApproval(address spender, uint256 addedValue) external returns (bool success);
function increaseApproval(address spender, uint256 subtractedValue) external;
function name() external view returns (string memory tokenName);
function symbol() external view returns (string memory tokenSymbol);
function totalSupply() external view returns (uint256 totalTokensIssued);
function transfer(address to, uint256 value) external returns (bool success);
function transferAndCall(
address to,
uint256 value,
bytes calldata data
) external returns (bool success);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool success);
}
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
}
function totalSupply() public view virtual override returns (uint256) {
return _owners.length;
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
require(index < _owners.length, "ERC721Enumerable: global index out of bounds");
return index;
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256 tokenId) {
require(index < balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
uint256 count;
for (uint256 i; i < _owners.length; i++) {
if (owner == _owners[i]) {
if (count == index) return i;
else count++;
}
}
revert("ERC721Enumerable: owner index out of bounds");
}
}
interface IIllogics {
function isAdmin(address addr) external view returns (bool);
function mintGoop(address _addr, uint256 _goop) external;
function burnGoop(address _addr, uint256 _goop) external;
function spendGoop(uint256 _item, uint256 _count) external;
function mintGoopBatch(address[] calldata _addr, uint256 _goop) external;
function burnGoopBatch(address[] calldata _addr, uint256 _goop) external;
}
abstract contract VRFConsumerBase is VRFRequestIDBase {
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal virtual;
uint256 private constant USER_SEED_PLACEHOLDER = 0;
function requestRandomness(bytes32 _keyHash, uint256 _fee) internal returns (bytes32 requestId) {
LINK.transferAndCall(vrfCoordinator, _fee, abi.encode(_keyHash, USER_SEED_PLACEHOLDER));
uint256 vRFSeed = makeVRFInputSeed(_keyHash, USER_SEED_PLACEHOLDER, address(this), nonces[_keyHash]);
nonces[_keyHash] = nonces[_keyHash] + 1;
return makeRequestId(_keyHash, vRFSeed);
}
LinkTokenInterface internal immutable LINK;
address private immutable vrfCoordinator;
mapping(bytes32 => uint256)
private nonces;
constructor(address _vrfCoordinator, address _link) {
vrfCoordinator = _vrfCoordinator;
LINK = LinkTokenInterface(_link);
}
function rawFulfillRandomness(bytes32 requestId, uint256 randomness) external {
require(msg.sender == vrfCoordinator, "Only VRFCoordinator can fulfill");
fulfillRandomness(requestId, randomness);
}
}
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);
}
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);
}
}
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
return processProof(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++) {
bytes32 proofElement = proof[i];
if (computedHash <= proofElement) {
computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
} else {
computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
}
}
return computedHash;
}
}
interface ILab {
function getIllogical(uint256 _tokenId) external view returns (uint256);
}
contract illogics is IIllogics, ERC721Enumerable, Ownable, VRFConsumerBase {
struct StakedToken {
address ownerOfNFT;
uint256 timestamp;
uint256 lastRerollPeriod;
}
struct Sale {
string description;
bool saleStatus;
uint256 price;
uint256 supply;
uint256 maxPurchase;
}
uint256 public maxMint = 2;
uint256 public constant REROLL_COST = 50;
uint256 public constant GOOP_INTERVAL = 12 hours;
uint256 public goopPerInterval = 5;
address public teamWallet = 0xB3D1b19202423EcD55ACF1E635ea1Bded11a5c9f;
bool public mintingState;
bytes32 public merkleRoot;
IERC20 public link;
uint256 public VRF_fee;
uint256 public periodCounter;
bytes32 public VRF_keyHash;
string public baseURI;
uint256 public totalGoopSupply;
uint256 public totalGoopSpent;
uint256 public saleId;
bool public spendState;
bool public rerollState;
bool public stakingState;
bool public transferState;
bool public claimStatus;
bool public verifyVRF;
address public proxyRegistryAddress;
address public labAddress;
mapping(uint256 => Sale) public saleItems;
mapping(uint256 => StakedToken) public stakedToken;
mapping(address => uint256) public goop;
mapping(address => uint256[]) public staker;
mapping(uint256 => uint256) public collectionDNA;
mapping(uint256 => uint256[]) public rollTracker;
mapping(address => bool) private admins;
mapping(address => bool) public projectProxy;
mapping(address => bool) public addressToMinted;
mapping(address => mapping(uint256 => uint256)) public addressPurchases;
event RequestedRandomNumber(bytes32 indexed requestId);
event RecievedRandomNumber(bytes32 indexed requestId, uint256 periodCounter, uint256 randomNumber);
event spentGoop(address indexed purchaser, uint256 indexed item, uint256 indexed count);
constructor(
bytes32 _VRF_keyHash,
uint256 _VRF_Fee,
address _vrfCoordinator,
address _linkToken
) ERC721("illogics", "ill") VRFConsumerBase(_vrfCoordinator, _linkToken) {
VRF_keyHash = _VRF_keyHash;
VRF_fee = _VRF_Fee;
link = IERC20(address(_linkToken));
admins[_msgSender()] = true;
proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
}
modifier onlyAdmin() {
require(isAdmin(_msgSender()), "admins only");
_;
}
function isAdmin(address _addr) public view override returns (bool) {
return owner() == _addr || admins[_addr];
}
function addAdmin(address _addr) external onlyAdmin {
admins[_addr] = true;
}
function removeAdmin(address _addr) external onlyAdmin {
admins[_addr] = false;
}
function init() external onlyAdmin {
admins[address(this)] = true;
}
function setMintingState(bool _state) external onlyAdmin {
mintingState = _state;
}
function setStakingState(bool _state) external onlyAdmin {
stakingState = _state;
}
function setRerollState(bool _state) external onlyAdmin {
rerollState = _state;
}
function setTransferState(bool _state) external onlyAdmin {
transferState = _state;
}
function setSpendState(bool _state) external onlyAdmin {
spendState = _state;
}
function setLabAddress(address _labAddress) external onlyAdmin {
labAddress = _labAddress;
}
function setBaseURI(string memory _baseURI) public onlyAdmin {
baseURI = _baseURI;
}
function setMaxMint(uint256 _maxMint) external onlyAdmin {
maxMint = _maxMint;
}
function setGoopPerInterval(uint256 _goopPerInterval) external onlyAdmin {
goopPerInterval = _goopPerInterval;
}
function setClaim(bool _claimStatus) external onlyAdmin {
claimStatus = _claimStatus;
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyAdmin {
merkleRoot = _merkleRoot;
}
function leaf(string memory payload) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(payload));
}
function verify(bytes32 leaf, bytes32[] memory proof) internal view returns (bool) {
return MerkleProof.verify(proof, merkleRoot, leaf);
}
function multiHelix(uint256 _tokenId) public view returns (uint256) {
require(labAddress != address(0x0), "The Lab is being setup.");
return ILab(labAddress).getIllogical(_tokenId);
}
function illListMint(bytes32[] calldata proof) public payable {
string memory payload = string(abi.encodePacked(_msgSender()));
uint256 totalSupply = _owners.length;
require(mintingState, "Ill-list not active");
require(verify(leaf(payload), proof), "Invalid Merkle Tree proof supplied");
require(addressToMinted[_msgSender()] == false, "can not mint twice");
require(totalSupply + maxMint < 8889, "project fully minted");
addressToMinted[_msgSender()] = true;
for (uint256 i; i < maxMint; i++) {
_mint(_msgSender(), totalSupply + i);
}
}
function _mint(address to, uint256 tId) internal virtual override {
_owners.push(to);
emit Transfer(address(0), to, tId);
}
function tokenURI(uint256 _tId) public view override returns (string memory) {
require(_exists(_tId), "Token does not exist.");
return string(abi.encodePacked(baseURI, Strings.toString(_tId)));
}
function batchTransferFrom(
address _from,
address _to,
uint256[] memory _tIds
) public {
for (uint256 i = 0; i < _tIds.length; i++) {
transferFrom(_from, _to, _tIds[i]);
}
}
function batchSafeTransferFrom(
address _from,
address _to,
uint256[] memory _tIds,
bytes memory data_
) public {
for (uint256 i = 0; i < _tIds.length; i++) {
safeTransferFrom(_from, _to, _tIds[i], data_);
}
}
function isOwnerOf(address account, uint256[] calldata _tIds) external view returns (bool) {
for (uint256 i; i < _tIds.length; ++i) {
if (_owners[_tIds[i]] != account) return false;
}
return true;
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) return new uint256[](0);
uint256[] memory tokensId = new uint256[](tokenCount);
for (uint256 i; i < tokenCount; i++) {
tokensId[i] = tokenOfOwnerByIndex(_owner, i);
}
return tokensId;
}
function withdraw() public {
(bool success, ) = teamWallet.call{value: address(this).balance}("");
require(success, "Failed to send.");
}
receive() external payable {}
function requestRandomNumber() external onlyAdmin returns (bytes32 requestId) {
require(LINK.balanceOf(address(this)) >= VRF_fee, "Not enough LINK");
requestId = requestRandomness(VRF_keyHash, VRF_fee);
emit RequestedRandomNumber(requestId);
}
function fulfillRandomness(bytes32 _requestId, uint256 _randomNumber) internal override {
periodCounter++;
collectionDNA[periodCounter] = _randomNumber;
emit RecievedRandomNumber(_requestId, periodCounter, _randomNumber);
}
function setVerifyVRF() external onlyAdmin {
require(!verifyVRF, "this is a one way function it can not be called twice");
collectionDNA[1] = 0;
periodCounter = 0;
verifyVRF = true;
}
function reroll(uint256[] calldata _tokenIds) external {
uint256 amount = REROLL_COST * _tokenIds.length;
require(rerollState, "reroll not enabled");
require(goop[_msgSender()] >= amount, "not enough goop for reroll");
for (uint256 i = 0; i < _tokenIds.length; i++) {
require(stakedToken[_tokenIds[i]].ownerOfNFT == _msgSender(), "you dont own this token or its not staked");
rollTracker[periodCounter + 1].push(_tokenIds[i]);
stakedToken[_tokenIds[i]].lastRerollPeriod = periodCounter;
}
_burnGoop(_msgSender(), amount);
}
function setVRFKeyHash(bytes32 _keyHash) external onlyAdmin {
VRF_keyHash = _keyHash;
}
function setVRFFee(uint256 _fee) external onlyAdmin {
VRF_fee = _fee;
}
function getTokenDNA(uint256 _tId) external view returns (uint256) {
require(_tId < _owners.length, "tokenId out of range");
for (uint256 i = periodCounter; i > 0; i--) {
if (i == 1) {
return uint256(keccak256(abi.encode(collectionDNA[i], _tId)));
} else {
for (uint256 j = 0; j < rollTracker[i].length; j++) {
if (rollTracker[i][j] == _tId) {
return uint256(keccak256(abi.encode(collectionDNA[i], _tId)));
}
}
}
}
}
function get1of1() external view returns (uint256[] memory) {
uint256[] memory oneOfOnes = new uint256[](20);
uint256 counter;
uint256 addCounter;
bool matchStatus;
while (addCounter < 20) {
uint256 result = (uint256(keccak256(abi.encode(collectionDNA[2], counter))) % 8887);
for (uint256 i = 0; i < oneOfOnes.length; i++) {
if (result == oneOfOnes[i]) {
matchStatus = true;
break;
}
}
if (!matchStatus) {
oneOfOnes[addCounter] = result;
addCounter++;
} else {
matchStatus = false;
}
counter++;
}
return oneOfOnes;
}
function stakeNFT(uint256[] calldata _tokenIds) external {
require(stakingState, "staking not enabled");
for (uint256 i = 0; i < _tokenIds.length; i++) {
require(ownerOf(_tokenIds[i]) == _msgSender(), "you are not the owner");
safeTransferFrom(_msgSender(), address(this), _tokenIds[i]);
stakedToken[_tokenIds[i]].ownerOfNFT = _msgSender();
stakedToken[_tokenIds[i]].timestamp = block.timestamp;
staker[_msgSender()].push(_tokenIds[i]);
}
}
function unstakeNFT(uint256[] calldata _tokenIds) public {
for (uint256 i = 0; i < _tokenIds.length; i++) {
require(stakedToken[_tokenIds[i]].ownerOfNFT == _msgSender(), "you are not the owner");
require(canBeUnstaked(_tokenIds[i]), "token in reroll or cool down period");
_transfer(address(this), _msgSender(), _tokenIds[i]);
delete stakedToken[_tokenIds[i]].ownerOfNFT;
delete stakedToken[_tokenIds[i]].timestamp;
delete stakedToken[_tokenIds[i]].lastRerollPeriod;
for (uint256 j = 0; j < staker[_msgSender()].length; j++) {
if (staker[_msgSender()][j] == _tokenIds[i]) {
staker[_msgSender()][j] = staker[_msgSender()][staker[_msgSender()].length - 1];
staker[_msgSender()].pop();
}
}
}
}
function unstakeAndClaim(uint256[] calldata _tokenIds) external {
claimGoop();
unstakeNFT(_tokenIds);
}
function canBeUnstaked(uint256 _tokenId) public view returns (bool) {
if (stakedToken[_tokenId].lastRerollPeriod == 0) {
return true;
}
if (stakedToken[_tokenId].lastRerollPeriod == periodCounter) {
return false;
}
if (periodCounter - stakedToken[_tokenId].lastRerollPeriod == 1) {
return false;
}
return true;
}
function ownerStaked(address _addr) public view returns (uint256[] memory) {
return staker[_addr];
}
function onERC721Received(
address operator,
address from,
uint256 tId,
bytes calldata data
) external pure returns (bytes4) {
return bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"));
}
function unclaimedGoop() external view returns (uint256) {
address addr = _msgSender();
uint256 stakedTime;
for (uint256 i = 0; i < staker[addr].length; i++) {
stakedTime += block.timestamp - stakedToken[staker[addr][i]].timestamp;
}
return (stakedTime / GOOP_INTERVAL) * goopPerInterval;
}
function claimGoop() public {
require(claimStatus, "GOOP: claim not enabled");
address addr = _msgSender();
uint256 stakedTime;
for (uint256 i = 0; i < staker[addr].length; i++) {
stakedTime += block.timestamp - stakedToken[staker[addr][i]].timestamp;
stakedToken[staker[addr][i]].timestamp = block.timestamp;
}
_mintGoop(addr, (stakedTime / GOOP_INTERVAL) * goopPerInterval);
}
function transferGoop(address _to, uint256 _amount) public returns (bool) {
address owner = _msgSender();
_transferGoop(owner, _to, _amount);
return true;
}
function _transferGoop(
address from,
address to,
uint256 _amount
) internal {
require(transferState, "GOOP: transfer not enabled");
require(from != address(0), "GOOP: transfer from the zero address");
require(to != address(0), "GOOP: transfer to the zero address");
uint256 fromBalance = goop[from];
require(goop[from] >= _amount, "GOOP: insufficient balance ");
unchecked {
goop[from] = fromBalance - _amount;
}
goop[to] += _amount;
}
function mintGoop(address _addr, uint256 _goop) external override onlyAdmin {
_mintGoop(_addr, _goop);
}
function mintGoopBatch(address[] calldata _addr, uint256 _goop) external override onlyAdmin {
for (uint256 i = 0; i < _addr.length; i++) {
_mintGoop(_addr[i], _goop);
}
}
function _mintGoop(address account, uint256 amount) internal {
require(account != address(0), "GOOP: mint to the zero address");
totalGoopSupply += amount;
goop[account] += amount;
}
function burnGoop(address _addr, uint256 _goop) external override onlyAdmin {
_burnGoop(_addr, _goop);
}
function burnGoopBatch(address[] calldata _addr, uint256 _goop) external override onlyAdmin {
for (uint256 i = 0; i < _addr.length; i++) {
_burnGoop(_addr[i], _goop);
}
}
function spendGoop(uint256 _item, uint256 _count) public override {
addressPurchases[_msgSender()][_item] += _count;
require(spendState, "GOOP: spending not enabled");
require(saleItems[_item].saleStatus, "Item not currently for sale");
require(saleItems[_item].supply >= _count, "Item sold out.");
require(addressPurchases[_msgSender()][_item] <= saleItems[_item].maxPurchase, "Exceeded allowed purchase quantity");
uint256 cost = _count * saleItems[_item].price;
require(goop[_msgSender()] >= cost, "Insufficient goop.");
_burnGoop(_msgSender(), cost);
saleItems[_item].supply -= _count;
totalGoopSpent += _count * saleItems[_item].price;
emit spentGoop(_msgSender(), _item, _count);
}
function _burnGoop(address account, uint256 amount) internal {
require(account != address(0), "GOOP: burn from the zero address");
uint256 accountBalance = goop[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
goop[account] = accountBalance - amount;
}
totalGoopSupply -= amount;
}
function createNewSale(
string memory _description,
bool _saleState,
uint256 _price,
uint256 _supply,
uint256 _maxPurchase
) external onlyAdmin {
saleId++;
saleItems[saleId] = Sale(_description, _saleState, _price, _supply, _maxPurchase);
}
function setSaleDescription(uint256 _item, string memory _description) external onlyAdmin {
saleItems[_item].description = _description;
}
function setSaleStatus(uint256 _item, bool _saleStatus) external onlyAdmin {
saleItems[_item].saleStatus = _saleStatus;
}
function setSalePrice(uint256 _item, uint256 _price) external onlyAdmin {
saleItems[_item].price = _price;
}
function setSaleSupply(uint256 _item, uint256 _supply) external onlyAdmin {
saleItems[_item].supply = _supply;
}
function setMaxPurchase(uint256 _item, uint256 _maxPurchase) external onlyAdmin {
saleItems[_item].maxPurchase = _maxPurchase;
}
function setProxyRegistryAddress(address _proxyRegistryAddress) external onlyAdmin {
proxyRegistryAddress = _proxyRegistryAddress;
}
function flipProxyState(address proxyAddress) public onlyOwner {
projectProxy[proxyAddress] = !projectProxy[proxyAddress];
}
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
OpenSeaProxyRegistry proxyRegistry = OpenSeaProxyRegistry(proxyRegistryAddress);
if (address(proxyRegistry.proxies(_owner)) == operator || projectProxy[operator]) return true;
return super.isApprovedForAll(_owner, operator);
}
}
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
