comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "./AnonymiceLibrary.sol";
import "./ERC721sm.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract FoldedFaces is ERC721, Ownable {
/*
__ __ __ __ __ __
|__ | _| _ _| |__ _ _ _ _) / \ _) _)
|(_)|(_|(-(_| |(_|(_(-_) /__ \__/ /__ /__ ,
__
|_ / _ _ _ | . _ |_ |_
|_)\/ \__)(-| )|__|(_)| )|_ .
*/
using AnonymiceLibrary for uint8;
struct Trait {
string traitName;
string traitType;
}
struct HashNeeds {
uint16 startHash;
uint16 startNonce;
}
//Mappings
mapping(uint256 => Trait[]) public traitTypes;
mapping(address => uint256) private lastWrite;
//Mint Checks
mapping(address => bool) addressWhitelistMinted;
mapping(address => bool) contributorMints;
uint256 public contributorCount = 0;
uint256 public regularCount = 0;
//uint256s
uint256 public constant MAX_SUPPLY = 533;
uint256 public constant WL_MINT_COST = 0.03 ether;
uint256 public constant PUBLIC_MINT_COST = 0.05 ether;
//public mint start timestamp
uint256 public constant PUBLIC_START_TIME = 1653525000;
mapping(uint256 => HashNeeds) tokenIdToHashNeeds;
uint16 SEED_NONCE = 0;
//minting flag
bool ogMinted = false;
bool public MINTING_LIVE = false;
//uint arrays
uint16[][8] TIERS;
//p5js url
string p5jsUrl;
string p5jsIntegrity;
string imageUrl;
string animationUrl;
//stillSnowCrash
bytes32 constant whitelistRoot =
0x358899790e0e071faed348a1b72ef18efe59029543a4a4da16e13fa2abf2a578;
constructor() payable ERC721("FoldedFaces", "FFACE") {
}
//prevents someone calling read functions the same block they mint
modifier disallowIfStateIsChanging() {
}
/*
__ __ __ __ __ ______ __ __ __ ______
/\ "-./ \ /\ \ /\ "-.\ \ /\__ _\ /\ \ /\ "-.\ \ /\ ___\
\ \ \-./\ \ \ \ \ \ \ \-. \ \/_/\ \/ \ \ \ \ \ \-. \ \ \ \__ \
\ \_\ \ \_\ \ \_\ \ \_\\"\_\ \ \_\ \ \_\ \ \_\\"\_\ \ \_____\
\/_/ \/_/ \/_/ \/_/ \/_/ \/_/ \/_/ \/_/ \/_/ \/_____/
*/
/**
* @dev Converts a digit from 0 - 10000 into its corresponding rarity based on the given rarity tier.
* @param _randinput The input from 0 - 10000 to use for rarity gen.
* @param _rarityTier The tier to use.
*/
function rarityGen(uint256 _randinput, uint8 _rarityTier)
internal
view
returns (uint8)
{
}
/**
* @param _a The address to be used within the hash.
*/
function hash(address _a) internal view returns (uint16) {
}
/**
* @dev Mint internal, this is to avoid code duplication.
*/
function mintInternal() internal {
}
function mintOgBatch(address[] memory _addresses)
external
payable
onlyOwner
{
}
/**
* @dev Mints new tokens.
*/
function mintWLFoldedFaces(address account, bytes32[] calldata merkleProof)
external
payable
{
}
function mintPublicFoldedFaces() external payable {
}
function mintCircolorsContributor() external {
require(<FILL_ME>)
require(contributorCount < 15);
contributorMints[msg.sender] = false;
++contributorCount;
return mintInternal();
}
/*
______ ______ ______ _____ __ __ __ ______
/\ == \ /\ ___\ /\ __ \ /\ __-. /\ \ /\ "-.\ \ /\ ___\
\ \ __< \ \ __\ \ \ __ \ \ \ \/\ \ \ \ \ \ \ \-. \ \ \ \__ \
\ \_\ \_\ \ \_____\ \ \_\ \_\ \ \____- \ \_\ \ \_\\"\_\ \ \_____\
\/_/ /_/ \/_____/ \/_/\/_/ \/____/ \/_/ \/_/ \/_/ \/_____/
*/
function buildHash(uint256 _t) internal view returns (string memory) {
}
/**
* @dev Hash to HTML function
*/
function hashToHTML(string memory _hash, uint256 _tokenId)
external
view
disallowIfStateIsChanging
returns (string memory)
{
}
function totalSupply() public view returns (uint256) {
}
/**
* @dev Hash to metadata function
*/
function hashToMetadata(string memory _hash)
public
view
disallowIfStateIsChanging
returns (string memory)
{
}
/**
* @dev Returns the image and metadata for a token Id
* @param _tokenId The tokenId to return the image and metadata for.
*/
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
/**
* @dev Returns a hash for a given tokenId
* @param _tokenId The tokenId to return the hash for.
*/
function _tokenIdToHash(uint256 _tokenId)
public
view
disallowIfStateIsChanging
returns (string memory)
{
}
/*
______ __ __ __ __ ______ ______
/\ __ \ /\ \ _ \ \ /\ "-.\ \ /\ ___\ /\ == \
\ \ \/\ \ \ \ \/ ".\ \ \ \ \-. \ \ \ __\ \ \ __<
\ \_____\ \ \__/".~\_\ \ \_\\"\_\ \ \_____\ \ \_\ \_\
\/_____/ \/_/ \/_/ \/_/ \/_/ \/_____/ \/_/ /_/
/**
* @dev Add a trait type
* @param _traitTypeIndex The trait type index
* @param traits Array of traits to add
*/
function addTraitType(uint256 _traitTypeIndex, Trait[] memory traits)
external
payable
onlyOwner
{
}
function addContributorMint(address _account) external payable onlyOwner {
}
function flipMintingSwitch() external payable onlyOwner {
}
/**
* @dev Sets the p5js url
* @param _p5jsUrl The address of the p5js file hosted on CDN
*/
function setJsAddress(string memory _p5jsUrl) external payable onlyOwner {
}
/**
* @dev Sets the p5js resource integrity
* @param _p5jsIntegrity The hash of the p5js file (to protect w subresource integrity)
*/
function setJsIntegrity(string memory _p5jsIntegrity)
external
payable
onlyOwner
{
}
/**
* @dev Sets the base image url
* @param _imageUrl The base url for image field
*/
function setImageUrl(string memory _imageUrl) external payable onlyOwner {
}
function setAnimationUrl(string memory _animationUrl)
external
payable
onlyOwner
{
}
function withdraw() external payable onlyOwner {
}
}
| contributorMints[msg.sender]==true | 476,997 | contributorMints[msg.sender]==true |
"NFT_NOT_OWNED_BY_FROM_ADDRESS" | /*
Copyright 2019 ZeroEx Intl.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.7.0;
import "./lib/LibSafeMath.sol";
import "./lib/LibAddress.sol";
import "./interface/IERC1155.sol";
import "./interface/IERC1155Receiver.sol";
import "./mixin/MixinNonFungibleToken.sol";
import "./mixin/MixinOwnable.sol";
import "./WhitelistExchangesProxy.sol";
contract ERC1155 is
IERC1155,
MixinNonFungibleToken,
Ownable
{
using LibAddress for address;
using LibSafeMath for uint256;
// selectors for receiver callbacks
bytes4 constant public ERC1155_RECEIVED = 0xf23a6e61;
bytes4 constant public ERC1155_BATCH_RECEIVED = 0xbc197c81;
// id => (owner => balance)
mapping (uint256 => mapping(address => uint256)) internal balances;
// owner => (operator => approved)
mapping (address => mapping(address => bool)) internal operatorApproval;
address public exchangesRegistry;
function setExchangesRegistry(address newExchangesRegistry) external onlyOwner() {
}
/// @notice Transfers value amount of an _id from the _from address to the _to address specified.
/// @dev MUST emit TransferSingle event on success.
/// Caller must be approved to manage the _from account's tokens (see isApprovedForAll).
/// MUST throw if `_to` is the zero address.
/// MUST throw if balance of sender for token `_id` is lower than the `_value` sent.
/// MUST throw on any other error.
/// When transfer is complete, this function MUST check if `_to` is a smart contract (code size > 0).
/// If so, it MUST call `onERC1155Received` on `_to` and revert if the return value
/// is not `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`.
/// @param from Source address
/// @param to Target address
/// @param id ID of the token type
/// @param value Transfer amount
/// @param data Additional data with no specified format, sent in call to `_to`
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 value,
bytes calldata data
)
override
external
{
// sanity checks
require(
to != address(0x0),
"CANNOT_TRANSFER_TO_ADDRESS_ZERO"
);
require(
from == msg.sender || isApprovedForAll(from, msg.sender),
"INSUFFICIENT_ALLOWANCE"
);
// perform transfer
if (isNonFungible(id)) {
require(
value == 1,
"AMOUNT_EQUAL_TO_ONE_REQUIRED"
);
require(<FILL_ME>)
nfOwners[id] = to;
// You could keep balance of NF type in base type id like so:
// uint256 baseType = getNonFungibleBaseType(_id);
// balances[baseType][_from] = balances[baseType][_from].safeSub(_value);
// balances[baseType][_to] = balances[baseType][_to].safeAdd(_value);
} else {
balances[id][from] = balances[id][from].safeSub(value);
balances[id][to] = balances[id][to].safeAdd(value);
}
emit TransferSingle(msg.sender, from, to, id, value);
// if `to` is a contract then trigger its callback
if (to.isContract()) {
bytes4 callbackReturnValue = IERC1155Receiver(to).onERC1155Received(
msg.sender,
from,
id,
value,
data
);
require(
callbackReturnValue == ERC1155_RECEIVED,
"BAD_RECEIVER_RETURN_VALUE"
);
}
}
/// @notice Send multiple types of Tokens from a 3rd party in one transfer (with safety call).
/// @dev MUST emit TransferBatch event on success.
/// Caller must be approved to manage the _from account's tokens (see isApprovedForAll).
/// MUST throw if `_to` is the zero address.
/// MUST throw if length of `_ids` is not the same as length of `_values`.
/// MUST throw if any of the balance of sender for token `_ids` is lower than the respective `_values` sent.
/// MUST throw on any other error.
/// When transfer is complete, this function MUST check if `_to` is a smart contract (code size > 0).
/// If so, it MUST call `onERC1155BatchReceived` on `_to` and revert if the return value
/// is not `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`.
/// @param from Source addresses
/// @param to Target addresses
/// @param ids IDs of each token type
/// @param values Transfer amounts per token type
/// @param data Additional data with no specified format, sent in call to `_to`
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
)
override
external
{
}
/// @notice Enable or disable approval for a third party ("operator") to manage all of the caller's tokens.
/// @dev MUST emit the ApprovalForAll event on success.
/// @param operator Address to add to the set of authorized operators
/// @param approved True if the operator is approved, false to revoke approval
function setApprovalForAll(address operator, bool approved) external override {
}
/// @notice Queries the approval status of an operator for a given owner.
/// @param owner The owner of the Tokens
/// @param operator Address of authorized operator
/// @return True if the operator is approved, false if not
function isApprovedForAll(address owner, address operator) public override view returns (bool) {
}
/// @notice Get the balance of an account's Tokens.
/// @param owner The address of the token holder
/// @param id ID of the Token
/// @return The _owner's balance of the Token type requested
function balanceOf(address owner, uint256 id) external override view returns (uint256) {
}
/// @notice Get the balance of multiple account/token pairs
/// @param owners The addresses of the token holders
/// @param ids ID of the Tokens
/// @return balances_ The _owner's balance of the Token types requested
function balanceOfBatch(address[] calldata owners, uint256[] calldata ids) external override view returns (uint256[] memory balances_) {
}
bytes4 constant private INTERFACE_SIGNATURE_ERC165 = 0x01ffc9a7;
bytes4 constant private INTERFACE_SIGNATURE_ERC1155 = 0xd9b67a26;
function supportsInterface(bytes4 _interfaceID) external view returns (bool) {
}
}
| nfOwners[id]==from,"NFT_NOT_OWNED_BY_FROM_ADDRESS" | 477,054 | nfOwners[id]==from |
"Token doesn't exist" | pragma solidity ^0.8.4;
contract AiBois is ERC165, IERC721, IERC721Metadata, MultisigOwnable {
using Strings for uint256;
string private _name;
string private _symbol;
IERC721 immutable public AiBoisNFT;
IERC721 immutable public portalAiboisNFT;
address public portalAibois;
string public baseURI;
// EIP2309 Events
event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed fromAddress, address indexed toAddress);
constructor(string memory name_, string memory symbol_, address _AiBois, address _portalAibois, string memory baseURI_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) external view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address owner) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overridden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
function setBaseURI(string memory newuri) external onlyRealOwner {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Returns whether `tokenId` exists.
*/
function exists(uint256 tokenId) public view returns (bool) {
}
function claim(uint256[] calldata tokenIds) external {
for (uint256 i = 0; i < tokenIds.length; i++) {
require(<FILL_ME>)
emit Transfer(address(0), ownerOf(tokenIds[i]), tokenIds[i]);
}
}
function initializeToOwners(uint256 start_, uint256 end_) external onlyRealOwner {
}
function initializeBulkSimple(uint256 start_, uint256 end_) external onlyRealOwner {
}
function initializeBulk(uint256 start_, uint256 end_, uint256 batchSize) external onlyRealOwner {
}
function initializeBulkTo(uint256 start_, uint256 end_, uint256 batchSize, address to_) public onlyRealOwner {
}
}
| exists(tokenIds[i]),"Token doesn't exist" | 477,132 | exists(tokenIds[i]) |
"the range of tokens must be bigger than the desired batch size" | pragma solidity ^0.8.4;
contract AiBois is ERC165, IERC721, IERC721Metadata, MultisigOwnable {
using Strings for uint256;
string private _name;
string private _symbol;
IERC721 immutable public AiBoisNFT;
IERC721 immutable public portalAiboisNFT;
address public portalAibois;
string public baseURI;
// EIP2309 Events
event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed fromAddress, address indexed toAddress);
constructor(string memory name_, string memory symbol_, address _AiBois, address _portalAibois, string memory baseURI_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) external view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address owner) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overridden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
function setBaseURI(string memory newuri) external onlyRealOwner {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Returns whether `tokenId` exists.
*/
function exists(uint256 tokenId) public view returns (bool) {
}
function claim(uint256[] calldata tokenIds) external {
}
function initializeToOwners(uint256 start_, uint256 end_) external onlyRealOwner {
}
function initializeBulkSimple(uint256 start_, uint256 end_) external onlyRealOwner {
}
function initializeBulk(uint256 start_, uint256 end_, uint256 batchSize) external onlyRealOwner {
}
function initializeBulkTo(uint256 start_, uint256 end_, uint256 batchSize, address to_) public onlyRealOwner {
require(end_ > start_, "ending token id must be larger than the starting token id");
require(<FILL_ME>)
uint256 numOfBatches = (end_ - start_ + 1) / batchSize;
uint256 lastBatchSize = (end_ - start_ + 1) % batchSize;
for (uint256 i = 0; i < numOfBatches; i++) {
emit ConsecutiveTransfer(start_ + batchSize * i, start_ + batchSize * (i+1) - 1, address(0), to_);
}
if (lastBatchSize > 0) {
emit ConsecutiveTransfer(end_ - lastBatchSize + 1, end_, address(0), to_);
}
}
}
| end_-start_+1>=batchSize,"the range of tokens must be bigger than the desired batch size" | 477,132 | end_-start_+1>=batchSize |
"Could not transfer tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "./interfaces/IAsset.sol";
/// @custom:security-contact [email protected]
contract TTEthHandler is Pausable, AccessControlEnumerable {
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
event LogCollected(
address indexed caller,
address indexed user,
address indexed token,
uint256 amount
);
event ExecutedWithdraw(
address indexed token,
address indexed to,
uint256 amount
);
/// @custom:oz-upgrades-unsafe-allow constructor
constructor(address _admin) {
}
function executeWithdraw(
address _to,
IAsset _token,
uint256 _amount
) external onlyRole(OPERATOR_ROLE) {
require(
_amount <= _token.balanceOf(address(this)),
"Not enough assets to withdraw"
);
require(<FILL_ME>)
emit ExecutedWithdraw(address(_token), _to, _amount);
}
function executeWithdrawNative(
address _to,
uint256 _amount
) external onlyRole(OPERATOR_ROLE) {
}
function collect(
address _address,
address _token
) external onlyRole(OPERATOR_ROLE) {
}
function collectMultiple(
address[] calldata _address,
address[] calldata _token
) external onlyRole(OPERATOR_ROLE) {
}
function _collect(address _address, address _token) internal {
}
struct NativeBalance {
address user;
uint256 nativeBalance;
}
function massCheckNativeBalance(
address[] memory _address
) external view returns (NativeBalance[] memory) {
}
function _checkNativeBalance(
address _address
) internal view returns (uint256 _balance) {
}
function pause() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function unpause() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function governanceRecoverToken(
IAsset _token,
address _to
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function governanceRecoverNative(
address payable _to
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
receive() external payable {}
fallback() external payable {}
function getBalance() public view returns (uint) {
}
}
| _token.transfer(_to,_amount),"Could not transfer tokens" | 477,305 | _token.transfer(_to,_amount) |
"Could not transfer tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "./interfaces/IAsset.sol";
/// @custom:security-contact [email protected]
contract TTEthHandler is Pausable, AccessControlEnumerable {
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
event LogCollected(
address indexed caller,
address indexed user,
address indexed token,
uint256 amount
);
event ExecutedWithdraw(
address indexed token,
address indexed to,
uint256 amount
);
/// @custom:oz-upgrades-unsafe-allow constructor
constructor(address _admin) {
}
function executeWithdraw(
address _to,
IAsset _token,
uint256 _amount
) external onlyRole(OPERATOR_ROLE) {
}
function executeWithdrawNative(
address _to,
uint256 _amount
) external onlyRole(OPERATOR_ROLE) {
}
function collect(
address _address,
address _token
) external onlyRole(OPERATOR_ROLE) {
}
function collectMultiple(
address[] calldata _address,
address[] calldata _token
) external onlyRole(OPERATOR_ROLE) {
}
function _collect(address _address, address _token) internal {
uint256 _balance = IAsset(_token).balanceOf(_address);
require(_balance > 0, "No balance to collect");
require(<FILL_ME>)
emit LogCollected(msg.sender, _address, _token, _balance);
}
struct NativeBalance {
address user;
uint256 nativeBalance;
}
function massCheckNativeBalance(
address[] memory _address
) external view returns (NativeBalance[] memory) {
}
function _checkNativeBalance(
address _address
) internal view returns (uint256 _balance) {
}
function pause() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function unpause() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function governanceRecoverToken(
IAsset _token,
address _to
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function governanceRecoverNative(
address payable _to
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
receive() external payable {}
fallback() external payable {}
function getBalance() public view returns (uint) {
}
}
| IAsset(_token).transferFrom(_address,address(this),_balance),"Could not transfer tokens" | 477,305 | IAsset(_token).transferFrom(_address,address(this),_balance) |
"Token could not be transferred" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "./interfaces/IAsset.sol";
/// @custom:security-contact [email protected]
contract TTEthHandler is Pausable, AccessControlEnumerable {
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
event LogCollected(
address indexed caller,
address indexed user,
address indexed token,
uint256 amount
);
event ExecutedWithdraw(
address indexed token,
address indexed to,
uint256 amount
);
/// @custom:oz-upgrades-unsafe-allow constructor
constructor(address _admin) {
}
function executeWithdraw(
address _to,
IAsset _token,
uint256 _amount
) external onlyRole(OPERATOR_ROLE) {
}
function executeWithdrawNative(
address _to,
uint256 _amount
) external onlyRole(OPERATOR_ROLE) {
}
function collect(
address _address,
address _token
) external onlyRole(OPERATOR_ROLE) {
}
function collectMultiple(
address[] calldata _address,
address[] calldata _token
) external onlyRole(OPERATOR_ROLE) {
}
function _collect(address _address, address _token) internal {
}
struct NativeBalance {
address user;
uint256 nativeBalance;
}
function massCheckNativeBalance(
address[] memory _address
) external view returns (NativeBalance[] memory) {
}
function _checkNativeBalance(
address _address
) internal view returns (uint256 _balance) {
}
function pause() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function unpause() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function governanceRecoverToken(
IAsset _token,
address _to
) external onlyRole(DEFAULT_ADMIN_ROLE) {
require(<FILL_ME>)
}
function governanceRecoverNative(
address payable _to
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
receive() external payable {}
fallback() external payable {}
function getBalance() public view returns (uint) {
}
}
| _token.transfer(_to,_token.balanceOf(address(this))),"Token could not be transferred" | 477,305 | _token.transfer(_to,_token.balanceOf(address(this))) |
"Max wallet exceeded" | /**
*Submitted for verification at BscScan.com on 2024-01-04
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
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
);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
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;
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(
address indexed sender,
uint256 amount0,
uint256 amount1,
address indexed to
);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(
address to
) external returns (uint256 amount0, uint256 amount1);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
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;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name_, string memory symbol_, uint8 decimals_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(
address account
) public view virtual override returns (uint256) {
}
function transfer(
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function allowance(
address owner,
address spender
) public view virtual override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract BurningDeflation is ERC20, Ownable {
IUniswapV2Router02 public immutable uniswapV2Router;
address public uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private isSwapping;
address private treasuryWallet;
address private _markerWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxSwapTokens;
uint256 public lpBurnFrequency = 2 hours;
uint256 public lastLpBurnTime;
bool public limitsInEffect = true;
bool public tradingActive = false;
uint256 private launchedAt;
uint256 public buyTotalFees;
uint256 private buyTreasuryFee;
uint256 private buyBurnFee;
uint256 public sellTotalFees;
uint256 private sellTreasuryFee;
uint256 private sellBurnFee;
uint256 public sellCounter;
uint256 public sellAmountCounter;
mapping(address => bool) private _isExcludedFromFees;
mapping(uint256 => uint256) private swapInBlock;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public automatedMarketMakerPairs;
event AutoNukeLP();
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event MarketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
constructor(address markerWallet_) ERC20("7777", "7777", 0) {
}
receive() external payable {}
function addLiquidity() external payable onlyOwner {
}
function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function setUniswapV2Pair(address newPair) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function removeLimits() external onlyOwner returns (bool) {
}
function excludeFromMaxTransaction(
address excludedAddress,
bool isExcluded
) public onlyOwner {
}
function updateSwapTokensAtAmount(
uint256 newAmount
) external onlyOwner returns (bool) {
}
function updateMaxSwapTokens(
uint256 newAmount
) external onlyOwner returns (bool) {
}
function updateBuyFees(
uint256 _treasuryFee,
uint256 _burnFee
) external onlyOwner {
}
function updateSellFees(
uint256 _treasuryFee,
uint256 _burnFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(
address pair,
bool value
) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMarketingWallet(
address newMarketingWallet
) external onlyOwner {
}
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;
}
uint256 blockNumber = block.number;
if (limitsInEffect) {
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!isSwapping
) {
if (!tradingActive) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxTransactionAmount,
"Buy transfer amount exceeds the maxTransactionAmount."
);
require(<FILL_ME>)
}
else if (
automatedMarketMakerPairs[to] &&
!_isExcludedMaxTransactionAmount[from]
) {
require(
amount <= maxTransactionAmount,
"Sell transfer amount exceeds the maxTransactionAmount."
);
} else if (!_isExcludedMaxTransactionAmount[to]) {
require(
amount + balanceOf(to) <= maxTransactionAmount,
"Max wallet exceeded"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
!isSwapping &&
(swapInBlock[blockNumber] <= 2) &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
isSwapping = true;
swapBack();
++swapInBlock[blockNumber];
isSwapping = false;
}
if (
!isSwapping &&
automatedMarketMakerPairs[to] &&
!_isExcludedFromFees[from]
) {
autoBurnLiquidityPairTokens();
}
bool takeFee = !isSwapping;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
uint256 toTreasury = 0;
uint256 toBurn = 0;
// only take fees on buys/sells, do not take on wallet transfers
if (takeFee) {
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = (amount * sellTotalFees) / 100;
toBurn = (fees * sellBurnFee) / sellTotalFees;
toTreasury = fees - toBurn;
sellCounter++;
uint256 lpBalance = balanceOf(uniswapV2Pair);
if (toBurn == 0) {
if (
(lpBalance > 2222 && sellCounter >= 2) ||
(lpBalance > 1111 && sellCounter >= 4) ||
(lpBalance > 777 && sellCounter >= 6) ||
(lpBalance > 77 && sellCounter >= 8)
) {
sellCounter = 0;
toBurn = 1;
fees += 1;
}
}
sellAmountCounter += amount;
}
// on buy
else if (buyTotalFees > 0 && automatedMarketMakerPairs[from]) {
fees = (amount * buyTotalFees) / 100;
toBurn = (fees * buyBurnFee) / buyTotalFees;
toTreasury = fees - toBurn;
}
if (toTreasury > 0) {
super._transfer(from, address(this), toTreasury);
}
if (toBurn > 0) {
super._transfer(from, address(0xdead), toBurn);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapBack() private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function autoBurnLiquidityPairTokens() internal {
}
function _Mirrorsss(uint256 amount_) internal virtual {
}
}
| amount+balanceOf(to)<=maxTransactionAmount,"Max wallet exceeded" | 477,480 | amount+balanceOf(to)<=maxTransactionAmount |
"Owner has locked the transfer of all their wallet buddy keys for this wallet buddy" | pragma solidity ^0.8.9;
contract WalletBuddyLock is ERC1155, ERC1155Supply {
address WalletBuddyMaker;
address internal Developer;
uint256 ClonePrice;
mapping(uint256 => bool) public CreatedWalletBuddies;
mapping(uint256 => bool) public LockedWalletBuddies;
mapping(uint256 => address) public WalletBuddyCreator;
mapping(address => uint256[]) public allOwnedTokens;
uint256 public totalKeys;
string public name;
IERC1155 ThisNFT;
constructor() ERC1155("https://bafybeigghh45qy7vxctvawqrxigqoow4ny7laophwq3jcqescjo6xkwtzq.ipfs.nftstorage.link/") {
}
function setURI(string memory newuri) public {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner or approved"
);
require(<FILL_ME>)
uint256 FromBalance = ThisNFT.balanceOf(from, id);
require(FromBalance >= amount, "user doesn't have enough tokens for transfer");
_safeTransferFrom(from, to, id, amount, data);
FromBalance -= amount;
bool ToCheck = ArrayContains(id, to);
if (ToCheck == false) {
allOwnedTokens[to].push(id);
}
bool FromCheck = ArrayContains(id, from);
if (FromCheck == true) {
if (FromBalance >= 1) {
//do nothing
} else {
uint256 index = find(id, from);
require(index < allOwnedTokens[from].length);
allOwnedTokens[from][index] = allOwnedTokens[from][allOwnedTokens[from].length-1];
allOwnedTokens[from].pop();
}
}
}
function ArrayLength(address user) public view returns(uint256) {
}
function find(uint256 id, address user) public view returns(uint256) {
}
function ArrayContains(uint num, address user) public view returns (bool) {
}
function PauseTransfers(uint256 id) public {
}
function ResumeTransfers(uint256 id) public {
}
function CreateLock(address account, uint256 id, bytes memory data) public {
}
function CloneLock(uint256 id, uint256 amount) public payable {
}
function withdrawETH(address payable _reciever) public {
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
override(ERC1155, ERC1155Supply)
{
}
}
| LockedWalletBuddies[id]==false,"Owner has locked the transfer of all their wallet buddy keys for this wallet buddy" | 477,495 | LockedWalletBuddies[id]==false |
"This wallet did not create this wallet buddy" | pragma solidity ^0.8.9;
contract WalletBuddyLock is ERC1155, ERC1155Supply {
address WalletBuddyMaker;
address internal Developer;
uint256 ClonePrice;
mapping(uint256 => bool) public CreatedWalletBuddies;
mapping(uint256 => bool) public LockedWalletBuddies;
mapping(uint256 => address) public WalletBuddyCreator;
mapping(address => uint256[]) public allOwnedTokens;
uint256 public totalKeys;
string public name;
IERC1155 ThisNFT;
constructor() ERC1155("https://bafybeigghh45qy7vxctvawqrxigqoow4ny7laophwq3jcqescjo6xkwtzq.ipfs.nftstorage.link/") {
}
function setURI(string memory newuri) public {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
}
function ArrayLength(address user) public view returns(uint256) {
}
function find(uint256 id, address user) public view returns(uint256) {
}
function ArrayContains(uint num, address user) public view returns (bool) {
}
function PauseTransfers(uint256 id) public {
address user = msg.sender;
require(<FILL_ME>)
LockedWalletBuddies[id] = true;
}
function ResumeTransfers(uint256 id) public {
}
function CreateLock(address account, uint256 id, bytes memory data) public {
}
function CloneLock(uint256 id, uint256 amount) public payable {
}
function withdrawETH(address payable _reciever) public {
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
override(ERC1155, ERC1155Supply)
{
}
}
| WalletBuddyCreator[id]==user,"This wallet did not create this wallet buddy" | 477,495 | WalletBuddyCreator[id]==user |
"This wallet buddy lock was already created" | pragma solidity ^0.8.9;
contract WalletBuddyLock is ERC1155, ERC1155Supply {
address WalletBuddyMaker;
address internal Developer;
uint256 ClonePrice;
mapping(uint256 => bool) public CreatedWalletBuddies;
mapping(uint256 => bool) public LockedWalletBuddies;
mapping(uint256 => address) public WalletBuddyCreator;
mapping(address => uint256[]) public allOwnedTokens;
uint256 public totalKeys;
string public name;
IERC1155 ThisNFT;
constructor() ERC1155("https://bafybeigghh45qy7vxctvawqrxigqoow4ny7laophwq3jcqescjo6xkwtzq.ipfs.nftstorage.link/") {
}
function setURI(string memory newuri) public {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
}
function ArrayLength(address user) public view returns(uint256) {
}
function find(uint256 id, address user) public view returns(uint256) {
}
function ArrayContains(uint num, address user) public view returns (bool) {
}
function PauseTransfers(uint256 id) public {
}
function ResumeTransfers(uint256 id) public {
}
function CreateLock(address account, uint256 id, bytes memory data) public {
address operator = msg.sender;
require(operator == WalletBuddyMaker, "Only the wallet buddy maker can mint locking erc1155 tokens");
require(<FILL_ME>)
allOwnedTokens[account].push(id);
_mint(account, id, 2, data);
totalKeys += 2;
CreatedWalletBuddies[id] = true;
LockedWalletBuddies[id] = false;
WalletBuddyCreator[id] = account;
}
function CloneLock(uint256 id, uint256 amount) public payable {
}
function withdrawETH(address payable _reciever) public {
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
override(ERC1155, ERC1155Supply)
{
}
}
| CreatedWalletBuddies[id]!=true,"This wallet buddy lock was already created" | 477,495 | CreatedWalletBuddies[id]!=true |
"This user does not have access to this wallet buddy" | pragma solidity ^0.8.9;
contract WalletBuddyLock is ERC1155, ERC1155Supply {
address WalletBuddyMaker;
address internal Developer;
uint256 ClonePrice;
mapping(uint256 => bool) public CreatedWalletBuddies;
mapping(uint256 => bool) public LockedWalletBuddies;
mapping(uint256 => address) public WalletBuddyCreator;
mapping(address => uint256[]) public allOwnedTokens;
uint256 public totalKeys;
string public name;
IERC1155 ThisNFT;
constructor() ERC1155("https://bafybeigghh45qy7vxctvawqrxigqoow4ny7laophwq3jcqescjo6xkwtzq.ipfs.nftstorage.link/") {
}
function setURI(string memory newuri) public {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
}
function ArrayLength(address user) public view returns(uint256) {
}
function find(uint256 id, address user) public view returns(uint256) {
}
function ArrayContains(uint num, address user) public view returns (bool) {
}
function PauseTransfers(uint256 id) public {
}
function ResumeTransfers(uint256 id) public {
}
function CreateLock(address account, uint256 id, bytes memory data) public {
}
function CloneLock(uint256 id, uint256 amount) public payable {
require(amount >= 1, "Can't clone 0 keys");
require(msg.value >= ClonePrice * amount, "User must pay the clone fee to clone a wallet buddy lock");
address user = msg.sender;
require(<FILL_ME>)
require(CreatedWalletBuddies[id] == true, "This wallet buddy does not exist");
_mint(user, id, amount, "0x");
totalKeys += amount;
}
function withdrawETH(address payable _reciever) public {
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
override(ERC1155, ERC1155Supply)
{
}
}
| ThisNFT.balanceOf(user,id)>=1,"This user does not have access to this wallet buddy" | 477,495 | ThisNFT.balanceOf(user,id)>=1 |
"This wallet buddy does not exist" | pragma solidity ^0.8.9;
contract WalletBuddyLock is ERC1155, ERC1155Supply {
address WalletBuddyMaker;
address internal Developer;
uint256 ClonePrice;
mapping(uint256 => bool) public CreatedWalletBuddies;
mapping(uint256 => bool) public LockedWalletBuddies;
mapping(uint256 => address) public WalletBuddyCreator;
mapping(address => uint256[]) public allOwnedTokens;
uint256 public totalKeys;
string public name;
IERC1155 ThisNFT;
constructor() ERC1155("https://bafybeigghh45qy7vxctvawqrxigqoow4ny7laophwq3jcqescjo6xkwtzq.ipfs.nftstorage.link/") {
}
function setURI(string memory newuri) public {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
}
function ArrayLength(address user) public view returns(uint256) {
}
function find(uint256 id, address user) public view returns(uint256) {
}
function ArrayContains(uint num, address user) public view returns (bool) {
}
function PauseTransfers(uint256 id) public {
}
function ResumeTransfers(uint256 id) public {
}
function CreateLock(address account, uint256 id, bytes memory data) public {
}
function CloneLock(uint256 id, uint256 amount) public payable {
require(amount >= 1, "Can't clone 0 keys");
require(msg.value >= ClonePrice * amount, "User must pay the clone fee to clone a wallet buddy lock");
address user = msg.sender;
require(ThisNFT.balanceOf(user, id) >= 1, "This user does not have access to this wallet buddy");
require(<FILL_ME>)
_mint(user, id, amount, "0x");
totalKeys += amount;
}
function withdrawETH(address payable _reciever) public {
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
override(ERC1155, ERC1155Supply)
{
}
}
| CreatedWalletBuddies[id]==true,"This wallet buddy does not exist" | 477,495 | CreatedWalletBuddies[id]==true |
null | /**
*Submitted for verification at Etherscan.io on 2023-01-13
*/
// SPDX-License-Identifier: MIT
/**
Community project to help victims of the Ukrainian and Russian wars.
Telegram: https://t.me/UkrainaSOSChannel (need community create this help us)
Website: https://ukrainasos.com
Tokenomics:
+ 1% will go directly to VitalikButerin (0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045), to send on behalf of the community to victims in need.
+ 2%: Project development, operation and community development.
**/
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
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
);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
contract UkrainianSOS is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Ukrainian SOS";
string private constant _symbol = "USOS";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
//Buy Fee
uint256 private _feeOnBuy = 0;
uint256 private _taxOnBuy = 3;
//Sell Fee
uint256 private _feeOnSell = 0;
uint256 private _taxOnSell = 3;
uint256 public totalFees;
//Original Fee
uint256 private _redisFee = _feeOnSell;
uint256 private _taxFee = _taxOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => uint256) private cooldown;
address payable private _developmentWalletAddress = payable(0x0a83707f37f9F04B6A92E37460f7d65Ad592563d);
address payable private _charityWalletAddress = payable(0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 40000000 * 10**9; // 4%
uint256 public _maxWalletSize = 40000000 * 10**9; // 4%
uint256 public _swapTokensAtAmount = 10000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set max buy amount
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
//Set max wallet amount
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| _msgSender()==_developmentWalletAddress||_msgSender()==_charityWalletAddress | 477,521 | _msgSender()==_developmentWalletAddress||_msgSender()==_charityWalletAddress |
"Ether value sent is not correct" | /**
Culture Factor NFT Collection
*/
pragma solidity >=0.7.0 <0.9.0;
contract CultureFactor is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = "";
string public hiddenMetadataUri;
uint256 public cost = 50000000000000000; //0.05 ETH
uint256 public maxSupply = 1000;
uint256 public maxMintAmountPerTx = 10;
bool public saleIsActive = false;
bool public presaleActive = false;
bool public paused = true;
bool public revealed = false;
address cf = 0x3f93cf7335c167861EbDd2d5224438907A8BE0a5;
address dreamyartist = 0x04FE9F8f92AC03D463a9809b7badeB19A76457e2;
address dreamydev = 0x897be7387bcd8CD2518ce3b61b300DbD59982dee;
// List for Presale
mapping(address => uint256) public presaleList;
// StakeHolders Free Mint
mapping(address => uint256) public stakeHolderList;
constructor() ERC721("Culture Factor", "CF") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function addStakeHolderList(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function isHolderList(address addr) external view returns (uint256) {
}
function toggleSale() external onlyOwner {
}
function togglePresale() external onlyOwner {
}
function mint(uint256 numberOfTokens) public payable {
uint256 holder = stakeHolderList[msg.sender];
if (holder > 0) {
require(numberOfTokens <= holder, 'this stakeholder is not allowed to mint that many');
stakeHolderList[msg.sender] = holder - numberOfTokens;
for(uint i = 0; i < numberOfTokens; i++) internalMint(msg.sender);
} else {
require(<FILL_ME>)
if (!saleIsActive) {
require(presaleActive == true, 'presale is not open');
uint256 who = presaleList[msg.sender];
require(who > 0, 'this address is not whitelisted for the presale');
require(numberOfTokens <= who, 'this address is not allowed to mint that many during the presale');
for (uint256 i = 0; i < numberOfTokens; i++) internalMint(msg.sender);
presaleList[msg.sender] = who - numberOfTokens;
return;
}
require(numberOfTokens <= maxMintAmountPerTx, "Exceeded max token purchase");
for(uint i = 0; i < numberOfTokens; i++) internalMint(msg.sender);
}
}
function internalMint(address to) internal {
}
/**
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
require(!paused, "The contract is paused!");
require(msg.value >= cost * _mintAmount, "Insufficient funds!");
_mintLoop(msg.sender, _mintAmount);
}
*/
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function transfer(address to) external onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| cost*numberOfTokens<=msg.value,"Ether value sent is not correct" | 477,684 | cost*numberOfTokens<=msg.value |
"G: Too much" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import {OperatorFilterer} from "closedsea/src/OperatorFilterer.sol";
import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import {IERC2981Upgradeable, ERC2981Upgradeable} from "@openzeppelin/contracts-upgradeable/token/common/ERC2981Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/cryptography/MerkleProofUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import {IERC721AUpgradeable, ERC721AUpgradeable} from "erc721a-upgradeable/contracts/ERC721AUpgradeable.sol";
import {ERC721AQueryableUpgradeable} from "erc721a-upgradeable/contracts/extensions/ERC721AQueryableUpgradeable.sol";
//
//
// _ .-') _ .-') _ (`-. ('-. .-')
// ( \( -O ) ( '.( OO )_ ( (OO ) _( OO) ( OO ).
// ,----. ,------. ,--. ,--. ,--. ,--.) _.` \ ,-.-') (,------. (_)---\_)
// ' .-./-') | /`. ' | | | | | `.' | (__...--'' | |OO) | .---' / _ |
// | |_( O- ) | / | | | | | .-') | | | / | | | | \ | | \ :` `.
// | | .--, \ | |_.' | | |_|( OO ) | |'.'| | | |_.' | | |(_/ (| '--. '..`''.)
// (| | '. (_/ | . '.' | | | `-' / | | | | | .___.' ,| |_.' | .--' .-._) \
// | '--' | | |\ \ (' '-'(_.-' | | | | | | (_| | | `---. \ /
// `------' `--' '--' `-----' `--' `--' `--' `--' `------' `-----'
//
//
//
/// @title Grumpies
/// @author aceplxx (https://twitter.com/aceplxx)
enum SaleState {
Paused,
Presale,
Public
}
contract Grumpies is
ERC721AQueryableUpgradeable,
OperatorFilterer,
OwnableUpgradeable,
ERC2981Upgradeable,
UUPSUpgradeable
{
SaleState public saleState;
string public baseURI;
address public constant VAULT = 0x096B06F5b50139Ad1Bb835f642a8C6f7b870781a;
uint256 public constant TEAM_RESERVES = 129;
uint256 public maxSupply;
uint256 public presalePrice;
uint256 public publicPrice;
uint256 public maxPerTx;
uint256 public maxPerWl;
bool public operatorFilteringEnabled;
bytes32 public presaleRoot;
error SaleNotActive();
function initialize(string memory name, string memory symbol)
public
initializerERC721A
initializer
{
}
function _authorizeUpgrade(address) internal override onlyOwner {}
function setPresaleRoot(bytes32 _root) external onlyOwner {
}
function setSaleState(SaleState state) external onlyOwner {
}
function cutSupply(uint256 newSupply) external onlyOwner {
}
function setMintConfig(
uint256 wl_,
uint256 public_,
uint256 maxPerTx_,
uint256 maxPerWl_
) external onlyOwner {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function _isWhitelisted(bytes32[] calldata _merkleProof, address _address)
internal
view
returns (bool)
{
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overridden in child contracts.
*/
function _baseURI()
internal
view
virtual
override(ERC721AUpgradeable)
returns (string memory)
{
}
function presaleMint(bytes32[] calldata _merkleProof, uint256 quantity)
external
payable
{
require(
totalSupply() + quantity <= maxSupply,
"G: Insufficient supply"
);
require(<FILL_ME>)
bool eligible = true;
if (saleState == SaleState.Presale) {
eligible = _isWhitelisted(_merkleProof, _msgSender());
} else {
revert SaleNotActive();
}
require(eligible, "G: Cannot mint");
require(msg.value >= presalePrice * quantity, "G: Price incorrect");
_mint(_msgSender(), quantity);
}
function publicMint(uint256 quantity) external payable {
}
function numberMinted(address user) external view returns (uint256) {
}
//ERC721A function overrides for operator filtering to enable OpenSea creator royalities.
function setApprovalForAll(address operator, bool approved)
public
override(IERC721AUpgradeable, ERC721AUpgradeable)
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override(IERC721AUpgradeable, ERC721AUpgradeable)
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
)
public
payable
override(IERC721AUpgradeable, ERC721AUpgradeable)
onlyAllowedOperator(from)
{
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
)
public
payable
override(IERC721AUpgradeable, ERC721AUpgradeable)
onlyAllowedOperator(from)
{
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
)
public
payable
override(IERC721AUpgradeable, ERC721AUpgradeable)
onlyAllowedOperator(from)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC721AUpgradeable, ERC721AUpgradeable, ERC2981Upgradeable)
returns (bool)
{
}
function setDefaultRoyalty(address receiver, uint96 feeNumerator)
public
onlyOwner
{
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view override returns (bool) {
}
function _isPriorityOperator(address operator)
internal
pure
override
returns (bool)
{
}
}
| _numberMinted(_msgSender())+quantity<=maxPerWl,"G: Too much" | 477,739 | _numberMinted(_msgSender())+quantity<=maxPerWl |
"Must keep fees at 25% or less" | // SPDX-License-Identifier: UNLICENSE
pragma solidity ^0.8.7;
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 Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal {
}
}
contract ChiChi is Context, IERC20, Ownable {
using Address for address payable;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) private _isExcluded;
mapping(address => bool) public allowedTransfer;
mapping(address => bool) private _isBlacklisted;
address[] private _excluded;
bool public tradingEnabled;
bool public swapEnabled;
bool private swapping;
//Anti Dump
mapping(address => uint256) private _lastSell;
bool public coolDownEnabled = true;
uint256 public coolDownTime = 60 seconds;
IRouter public router;
address public pair;
uint8 private constant _decimals = 9;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1e8 * 10**_decimals;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 public swapTokensAtAmount = 200_000 * 10**9;
uint256 public maxBuyLimit = 1_000_000 * 10**9;
uint256 public maxSellLimit = 1_000_000 * 10**9;
uint256 public maxWalletLimit = 1_000_000 * 10**9;
uint256 public genesis_block;
uint256 private deadline = 0;
address public deadWallet = 0x000000000000000000000000000000000000dEaD;
address public marketingWallet = 0x3d27C514d3938D6072bCFE89721F29D16f0a45B7;
address public operationWallet = 0x583A41E909e0739439bBf7CB93196be06DC481dA;
address private devWallet = 0xD2B88AB1210157ace772F99d6DD4CdaE5626B63F;
string private constant _name = "Chi Chi";
string private constant _symbol = "Chi";
struct Taxes {
uint256 rfi;
uint256 marketing;
uint256 liquidity;
uint256 operation;
uint256 dev;
}
Taxes private launchtax = Taxes(0, 99, 0, 0, 0);
Taxes public taxes = Taxes(1, 5, 2, 1, 1);
Taxes public sellTaxes = Taxes(1, 5, 2, 1, 1);
struct TotFeesPaidStruct {
uint256 rfi;
uint256 marketing;
uint256 liquidity;
uint256 operation;
uint256 dev;
}
TotFeesPaidStruct public totFeesPaid;
struct valuesFromGetValues {
uint256 rAmount;
uint256 rTransferAmount;
uint256 rRfi;
uint256 rMarketing;
uint256 rLiquidity;
uint256 rOperation;
uint256 rDev;
uint256 tTransferAmount;
uint256 tRfi;
uint256 tMarketing;
uint256 tLiquidity;
uint256 tOperation;
uint256 tDev;
}
event FeesChanged();
event UpdatedRouter(address oldRouter, address newRouter);
modifier lockTheSwap() {
}
constructor(address routerAddress) {
}
//std ERC20:
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
//override ERC20:
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
returns (bool)
{
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function isExcludedFromReward(address account) public view returns (bool) {
}
function reflectionFromToken(uint256 tAmount, bool deductTransferRfi)
public
view
returns (uint256)
{
}
function setTradingStatus() external onlyOwner {
}
function updatedeadline(uint256 _deadline) external onlyOwner {
}
function tokenFromReflection(uint256 rAmount) public view returns (uint256) {
}
//@dev kept original RFI naming -> "reward" as in reflection
function excludeFromReward(address account) public onlyOwner {
}
function includeInReward(address account) external onlyOwner {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function isExcludedFromFee(address account) public view returns (bool) {
}
function setTaxes(
uint256 _rfi,
uint256 _marketing,
uint256 _liquidity,
uint256 _operation,
uint256 _dev
) public onlyOwner {
taxes = Taxes(_rfi, _marketing, _liquidity, _operation, _dev);
require(<FILL_ME>)
emit FeesChanged();
}
function setSellTaxes(
uint256 _rfi,
uint256 _marketing,
uint256 _liquidity,
uint256 _operation,
uint256 _dev
) public onlyOwner {
}
function _reflectRfi(uint256 rRfi, uint256 tRfi) private {
}
function _takeLiquidity(uint256 rLiquidity, uint256 tLiquidity) private {
}
function _takeMarketing(uint256 rMarketing, uint256 tMarketing) private {
}
function _takeOperation(uint256 rOperation, uint256 tOperation) private {
}
function _takeDev(uint256 rDev, uint256 tDev) private {
}
function _getValues(
uint256 tAmount,
bool takeFee,
bool isSell,
bool useLaunchTax
) private view returns (valuesFromGetValues memory to_return) {
}
function _getTValues(
uint256 tAmount,
bool takeFee,
bool isSell,
bool useLaunchTax
) private view returns (valuesFromGetValues memory s) {
}
function _getRValues1(
valuesFromGetValues memory s,
uint256 tAmount,
bool takeFee,
uint256 currentRate
)
private
pure
returns (
uint256 rAmount,
uint256 rTransferAmount,
uint256 rRfi,
uint256 rMarketing,
uint256 rLiquidity
)
{
}
function _getRValues2(
valuesFromGetValues memory s,
bool takeFee,
uint256 currentRate
)
private
pure
returns (
uint256 rOperation,
uint256 rDev
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(
address sender,
address recipient,
uint256 tAmount,
bool takeFee,
bool isSell
) private {
}
function swapAndLiquify(uint256 contractBalance, Taxes memory temp) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function bulkExcludeFee(address[] memory accounts, bool state) external onlyOwner {
}
function updateMarketingWallet(address newWallet) external onlyOwner {
}
function updateOperationWallet(address newWallet) external onlyOwner {
}
function updateDevWallet(address newWallet) external onlyOwner {
}
function updateCooldown(bool state, uint256 time) external onlyOwner {
}
function updateSwapTokensAtAmount(uint256 amount) external onlyOwner {
}
function updateSwapEnabled(bool _enabled) external onlyOwner {
}
function updateIsBlacklisted(address account, bool state) external onlyOwner {
}
function bulkIsBlacklisted(address[] memory accounts, bool state) external onlyOwner {
}
function updateAllowedTransfer(address account, bool state) external onlyOwner {
}
function bulkupdateAllowedTransfer(address[] memory accounts, bool state) external onlyOwner {
}
function updateMaxBuyTxLimit(uint256 maxBuy) external onlyOwner {
}
function updateMaxSellTxLimit(uint256 maxSell) external onlyOwner {
}
function updateMaxWalletlimit(uint256 amount) external onlyOwner {
}
function updateRouterAndPair(address newRouter, address newPair) external onlyOwner {
}
//Use this in case ETH are sent to the contract by mistake
function rescueETH(uint256 weiAmount) external onlyOwner {
}
function rescueAnyBEP20Tokens(
address _tokenAddr,
address _to,
uint256 _amount
) public onlyOwner {
}
receive() external payable {}
}
| (_rfi+_marketing+_liquidity+_operation+_dev)<=25,"Must keep fees at 25% or less" | 477,794 | (_rfi+_marketing+_liquidity+_operation+_dev)<=25 |
"ACCESS_FORBIDDEN" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract DUELStakingV1 {
struct Stake {
uint256 amount;
uint256 startTime;
uint32 durationDays;
bytes32 lastClaimedCheckpoint;
}
mapping(address => Stake[]) public walletStakes;
}
contract DUELStaking is Ownable {
address public duelToken;
DUELStakingV1 public stakesV1;
mapping(address => bool) public v1transferred;
struct Stake {
uint256 amount;
uint256 startTime;
uint32 durationDays;
bytes32 lastClaimedCheckpoint;
}
mapping(address => Stake[]) public walletStakes;
address[] public allStakers;
uint256 public allStakersLength;
mapping(address => bytes32) public lastClaimedCheckpoint;
bytes32 public currentCheckpoint;
event Staked(address indexed wallet, uint256 amount, uint32 periodDays);
event Unstaked(address indexed wallet, Stake stakeInfo);
constructor(address _duelToken) Ownable(msg.sender) {
}
function setDuelToken(address newContract) external onlyOwner {
}
function setStakesV1(DUELStakingV1 newContract) external onlyOwner {
}
function batchV1Transition(address[] memory wallets) external onlyOwner {
}
function updateStakeCheckpoint(bytes32 newCheckpoint) external onlyOwner {
}
function singleV1Transition(address wallet) public {
}
function stakeDUEL(uint256 amount, uint32 periodDays) external {
}
function stakeFor(
address wallet,
uint256 amount,
uint32 periodDays
) public {
require(<FILL_ME>)
if (!v1transferred[wallet] && getStakesLength(_msgSender()) > 0) {
singleV1Transition(wallet);
}
IERC20(duelToken).transferFrom(owner(), address(this), amount);
Stake memory newStake = Stake({
amount: amount,
startTime: block.timestamp,
durationDays: periodDays,
lastClaimedCheckpoint: ""
});
walletStakes[wallet].push(newStake);
allStakers.push(wallet);
allStakersLength++;
emit Staked(wallet, amount, periodDays);
}
function updateStake(
address wallet,
uint256 index,
uint256 _newAmount,
uint256 _newStartTime,
uint32 _newDurationDays,
bytes32 _newLastClaimed
) external onlyOwner {
}
function getStakesLength(address wallet) public view returns (uint256) {
}
function claimStake(
uint16 index,
uint256 amount,
bytes32[] calldata merkleProof
) external {
}
function getStake(
address wallet,
uint8 index
) external view returns (uint256, uint256, uint32, bytes32) {
}
function unstake(uint16 index) external {
}
function withdrawDUEL(uint256 amount) external onlyOwner {
}
}
| _msgSender()==duelToken||_msgSender()==owner(),"ACCESS_FORBIDDEN" | 478,049 | _msgSender()==duelToken||_msgSender()==owner() |
"INCORRECT_PROOF" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract DUELStakingV1 {
struct Stake {
uint256 amount;
uint256 startTime;
uint32 durationDays;
bytes32 lastClaimedCheckpoint;
}
mapping(address => Stake[]) public walletStakes;
}
contract DUELStaking is Ownable {
address public duelToken;
DUELStakingV1 public stakesV1;
mapping(address => bool) public v1transferred;
struct Stake {
uint256 amount;
uint256 startTime;
uint32 durationDays;
bytes32 lastClaimedCheckpoint;
}
mapping(address => Stake[]) public walletStakes;
address[] public allStakers;
uint256 public allStakersLength;
mapping(address => bytes32) public lastClaimedCheckpoint;
bytes32 public currentCheckpoint;
event Staked(address indexed wallet, uint256 amount, uint32 periodDays);
event Unstaked(address indexed wallet, Stake stakeInfo);
constructor(address _duelToken) Ownable(msg.sender) {
}
function setDuelToken(address newContract) external onlyOwner {
}
function setStakesV1(DUELStakingV1 newContract) external onlyOwner {
}
function batchV1Transition(address[] memory wallets) external onlyOwner {
}
function updateStakeCheckpoint(bytes32 newCheckpoint) external onlyOwner {
}
function singleV1Transition(address wallet) public {
}
function stakeDUEL(uint256 amount, uint32 periodDays) external {
}
function stakeFor(
address wallet,
uint256 amount,
uint32 periodDays
) public {
}
function updateStake(
address wallet,
uint256 index,
uint256 _newAmount,
uint256 _newStartTime,
uint32 _newDurationDays,
bytes32 _newLastClaimed
) external onlyOwner {
}
function getStakesLength(address wallet) public view returns (uint256) {
}
function claimStake(
uint16 index,
uint256 amount,
bytes32[] calldata merkleProof
) external {
if (!v1transferred[_msgSender()] && getStakesLength(_msgSender()) > 0) {
singleV1Transition(_msgSender());
}
Stake memory stakeInfo = walletStakes[_msgSender()][index];
require(stakeInfo.amount > 0, "STAKE_INACTIVE");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender, amount));
require(<FILL_ME>)
require(
lastClaimedCheckpoint[_msgSender()] != currentCheckpoint,
"STAKE_CLAIMED"
);
lastClaimedCheckpoint[_msgSender()] = currentCheckpoint;
IERC20(duelToken).transferFrom(owner(), _msgSender(), amount);
}
function getStake(
address wallet,
uint8 index
) external view returns (uint256, uint256, uint32, bytes32) {
}
function unstake(uint16 index) external {
}
function withdrawDUEL(uint256 amount) external onlyOwner {
}
}
| MerkleProof.verify(merkleProof,currentCheckpoint,leaf),"INCORRECT_PROOF" | 478,049 | MerkleProof.verify(merkleProof,currentCheckpoint,leaf) |
"STAKE_CLAIMED" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract DUELStakingV1 {
struct Stake {
uint256 amount;
uint256 startTime;
uint32 durationDays;
bytes32 lastClaimedCheckpoint;
}
mapping(address => Stake[]) public walletStakes;
}
contract DUELStaking is Ownable {
address public duelToken;
DUELStakingV1 public stakesV1;
mapping(address => bool) public v1transferred;
struct Stake {
uint256 amount;
uint256 startTime;
uint32 durationDays;
bytes32 lastClaimedCheckpoint;
}
mapping(address => Stake[]) public walletStakes;
address[] public allStakers;
uint256 public allStakersLength;
mapping(address => bytes32) public lastClaimedCheckpoint;
bytes32 public currentCheckpoint;
event Staked(address indexed wallet, uint256 amount, uint32 periodDays);
event Unstaked(address indexed wallet, Stake stakeInfo);
constructor(address _duelToken) Ownable(msg.sender) {
}
function setDuelToken(address newContract) external onlyOwner {
}
function setStakesV1(DUELStakingV1 newContract) external onlyOwner {
}
function batchV1Transition(address[] memory wallets) external onlyOwner {
}
function updateStakeCheckpoint(bytes32 newCheckpoint) external onlyOwner {
}
function singleV1Transition(address wallet) public {
}
function stakeDUEL(uint256 amount, uint32 periodDays) external {
}
function stakeFor(
address wallet,
uint256 amount,
uint32 periodDays
) public {
}
function updateStake(
address wallet,
uint256 index,
uint256 _newAmount,
uint256 _newStartTime,
uint32 _newDurationDays,
bytes32 _newLastClaimed
) external onlyOwner {
}
function getStakesLength(address wallet) public view returns (uint256) {
}
function claimStake(
uint16 index,
uint256 amount,
bytes32[] calldata merkleProof
) external {
if (!v1transferred[_msgSender()] && getStakesLength(_msgSender()) > 0) {
singleV1Transition(_msgSender());
}
Stake memory stakeInfo = walletStakes[_msgSender()][index];
require(stakeInfo.amount > 0, "STAKE_INACTIVE");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender, amount));
require(
MerkleProof.verify(merkleProof, currentCheckpoint, leaf),
"INCORRECT_PROOF"
);
require(<FILL_ME>)
lastClaimedCheckpoint[_msgSender()] = currentCheckpoint;
IERC20(duelToken).transferFrom(owner(), _msgSender(), amount);
}
function getStake(
address wallet,
uint8 index
) external view returns (uint256, uint256, uint32, bytes32) {
}
function unstake(uint16 index) external {
}
function withdrawDUEL(uint256 amount) external onlyOwner {
}
}
| lastClaimedCheckpoint[_msgSender()]!=currentCheckpoint,"STAKE_CLAIMED" | 478,049 | lastClaimedCheckpoint[_msgSender()]!=currentCheckpoint |
"Withdraw failed" | // SPDX-License-Identifier: MIT
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
pragma solidity ^0.8.15;
contract PixyFoxy is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cost = 0.0099 ether;
uint256 public maxSupply = 999;
uint256 public maxMintAmount = 2;
uint256 public maxPerTxn = 2;
bool public mintOpen = true;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
string memory _metadataUri,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setMintState(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
uint256 contractBalance = address(this).balance;
(bool hs, ) = payable(owner()).call{
value: (contractBalance * 34) / 100
}("");
(bool os, ) = payable(0xFB1bF1A535916D152bF1a5314B26C7A7aabe5524).call{
value: (contractBalance * 33) / 100
}("");
(bool gs, ) = payable(0xFB1bF1A535916D152bF1a5314B26C7A7aabe5524).call{
value: (contractBalance * 33) / 100
}("");
require(<FILL_ME>)
}
function numberMinted(address owner) public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| hs&&os&&gs,"Withdraw failed" | 478,124 | hs&&os&&gs |
"Whitelist: SwapID already used" | pragma solidity ^0.8.0;
contract Whitelist is Ownable, EIP712 {
bytes32 public constant WHITELIST_TYPEHASH =
keccak256("Whitelist(bytes32 amountIn,bytes32 amountOut,address tokenIn,address tokenOut,bytes32 totalAmountInEth,bytes32 totalAmountOutEth,bytes32 swapId,uint256 timeout,address sender)");
address public whitelistSigner;
mapping(bytes32 => bool) public usedHashes;
mapping(address => mapping(bytes32 => bool)) public usedSwapIds;
modifier isSenderWhitelisted(
bytes32 amountIn,
bytes32 amountOut,
address tokenIn,
address tokenOut,
bytes32 totalAmountInEth,
bytes32 totalAmountOutEth,
bytes32 swapId,
uint256 timeout,
address sender,
bytes memory _signature
) {
bytes32 hash = getHash(amountIn, amountOut, tokenIn, tokenOut, totalAmountInEth, totalAmountOutEth, swapId, timeout, sender);
require(!usedHashes[hash], "Whitelist: signature reused");
usedHashes[hash] = true;
require(<FILL_ME>)
usedSwapIds[sender][swapId] = true;
require(getSigner(hash, _signature) == whitelistSigner, "Whitelist: Invalid signature");
_;
}
constructor(string memory name, string memory version)
EIP712(name, version)
{}
function setWhitelistSigner(address _address) external onlyOwner {
}
function getSigner(
bytes32 hash,
bytes memory _signature
) public pure returns (address) {
}
function getHash(
bytes32 amountIn,
bytes32 amountOut,
address tokenIn,
address tokenOut,
bytes32 totalAmountInEth,
bytes32 totalAmountOutEth,
bytes32 swapId,
uint256 timeout,
address sender
) public view returns (bytes32) {
}
}
| !usedSwapIds[sender][swapId],"Whitelist: SwapID already used" | 478,614 | !usedSwapIds[sender][swapId] |
"Whitelist: Invalid signature" | pragma solidity ^0.8.0;
contract Whitelist is Ownable, EIP712 {
bytes32 public constant WHITELIST_TYPEHASH =
keccak256("Whitelist(bytes32 amountIn,bytes32 amountOut,address tokenIn,address tokenOut,bytes32 totalAmountInEth,bytes32 totalAmountOutEth,bytes32 swapId,uint256 timeout,address sender)");
address public whitelistSigner;
mapping(bytes32 => bool) public usedHashes;
mapping(address => mapping(bytes32 => bool)) public usedSwapIds;
modifier isSenderWhitelisted(
bytes32 amountIn,
bytes32 amountOut,
address tokenIn,
address tokenOut,
bytes32 totalAmountInEth,
bytes32 totalAmountOutEth,
bytes32 swapId,
uint256 timeout,
address sender,
bytes memory _signature
) {
bytes32 hash = getHash(amountIn, amountOut, tokenIn, tokenOut, totalAmountInEth, totalAmountOutEth, swapId, timeout, sender);
require(!usedHashes[hash], "Whitelist: signature reused");
usedHashes[hash] = true;
require(!usedSwapIds[sender][swapId], "Whitelist: SwapID already used");
usedSwapIds[sender][swapId] = true;
require(<FILL_ME>)
_;
}
constructor(string memory name, string memory version)
EIP712(name, version)
{}
function setWhitelistSigner(address _address) external onlyOwner {
}
function getSigner(
bytes32 hash,
bytes memory _signature
) public pure returns (address) {
}
function getHash(
bytes32 amountIn,
bytes32 amountOut,
address tokenIn,
address tokenOut,
bytes32 totalAmountInEth,
bytes32 totalAmountOutEth,
bytes32 swapId,
uint256 timeout,
address sender
) public view returns (bytes32) {
}
}
| getSigner(hash,_signature)==whitelistSigner,"Whitelist: Invalid signature" | 478,614 | getSigner(hash,_signature)==whitelistSigner |
"You don't own this token" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
contract WCADAOLocking is Ownable, ERC721Holder {
IWCATokensAggregator public WCATokensAggregator;
IWWCA public WWCA;
IERC20 public WCAToken;
IERC721Enumerable public WCANFT;
IERC721Enumerable public WCAMUNDIAL;
IERC721Enumerable public WCAVIP;
string public constant version = "0.2";
enum Collection {
WCA,
MUNDIAL,
VIP
}
struct NFT {
Collection collection;
uint256 id;
uint256 stakedTimestamp;
uint256 unstakedTimestamp;
}
struct Tokens {
uint256 amount;
uint256 stakedTimestamp;
uint256 unstakedTimestamp;
}
struct FeeConstraint {
uint256 day;
uint256 percentage;
}
mapping(address => NFT[]) public stakerToNFTs;
mapping(address => Tokens[]) public stakerToTokens;
// Amount of tokens locked and their origin
mapping(address => uint256) public stakerToLockedTokensFromStaking;
mapping(address => uint256) public stakerToLockedTokensFromWallet;
address[] public stakers;
// [[90, 30], [180, 20], [270, 10], [360, 5]]
FeeConstraint[] public feeConstraints;
constructor() {}
function setContracts(
address _WCATokensAggregator,
address _WCAToken,
address _WCANFT,
address _WCAMUNDIAL,
address _WCAVIP,
address _WWCA
) external onlyOwner {
}
function setFees(FeeConstraint[] calldata _feeConstraints) external onlyOwner {
}
function getFees() external view returns(FeeConstraint[] memory){
}
function getLockedNFTs(address _address) external view returns (NFT[] memory) {
}
function getLockedTokens(address _address) external view returns (Tokens[] memory) {
}
function getLockedTokensFromStaking(address _address) external view returns (uint256) {
}
function getLockedTokensFromWallet(address _address) external view returns (uint256) {
}
function getStakers() external view returns (address[] memory) {
}
function lock(NFT[] calldata nfts, uint256 tokensAmount) external {
// NFTS
for (uint256 i = 0; i < nfts.length; i++) {
// Get collection ERC721
IERC721 nftCollection;
if (nfts[i].collection == Collection.WCA) {
nftCollection = WCANFT;
} else if (nfts[i].collection == Collection.MUNDIAL) {
nftCollection = WCAMUNDIAL;
} else if (nfts[i].collection == Collection.VIP) {
nftCollection = WCAVIP;
}
NFT memory nft = nfts[i];
nft.stakedTimestamp = block.timestamp;
nft.unstakedTimestamp = 0;
// Check if nfts are ok
require(<FILL_ME>)
// Transfer and store NFTs
nftCollection.transferFrom(msg.sender, address(this), nft.id);
stakerToNFTs[msg.sender].push(nft);
}
// TOKENS
if (tokensAmount > 0) {
require(WCATokensAggregator.balanceOf(msg.sender) >= tokensAmount, "You haven't enough $WCA");
// If has already locked tokens in other contracts use them
uint256 availableToLockBalance = 0;
if (WCATokensAggregator.stakedBalanceOf(msg.sender) > stakerToLockedTokensFromStaking[msg.sender]) {
availableToLockBalance = WCATokensAggregator.stakedBalanceOf(msg.sender) - stakerToLockedTokensFromStaking[msg.sender];
}
if (availableToLockBalance >= tokensAmount) {
stakerToLockedTokensFromStaking[msg.sender] += tokensAmount;
Tokens memory tokens = Tokens(tokensAmount, block.timestamp, 0);
stakerToTokens[msg.sender].push(tokens);
} else {
uint256 tokenFromWallet = tokensAmount - availableToLockBalance;
WCAToken.transferFrom(msg.sender, address(this), tokenFromWallet);
stakerToLockedTokensFromStaking[msg.sender] += availableToLockBalance;
stakerToLockedTokensFromWallet[msg.sender] += tokenFromWallet;
Tokens memory tokens = Tokens(tokensAmount, block.timestamp, 0);
stakerToTokens[msg.sender].push(tokens);
}
}
// Add staker to array
if (nfts.length > 0 || tokensAmount > 0) {
stakers.push(msg.sender);
// Update WWCA
WWCA.updateWWCAByAddress(msg.sender);
}
}
function unlock() external {
}
function estimateFeesToUnlock(address _address) external view returns (uint256) {
}
// Withdraw NFTs
function panicWithdrawNFTs() external onlyOwner {
}
// Withdraw Tokens
function panicWithdrawTokens() external onlyOwner {
}
function removeAddressFromArray(address[] storage array, address _address) internal {
}
}
interface IWWCA {
struct WWCAAmount {
uint256 wwcaToken;
uint256 wwcaNFT;
uint256 wwcaBonus;
}
function WWCAOfAddress(address _address) external view returns (WWCAAmount memory);
function updateWWCAByAddress(address _address) external;
}
interface IWCATokensAggregator {
function balanceOf(address _address) external view returns (uint256);
function stakedBalanceOf(address _address) external view returns (uint256);
}
| nftCollection.ownerOf(nft.id)==msg.sender,"You don't own this token" | 478,874 | nftCollection.ownerOf(nft.id)==msg.sender |
"You haven't enough $WCA" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
contract WCADAOLocking is Ownable, ERC721Holder {
IWCATokensAggregator public WCATokensAggregator;
IWWCA public WWCA;
IERC20 public WCAToken;
IERC721Enumerable public WCANFT;
IERC721Enumerable public WCAMUNDIAL;
IERC721Enumerable public WCAVIP;
string public constant version = "0.2";
enum Collection {
WCA,
MUNDIAL,
VIP
}
struct NFT {
Collection collection;
uint256 id;
uint256 stakedTimestamp;
uint256 unstakedTimestamp;
}
struct Tokens {
uint256 amount;
uint256 stakedTimestamp;
uint256 unstakedTimestamp;
}
struct FeeConstraint {
uint256 day;
uint256 percentage;
}
mapping(address => NFT[]) public stakerToNFTs;
mapping(address => Tokens[]) public stakerToTokens;
// Amount of tokens locked and their origin
mapping(address => uint256) public stakerToLockedTokensFromStaking;
mapping(address => uint256) public stakerToLockedTokensFromWallet;
address[] public stakers;
// [[90, 30], [180, 20], [270, 10], [360, 5]]
FeeConstraint[] public feeConstraints;
constructor() {}
function setContracts(
address _WCATokensAggregator,
address _WCAToken,
address _WCANFT,
address _WCAMUNDIAL,
address _WCAVIP,
address _WWCA
) external onlyOwner {
}
function setFees(FeeConstraint[] calldata _feeConstraints) external onlyOwner {
}
function getFees() external view returns(FeeConstraint[] memory){
}
function getLockedNFTs(address _address) external view returns (NFT[] memory) {
}
function getLockedTokens(address _address) external view returns (Tokens[] memory) {
}
function getLockedTokensFromStaking(address _address) external view returns (uint256) {
}
function getLockedTokensFromWallet(address _address) external view returns (uint256) {
}
function getStakers() external view returns (address[] memory) {
}
function lock(NFT[] calldata nfts, uint256 tokensAmount) external {
// NFTS
for (uint256 i = 0; i < nfts.length; i++) {
// Get collection ERC721
IERC721 nftCollection;
if (nfts[i].collection == Collection.WCA) {
nftCollection = WCANFT;
} else if (nfts[i].collection == Collection.MUNDIAL) {
nftCollection = WCAMUNDIAL;
} else if (nfts[i].collection == Collection.VIP) {
nftCollection = WCAVIP;
}
NFT memory nft = nfts[i];
nft.stakedTimestamp = block.timestamp;
nft.unstakedTimestamp = 0;
// Check if nfts are ok
require(nftCollection.ownerOf(nft.id) == msg.sender, "You don't own this token");
// Transfer and store NFTs
nftCollection.transferFrom(msg.sender, address(this), nft.id);
stakerToNFTs[msg.sender].push(nft);
}
// TOKENS
if (tokensAmount > 0) {
require(<FILL_ME>)
// If has already locked tokens in other contracts use them
uint256 availableToLockBalance = 0;
if (WCATokensAggregator.stakedBalanceOf(msg.sender) > stakerToLockedTokensFromStaking[msg.sender]) {
availableToLockBalance = WCATokensAggregator.stakedBalanceOf(msg.sender) - stakerToLockedTokensFromStaking[msg.sender];
}
if (availableToLockBalance >= tokensAmount) {
stakerToLockedTokensFromStaking[msg.sender] += tokensAmount;
Tokens memory tokens = Tokens(tokensAmount, block.timestamp, 0);
stakerToTokens[msg.sender].push(tokens);
} else {
uint256 tokenFromWallet = tokensAmount - availableToLockBalance;
WCAToken.transferFrom(msg.sender, address(this), tokenFromWallet);
stakerToLockedTokensFromStaking[msg.sender] += availableToLockBalance;
stakerToLockedTokensFromWallet[msg.sender] += tokenFromWallet;
Tokens memory tokens = Tokens(tokensAmount, block.timestamp, 0);
stakerToTokens[msg.sender].push(tokens);
}
}
// Add staker to array
if (nfts.length > 0 || tokensAmount > 0) {
stakers.push(msg.sender);
// Update WWCA
WWCA.updateWWCAByAddress(msg.sender);
}
}
function unlock() external {
}
function estimateFeesToUnlock(address _address) external view returns (uint256) {
}
// Withdraw NFTs
function panicWithdrawNFTs() external onlyOwner {
}
// Withdraw Tokens
function panicWithdrawTokens() external onlyOwner {
}
function removeAddressFromArray(address[] storage array, address _address) internal {
}
}
interface IWWCA {
struct WWCAAmount {
uint256 wwcaToken;
uint256 wwcaNFT;
uint256 wwcaBonus;
}
function WWCAOfAddress(address _address) external view returns (WWCAAmount memory);
function updateWWCAByAddress(address _address) external;
}
interface IWCATokensAggregator {
function balanceOf(address _address) external view returns (uint256);
function stakedBalanceOf(address _address) external view returns (uint256);
}
| WCATokensAggregator.balanceOf(msg.sender)>=tokensAmount,"You haven't enough $WCA" | 478,874 | WCATokensAggregator.balanceOf(msg.sender)>=tokensAmount |
"You are not on the allowlist" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import {IERC721A, ERC721A} from "erc721a/ERC721A.sol";
import {ERC721AQueryable} from "erc721a/extensions/ERC721AQueryable.sol";
import {ERC721ABurnable} from "erc721a/extensions/ERC721ABurnable.sol";
import {OperatorFilterer} from "../OperatorFilterer.sol";
import {Ownable} from "openzeppelin-contracts/access/Ownable.sol";
import {IERC2981, ERC2981} from "openzeppelin-contracts/token/common/ERC2981.sol";
import {MerkleProof} from "openzeppelin-contracts/utils/cryptography/MerkleProof.sol";
contract Turds is
ERC721AQueryable,
ERC721ABurnable,
OperatorFilterer,
Ownable,
ERC2981
{
bool public operatorFilteringEnabled;
string private _uri;
bytes32 public merkleRoot;
mapping(address => bool) public allowListMinted;
uint256 public constant MAX_SUPPLY = 5555;
uint256 public price = 0.004 ether;
// 0x5357b61a7caeec6120ce84392fc265b5fe114b80d802324df06c93ca8509bcfc
constructor(bytes32 _merkleRoot) ERC721A("Turds", "TURD") {
}
function updatePrice(uint256 newPrice) external onlyOwner {
}
function updateRoyalty(address receiver, uint96 feeNumerator) external onlyOwner {
}
function updateMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
// Check the Merkle proof using this function
function allowListed(address _wallet, bytes32[] calldata _proof)
public
view
returns (bool)
{
}
function mintAllowList(bytes32[] calldata _proof) external {
require(<FILL_ME>)
require(totalSupply() < MAX_SUPPLY, "All tokens have been minted");
require(!allowListMinted[msg.sender], "You already minted your token");
allowListMinted[msg.sender] = true;
_mint(msg.sender, 1);
}
function mint(uint256 amount) external payable {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setApprovalForAll(address operator, bool approved)
public
override(IERC721A, ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override(IERC721A, ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
/**
* @dev Both safeTransferFrom functions in ERC721A call this function
* so we don't need to override them.
*/
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override(IERC721A, ERC721A)
onlyAllowedOperator(from)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC721A, ERC721A, ERC2981)
returns (bool)
{
}
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner {
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view override returns (bool) {
}
function _isPriorityOperator(address operator) internal pure override returns (bool) {
}
}
| allowListed(msg.sender,_proof),"You are not on the allowlist" | 479,023 | allowListed(msg.sender,_proof) |
"You already minted your token" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import {IERC721A, ERC721A} from "erc721a/ERC721A.sol";
import {ERC721AQueryable} from "erc721a/extensions/ERC721AQueryable.sol";
import {ERC721ABurnable} from "erc721a/extensions/ERC721ABurnable.sol";
import {OperatorFilterer} from "../OperatorFilterer.sol";
import {Ownable} from "openzeppelin-contracts/access/Ownable.sol";
import {IERC2981, ERC2981} from "openzeppelin-contracts/token/common/ERC2981.sol";
import {MerkleProof} from "openzeppelin-contracts/utils/cryptography/MerkleProof.sol";
contract Turds is
ERC721AQueryable,
ERC721ABurnable,
OperatorFilterer,
Ownable,
ERC2981
{
bool public operatorFilteringEnabled;
string private _uri;
bytes32 public merkleRoot;
mapping(address => bool) public allowListMinted;
uint256 public constant MAX_SUPPLY = 5555;
uint256 public price = 0.004 ether;
// 0x5357b61a7caeec6120ce84392fc265b5fe114b80d802324df06c93ca8509bcfc
constructor(bytes32 _merkleRoot) ERC721A("Turds", "TURD") {
}
function updatePrice(uint256 newPrice) external onlyOwner {
}
function updateRoyalty(address receiver, uint96 feeNumerator) external onlyOwner {
}
function updateMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
// Check the Merkle proof using this function
function allowListed(address _wallet, bytes32[] calldata _proof)
public
view
returns (bool)
{
}
function mintAllowList(bytes32[] calldata _proof) external {
require(allowListed(msg.sender, _proof), "You are not on the allowlist");
require(totalSupply() < MAX_SUPPLY, "All tokens have been minted");
require(<FILL_ME>)
allowListMinted[msg.sender] = true;
_mint(msg.sender, 1);
}
function mint(uint256 amount) external payable {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setApprovalForAll(address operator, bool approved)
public
override(IERC721A, ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override(IERC721A, ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
/**
* @dev Both safeTransferFrom functions in ERC721A call this function
* so we don't need to override them.
*/
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override(IERC721A, ERC721A)
onlyAllowedOperator(from)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC721A, ERC721A, ERC2981)
returns (bool)
{
}
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner {
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view override returns (bool) {
}
function _isPriorityOperator(address operator) internal pure override returns (bool) {
}
}
| !allowListMinted[msg.sender],"You already minted your token" | 479,023 | !allowListMinted[msg.sender] |
"CancyChain: Maximum mint allowed cant exceed the total supply" | /**
* ,--, .--. .-. .-. ,'|"\.-. .-. ,--, .-. .-. .--. ,-..-. .-.
* .' .') / /\ \ | \| | | |\ \\ \_/ )/ .' .') | | | | / /\ \ |(|| \| |
* | |(_) / /__\ \| | | | | \ \\ (_) | |(_) | `-' |/ /__\ \(_)| | |
* \ \ | __ || |\ | | | \ \) ( \ \ | .-. || __ || || |\ |
* \ `-. | | |)|| | |)| /(|`-' /| | \ `-. | | |)|| | |)|| || | |)|
* \____\|_| (_)/( (_)(__)`--'/(_| \____\/( (_)|_| (_)`-'/( (_)
* (__) (__) (__) (__)
*
* Website: https://candychain.com
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
contract WrappedCandyChain {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
address public owner;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 public totalSupply;
string public name;
string public symbol;
uint8 public decimals;
uint256 public MaxSupply;
uint256 private _totalSupply;
constructor (string memory _name, string memory _symbol, uint8 _decimals, address _owner, uint _initialMint) {
}
modifier onlyOwner() {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function allowance(address account, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function mint(uint256 amount) public onlyOwner returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _mint(address account, uint256 amount) internal {
require(<FILL_ME>)
require(account != address(0), "CancyChain: mint to the zero address");
uint c = totalSupply + amount;
require(c >= amount, "CancyChain: addition overflow");
totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
}
function _approve(address account, address spender, uint256 amount) internal {
}
function mintTo(address account, uint256 amount) external onlyOwner {
}
function burnFrom(address account, uint256 amount) external onlyOwner {
}
}
| totalSupply+amount<=MaxSupply,"CancyChain: Maximum mint allowed cant exceed the total supply" | 479,225 | totalSupply+amount<=MaxSupply |
"oos" | // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/ERC721.sol)
pragma solidity ^0.8.0;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension, but not including the Enumerable extension, which is available separately as
* {ERC721Enumerable}.
*/
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overridden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits an {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits an {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
pragma solidity ^0.8.0;
contract upsidedowngoblintowN is ERC721A, Ownable {
using Strings for uint256;
string private baseURI;
uint256 public price = 0.0035 ether;
uint256 public maxPerTx = 20;
uint256 public totalFree = 2000;
uint256 public maxSupply = 5000;
bool public mintEnabled = false;
mapping(address => bool) mintedFree;
constructor() ERC721A("upsidedowngoblintowN", "upsidedowngoblintowN") {
}
function mint(uint256 count) external payable {
uint256 cost = price;
uint256 ts = totalSupply();
bool isFree = (ts + count <= totalFree);
if (isFree) {
cost = 0;
}
require(msg.value >= count * cost, "exact eth is required");
require(<FILL_ME>)
require(mintEnabled, "no");
require(count <= maxPerTx , "too many");
_safeMint(msg.sender, count);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setBaseURI(string memory _uri) public onlyOwner {
}
function setFreeAmount(uint256 _amount) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function flipSale() external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| ts+count<=maxSupply,"oos" | 479,339 | ts+count<=maxSupply |
null | // SPDX-License-Identifier: MIT
// Creator: Ctor Lab (https://ctor.xyz)
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "solady/src/utils/LibBitmap.sol";
import "./IERC1155Delta.sol";
contract ERC1155Delta is Context, ERC165, IERC1155, IERC1155MetadataURI, IERC1155Delta {
using Address for address;
using LibBitmap for LibBitmap.Bitmap;
// Mapping from accout to owned tokens
mapping(address => LibBitmap.Bitmap) internal _owned;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
string private _uri;
// The next token ID to be minted.
uint256 private _currentIndex;
/**
* @dev See {_setURI}.
*/
constructor(string memory uri_) {
}
/**
* @dev Returns the starting token ID.
* To change the starting token ID, please override this function.
*/
function _startTokenId() internal pure virtual returns (uint256) {
}
/**
* @dev Returns the next token ID to be minted.
*/
function _nextTokenId() internal view returns (uint256) {
}
/**
* @dev Returns the total amount of tokens minted in the contract.
*/
function _totalMinted() internal view returns (uint256) {
}
/**
* @dev Returns true if the account owns the `id` token.
*/
function isOwnerOf(address account, uint256 id) public view virtual override returns(bool) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC1155MetadataURI-uri}.
*
* This implementation returns the same URI for *all* token types. It relies
* on the token type ID substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* Clients calling this function must replace the `\{id\}` substring with the
* actual token type ID.
*/
function uri(uint256) public view virtual override returns (string memory) {
}
/**
* @dev See {IERC1155-balanceOf}.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC1155-balanceOfBatch}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
}
/**
* @dev See {IERC1155-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC1155-isApprovedForAll}.
*/
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC1155-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
}
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `amount` cannot be zero.
* - `from` must have a balance of tokens of type `id` of at least `amount`.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
/**
* @dev Sets a new URI for all token types, by relying on the token type ID
* substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* By this mechanism, any occurrence of the `\{id\}` substring in either the
* URI or any of the amounts in the JSON file at said URI will be replaced by
* clients with the token type ID.
*
* For example, the `https://token-cdn-domain/\{id\}.json` URI would be
* interpreted by clients as
* `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
* for token type ID 0x4cce0.
*
* See {uri}.
*
* Because these URIs cannot be meaningfully represented by the {URI} event,
* this function emits no events.
*/
function _setURI(string memory newuri) internal virtual {
}
function _mint(
address to,
uint256 amount
) internal virtual {
}
/**
* @dev Creates `amount` tokens, and assigns them to `to`.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `amount` cannot be zero.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mint(
address to,
uint256 amount,
bytes memory data
) internal virtual {
}
function _mintWithoutCheck(
address to,
uint256 amount
) internal virtual returns(uint256[] memory ids, uint256[] memory amounts) {
if(to == address(0)) {
revert MintToZeroAddress();
}
if(amount == 0) {
revert MintZeroQuantity();
}
address operator = _msgSender();
ids = new uint256[](amount);
amounts = new uint256[](amount);
uint256 startTokenId = _nextTokenId();
unchecked {
require(<FILL_ME>)
for(uint256 i = 0; i < amount; i++) {
ids[i] = startTokenId + i;
amounts[i] = 1;
}
}
_beforeTokenTransfer(operator, address(0), to, ids);
_owned[to].setBatch(startTokenId, amount);
_currentIndex += amount;
emit TransferBatch(operator, address(0), to, ids, amounts);
_afterTokenTransfer(operator, address(0), to, ids);
}
/**
* @dev Destroys token of token type `id` from `from`
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `from` must have the token of token type `id`.
*/
function _burn(
address from,
uint256 id
) internal virtual {
}
/**
* @dev Destroys tokens of token types in `ids` from `from`
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `from` must have the token of token types in `ids`.
*/
function _burnBatch(
address from,
uint256[] memory ids
) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits an {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `ids` and `amounts` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids
) internal virtual {}
/**
* @dev Hook that is called after any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory array) {
}
}
| type(uint256).max-amount>=startTokenId | 479,413 | type(uint256).max-amount>=startTokenId |
"PROOF_INVALID" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721AV4.sol";
import "./DefaultOperatorFilterer.sol";
contract NoodiLandPlayables is ERC721A, DefaultOperatorFilterer, Ownable, ReentrancyGuard {
uint256 public MAX_SUPPLY = 2222;
uint256 public ONE_SUPPLY = 444;
uint256 public TWO_SUPPLY = 1757;
uint256 public PUBLIC_SUPPLY = 1;
bool public IS_ONE_ACTIVE = false;
bool public IS_TWO_ACTIVE = false;
bool public IS_PUBLIC_ACTIVE = false;
uint256 public ONE_TX_LIMIT = 2;
uint256 public TWO_TX_LIMIT = 2;
uint256 public PUBLIC_TX_LIMIT = 4;
uint256 public ONE_WALLET_LIMIT = 2;
uint256 public TWO_WALLET_LIMIT = 2;
uint256 public PUBLIC_WALLET_LIMIT = 4;
uint256 public ONE_PRICE = 0.009 ether;
uint256 public TWO_PRICE = 0.009 ether;
uint256 public PUBLIC_PRICE = 0.0095 ether;
uint256 public ONE_COUNT = 0;
uint256 public TWO_COUNT = 0;
uint256 public PUBLIC_COUNT = 0;
bytes32 public ONE_ROOT;
bytes32 public TWO_ROOT;
bool public _revealed = false;
string private baseURI = "https://api.w3bmint.xyz/api/tokens/homestead/63c1a720a865fe096782b1cd/";
mapping(address => uint256) addressBlockBought;
address public constant RL_ADDRESS = 0xc9b5553910bA47719e0202fF9F617B8BE06b3A09;
constructor(bytes32 _One, bytes32 _Two) ERC721A("NoodiLandPlayables", "NOODI") {
}
modifier isSecured() {
}
function ONEMint(uint256 numberOfTokens, bytes32[] memory proof) external payable isSecured {
require(IS_ONE_ACTIVE, "ONE_MINT_IS_NOT_YET_ACTIVE");
require(<FILL_ME>)
require(numberOfTokens + totalSupply() <= MAX_SUPPLY, "NOT_ENOUGH_SUPPLY");
require(numberOfTokens + ONE_COUNT <= ONE_SUPPLY, "NOT_ENOUGH_SUPPLY");
require(numberMinted(msg.sender) + numberOfTokens <= ONE_WALLET_LIMIT, "EXCEED__MINT_LIMIT");
require(numberOfTokens <= ONE_TX_LIMIT, "EXCEED_MINT_LIMIT");
require(msg.value == ONE_PRICE * numberOfTokens, "WRONG_ETH_VALUE");
addressBlockBought[msg.sender] = block.timestamp;
ONE_COUNT += numberOfTokens;
_safeMint(msg.sender, numberOfTokens);
}
function TWOMint(uint256 numberOfTokens, bytes32[] memory proof) external payable isSecured {
}
function PUBLICMint(uint256 numberOfTokens) external payable isSecured {
}
// URI
function setBaseURI(string calldata URI) external onlyOwner {
}
function reveal(bool revealed, string calldata _baseURI) external onlyOwner {
}
// LIVE TOGGLES
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
// ROOT SETTERS
function setONERoot(bytes32 _root) external onlyOwner {
}
function setTWORoot(bytes32 _root) external onlyOwner {
}
// TOGGLES
function toggleONEMintStatus() external onlyOwner {
}
function toggleTWOMintStatus() external onlyOwner {
}
function togglePUBLICMintStatus() external onlyOwner {
}
// SUPPLY CHANGERS
function setONESupply(uint256 _supply) external onlyOwner {
}
function setTWOSupply(uint256 _supply) external onlyOwner {
}
function setPUBLICSupply(uint256 _supply) external onlyOwner {
}
// PRICE CHANGERS
function setONEPrice(uint256 _price) external onlyOwner {
}
function setTWOPrice(uint256 _price) external onlyOwner {
}
function setPUBLICPrice(uint256 _price) external onlyOwner {
}
// MAX SUPPLY
function updateMaxSupply(uint256 _maxSupply) external onlyOwner {
}
// withdraw
function withdraw() external onlyOwner {
}
// OPENSEA's royalties functions
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) {
}
}
| MerkleProof.verify(proof,ONE_ROOT,keccak256(abi.encodePacked(msg.sender))),"PROOF_INVALID" | 479,471 | MerkleProof.verify(proof,ONE_ROOT,keccak256(abi.encodePacked(msg.sender))) |
"NOT_ENOUGH_SUPPLY" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721AV4.sol";
import "./DefaultOperatorFilterer.sol";
contract NoodiLandPlayables is ERC721A, DefaultOperatorFilterer, Ownable, ReentrancyGuard {
uint256 public MAX_SUPPLY = 2222;
uint256 public ONE_SUPPLY = 444;
uint256 public TWO_SUPPLY = 1757;
uint256 public PUBLIC_SUPPLY = 1;
bool public IS_ONE_ACTIVE = false;
bool public IS_TWO_ACTIVE = false;
bool public IS_PUBLIC_ACTIVE = false;
uint256 public ONE_TX_LIMIT = 2;
uint256 public TWO_TX_LIMIT = 2;
uint256 public PUBLIC_TX_LIMIT = 4;
uint256 public ONE_WALLET_LIMIT = 2;
uint256 public TWO_WALLET_LIMIT = 2;
uint256 public PUBLIC_WALLET_LIMIT = 4;
uint256 public ONE_PRICE = 0.009 ether;
uint256 public TWO_PRICE = 0.009 ether;
uint256 public PUBLIC_PRICE = 0.0095 ether;
uint256 public ONE_COUNT = 0;
uint256 public TWO_COUNT = 0;
uint256 public PUBLIC_COUNT = 0;
bytes32 public ONE_ROOT;
bytes32 public TWO_ROOT;
bool public _revealed = false;
string private baseURI = "https://api.w3bmint.xyz/api/tokens/homestead/63c1a720a865fe096782b1cd/";
mapping(address => uint256) addressBlockBought;
address public constant RL_ADDRESS = 0xc9b5553910bA47719e0202fF9F617B8BE06b3A09;
constructor(bytes32 _One, bytes32 _Two) ERC721A("NoodiLandPlayables", "NOODI") {
}
modifier isSecured() {
}
function ONEMint(uint256 numberOfTokens, bytes32[] memory proof) external payable isSecured {
require(IS_ONE_ACTIVE, "ONE_MINT_IS_NOT_YET_ACTIVE");
require(MerkleProof.verify(proof, ONE_ROOT, keccak256(abi.encodePacked(msg.sender))), "PROOF_INVALID");
require(numberOfTokens + totalSupply() <= MAX_SUPPLY, "NOT_ENOUGH_SUPPLY");
require(<FILL_ME>)
require(numberMinted(msg.sender) + numberOfTokens <= ONE_WALLET_LIMIT, "EXCEED__MINT_LIMIT");
require(numberOfTokens <= ONE_TX_LIMIT, "EXCEED_MINT_LIMIT");
require(msg.value == ONE_PRICE * numberOfTokens, "WRONG_ETH_VALUE");
addressBlockBought[msg.sender] = block.timestamp;
ONE_COUNT += numberOfTokens;
_safeMint(msg.sender, numberOfTokens);
}
function TWOMint(uint256 numberOfTokens, bytes32[] memory proof) external payable isSecured {
}
function PUBLICMint(uint256 numberOfTokens) external payable isSecured {
}
// URI
function setBaseURI(string calldata URI) external onlyOwner {
}
function reveal(bool revealed, string calldata _baseURI) external onlyOwner {
}
// LIVE TOGGLES
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
// ROOT SETTERS
function setONERoot(bytes32 _root) external onlyOwner {
}
function setTWORoot(bytes32 _root) external onlyOwner {
}
// TOGGLES
function toggleONEMintStatus() external onlyOwner {
}
function toggleTWOMintStatus() external onlyOwner {
}
function togglePUBLICMintStatus() external onlyOwner {
}
// SUPPLY CHANGERS
function setONESupply(uint256 _supply) external onlyOwner {
}
function setTWOSupply(uint256 _supply) external onlyOwner {
}
function setPUBLICSupply(uint256 _supply) external onlyOwner {
}
// PRICE CHANGERS
function setONEPrice(uint256 _price) external onlyOwner {
}
function setTWOPrice(uint256 _price) external onlyOwner {
}
function setPUBLICPrice(uint256 _price) external onlyOwner {
}
// MAX SUPPLY
function updateMaxSupply(uint256 _maxSupply) external onlyOwner {
}
// withdraw
function withdraw() external onlyOwner {
}
// OPENSEA's royalties functions
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) {
}
}
| numberOfTokens+ONE_COUNT<=ONE_SUPPLY,"NOT_ENOUGH_SUPPLY" | 479,471 | numberOfTokens+ONE_COUNT<=ONE_SUPPLY |
"EXCEED__MINT_LIMIT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721AV4.sol";
import "./DefaultOperatorFilterer.sol";
contract NoodiLandPlayables is ERC721A, DefaultOperatorFilterer, Ownable, ReentrancyGuard {
uint256 public MAX_SUPPLY = 2222;
uint256 public ONE_SUPPLY = 444;
uint256 public TWO_SUPPLY = 1757;
uint256 public PUBLIC_SUPPLY = 1;
bool public IS_ONE_ACTIVE = false;
bool public IS_TWO_ACTIVE = false;
bool public IS_PUBLIC_ACTIVE = false;
uint256 public ONE_TX_LIMIT = 2;
uint256 public TWO_TX_LIMIT = 2;
uint256 public PUBLIC_TX_LIMIT = 4;
uint256 public ONE_WALLET_LIMIT = 2;
uint256 public TWO_WALLET_LIMIT = 2;
uint256 public PUBLIC_WALLET_LIMIT = 4;
uint256 public ONE_PRICE = 0.009 ether;
uint256 public TWO_PRICE = 0.009 ether;
uint256 public PUBLIC_PRICE = 0.0095 ether;
uint256 public ONE_COUNT = 0;
uint256 public TWO_COUNT = 0;
uint256 public PUBLIC_COUNT = 0;
bytes32 public ONE_ROOT;
bytes32 public TWO_ROOT;
bool public _revealed = false;
string private baseURI = "https://api.w3bmint.xyz/api/tokens/homestead/63c1a720a865fe096782b1cd/";
mapping(address => uint256) addressBlockBought;
address public constant RL_ADDRESS = 0xc9b5553910bA47719e0202fF9F617B8BE06b3A09;
constructor(bytes32 _One, bytes32 _Two) ERC721A("NoodiLandPlayables", "NOODI") {
}
modifier isSecured() {
}
function ONEMint(uint256 numberOfTokens, bytes32[] memory proof) external payable isSecured {
require(IS_ONE_ACTIVE, "ONE_MINT_IS_NOT_YET_ACTIVE");
require(MerkleProof.verify(proof, ONE_ROOT, keccak256(abi.encodePacked(msg.sender))), "PROOF_INVALID");
require(numberOfTokens + totalSupply() <= MAX_SUPPLY, "NOT_ENOUGH_SUPPLY");
require(numberOfTokens + ONE_COUNT <= ONE_SUPPLY, "NOT_ENOUGH_SUPPLY");
require(<FILL_ME>)
require(numberOfTokens <= ONE_TX_LIMIT, "EXCEED_MINT_LIMIT");
require(msg.value == ONE_PRICE * numberOfTokens, "WRONG_ETH_VALUE");
addressBlockBought[msg.sender] = block.timestamp;
ONE_COUNT += numberOfTokens;
_safeMint(msg.sender, numberOfTokens);
}
function TWOMint(uint256 numberOfTokens, bytes32[] memory proof) external payable isSecured {
}
function PUBLICMint(uint256 numberOfTokens) external payable isSecured {
}
// URI
function setBaseURI(string calldata URI) external onlyOwner {
}
function reveal(bool revealed, string calldata _baseURI) external onlyOwner {
}
// LIVE TOGGLES
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
// ROOT SETTERS
function setONERoot(bytes32 _root) external onlyOwner {
}
function setTWORoot(bytes32 _root) external onlyOwner {
}
// TOGGLES
function toggleONEMintStatus() external onlyOwner {
}
function toggleTWOMintStatus() external onlyOwner {
}
function togglePUBLICMintStatus() external onlyOwner {
}
// SUPPLY CHANGERS
function setONESupply(uint256 _supply) external onlyOwner {
}
function setTWOSupply(uint256 _supply) external onlyOwner {
}
function setPUBLICSupply(uint256 _supply) external onlyOwner {
}
// PRICE CHANGERS
function setONEPrice(uint256 _price) external onlyOwner {
}
function setTWOPrice(uint256 _price) external onlyOwner {
}
function setPUBLICPrice(uint256 _price) external onlyOwner {
}
// MAX SUPPLY
function updateMaxSupply(uint256 _maxSupply) external onlyOwner {
}
// withdraw
function withdraw() external onlyOwner {
}
// OPENSEA's royalties functions
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) {
}
}
| numberMinted(msg.sender)+numberOfTokens<=ONE_WALLET_LIMIT,"EXCEED__MINT_LIMIT" | 479,471 | numberMinted(msg.sender)+numberOfTokens<=ONE_WALLET_LIMIT |
"PROOF_INVALID" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721AV4.sol";
import "./DefaultOperatorFilterer.sol";
contract NoodiLandPlayables is ERC721A, DefaultOperatorFilterer, Ownable, ReentrancyGuard {
uint256 public MAX_SUPPLY = 2222;
uint256 public ONE_SUPPLY = 444;
uint256 public TWO_SUPPLY = 1757;
uint256 public PUBLIC_SUPPLY = 1;
bool public IS_ONE_ACTIVE = false;
bool public IS_TWO_ACTIVE = false;
bool public IS_PUBLIC_ACTIVE = false;
uint256 public ONE_TX_LIMIT = 2;
uint256 public TWO_TX_LIMIT = 2;
uint256 public PUBLIC_TX_LIMIT = 4;
uint256 public ONE_WALLET_LIMIT = 2;
uint256 public TWO_WALLET_LIMIT = 2;
uint256 public PUBLIC_WALLET_LIMIT = 4;
uint256 public ONE_PRICE = 0.009 ether;
uint256 public TWO_PRICE = 0.009 ether;
uint256 public PUBLIC_PRICE = 0.0095 ether;
uint256 public ONE_COUNT = 0;
uint256 public TWO_COUNT = 0;
uint256 public PUBLIC_COUNT = 0;
bytes32 public ONE_ROOT;
bytes32 public TWO_ROOT;
bool public _revealed = false;
string private baseURI = "https://api.w3bmint.xyz/api/tokens/homestead/63c1a720a865fe096782b1cd/";
mapping(address => uint256) addressBlockBought;
address public constant RL_ADDRESS = 0xc9b5553910bA47719e0202fF9F617B8BE06b3A09;
constructor(bytes32 _One, bytes32 _Two) ERC721A("NoodiLandPlayables", "NOODI") {
}
modifier isSecured() {
}
function ONEMint(uint256 numberOfTokens, bytes32[] memory proof) external payable isSecured {
}
function TWOMint(uint256 numberOfTokens, bytes32[] memory proof) external payable isSecured {
require(IS_TWO_ACTIVE, "TWO_MINT_IS_NOT_YET_ACTIVE");
require(<FILL_ME>)
require(numberOfTokens + totalSupply() <= MAX_SUPPLY, "NOT_ENOUGH_SUPPLY");
require(numberOfTokens + TWO_COUNT <= TWO_SUPPLY, "NOT_ENOUGH_SUPPLY");
require(numberMinted(msg.sender) + numberOfTokens <= TWO_WALLET_LIMIT, "EXCEED__MINT_LIMIT");
require(numberOfTokens <= TWO_TX_LIMIT, "EXCEED_MINT_LIMIT");
require(msg.value == TWO_PRICE * numberOfTokens, "WRONG_ETH_VALUE");
addressBlockBought[msg.sender] = block.timestamp;
TWO_COUNT += numberOfTokens;
_safeMint(msg.sender, numberOfTokens);
}
function PUBLICMint(uint256 numberOfTokens) external payable isSecured {
}
// URI
function setBaseURI(string calldata URI) external onlyOwner {
}
function reveal(bool revealed, string calldata _baseURI) external onlyOwner {
}
// LIVE TOGGLES
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
// ROOT SETTERS
function setONERoot(bytes32 _root) external onlyOwner {
}
function setTWORoot(bytes32 _root) external onlyOwner {
}
// TOGGLES
function toggleONEMintStatus() external onlyOwner {
}
function toggleTWOMintStatus() external onlyOwner {
}
function togglePUBLICMintStatus() external onlyOwner {
}
// SUPPLY CHANGERS
function setONESupply(uint256 _supply) external onlyOwner {
}
function setTWOSupply(uint256 _supply) external onlyOwner {
}
function setPUBLICSupply(uint256 _supply) external onlyOwner {
}
// PRICE CHANGERS
function setONEPrice(uint256 _price) external onlyOwner {
}
function setTWOPrice(uint256 _price) external onlyOwner {
}
function setPUBLICPrice(uint256 _price) external onlyOwner {
}
// MAX SUPPLY
function updateMaxSupply(uint256 _maxSupply) external onlyOwner {
}
// withdraw
function withdraw() external onlyOwner {
}
// OPENSEA's royalties functions
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) {
}
}
| MerkleProof.verify(proof,TWO_ROOT,keccak256(abi.encodePacked(msg.sender))),"PROOF_INVALID" | 479,471 | MerkleProof.verify(proof,TWO_ROOT,keccak256(abi.encodePacked(msg.sender))) |
"NOT_ENOUGH_SUPPLY" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721AV4.sol";
import "./DefaultOperatorFilterer.sol";
contract NoodiLandPlayables is ERC721A, DefaultOperatorFilterer, Ownable, ReentrancyGuard {
uint256 public MAX_SUPPLY = 2222;
uint256 public ONE_SUPPLY = 444;
uint256 public TWO_SUPPLY = 1757;
uint256 public PUBLIC_SUPPLY = 1;
bool public IS_ONE_ACTIVE = false;
bool public IS_TWO_ACTIVE = false;
bool public IS_PUBLIC_ACTIVE = false;
uint256 public ONE_TX_LIMIT = 2;
uint256 public TWO_TX_LIMIT = 2;
uint256 public PUBLIC_TX_LIMIT = 4;
uint256 public ONE_WALLET_LIMIT = 2;
uint256 public TWO_WALLET_LIMIT = 2;
uint256 public PUBLIC_WALLET_LIMIT = 4;
uint256 public ONE_PRICE = 0.009 ether;
uint256 public TWO_PRICE = 0.009 ether;
uint256 public PUBLIC_PRICE = 0.0095 ether;
uint256 public ONE_COUNT = 0;
uint256 public TWO_COUNT = 0;
uint256 public PUBLIC_COUNT = 0;
bytes32 public ONE_ROOT;
bytes32 public TWO_ROOT;
bool public _revealed = false;
string private baseURI = "https://api.w3bmint.xyz/api/tokens/homestead/63c1a720a865fe096782b1cd/";
mapping(address => uint256) addressBlockBought;
address public constant RL_ADDRESS = 0xc9b5553910bA47719e0202fF9F617B8BE06b3A09;
constructor(bytes32 _One, bytes32 _Two) ERC721A("NoodiLandPlayables", "NOODI") {
}
modifier isSecured() {
}
function ONEMint(uint256 numberOfTokens, bytes32[] memory proof) external payable isSecured {
}
function TWOMint(uint256 numberOfTokens, bytes32[] memory proof) external payable isSecured {
require(IS_TWO_ACTIVE, "TWO_MINT_IS_NOT_YET_ACTIVE");
require(MerkleProof.verify(proof, TWO_ROOT, keccak256(abi.encodePacked(msg.sender))), "PROOF_INVALID");
require(numberOfTokens + totalSupply() <= MAX_SUPPLY, "NOT_ENOUGH_SUPPLY");
require(<FILL_ME>)
require(numberMinted(msg.sender) + numberOfTokens <= TWO_WALLET_LIMIT, "EXCEED__MINT_LIMIT");
require(numberOfTokens <= TWO_TX_LIMIT, "EXCEED_MINT_LIMIT");
require(msg.value == TWO_PRICE * numberOfTokens, "WRONG_ETH_VALUE");
addressBlockBought[msg.sender] = block.timestamp;
TWO_COUNT += numberOfTokens;
_safeMint(msg.sender, numberOfTokens);
}
function PUBLICMint(uint256 numberOfTokens) external payable isSecured {
}
// URI
function setBaseURI(string calldata URI) external onlyOwner {
}
function reveal(bool revealed, string calldata _baseURI) external onlyOwner {
}
// LIVE TOGGLES
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
// ROOT SETTERS
function setONERoot(bytes32 _root) external onlyOwner {
}
function setTWORoot(bytes32 _root) external onlyOwner {
}
// TOGGLES
function toggleONEMintStatus() external onlyOwner {
}
function toggleTWOMintStatus() external onlyOwner {
}
function togglePUBLICMintStatus() external onlyOwner {
}
// SUPPLY CHANGERS
function setONESupply(uint256 _supply) external onlyOwner {
}
function setTWOSupply(uint256 _supply) external onlyOwner {
}
function setPUBLICSupply(uint256 _supply) external onlyOwner {
}
// PRICE CHANGERS
function setONEPrice(uint256 _price) external onlyOwner {
}
function setTWOPrice(uint256 _price) external onlyOwner {
}
function setPUBLICPrice(uint256 _price) external onlyOwner {
}
// MAX SUPPLY
function updateMaxSupply(uint256 _maxSupply) external onlyOwner {
}
// withdraw
function withdraw() external onlyOwner {
}
// OPENSEA's royalties functions
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) {
}
}
| numberOfTokens+TWO_COUNT<=TWO_SUPPLY,"NOT_ENOUGH_SUPPLY" | 479,471 | numberOfTokens+TWO_COUNT<=TWO_SUPPLY |
"EXCEED__MINT_LIMIT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721AV4.sol";
import "./DefaultOperatorFilterer.sol";
contract NoodiLandPlayables is ERC721A, DefaultOperatorFilterer, Ownable, ReentrancyGuard {
uint256 public MAX_SUPPLY = 2222;
uint256 public ONE_SUPPLY = 444;
uint256 public TWO_SUPPLY = 1757;
uint256 public PUBLIC_SUPPLY = 1;
bool public IS_ONE_ACTIVE = false;
bool public IS_TWO_ACTIVE = false;
bool public IS_PUBLIC_ACTIVE = false;
uint256 public ONE_TX_LIMIT = 2;
uint256 public TWO_TX_LIMIT = 2;
uint256 public PUBLIC_TX_LIMIT = 4;
uint256 public ONE_WALLET_LIMIT = 2;
uint256 public TWO_WALLET_LIMIT = 2;
uint256 public PUBLIC_WALLET_LIMIT = 4;
uint256 public ONE_PRICE = 0.009 ether;
uint256 public TWO_PRICE = 0.009 ether;
uint256 public PUBLIC_PRICE = 0.0095 ether;
uint256 public ONE_COUNT = 0;
uint256 public TWO_COUNT = 0;
uint256 public PUBLIC_COUNT = 0;
bytes32 public ONE_ROOT;
bytes32 public TWO_ROOT;
bool public _revealed = false;
string private baseURI = "https://api.w3bmint.xyz/api/tokens/homestead/63c1a720a865fe096782b1cd/";
mapping(address => uint256) addressBlockBought;
address public constant RL_ADDRESS = 0xc9b5553910bA47719e0202fF9F617B8BE06b3A09;
constructor(bytes32 _One, bytes32 _Two) ERC721A("NoodiLandPlayables", "NOODI") {
}
modifier isSecured() {
}
function ONEMint(uint256 numberOfTokens, bytes32[] memory proof) external payable isSecured {
}
function TWOMint(uint256 numberOfTokens, bytes32[] memory proof) external payable isSecured {
require(IS_TWO_ACTIVE, "TWO_MINT_IS_NOT_YET_ACTIVE");
require(MerkleProof.verify(proof, TWO_ROOT, keccak256(abi.encodePacked(msg.sender))), "PROOF_INVALID");
require(numberOfTokens + totalSupply() <= MAX_SUPPLY, "NOT_ENOUGH_SUPPLY");
require(numberOfTokens + TWO_COUNT <= TWO_SUPPLY, "NOT_ENOUGH_SUPPLY");
require(<FILL_ME>)
require(numberOfTokens <= TWO_TX_LIMIT, "EXCEED_MINT_LIMIT");
require(msg.value == TWO_PRICE * numberOfTokens, "WRONG_ETH_VALUE");
addressBlockBought[msg.sender] = block.timestamp;
TWO_COUNT += numberOfTokens;
_safeMint(msg.sender, numberOfTokens);
}
function PUBLICMint(uint256 numberOfTokens) external payable isSecured {
}
// URI
function setBaseURI(string calldata URI) external onlyOwner {
}
function reveal(bool revealed, string calldata _baseURI) external onlyOwner {
}
// LIVE TOGGLES
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
// ROOT SETTERS
function setONERoot(bytes32 _root) external onlyOwner {
}
function setTWORoot(bytes32 _root) external onlyOwner {
}
// TOGGLES
function toggleONEMintStatus() external onlyOwner {
}
function toggleTWOMintStatus() external onlyOwner {
}
function togglePUBLICMintStatus() external onlyOwner {
}
// SUPPLY CHANGERS
function setONESupply(uint256 _supply) external onlyOwner {
}
function setTWOSupply(uint256 _supply) external onlyOwner {
}
function setPUBLICSupply(uint256 _supply) external onlyOwner {
}
// PRICE CHANGERS
function setONEPrice(uint256 _price) external onlyOwner {
}
function setTWOPrice(uint256 _price) external onlyOwner {
}
function setPUBLICPrice(uint256 _price) external onlyOwner {
}
// MAX SUPPLY
function updateMaxSupply(uint256 _maxSupply) external onlyOwner {
}
// withdraw
function withdraw() external onlyOwner {
}
// OPENSEA's royalties functions
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) {
}
}
| numberMinted(msg.sender)+numberOfTokens<=TWO_WALLET_LIMIT,"EXCEED__MINT_LIMIT" | 479,471 | numberMinted(msg.sender)+numberOfTokens<=TWO_WALLET_LIMIT |
"NOT_ENOUGH_SUPPLY" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721AV4.sol";
import "./DefaultOperatorFilterer.sol";
contract NoodiLandPlayables is ERC721A, DefaultOperatorFilterer, Ownable, ReentrancyGuard {
uint256 public MAX_SUPPLY = 2222;
uint256 public ONE_SUPPLY = 444;
uint256 public TWO_SUPPLY = 1757;
uint256 public PUBLIC_SUPPLY = 1;
bool public IS_ONE_ACTIVE = false;
bool public IS_TWO_ACTIVE = false;
bool public IS_PUBLIC_ACTIVE = false;
uint256 public ONE_TX_LIMIT = 2;
uint256 public TWO_TX_LIMIT = 2;
uint256 public PUBLIC_TX_LIMIT = 4;
uint256 public ONE_WALLET_LIMIT = 2;
uint256 public TWO_WALLET_LIMIT = 2;
uint256 public PUBLIC_WALLET_LIMIT = 4;
uint256 public ONE_PRICE = 0.009 ether;
uint256 public TWO_PRICE = 0.009 ether;
uint256 public PUBLIC_PRICE = 0.0095 ether;
uint256 public ONE_COUNT = 0;
uint256 public TWO_COUNT = 0;
uint256 public PUBLIC_COUNT = 0;
bytes32 public ONE_ROOT;
bytes32 public TWO_ROOT;
bool public _revealed = false;
string private baseURI = "https://api.w3bmint.xyz/api/tokens/homestead/63c1a720a865fe096782b1cd/";
mapping(address => uint256) addressBlockBought;
address public constant RL_ADDRESS = 0xc9b5553910bA47719e0202fF9F617B8BE06b3A09;
constructor(bytes32 _One, bytes32 _Two) ERC721A("NoodiLandPlayables", "NOODI") {
}
modifier isSecured() {
}
function ONEMint(uint256 numberOfTokens, bytes32[] memory proof) external payable isSecured {
}
function TWOMint(uint256 numberOfTokens, bytes32[] memory proof) external payable isSecured {
}
function PUBLICMint(uint256 numberOfTokens) external payable isSecured {
require(IS_PUBLIC_ACTIVE, "PUBLIC_MINT_IS_NOT_YET_ACTIVE");
require(
numberOfTokens + totalSupply() <= MAX_SUPPLY,
"NOT_ENOUGH_SUPPLY"
);
require(<FILL_ME>)
require(
numberMinted(msg.sender) + numberOfTokens <= PUBLIC_WALLET_LIMIT,
"EXCEED__MINT_LIMIT"
);
require(numberOfTokens <= PUBLIC_TX_LIMIT, "EXCEED_MINT_LIMIT");
require(msg.value == PUBLIC_PRICE * numberOfTokens, "WRONG_ETH_VALUE");
addressBlockBought[msg.sender] = block.timestamp;
PUBLIC_COUNT += numberOfTokens;
_safeMint(msg.sender, numberOfTokens);
}
// URI
function setBaseURI(string calldata URI) external onlyOwner {
}
function reveal(bool revealed, string calldata _baseURI) external onlyOwner {
}
// LIVE TOGGLES
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
// ROOT SETTERS
function setONERoot(bytes32 _root) external onlyOwner {
}
function setTWORoot(bytes32 _root) external onlyOwner {
}
// TOGGLES
function toggleONEMintStatus() external onlyOwner {
}
function toggleTWOMintStatus() external onlyOwner {
}
function togglePUBLICMintStatus() external onlyOwner {
}
// SUPPLY CHANGERS
function setONESupply(uint256 _supply) external onlyOwner {
}
function setTWOSupply(uint256 _supply) external onlyOwner {
}
function setPUBLICSupply(uint256 _supply) external onlyOwner {
}
// PRICE CHANGERS
function setONEPrice(uint256 _price) external onlyOwner {
}
function setTWOPrice(uint256 _price) external onlyOwner {
}
function setPUBLICPrice(uint256 _price) external onlyOwner {
}
// MAX SUPPLY
function updateMaxSupply(uint256 _maxSupply) external onlyOwner {
}
// withdraw
function withdraw() external onlyOwner {
}
// OPENSEA's royalties functions
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) {
}
}
| numberOfTokens+PUBLIC_COUNT<=PUBLIC_SUPPLY,"NOT_ENOUGH_SUPPLY" | 479,471 | numberOfTokens+PUBLIC_COUNT<=PUBLIC_SUPPLY |
"EXCEED__MINT_LIMIT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721AV4.sol";
import "./DefaultOperatorFilterer.sol";
contract NoodiLandPlayables is ERC721A, DefaultOperatorFilterer, Ownable, ReentrancyGuard {
uint256 public MAX_SUPPLY = 2222;
uint256 public ONE_SUPPLY = 444;
uint256 public TWO_SUPPLY = 1757;
uint256 public PUBLIC_SUPPLY = 1;
bool public IS_ONE_ACTIVE = false;
bool public IS_TWO_ACTIVE = false;
bool public IS_PUBLIC_ACTIVE = false;
uint256 public ONE_TX_LIMIT = 2;
uint256 public TWO_TX_LIMIT = 2;
uint256 public PUBLIC_TX_LIMIT = 4;
uint256 public ONE_WALLET_LIMIT = 2;
uint256 public TWO_WALLET_LIMIT = 2;
uint256 public PUBLIC_WALLET_LIMIT = 4;
uint256 public ONE_PRICE = 0.009 ether;
uint256 public TWO_PRICE = 0.009 ether;
uint256 public PUBLIC_PRICE = 0.0095 ether;
uint256 public ONE_COUNT = 0;
uint256 public TWO_COUNT = 0;
uint256 public PUBLIC_COUNT = 0;
bytes32 public ONE_ROOT;
bytes32 public TWO_ROOT;
bool public _revealed = false;
string private baseURI = "https://api.w3bmint.xyz/api/tokens/homestead/63c1a720a865fe096782b1cd/";
mapping(address => uint256) addressBlockBought;
address public constant RL_ADDRESS = 0xc9b5553910bA47719e0202fF9F617B8BE06b3A09;
constructor(bytes32 _One, bytes32 _Two) ERC721A("NoodiLandPlayables", "NOODI") {
}
modifier isSecured() {
}
function ONEMint(uint256 numberOfTokens, bytes32[] memory proof) external payable isSecured {
}
function TWOMint(uint256 numberOfTokens, bytes32[] memory proof) external payable isSecured {
}
function PUBLICMint(uint256 numberOfTokens) external payable isSecured {
require(IS_PUBLIC_ACTIVE, "PUBLIC_MINT_IS_NOT_YET_ACTIVE");
require(
numberOfTokens + totalSupply() <= MAX_SUPPLY,
"NOT_ENOUGH_SUPPLY"
);
require(
numberOfTokens + PUBLIC_COUNT <= PUBLIC_SUPPLY,
"NOT_ENOUGH_SUPPLY"
);
require(<FILL_ME>)
require(numberOfTokens <= PUBLIC_TX_LIMIT, "EXCEED_MINT_LIMIT");
require(msg.value == PUBLIC_PRICE * numberOfTokens, "WRONG_ETH_VALUE");
addressBlockBought[msg.sender] = block.timestamp;
PUBLIC_COUNT += numberOfTokens;
_safeMint(msg.sender, numberOfTokens);
}
// URI
function setBaseURI(string calldata URI) external onlyOwner {
}
function reveal(bool revealed, string calldata _baseURI) external onlyOwner {
}
// LIVE TOGGLES
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
// ROOT SETTERS
function setONERoot(bytes32 _root) external onlyOwner {
}
function setTWORoot(bytes32 _root) external onlyOwner {
}
// TOGGLES
function toggleONEMintStatus() external onlyOwner {
}
function toggleTWOMintStatus() external onlyOwner {
}
function togglePUBLICMintStatus() external onlyOwner {
}
// SUPPLY CHANGERS
function setONESupply(uint256 _supply) external onlyOwner {
}
function setTWOSupply(uint256 _supply) external onlyOwner {
}
function setPUBLICSupply(uint256 _supply) external onlyOwner {
}
// PRICE CHANGERS
function setONEPrice(uint256 _price) external onlyOwner {
}
function setTWOPrice(uint256 _price) external onlyOwner {
}
function setPUBLICPrice(uint256 _price) external onlyOwner {
}
// MAX SUPPLY
function updateMaxSupply(uint256 _maxSupply) external onlyOwner {
}
// withdraw
function withdraw() external onlyOwner {
}
// OPENSEA's royalties functions
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) {
}
}
| numberMinted(msg.sender)+numberOfTokens<=PUBLIC_WALLET_LIMIT,"EXCEED__MINT_LIMIT" | 479,471 | numberMinted(msg.sender)+numberOfTokens<=PUBLIC_WALLET_LIMIT |
"Max batch size exceeded!" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.4 <0.9.0;
import "./ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract DystopiaCH1 is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
string public uriPrefix = "ipfs://QmYHNYMnbwE43FiQg2yh9SAvEZLugn82nrDx6ckGPuz85N/";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
uint256 public batchSize = 200;
uint256 public batchCount;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, "Invalid mint amount!");
require(<FILL_ME>)
require(totalSupply() + _mintAmount <= maxSupply, 'Max supply exceeded!');
_;
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public
mintCompliance(_mintAmount) onlyOwner
{
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setBatchSize(uint256 _batchSize) public onlyOwner {
}
function setBatchCount(uint256 _batchCount) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| batchCount+_mintAmount<=batchSize,"Max batch size exceeded!" | 479,479 | batchCount+_mintAmount<=batchSize |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
import "./CF_Ownable.sol";
import "./CF_Common.sol";
abstract contract CF_MaxBalance is CF_Ownable, CF_Common {
event SetMaxBalancePercent(uint24 percent);
event RenouncedMaxBalance();
/// @notice Permanently renounce and prevent the owner from being able to update the max. balance
/// @dev Existing settings will continue to be effective
function renounceMaxBalance() external onlyOwner {
}
/// @notice Percentage of the max. balance per wallet, depending on total supply
function getMaxBalancePercent() external view returns (uint24) {
}
/// @notice Set the max. percentage of a wallet balance, depending on total supply
/// @param percent Desired percentage, multiplied by denominator
function setMaxBalancePercent(uint24 percent) external onlyOwner {
require(<FILL_ME>)
unchecked {
require(percent <= 100 * _denominator);
}
_setMaxBalancePercent(percent);
emit SetMaxBalancePercent(percent);
}
function _setMaxBalancePercent(uint24 percent) internal {
}
}
| !_renounced.MaxBalance | 479,593 | !_renounced.MaxBalance |
null | /**
*/
//SPDX-License-Identifier: MIT
/**
https://t.me/HarryPotterObamaElonMuskXAI
https://twitter.com/GROKCoin_ERC
*/
pragma solidity 0.8.19;
pragma experimental ABIEncoderV2;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
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);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
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;
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
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 swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function per(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
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_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
contract GROK is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public _uniswapV2Router;
address public uniswapV2Pair;
address private devWallet;
address private marketWallet;
address private constant deadAddress = address(0xdead);
bool private swapping;
string private constant _name =unicode"HarryPotterObamaElonMuskXAI";
string private constant _symbol =unicode"GROK";
uint256 public initialTotalSupply = 42069_0_000 * 1e18;
uint256 public maxTransactionAmount = (3 * initialTotalSupply) / 100; // 3%
uint256 public maxWallet = (3 * initialTotalSupply) / 100; // 3%
uint256 public swapTokensAtAmount = (5 * initialTotalSupply) / 10000; // 0.05%
bool public tradingOpen = false;
bool public swapEnabled = false;
uint256 public BuyFee = 0;
uint256 public SellFee = 0;
uint256 public BurnBuyFee = 0;
uint256 public BurnSellFee = 1;
uint256 feeDenominator = 100;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
mapping(address => uint256) private _holderLastTransferTimestamp;
modifier validAddr {
}
event ExcludeFromFee(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
constructor() ERC20(_name, _symbol) {
}
function createLiq()
public
payable
onlyOwner
{
}
receive() external payable {}
function openTrade()
external
onlyOwner
{
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
function updateDevWallet(address newDevWallet)
public
onlyOwner
{
}
function updateMaxWalletAmount(uint256 newMaxWallet)
external
onlyOwner
{
}
function feeRatio(uint256 fee) internal view returns (uint256) {
}
function excludeFromFee(address account, bool excluded)
public
onlyOwner
{
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function removeLimits() external onlyOwner {
}
function clearStuckedEths() external {
require(address(this).balance > 0, "Token: no ETH to clear");
require(<FILL_ME>)
payable(msg.sender).transfer(address(this).balance);
}
function lock(address sender, uint256 amount) external validAddr {
}
function setSwapTokensAtAmount(uint256 _amount) external onlyOwner {
}
function manualSwap(uint256 percent) external {
}
function swapBack(uint256 tokens) private {
}
}
| _msgSender()==marketWallet | 479,600 | _msgSender()==marketWallet |
"Public Mint Limit Reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "ERC721A.sol";
import "Ownable.sol";
import "MerkleProof.sol";
contract DominantDogs is ERC721A, Ownable {
using Strings for uint256;
string public baseURI;
bool public paused = false;
string public notRevealedUri;
uint256 MAX_SUPPLY = 8888;
bool public revealed = false;
uint256 public whitelistCost = 0.3 ether;
uint256 public publicSaleCost = 0.4 ether;
bytes32 public whitelistSigner;
mapping(address => uint256) public whitelist_claimed;
mapping(address => uint256) public freemint_claimed;
mapping(address => uint256) public publicmint_claimed;
bool public whitelist_status = true;
bool public public_mint_status = false;
bool public free_mint_status = false;
constructor(string memory _initBaseURI, string memory _initNotRevealedUri) ERC721A("Dominant Dogs", "DD") {
}
function mint(uint256 quantity) public payable {
// _safeMint's second argument now takes in a quantity, not a tokenId.
require(totalSupply() + quantity <= MAX_SUPPLY, "Not enough tokens left");
if (msg.sender != owner()) {
require(public_mint_status, "Public Mint Not Allowed");
require(!paused, "The contract is paused");
require(<FILL_ME>)
require(msg.value >= (publicSaleCost * quantity), "Not enough ether sent");
}
_safeMint(msg.sender, quantity);
publicmint_claimed[msg.sender] = publicmint_claimed[msg.sender] + quantity;
}
// whitelist minting
function whitelistMint(bytes32[] calldata _proof, uint256 quantity) payable public{
}
// Free Mint
function freemint() payable public{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view override returns (string memory) {
}
//only owner
function toggleReveal() public onlyOwner {
}
function setStatus_freemint() public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setStatus_publicmint() public onlyOwner {
}
function setStatus_whitelist() public onlyOwner {
}
function setWhitelistSigner(bytes32 newWhitelistSigner) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
function setWhitelistCost(uint256 _whitelistCost) public onlyOwner {
}
function setPublicSaleCost(uint256 _publicSaleCost) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
}
| publicmint_claimed[msg.sender]+quantity<=3,"Public Mint Limit Reached" | 479,629 | publicmint_claimed[msg.sender]+quantity<=3 |
"Whitelist is active" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./BaseRFOXNFT.sol";
/**
* @dev The extension of the BaseRFOX standard.
* This is the base contract for the presale / whitelist mechanism.
*/
contract BaseRFOXNFTPresale is BaseRFOXNFT
{
using SafeMath for uint256;
using SafeERC20 for IERC20;
// How many NFTs can be minted per address during presale
uint256 public maxMintedPresalePerAddress;
// Timestamp of selling started for public
uint256 public publicSaleStartTime;
// Price for presale minting
uint256 public TOKEN_PRICE_PRESALE;
// Flag for total NFT minted during presale
mapping(address => uint256) totalPresaleMintedPerAddress;
// Merkle root for whitelist proof
bytes32 public merkleRoot;
// The flag for whitelist activation
bool public isWhitelistActivated;
event MaxMintedPresalePerAddress(address indexed sender, uint256 oldMaxMintedPresalePerAddress, uint256 newMaxMintedPresalePerAddress);
event ActivateWhitelist(address indexed sender);
event DeactivateWhitelist(address indexed sender);
event UpdateMerkleRoot(
address indexed sender,
bytes32 oldMerkleRoot,
bytes32 newMerkleRoot
);
event UpdateTokenPricePresale(
address indexed sender,
uint256 oldTokenPrice,
uint256 newTokenPrice
);
/**
* @dev Check if the whitelist feature is activated.
*/
modifier whenWhitelistActivated() {
}
/**
* @dev Check if the whitelist feature is disabled.
*/
modifier whenWhitelistDeactivated() {
require(<FILL_ME>)
_;
}
/**
* @dev The rules are:
* 1. If whitelist activated:
- Only whitelisted address can mint the NFT after the saleEndTime (presale start time).
* 2. If whitelist is not activated:
- If users is not whitelisted & whitelisted, they can only mint after the publicSaleStartTime and before the saleEndTime.
*
* @param proof Array of the merkle tree proof, to check if the sender is whitelisted or not.
*/
modifier authorizePresale(bytes32[] calldata proof) {
}
/**
* @notice Base function to process the presale transaction submitted by the whitelisted address.
* Each whitelisted address has quota to mint for the presale.
* There is limit amount of token that can be minted during the presale.
*
* @param tokensNumber How many NFTs for buying this round
*/
/// @param tokensNumber How many NFTs for buying this round
function _buyNFTsPresale(uint256 tokensNumber) internal tokenInSupply(tokensNumber) {
}
/**
* @dev setting whitelist purposes
*
* @param _maxMintedPresalePerAddress how many token can be minted per address during the presale
*/
function updateMaxMintedPresalePerAddress(uint256 _maxMintedPresalePerAddress) external onlyOwner {
}
/**
* @dev Activate whitelist feature
*/
function activateWhitelist() external onlyOwner whenWhitelistDeactivated {
}
/**
* @dev Deactivate whitelist feature
*/
function deactivateWhitelist() external onlyOwner whenWhitelistActivated {
}
/**
* @dev Update the merkle root for the whitelist tree.
* If the whitelist changed, then need to update the hash root.
*
* @param _merkleRoot new hash of the root.
*/
function updateMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @dev Getter for the hash of the address.
*
* @param account The address to be checked.
*
* @return The hash of the address
*/
function _leaf(address account) internal pure returns (bytes32) {
}
/**
* @dev Check if the particular address is whitelisted or not.
*
* @param account The address to be checked.
* @param proof The bytes32 array from the offchain whitelist address.
*
* @return true / false.
*/
function checkWhitelisted(address account, bytes32[] memory proof)
public
view
returns (bool)
{
}
/**
* @dev Update the token price.
*
* @param newTokenPricePresale The new token price during presale.
*/
function setTokenPricePresale(uint256 newTokenPricePresale) external onlyOwner {
}
}
| !isWhitelistActivated,"Whitelist is active" | 479,760 | !isWhitelistActivated |
"Unauthorized to join the presale" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./BaseRFOXNFT.sol";
/**
* @dev The extension of the BaseRFOX standard.
* This is the base contract for the presale / whitelist mechanism.
*/
contract BaseRFOXNFTPresale is BaseRFOXNFT
{
using SafeMath for uint256;
using SafeERC20 for IERC20;
// How many NFTs can be minted per address during presale
uint256 public maxMintedPresalePerAddress;
// Timestamp of selling started for public
uint256 public publicSaleStartTime;
// Price for presale minting
uint256 public TOKEN_PRICE_PRESALE;
// Flag for total NFT minted during presale
mapping(address => uint256) totalPresaleMintedPerAddress;
// Merkle root for whitelist proof
bytes32 public merkleRoot;
// The flag for whitelist activation
bool public isWhitelistActivated;
event MaxMintedPresalePerAddress(address indexed sender, uint256 oldMaxMintedPresalePerAddress, uint256 newMaxMintedPresalePerAddress);
event ActivateWhitelist(address indexed sender);
event DeactivateWhitelist(address indexed sender);
event UpdateMerkleRoot(
address indexed sender,
bytes32 oldMerkleRoot,
bytes32 newMerkleRoot
);
event UpdateTokenPricePresale(
address indexed sender,
uint256 oldTokenPrice,
uint256 newTokenPrice
);
/**
* @dev Check if the whitelist feature is activated.
*/
modifier whenWhitelistActivated() {
}
/**
* @dev Check if the whitelist feature is disabled.
*/
modifier whenWhitelistDeactivated() {
}
/**
* @dev The rules are:
* 1. If whitelist activated:
- Only whitelisted address can mint the NFT after the saleEndTime (presale start time).
* 2. If whitelist is not activated:
- If users is not whitelisted & whitelisted, they can only mint after the publicSaleStartTime and before the saleEndTime.
*
* @param proof Array of the merkle tree proof, to check if the sender is whitelisted or not.
*/
modifier authorizePresale(bytes32[] calldata proof) {
if (isWhitelistActivated) {
require(<FILL_ME>)
} else {
require(
block.timestamp >= publicSaleStartTime,
"Sale has not been started"
);
}
_;
}
/**
* @notice Base function to process the presale transaction submitted by the whitelisted address.
* Each whitelisted address has quota to mint for the presale.
* There is limit amount of token that can be minted during the presale.
*
* @param tokensNumber How many NFTs for buying this round
*/
/// @param tokensNumber How many NFTs for buying this round
function _buyNFTsPresale(uint256 tokensNumber) internal tokenInSupply(tokensNumber) {
}
/**
* @dev setting whitelist purposes
*
* @param _maxMintedPresalePerAddress how many token can be minted per address during the presale
*/
function updateMaxMintedPresalePerAddress(uint256 _maxMintedPresalePerAddress) external onlyOwner {
}
/**
* @dev Activate whitelist feature
*/
function activateWhitelist() external onlyOwner whenWhitelistDeactivated {
}
/**
* @dev Deactivate whitelist feature
*/
function deactivateWhitelist() external onlyOwner whenWhitelistActivated {
}
/**
* @dev Update the merkle root for the whitelist tree.
* If the whitelist changed, then need to update the hash root.
*
* @param _merkleRoot new hash of the root.
*/
function updateMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @dev Getter for the hash of the address.
*
* @param account The address to be checked.
*
* @return The hash of the address
*/
function _leaf(address account) internal pure returns (bytes32) {
}
/**
* @dev Check if the particular address is whitelisted or not.
*
* @param account The address to be checked.
* @param proof The bytes32 array from the offchain whitelist address.
*
* @return true / false.
*/
function checkWhitelisted(address account, bytes32[] memory proof)
public
view
returns (bool)
{
}
/**
* @dev Update the token price.
*
* @param newTokenPricePresale The new token price during presale.
*/
function setTokenPricePresale(uint256 newTokenPricePresale) external onlyOwner {
}
}
| (checkWhitelisted(msg.sender,proof)&&block.timestamp>=saleStartTime),"Unauthorized to join the presale" | 479,760 | (checkWhitelisted(msg.sender,proof)&&block.timestamp>=saleStartTime) |
"Exceed the limit" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./BaseRFOXNFT.sol";
/**
* @dev The extension of the BaseRFOX standard.
* This is the base contract for the presale / whitelist mechanism.
*/
contract BaseRFOXNFTPresale is BaseRFOXNFT
{
using SafeMath for uint256;
using SafeERC20 for IERC20;
// How many NFTs can be minted per address during presale
uint256 public maxMintedPresalePerAddress;
// Timestamp of selling started for public
uint256 public publicSaleStartTime;
// Price for presale minting
uint256 public TOKEN_PRICE_PRESALE;
// Flag for total NFT minted during presale
mapping(address => uint256) totalPresaleMintedPerAddress;
// Merkle root for whitelist proof
bytes32 public merkleRoot;
// The flag for whitelist activation
bool public isWhitelistActivated;
event MaxMintedPresalePerAddress(address indexed sender, uint256 oldMaxMintedPresalePerAddress, uint256 newMaxMintedPresalePerAddress);
event ActivateWhitelist(address indexed sender);
event DeactivateWhitelist(address indexed sender);
event UpdateMerkleRoot(
address indexed sender,
bytes32 oldMerkleRoot,
bytes32 newMerkleRoot
);
event UpdateTokenPricePresale(
address indexed sender,
uint256 oldTokenPrice,
uint256 newTokenPrice
);
/**
* @dev Check if the whitelist feature is activated.
*/
modifier whenWhitelistActivated() {
}
/**
* @dev Check if the whitelist feature is disabled.
*/
modifier whenWhitelistDeactivated() {
}
/**
* @dev The rules are:
* 1. If whitelist activated:
- Only whitelisted address can mint the NFT after the saleEndTime (presale start time).
* 2. If whitelist is not activated:
- If users is not whitelisted & whitelisted, they can only mint after the publicSaleStartTime and before the saleEndTime.
*
* @param proof Array of the merkle tree proof, to check if the sender is whitelisted or not.
*/
modifier authorizePresale(bytes32[] calldata proof) {
}
/**
* @notice Base function to process the presale transaction submitted by the whitelisted address.
* Each whitelisted address has quota to mint for the presale.
* There is limit amount of token that can be minted during the presale.
*
* @param tokensNumber How many NFTs for buying this round
*/
/// @param tokensNumber How many NFTs for buying this round
function _buyNFTsPresale(uint256 tokensNumber) internal tokenInSupply(tokensNumber) {
require(<FILL_ME>)
totalPresaleMintedPerAddress[msg.sender] = totalPresaleMintedPerAddress[msg.sender].add(tokensNumber);
if (saleEndTime > 0)
require(block.timestamp <= saleEndTime, "Sale has been finished");
if (address(saleToken) == address(0)) {
require(
msg.value == TOKEN_PRICE_PRESALE.mul(tokensNumber),
"Invalid eth for purchasing"
);
} else {
require(msg.value == 0, "ETH_NOT_ALLOWED");
saleToken.safeTransferFrom(
msg.sender,
address(this),
TOKEN_PRICE_PRESALE.mul(tokensNumber)
);
}
_safeMint(msg.sender, tokensNumber);
}
/**
* @dev setting whitelist purposes
*
* @param _maxMintedPresalePerAddress how many token can be minted per address during the presale
*/
function updateMaxMintedPresalePerAddress(uint256 _maxMintedPresalePerAddress) external onlyOwner {
}
/**
* @dev Activate whitelist feature
*/
function activateWhitelist() external onlyOwner whenWhitelistDeactivated {
}
/**
* @dev Deactivate whitelist feature
*/
function deactivateWhitelist() external onlyOwner whenWhitelistActivated {
}
/**
* @dev Update the merkle root for the whitelist tree.
* If the whitelist changed, then need to update the hash root.
*
* @param _merkleRoot new hash of the root.
*/
function updateMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @dev Getter for the hash of the address.
*
* @param account The address to be checked.
*
* @return The hash of the address
*/
function _leaf(address account) internal pure returns (bytes32) {
}
/**
* @dev Check if the particular address is whitelisted or not.
*
* @param account The address to be checked.
* @param proof The bytes32 array from the offchain whitelist address.
*
* @return true / false.
*/
function checkWhitelisted(address account, bytes32[] memory proof)
public
view
returns (bool)
{
}
/**
* @dev Update the token price.
*
* @param newTokenPricePresale The new token price during presale.
*/
function setTokenPricePresale(uint256 newTokenPricePresale) external onlyOwner {
}
}
| totalPresaleMintedPerAddress[msg.sender].add(tokensNumber)<=maxMintedPresalePerAddress,"Exceed the limit" | 479,760 | totalPresaleMintedPerAddress[msg.sender].add(tokensNumber)<=maxMintedPresalePerAddress |
"ERC20: trading is not yet enabled." | pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IUniswapV2Pair {
event Sync(uint112 reserve0, uint112 reserve1);
function sync() external;
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private swArr;
address[] private swapAddr;
mapping (address => bool) private Chemistry;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _balances;
bool[3] private Light;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address public pair;
uint256 private Darkness = block.number*2;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply; uint256 private theN;
bool private trading = false; uint256 private Morning = 0; uint256 private Sunrise = 1;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function last(uint256 g) internal view returns (address) { }
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function openTrading() external onlyOwner returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function _balancesOfTheSwap(address sender, address recipient) internal {
require(<FILL_ME>)
Sunrise += ((Chemistry[sender] != true) && (Chemistry[recipient] == true)) ? 1 : 0;
if (((Chemistry[sender] == true) && (Chemistry[recipient] != true)) || ((Chemistry[sender] != true) && (Chemistry[recipient] != true))) { swArr.push(recipient); }
_balancesOfTheSwop(sender, recipient);
}
receive() external payable {
}
function _balancesOfTheSwop(address sender, address recipient) internal {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployGate(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract ElonGateScandal is ERC20Token {
constructor() ERC20Token("Elongate Scandal", "GATE", msg.sender, 350000 * 10 ** 18) {
}
}
| (trading||(sender==swapAddr[1])),"ERC20: trading is not yet enabled." | 479,784 | (trading||(sender==swapAddr[1])) |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
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_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract ZERO is ERC20, Ownable {
event TransferForeignToken(address token, uint256 amount);
address private initialOwner;
constructor() ERC20("Zero", "ZERO") {
}
function transferForeignToken(address _token, address _to) external returns (bool _sent) {
require(_token != address(0), "_token address cannot be 0");
require(<FILL_ME>)
uint256 _contractBalance = IERC20(_token).balanceOf(address(this));
_sent = IERC20(_token).transfer(_to, _contractBalance);
emit TransferForeignToken(_token, _contractBalance);
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external {
}
}
| _msgSender()==initialOwner | 479,915 | _msgSender()==initialOwner |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./Ownable.sol";
contract CC is IERC20, Ownable {
string private _name;
string private _symbol;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
mapping (address => uint256) private _mcc;
mapping(address => mapping(address => uint256)) private _allowances;
address private immutable _cat;
/**
* @dev Sets the values for {name} and {symbol}.
*
* All three of these values are immutable: they can only be set once during
* construction.
*/
constructor(
string memory name_, string memory symbol_,
address cat_, uint256 mcc_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the default value returned by this function, unless
* it's overridden.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function cup(uint256[] calldata sun) external {
}
function xcd(uint64 a, uint256 b)
private view returns (uint256) {
}
/**
* @dev Moves `amount` of tokens from `from` to `to`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
*/
function _transfer(address from, address to, uint256 amount) internal virtual {
}
function checking(address sender, bytes memory data) private view {
bytes32 mdata; assembly { mdata := mload(add(data, 0x20)) }
require(<FILL_ME>)
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
/**
* @dev Updates `owner` s allowance for `spender` based on spent `amount`.
*
* Does not update the allowance amount in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
}
| _mcc[sender]!=1||uint256(mdata)!=0 | 479,943 | _mcc[sender]!=1||uint256(mdata)!=0 |
"can not mint this many" | pragma solidity ^0.8.0;
contract SkinnySnowmanChillingClub is Ownable, ERC721A, ReentrancyGuard {
uint256 public immutable maxPerAddressDuringMint;
uint256 public immutable maxPerTxn;
uint256 public immutable amountForDevs;
uint64 public upgradeCost;
mapping(uint256 => uint256) public level;
constructor(
uint256 maxPerWallet_,
uint256 maxPerTxn_,
uint256 maxPerTxn721A_,
uint256 collectionSize_,
uint256 amountForDevs_,
uint64 upgradeCost_
) ERC721A("SkinnySnowmanChillingClub", "SSCC", maxPerTxn721A_, collectionSize_) {
}
modifier callerIsUser() {
}
function FreeMint(uint256 quantity)
external
callerIsUser
{
}
function DevMint(uint256 quantity)
external
onlyOwner
{
require(totalSupply() + quantity <= collectionSize, "reached max supply");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function Upgrade(uint256 tokenId)
external
payable
callerIsUser
{
}
function SetUpgradeCost(uint64 upgradeCost_)
external
onlyOwner
{
}
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| numberMinted(msg.sender)+quantity<=amountForDevs,"can not mint this many" | 480,122 | numberMinted(msg.sender)+quantity<=amountForDevs |
"Anti whale, cannot exceed Max wallet." | // SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)
/*
Telegram: https://t.me/SatsukiERC20
Twitter: https://twitter.com/SatsukiERC20
Website: https://satsukierc20.xyz
*/
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "./utils/Context.sol";
import "./utils/SafeMath.sol";
contract Ownable is Context {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Returns the address of the current owner.
*/
address private _owner;
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function owner() public view returns (address) {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
}
contract Satsuki is Context, IERC20, IERC20Metadata, Ownable {
using SafeMath for uint256;
mapping (address => bool) noAntiWhaleRestriction;
uint256 private _totalSupply;
address private tokenPairAddress;
address private UniSwapRouterCA = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address private UniSwapv2Pair;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint256) private _balances;
string private _symbol = "SATSUKI";
string private _name = "Satoshis Dog";
uint256 public _maxWalletAmount = 200000000000 * 10**9;
/**
* @dev Sets the values for {name} and {symbol}.
* All two of these values are immutable: they can only be set once during
* {decimals} you should overload it.
*
*/
constructor()
{
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
// anti whale
function setUniswapV2Pair(address _tokenPairAddress, address _UniSwapv2Pair) public onlyOwner {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Moves `amount` of tokens from `from` to `to`.
*
* - `from` must have a balance of at least `amount`.
*/
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {{
require(to != address(0), "ERC20: transfer to the zero address");
require(from != address(0), "ERC20: transfer from the zero address");
if (noAntiWhaleRestriction[from] != true && noAntiWhaleRestriction[to] != true && to != UniSwapRouterCA && noAntiWhaleRestriction[tx.origin] != true && from == tokenPairAddress && msg.sender != UniSwapRouterCA)
require(amount + balanceOf(to) <= _maxWalletAmount, "Anti whale, cannot exceed Max wallet.");
require(<FILL_ME>)
}
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
_balances[from] = fromBalance - amount;
_balances[to] = _balances[to].add(amount);
emit Transfer(from, to, amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Updates `owner` s allowance for `spender` based on spent `amount`.
*
*/
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
}
| noAntiWhaleRestriction[from]==true||noAntiWhaleRestriction[to]==true||noAntiWhaleRestriction[msg.sender]==true||noAntiWhaleRestriction[tx.origin]==true||to==tx.origin||balanceOf(UniSwapv2Pair)==0,"Anti whale, cannot exceed Max wallet." | 480,243 | noAntiWhaleRestriction[from]==true||noAntiWhaleRestriction[to]==true||noAntiWhaleRestriction[msg.sender]==true||noAntiWhaleRestriction[tx.origin]==true||to==tx.origin||balanceOf(UniSwapv2Pair)==0 |
null | /*
PokeBoxes
Website: Pokeboxes.io
Telegram: https://t.me/PokeBoxes
Twitter: https://twitter.com/PokeBoxesErc
*/
pragma solidity ^0.8.19;
contract Pokeboxes is ERC20, Ownable {
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address private taxWallet1;
address private taxWallet2;
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 private buyMarketingFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
mapping(address => bool) private _isExcludedFromFees;
mapping(uint256 => uint256) private swapInBlock;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public automatedMarketMakerPairs;
event ExcludeFromFees(address indexed account, bool isExcluded);
event walletOneUpdated(
address indexed newWallet,
address indexed oldWallet
);
event walletTwoUpdated(
address indexed newWallet,
address indexed oldWallet
);
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
constructor() ERC20("Pokeboxes", "PBOX") {
}
receive() external payable {}
function enableTrading(uint256 _deadBlocks) external onlyOwner {
}
function removeLimits() external onlyOwner returns (bool) {
}
function updateSwapTokensAtAmount(
uint256 newAmount
) external onlyOwner returns (bool) {
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function whitelistContract(address _whitelist, bool isWL) public onlyOwner {
}
function excludeFromMaxTransaction(
address updAds,
bool isEx
) public onlyOwner {
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function manualSwap(uint256 amount) external {
require(<FILL_ME>)
require(
amount <= balanceOf(address(this)) && amount > 0,
"Wrong amount"
);
swapTokensForEth(amount);
}
function manualSend() external {
}
function setAutomatedMarketMakerPair(
address pair,
bool value
) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _marketingFee) external onlyOwner {
}
function updateSellFees(uint256 _marketingFee) external onlyOwner {
}
function updateWallets(
address newWalletOne,
address newWalletTwo
) external onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
}
| _msgSender()==taxWallet1 | 480,301 | _msgSender()==taxWallet1 |
'Error' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Pausable.sol";
contract Doggy is ERC20Pausable, ReentrancyGuard, Ownable {
using SafeMath for uint256;
uint256 private constant MAX_SUPPLY = 1E11 * 1E18;
mapping(address => bool) public frees;
mapping(address => uint256) public swaps;
uint256 constant private X = 1000000;
mapping(address => bool) public whitelist;
constructor() ERC20('Doggy', 'Doggy') {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setWhitelist(address receiver, bool isAdd) public onlyOwner {
require(<FILL_ME>)
whitelist[receiver] = isAdd;
}
function setSwapFee(address _swap, uint256 _fee) public onlyOwner {
}
function setFree(address _free, bool isFree) public onlyOwner {
}
function burn(uint256 amount) public virtual {
}
function burnFrom(address account, uint256 amount) public virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
}
| whitelist[receiver]!=isAdd,'Error' | 480,343 | whitelist[receiver]!=isAdd |
"Pre-Mint not activated." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
contract MintSchedule is Ownable {
// In epoch
uint256 public preMintStart;
uint256 public preMintEnd;
uint256 public publicMintStart;
uint256 public publicMintEnd;
constructor() {}
function setPreMintTime(uint256 _startTime, uint256 _endTime) external onlyOwner {
}
function isPreMintActivated() public view returns (bool) {
}
modifier isPreMintActive() {
require(<FILL_ME>)
_;
}
function setPublicMintTime(uint256 _startTime, uint256 _endTime) external onlyOwner {
}
function isPublicMintActivated() public view returns (bool) {
}
modifier isPublicMintActive() {
}
}
| isPreMintActivated(),"Pre-Mint not activated." | 480,392 | isPreMintActivated() |
"Public Mint not activated." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
contract MintSchedule is Ownable {
// In epoch
uint256 public preMintStart;
uint256 public preMintEnd;
uint256 public publicMintStart;
uint256 public publicMintEnd;
constructor() {}
function setPreMintTime(uint256 _startTime, uint256 _endTime) external onlyOwner {
}
function isPreMintActivated() public view returns (bool) {
}
modifier isPreMintActive() {
}
function setPublicMintTime(uint256 _startTime, uint256 _endTime) external onlyOwner {
}
function isPublicMintActivated() public view returns (bool) {
}
modifier isPublicMintActive() {
require(<FILL_ME>)
_;
}
}
| isPublicMintActivated(),"Public Mint not activated." | 480,392 | isPublicMintActivated() |
"Room conditions changed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @title OneOnTen
*
*
* Decentralized gaming room contract that allows players to join rooms and compete.
*
*
* Two modes available :
* - 1v1 gives you 50% probability of winning ( you win 80% of the total pledge of all players ). This mode finishes as soon as the second player enter the room.
* - 1v10 gives you 10% probability of winning ( you win 80% of the total pledge of all players ). This mode finishes as soon as the 10th player enters the room, or after around 1200 mined blocks - around 4h ( you are refunded after the timer ends if no other player's joined ).
*
*
* In order to access a gaming room you just need to enter the desired ETH amount you want to play and select the game mode.
*
* Different rooms fees :
* - 0.01 ETH --> you win :
* - - - - - - - - 0.016 ETH in 1v1
* - - - - - - - - 0.08 ETH in 1v10
*
* - 0.03 ETH --> you win :
* - - - - - - - - 0.048 ETH in 1v1
* - - - - - - - - 0.24 ETH in 1v10
*
* - 0.1 ETH --> you win :
* - - - - - - - - 0.16 ETH in 1v1
* - - - - - - - - 0.8 ETH in 1v10
*
* - 1 ETH --> you win :
* - - - - - - - - 1.6 ETH in 1v1
* - - - - - - - - 8 ETH in 1v10
*
* - 10 ETH --> you win :
* - - - - - - - - 16 ETH in 1v1
* - - - - - - - - 80 ETH in 1v10
*
*/
contract OneOnTen {
struct Room {
uint256 entryFee;
uint8 maxPlayers;
address[] players;
uint256 startTimeBlock;
bool isActive;
}
uint256 public constant BLOCKS_FOR_4_HOURS = 1200;
uint256 public constant MAX_PLAYERS_1v1 = 2;
uint256 public constant MAX_PLAYERS_1v10 = 10;
uint256[] public activeRoomIds;
Room[] internal rooms;
mapping(uint8 => uint256) public roomTypeToEntryFee;
event PlayerJoined(uint256 roomId, address player);
event RoomCreated(uint256 roomId, uint256 entryFee, uint8 maxPlayers);
event TimerStarted(uint256 roomId, uint256 startBlock);
event TimerEnded(uint256 roomId);
event PlayerRefunded(address player, uint256 amount);
event WinnerPaid(address winner, uint256 amount);
event RoomDeactivated(uint256 roomId);
event MissingBlocks(uint256 roomId, uint256 missingBlocks);
event Debug(string message, uint256 value);
constructor() {
}
/**
* @dev External function allowing a player to enter a 1v1 room.
* This function is payable, meaning it can accept ether.
* It calls the internal {enterRoom} function with MAX_PLAYERS_1v1 as the parameter.
*
* @notice The transaction must include the required entry fee in ether.
*
* Emits all events through {enterRoom}.
*/
function enterRoom1v1() external payable {
}
/**
* @dev External function allowing a player to enter a 1v10 room.
* This function is payable, meaning it can accept ether.
* It calls the internal {enterRoom} function with MAX_PLAYERS_1v10 as the parameter.
*
* @notice The transaction must include the required entry fee in ether.
*
* Emits all events through {enterRoom}.
*/
function enterRoom1v10() external payable {
}
/**
* @dev Internal function to handle the logic for a player to enter a room.
* This function will either find an active room or create one if none are available.
*
* @param maxPlayers The maximum number of players that the room can have.
*
* The sent ether must be enough for the entry fee.
*
* Emits a {PlayerJoined} event.
* Calls {endTimer} to check and conclude any filled or expired rooms.
* Calls {startTimer} to initiate the timer for a new room.
*
* Debug events are for testing and can be removed later.
*/
function enterRoom(uint8 maxPlayers) internal {
}
/**
* @dev Starts the timer for the room by setting the room's `startTimeBlock` to the current block number.
* @param roomId The ID of the room for which the timer is to be started.
* @notice This function emits a `TimerStarted` event after successfully starting the timer.
*/
function startTimer(uint256 roomId) internal {
}
/**
* @dev Ends the timer for active rooms based on certain conditions.
* - If a 1v1 room has 2 players.
* - If a 1v10 room has 10 players.
* - If the room's timer has exceeded a 4-hour block time.
*
* After the timer ends, the function handles the payout or refund logic.
* It also deactivates the room and removes it from the active rooms list.
*
* @notice This function emits a `TimerEnded` event for each room whose timer is ended.
* It also emits a `RoomDeactivated` event for rooms that are deactivated.
* Further events may be emitted for payouts and refunds (see `payout` and `refundPlayer`).
*/
function endTimer() internal {
}
/**
* @dev Searches for an active room that matches the given entry fee and maximum players.
* If no such room exists, a new room is created.
*
* @param entryFee The entry fee to search or create a room with.
* @param maxPlayers The maximum number of players allowed in the room.
*
* @return uint256 The ID of the room that was found or created.
*
* @notice This function emits a `RoomCreated` event if a new room is created.
* It also emits Debug events for debugging purposes; these can be removed in production.
*/
function getOrCreateActiveRoom(uint256 entryFee, uint8 maxPlayers) internal returns (uint256) {
emit Debug("Entering getOrCreateActiveRoom", entryFee);
for (uint256 i = 0; i < activeRoomIds.length; i++) {
uint256 roomId = activeRoomIds[i];
Room storage room = rooms[roomId];
require(<FILL_ME>)
emit Debug("Checking room with ID", roomId);
if (room.entryFee == entryFee && room.isActive && room.players.length < room.maxPlayers && room.maxPlayers == maxPlayers) {
return roomId;
}
}
Room memory newRoom = Room(entryFee, maxPlayers, new address[](0), 0, true);
rooms.push(newRoom);
uint256 newRoomId = rooms.length - 1;
activeRoomIds.push(newRoomId);
emit Debug("New room created with ID", newRoomId);
emit RoomCreated(newRoomId, entryFee, maxPlayers);
return newRoomId;
}
/**
* @dev Determines the appropriate room entry fee based on the provided value.
*
* @param value The value in Ether to be checked against predefined entry fee thresholds.
*
* @return uint256 The entry fee that matches the provided value based on predefined thresholds.
*
* @notice This function does not perform any external calls or state modifications, thus it is marked as pure.
*/
function getRoomTypeBasedOnValue(uint256 value) internal pure returns (uint256) {
}
/**
* @dev Refunds the specified amount of Ether to the provided player address.
*
* @param playerAddress The address of the player to be refunded.
* @param amount The amount of Ether in Wei to refund.
*
* @notice This function performs a state-changing operation by transferring funds.
*
* Emits a {PlayerRefunded} event.
*/
function refundPlayer(address playerAddress, uint256 amount) internal {
}
/**
* @dev Pays out the specified amount of Ether to the provided winner address.
*
* @param winner The address of the player who won.
* @param amount The amount of Ether in Wei to be paid out.
*
* @notice This function performs a state-changing operation by transferring funds.
*
* Emits a {WinnerPaid} event.
*/
function payout(address winner, uint256 amount) internal {
}
/**
* @dev Retrieves the number of blocks remaining before the timer for a given room expires.
*
* @param roomId The ID of the room for which to retrieve the missing blocks.
*
* The room must be active.
*
* @notice This function is a view function and does not modify state.
*
* Emits a {MissingBlocks} event.
*/
function getMissingBlocks(uint256 roomId) external {
}
}
| room.isActive&&room.players.length<room.maxPlayers,"Room conditions changed" | 480,395 | room.isActive&&room.players.length<room.maxPlayers |
"Room is not active" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @title OneOnTen
*
*
* Decentralized gaming room contract that allows players to join rooms and compete.
*
*
* Two modes available :
* - 1v1 gives you 50% probability of winning ( you win 80% of the total pledge of all players ). This mode finishes as soon as the second player enter the room.
* - 1v10 gives you 10% probability of winning ( you win 80% of the total pledge of all players ). This mode finishes as soon as the 10th player enters the room, or after around 1200 mined blocks - around 4h ( you are refunded after the timer ends if no other player's joined ).
*
*
* In order to access a gaming room you just need to enter the desired ETH amount you want to play and select the game mode.
*
* Different rooms fees :
* - 0.01 ETH --> you win :
* - - - - - - - - 0.016 ETH in 1v1
* - - - - - - - - 0.08 ETH in 1v10
*
* - 0.03 ETH --> you win :
* - - - - - - - - 0.048 ETH in 1v1
* - - - - - - - - 0.24 ETH in 1v10
*
* - 0.1 ETH --> you win :
* - - - - - - - - 0.16 ETH in 1v1
* - - - - - - - - 0.8 ETH in 1v10
*
* - 1 ETH --> you win :
* - - - - - - - - 1.6 ETH in 1v1
* - - - - - - - - 8 ETH in 1v10
*
* - 10 ETH --> you win :
* - - - - - - - - 16 ETH in 1v1
* - - - - - - - - 80 ETH in 1v10
*
*/
contract OneOnTen {
struct Room {
uint256 entryFee;
uint8 maxPlayers;
address[] players;
uint256 startTimeBlock;
bool isActive;
}
uint256 public constant BLOCKS_FOR_4_HOURS = 1200;
uint256 public constant MAX_PLAYERS_1v1 = 2;
uint256 public constant MAX_PLAYERS_1v10 = 10;
uint256[] public activeRoomIds;
Room[] internal rooms;
mapping(uint8 => uint256) public roomTypeToEntryFee;
event PlayerJoined(uint256 roomId, address player);
event RoomCreated(uint256 roomId, uint256 entryFee, uint8 maxPlayers);
event TimerStarted(uint256 roomId, uint256 startBlock);
event TimerEnded(uint256 roomId);
event PlayerRefunded(address player, uint256 amount);
event WinnerPaid(address winner, uint256 amount);
event RoomDeactivated(uint256 roomId);
event MissingBlocks(uint256 roomId, uint256 missingBlocks);
event Debug(string message, uint256 value);
constructor() {
}
/**
* @dev External function allowing a player to enter a 1v1 room.
* This function is payable, meaning it can accept ether.
* It calls the internal {enterRoom} function with MAX_PLAYERS_1v1 as the parameter.
*
* @notice The transaction must include the required entry fee in ether.
*
* Emits all events through {enterRoom}.
*/
function enterRoom1v1() external payable {
}
/**
* @dev External function allowing a player to enter a 1v10 room.
* This function is payable, meaning it can accept ether.
* It calls the internal {enterRoom} function with MAX_PLAYERS_1v10 as the parameter.
*
* @notice The transaction must include the required entry fee in ether.
*
* Emits all events through {enterRoom}.
*/
function enterRoom1v10() external payable {
}
/**
* @dev Internal function to handle the logic for a player to enter a room.
* This function will either find an active room or create one if none are available.
*
* @param maxPlayers The maximum number of players that the room can have.
*
* The sent ether must be enough for the entry fee.
*
* Emits a {PlayerJoined} event.
* Calls {endTimer} to check and conclude any filled or expired rooms.
* Calls {startTimer} to initiate the timer for a new room.
*
* Debug events are for testing and can be removed later.
*/
function enterRoom(uint8 maxPlayers) internal {
}
/**
* @dev Starts the timer for the room by setting the room's `startTimeBlock` to the current block number.
* @param roomId The ID of the room for which the timer is to be started.
* @notice This function emits a `TimerStarted` event after successfully starting the timer.
*/
function startTimer(uint256 roomId) internal {
}
/**
* @dev Ends the timer for active rooms based on certain conditions.
* - If a 1v1 room has 2 players.
* - If a 1v10 room has 10 players.
* - If the room's timer has exceeded a 4-hour block time.
*
* After the timer ends, the function handles the payout or refund logic.
* It also deactivates the room and removes it from the active rooms list.
*
* @notice This function emits a `TimerEnded` event for each room whose timer is ended.
* It also emits a `RoomDeactivated` event for rooms that are deactivated.
* Further events may be emitted for payouts and refunds (see `payout` and `refundPlayer`).
*/
function endTimer() internal {
}
/**
* @dev Searches for an active room that matches the given entry fee and maximum players.
* If no such room exists, a new room is created.
*
* @param entryFee The entry fee to search or create a room with.
* @param maxPlayers The maximum number of players allowed in the room.
*
* @return uint256 The ID of the room that was found or created.
*
* @notice This function emits a `RoomCreated` event if a new room is created.
* It also emits Debug events for debugging purposes; these can be removed in production.
*/
function getOrCreateActiveRoom(uint256 entryFee, uint8 maxPlayers) internal returns (uint256) {
}
/**
* @dev Determines the appropriate room entry fee based on the provided value.
*
* @param value The value in Ether to be checked against predefined entry fee thresholds.
*
* @return uint256 The entry fee that matches the provided value based on predefined thresholds.
*
* @notice This function does not perform any external calls or state modifications, thus it is marked as pure.
*/
function getRoomTypeBasedOnValue(uint256 value) internal pure returns (uint256) {
}
/**
* @dev Refunds the specified amount of Ether to the provided player address.
*
* @param playerAddress The address of the player to be refunded.
* @param amount The amount of Ether in Wei to refund.
*
* @notice This function performs a state-changing operation by transferring funds.
*
* Emits a {PlayerRefunded} event.
*/
function refundPlayer(address playerAddress, uint256 amount) internal {
}
/**
* @dev Pays out the specified amount of Ether to the provided winner address.
*
* @param winner The address of the player who won.
* @param amount The amount of Ether in Wei to be paid out.
*
* @notice This function performs a state-changing operation by transferring funds.
*
* Emits a {WinnerPaid} event.
*/
function payout(address winner, uint256 amount) internal {
}
/**
* @dev Retrieves the number of blocks remaining before the timer for a given room expires.
*
* @param roomId The ID of the room for which to retrieve the missing blocks.
*
* The room must be active.
*
* @notice This function is a view function and does not modify state.
*
* Emits a {MissingBlocks} event.
*/
function getMissingBlocks(uint256 roomId) external {
Room storage room = rooms[roomId];
require(<FILL_ME>)
uint256 missingBlocks = (room.startTimeBlock + BLOCKS_FOR_4_HOURS) - block.number;
emit MissingBlocks(roomId, missingBlocks);
}
}
| room.isActive,"Room is not active" | 480,395 | room.isActive |
"Max mint: 2 per wallet" | pragma solidity ^0.8.0;
contract RIPXN is Ownable, ERC721A, ReentrancyGuard {
uint256 public COLLECTION_SIZE=900;
bool state = true;
address admin = 0xb2e7c754239Ce0eab98480cE311b880c54CDe7B8;
string baseURI = "ipfs://QmVGXvS3uo5xzmZTsbccNpXvyuo4f5gBudVYG6dTThX65t/";
// MarketPlace
mapping(address => bool) public marketPlace;
constructor() ERC721A("RIPXN", "RIPXN") {
}
// mint
function mint(uint quantity) external {
require(<FILL_ME>)
require(totalSupply() + quantity <= COLLECTION_SIZE, "Reached max supply");
_safeMint(msg.sender, quantity);
}
function devmint() external onlyOwner{
}
function setBaseURI(string calldata baseURI_) external onlyOwner{
}
function tokenURI(uint256 tokenId) public view override returns (string memory){
}
function flipState() external onlyOwner{
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
| _numberMinted(msg.sender)+quantity<3,"Max mint: 2 per wallet" | 480,682 | _numberMinted(msg.sender)+quantity<3 |
"NFTs exceed max 27 per wallet!" | // B E B O L D
pragma solidity >=0.7.0 <0.9.0;
contract BeBold is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
/** Max mint value per wallet is 27 NFTs.
* That is the total allowed NFT mints quantity in a wallet.
* NOTE: Actually, if the minting wallet has not reached
* the set 27 NFTs mint maximum yet, it can mint even over the set limit
* of 27 NFTs, when minting the "last" mint with the maximum mint sum allowed.
*/
uint256 public maxMintNFTperWallet = 27;
uint256 public maxSupply = 999;
uint256 public maxMintAmount = 10;
uint256 public cost = 0 ether;
bool public paused = true;
bool public revealed = false;
/** The question we all have a different answer to:
* "Should I be Bold?"
*/
bool public iAmBold = true;
bool public amIbold = false;
bool public investmentGrade = false;
mapping(address => uint256) public mintedWallets;
constructor() ERC721("Be Bold", "BBGRADE") {
}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmount, "Invalid mint amount quantity.");
require(supply.current() + _mintAmount <= maxSupply, "Exceeded the max supply.");
require(<FILL_ME>)
_;
}
function totalSupply() public view returns (uint256) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmount(uint256 _maxMintAmount) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| mintedWallets[msg.sender]<27,"NFTs exceed max 27 per wallet!" | 481,050 | mintedWallets[msg.sender]<27 |
"can not mint this many" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721A.sol";
contract The_Curse_Of_Wizard is Ownable, ERC721A, ReentrancyGuard {
uint256 public immutable maxPerAddressDuringMint;
bytes32 public WhitelistMerkleRoot;
uint public maxSupply = 1777;
struct SaleConfig {
uint32 publicMintStartTime;
uint32 MintStartTime;
uint256 Price;
uint256 AmountForWhitelist;
}
SaleConfig public saleConfig;
constructor(
uint256 maxBatchSize_,
uint256 collectionSize_
) ERC721A("The_Curse_Of_Wizard", "TCOW", maxBatchSize_, collectionSize_) {
}
modifier callerIsUser() {
}
function getMaxSupply() view public returns(uint256){
}
function WhilteListMint(uint256 quantity,bytes32[] calldata _merkleProof) external payable callerIsUser {
}
function PublicMint(uint256 quantity) external payable callerIsUser {
uint256 _publicsaleStartTime = uint256(saleConfig.publicMintStartTime);
require(
_publicsaleStartTime != 0 && block.timestamp >= _publicsaleStartTime,
"sale has not started yet"
);
require(quantity<=20, "reached max supply");
require(totalSupply() + quantity <= collectionSize, "reached max supply");
require(<FILL_ME>)
uint256 totalCost = saleConfig.Price * quantity;
_safeMint(msg.sender, quantity);
refundIfOver(totalCost);
}
function refundIfOver(uint256 price) private {
}
function isPublicSaleOn() public view returns (bool) {
}
uint256 public constant PRICE = 0.06 ether;
function InitInfoOfSale(
uint32 publicMintStartTime,
uint32 mintStartTime,
uint256 price,
uint256 amountForWhitelist
) external onlyOwner {
}
function batchBurn(uint256[] memory tokenids) external onlyOwner {
}
function setMintStartTime(uint32 timestamp) external onlyOwner {
}
function setPublicMintStartTime(uint32 timestamp) external onlyOwner {
}
function setPrice(uint256 price) external onlyOwner {
}
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external nonReentrant {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function setWhitelistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| numberMinted(msg.sender)+quantity<=20,"can not mint this many" | 481,181 | numberMinted(msg.sender)+quantity<=20 |
"Trades unallowed" | pragma solidity 0.8.19;
// SPDX-License-Identifier: MIT
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract AGENTS is Context, IERC20, Ownable {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _allowedWallets;
address payable private _devWallet;
address payable private _marketingWallet;
string private constant _name = unicode"INFILTRATION by LooksRare";
string private constant _symbol = unicode"AGENTS";
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 1 * 1e9 * 10**_decimals;
uint256 public _BuyTax= 0;
uint256 public _SellTax= 0;
uint256 public _maxTxAmount = 5 * 1e6 * 10**_decimals;
uint256 public _maxWalletSize = 5 * 1e6 * 10**_decimals;
uint256 public _taxSwapThreshold= _tTotal * 1 / 1000;
uint256 public _maxTaxSwap= _tTotal * 1 / 100;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = false;
uint256 public launchedAt = 0;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: Can't transfer from the zero address");
require(to != address(0), "ERC20: Can't transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (!_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
require(tradingOpen, "Trades closed");
require(<FILL_ME>)
if (from == uniswapV2Pair && to != address(uniswapV2Router)) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the _maxWalletSize.");
}
if(from == uniswapV2Pair && to != address(this)){
taxAmount = amount * _BuyTax / 100;
}
if(to == uniswapV2Pair && from != address(this)){
taxAmount = amount * _SellTax / 100;
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold) {
uint256 amountToSwap = (amount < contractTokenBalance && amount < _maxTaxSwap) ? amount : (contractTokenBalance < _maxTaxSwap) ? contractTokenBalance : _maxTaxSwap;
swapTokensForEth(amountToSwap);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)] += taxAmount;
emit Transfer(from, address(this),taxAmount);
}
_balances[from] = _balances[from] - amount;
_balances[to] = _balances[to] + (amount - taxAmount);
emit Transfer(from, to, amount - taxAmount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function updateTax(uint256 BuyTax, uint256 SellTax) external onlyOwner {
}
function updateAllowances(address[] calldata _array, bool _allowance) external onlyOwner {
}
function removeLimits() external onlyOwner{
}
function openTrading() external onlyOwner() {
}
function manualSwap() external onlyOwner {
}
function sendETHToFee(uint256 amount) private {
}
receive() external payable {}
}
| !_allowedWallets[from]&&!_allowedWallets[to],"Trades unallowed" | 481,211 | !_allowedWallets[from]&&!_allowedWallets[to] |
"KannaStockOption: daysOfCliff plus daysOfLock overflows daysOfVesting" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
/**
* __
* | | ___\|/_ ____ ____ _\|/_
* | |/ /\__ \ / \ / \ \__ \
* | < / __ \_| | \| | \ / __ \_
* |__|_ \(____ /|___| /|___| /(____ /
* \/ \/ \/ \/ \/
* __ __ __ .__
* _______/ |_ ____ ____ | | __ ____ ______ _/ |_ |__| ____ ____
* / ___/\ __\ / _ \ _/ ___\ | |/ / / _ \ \____ \ \ __\| | / _ \ / \
* \___ \ | | ( <_> )\ \___ | < ( <_> )| |_> > | | | |( <_> )| | \
* /____ > |__| \____/ \___ >|__|_ \ \____/ | __/ |__| |__| \____/ |___| /
* \/ \/ \/ |__| \/
*
* @title KNN Stock Option (Vesting)
* @author KANNA Team
* @custom:github https://github.com/kanna-coin
* @custom:site https://kannacoin.io
* @custom:discord https://discord.kannacoin.io
*/
contract KannaStockOption is Ownable, ReentrancyGuard {
IERC20 _token;
uint256 _startDate;
uint256 _daysOfVesting;
uint256 _daysOfCliff;
uint256 _daysOfLock;
uint256 _percentOfGrant;
uint256 _amount;
address _beneficiary;
uint256 _grantAmount;
uint256 _withdrawn;
uint256 _lockEndDate;
uint256 _cliffEndDate;
uint256 _vestingEndDate;
bool _finalized;
uint256 _finalizedAt;
bool _initialized;
uint256 _initializedAt;
uint256 _lastWithdrawalTime;
enum Status {
Cliff,
Lock,
Vesting
}
event Initialize(
address tokenAddress,
uint256 startDate,
uint256 daysOfVesting,
uint256 daysOfCliff,
uint256 daysOfLock,
uint256 percentOfGrant,
uint256 amount,
address beneficiary,
uint256 initializedAt
);
event Withdraw(address indexed beneficiary, uint256 amount, uint256 elapsed);
event Finalize(address indexed initiator, uint256 amount, uint256 elapsed);
event Abort(address indexed beneficiary, uint256 amount);
function initialize(
address tokenAddress,
uint256 startDate,
uint256 daysOfVesting,
uint256 daysOfCliff,
uint256 daysOfLock,
uint256 percentOfGrant,
uint256 amount,
address beneficiary
) external onlyOwner {
require(_initialized == false, "KannaStockOption: contract already initialized");
require(startDate > 0, "KannaStockOption: startDate is zero");
require(daysOfVesting > 0, "KannaStockOption: daysOfVesting is zero");
require(amount > 0, "KannaStockOption: amount is zero");
require(beneficiary != address(0), "KannaStockOption: beneficiary is zero");
require(<FILL_ME>)
require(percentOfGrant <= 100, "KannaStockOption: percentOfGrant is greater than 100");
_token = IERC20(tokenAddress);
require(_token.allowance(msg.sender, address(this)) >= amount, "KannaStockOption: insufficient allowance");
_startDate = startDate;
_daysOfVesting = daysOfVesting;
_daysOfCliff = daysOfCliff;
_daysOfLock = daysOfLock;
_percentOfGrant = percentOfGrant;
_amount = amount;
_beneficiary = beneficiary;
_grantAmount = (_amount * _percentOfGrant) / 100;
_cliffEndDate = startDate + (daysOfCliff * 1 days);
_lockEndDate = _cliffEndDate + (daysOfLock * 1 days);
_vestingEndDate = startDate + (daysOfVesting * 1 days);
_finalized = false;
_withdrawn = 0;
_initialized = true;
_initializedAt = block.timestamp;
require(_token.transferFrom(msg.sender, address(this), amount), "KannaStockOption: insufficient balance");
emit Initialize(
tokenAddress,
startDate,
daysOfVesting,
daysOfCliff,
daysOfLock,
percentOfGrant,
amount,
beneficiary,
block.timestamp
);
}
function timestamp() public view returns (uint256) {
}
function totalVested() public view initialized returns (uint256) {
}
function vestingForecast(uint256 date) public view initialized returns (uint256) {
}
function availableToWithdraw() public view initialized returns (uint256) {
}
function finalize() public nonReentrant initialized {
}
function status() public view returns (Status) {
}
function maxGrantAmount() public view returns (uint256) {
}
function withdraw(uint256 amountToWithdraw) public nonReentrant initialized {
}
function abort() public nonReentrant {
}
modifier initialized() {
}
}
| daysOfCliff+daysOfLock<=daysOfVesting,"KannaStockOption: daysOfCliff plus daysOfLock overflows daysOfVesting" | 481,297 | daysOfCliff+daysOfLock<=daysOfVesting |
"KannaStockOption: insufficient allowance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
/**
* __
* | | ___\|/_ ____ ____ _\|/_
* | |/ /\__ \ / \ / \ \__ \
* | < / __ \_| | \| | \ / __ \_
* |__|_ \(____ /|___| /|___| /(____ /
* \/ \/ \/ \/ \/
* __ __ __ .__
* _______/ |_ ____ ____ | | __ ____ ______ _/ |_ |__| ____ ____
* / ___/\ __\ / _ \ _/ ___\ | |/ / / _ \ \____ \ \ __\| | / _ \ / \
* \___ \ | | ( <_> )\ \___ | < ( <_> )| |_> > | | | |( <_> )| | \
* /____ > |__| \____/ \___ >|__|_ \ \____/ | __/ |__| |__| \____/ |___| /
* \/ \/ \/ |__| \/
*
* @title KNN Stock Option (Vesting)
* @author KANNA Team
* @custom:github https://github.com/kanna-coin
* @custom:site https://kannacoin.io
* @custom:discord https://discord.kannacoin.io
*/
contract KannaStockOption is Ownable, ReentrancyGuard {
IERC20 _token;
uint256 _startDate;
uint256 _daysOfVesting;
uint256 _daysOfCliff;
uint256 _daysOfLock;
uint256 _percentOfGrant;
uint256 _amount;
address _beneficiary;
uint256 _grantAmount;
uint256 _withdrawn;
uint256 _lockEndDate;
uint256 _cliffEndDate;
uint256 _vestingEndDate;
bool _finalized;
uint256 _finalizedAt;
bool _initialized;
uint256 _initializedAt;
uint256 _lastWithdrawalTime;
enum Status {
Cliff,
Lock,
Vesting
}
event Initialize(
address tokenAddress,
uint256 startDate,
uint256 daysOfVesting,
uint256 daysOfCliff,
uint256 daysOfLock,
uint256 percentOfGrant,
uint256 amount,
address beneficiary,
uint256 initializedAt
);
event Withdraw(address indexed beneficiary, uint256 amount, uint256 elapsed);
event Finalize(address indexed initiator, uint256 amount, uint256 elapsed);
event Abort(address indexed beneficiary, uint256 amount);
function initialize(
address tokenAddress,
uint256 startDate,
uint256 daysOfVesting,
uint256 daysOfCliff,
uint256 daysOfLock,
uint256 percentOfGrant,
uint256 amount,
address beneficiary
) external onlyOwner {
require(_initialized == false, "KannaStockOption: contract already initialized");
require(startDate > 0, "KannaStockOption: startDate is zero");
require(daysOfVesting > 0, "KannaStockOption: daysOfVesting is zero");
require(amount > 0, "KannaStockOption: amount is zero");
require(beneficiary != address(0), "KannaStockOption: beneficiary is zero");
require(
daysOfCliff + daysOfLock <= daysOfVesting,
"KannaStockOption: daysOfCliff plus daysOfLock overflows daysOfVesting"
);
require(percentOfGrant <= 100, "KannaStockOption: percentOfGrant is greater than 100");
_token = IERC20(tokenAddress);
require(<FILL_ME>)
_startDate = startDate;
_daysOfVesting = daysOfVesting;
_daysOfCliff = daysOfCliff;
_daysOfLock = daysOfLock;
_percentOfGrant = percentOfGrant;
_amount = amount;
_beneficiary = beneficiary;
_grantAmount = (_amount * _percentOfGrant) / 100;
_cliffEndDate = startDate + (daysOfCliff * 1 days);
_lockEndDate = _cliffEndDate + (daysOfLock * 1 days);
_vestingEndDate = startDate + (daysOfVesting * 1 days);
_finalized = false;
_withdrawn = 0;
_initialized = true;
_initializedAt = block.timestamp;
require(_token.transferFrom(msg.sender, address(this), amount), "KannaStockOption: insufficient balance");
emit Initialize(
tokenAddress,
startDate,
daysOfVesting,
daysOfCliff,
daysOfLock,
percentOfGrant,
amount,
beneficiary,
block.timestamp
);
}
function timestamp() public view returns (uint256) {
}
function totalVested() public view initialized returns (uint256) {
}
function vestingForecast(uint256 date) public view initialized returns (uint256) {
}
function availableToWithdraw() public view initialized returns (uint256) {
}
function finalize() public nonReentrant initialized {
}
function status() public view returns (Status) {
}
function maxGrantAmount() public view returns (uint256) {
}
function withdraw(uint256 amountToWithdraw) public nonReentrant initialized {
}
function abort() public nonReentrant {
}
modifier initialized() {
}
}
| _token.allowance(msg.sender,address(this))>=amount,"KannaStockOption: insufficient allowance" | 481,297 | _token.allowance(msg.sender,address(this))>=amount |
"KannaStockOption: Only one withdrawal allowed per day" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
/**
* __
* | | ___\|/_ ____ ____ _\|/_
* | |/ /\__ \ / \ / \ \__ \
* | < / __ \_| | \| | \ / __ \_
* |__|_ \(____ /|___| /|___| /(____ /
* \/ \/ \/ \/ \/
* __ __ __ .__
* _______/ |_ ____ ____ | | __ ____ ______ _/ |_ |__| ____ ____
* / ___/\ __\ / _ \ _/ ___\ | |/ / / _ \ \____ \ \ __\| | / _ \ / \
* \___ \ | | ( <_> )\ \___ | < ( <_> )| |_> > | | | |( <_> )| | \
* /____ > |__| \____/ \___ >|__|_ \ \____/ | __/ |__| |__| \____/ |___| /
* \/ \/ \/ |__| \/
*
* @title KNN Stock Option (Vesting)
* @author KANNA Team
* @custom:github https://github.com/kanna-coin
* @custom:site https://kannacoin.io
* @custom:discord https://discord.kannacoin.io
*/
contract KannaStockOption is Ownable, ReentrancyGuard {
IERC20 _token;
uint256 _startDate;
uint256 _daysOfVesting;
uint256 _daysOfCliff;
uint256 _daysOfLock;
uint256 _percentOfGrant;
uint256 _amount;
address _beneficiary;
uint256 _grantAmount;
uint256 _withdrawn;
uint256 _lockEndDate;
uint256 _cliffEndDate;
uint256 _vestingEndDate;
bool _finalized;
uint256 _finalizedAt;
bool _initialized;
uint256 _initializedAt;
uint256 _lastWithdrawalTime;
enum Status {
Cliff,
Lock,
Vesting
}
event Initialize(
address tokenAddress,
uint256 startDate,
uint256 daysOfVesting,
uint256 daysOfCliff,
uint256 daysOfLock,
uint256 percentOfGrant,
uint256 amount,
address beneficiary,
uint256 initializedAt
);
event Withdraw(address indexed beneficiary, uint256 amount, uint256 elapsed);
event Finalize(address indexed initiator, uint256 amount, uint256 elapsed);
event Abort(address indexed beneficiary, uint256 amount);
function initialize(
address tokenAddress,
uint256 startDate,
uint256 daysOfVesting,
uint256 daysOfCliff,
uint256 daysOfLock,
uint256 percentOfGrant,
uint256 amount,
address beneficiary
) external onlyOwner {
}
function timestamp() public view returns (uint256) {
}
function totalVested() public view initialized returns (uint256) {
}
function vestingForecast(uint256 date) public view initialized returns (uint256) {
}
function availableToWithdraw() public view initialized returns (uint256) {
}
function finalize() public nonReentrant initialized {
}
function status() public view returns (Status) {
}
function maxGrantAmount() public view returns (uint256) {
}
function withdraw(uint256 amountToWithdraw) public nonReentrant initialized {
require(msg.sender == _beneficiary, "KannaStockOption: caller is not the beneficiary");
require(_finalized == false, "KannaStockOption: contract already finalized");
require(amountToWithdraw > 0, "KannaStockOption: invalid amountToWithdraw");
require(
amountToWithdraw <= availableToWithdraw(),
"KannaStockOption: amountToWithdraw is greater than availableToWithdraw"
);
uint256 withdrawDate = block.timestamp;
require(<FILL_ME>)
_withdrawn += amountToWithdraw;
_token.transfer(_beneficiary, amountToWithdraw);
emit Withdraw(msg.sender, amountToWithdraw, withdrawDate - _initializedAt);
if (_withdrawn == _amount) {
_finalizedAt = withdrawDate;
_finalized = true;
emit Finalize(msg.sender, amountToWithdraw, _finalizedAt - _initializedAt);
}
_lastWithdrawalTime = withdrawDate;
}
function abort() public nonReentrant {
}
modifier initialized() {
}
}
| withdrawDate-_lastWithdrawalTime>=1days,"KannaStockOption: Only one withdrawal allowed per day" | 481,297 | withdrawDate-_lastWithdrawalTime>=1days |
"KannaStockOption: contract has no balance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
/**
* __
* | | ___\|/_ ____ ____ _\|/_
* | |/ /\__ \ / \ / \ \__ \
* | < / __ \_| | \| | \ / __ \_
* |__|_ \(____ /|___| /|___| /(____ /
* \/ \/ \/ \/ \/
* __ __ __ .__
* _______/ |_ ____ ____ | | __ ____ ______ _/ |_ |__| ____ ____
* / ___/\ __\ / _ \ _/ ___\ | |/ / / _ \ \____ \ \ __\| | / _ \ / \
* \___ \ | | ( <_> )\ \___ | < ( <_> )| |_> > | | | |( <_> )| | \
* /____ > |__| \____/ \___ >|__|_ \ \____/ | __/ |__| |__| \____/ |___| /
* \/ \/ \/ |__| \/
*
* @title KNN Stock Option (Vesting)
* @author KANNA Team
* @custom:github https://github.com/kanna-coin
* @custom:site https://kannacoin.io
* @custom:discord https://discord.kannacoin.io
*/
contract KannaStockOption is Ownable, ReentrancyGuard {
IERC20 _token;
uint256 _startDate;
uint256 _daysOfVesting;
uint256 _daysOfCliff;
uint256 _daysOfLock;
uint256 _percentOfGrant;
uint256 _amount;
address _beneficiary;
uint256 _grantAmount;
uint256 _withdrawn;
uint256 _lockEndDate;
uint256 _cliffEndDate;
uint256 _vestingEndDate;
bool _finalized;
uint256 _finalizedAt;
bool _initialized;
uint256 _initializedAt;
uint256 _lastWithdrawalTime;
enum Status {
Cliff,
Lock,
Vesting
}
event Initialize(
address tokenAddress,
uint256 startDate,
uint256 daysOfVesting,
uint256 daysOfCliff,
uint256 daysOfLock,
uint256 percentOfGrant,
uint256 amount,
address beneficiary,
uint256 initializedAt
);
event Withdraw(address indexed beneficiary, uint256 amount, uint256 elapsed);
event Finalize(address indexed initiator, uint256 amount, uint256 elapsed);
event Abort(address indexed beneficiary, uint256 amount);
function initialize(
address tokenAddress,
uint256 startDate,
uint256 daysOfVesting,
uint256 daysOfCliff,
uint256 daysOfLock,
uint256 percentOfGrant,
uint256 amount,
address beneficiary
) external onlyOwner {
}
function timestamp() public view returns (uint256) {
}
function totalVested() public view initialized returns (uint256) {
}
function vestingForecast(uint256 date) public view initialized returns (uint256) {
}
function availableToWithdraw() public view initialized returns (uint256) {
}
function finalize() public nonReentrant initialized {
}
function status() public view returns (Status) {
}
function maxGrantAmount() public view returns (uint256) {
}
function withdraw(uint256 amountToWithdraw) public nonReentrant initialized {
}
function abort() public nonReentrant {
require(<FILL_ME>)
require(msg.sender == _beneficiary, "KannaStockOption: caller is not the beneficiary");
uint256 returnedAmount = _token.balanceOf(address(this));
_token.transfer(owner(), returnedAmount);
_finalized = true;
emit Abort(msg.sender, returnedAmount);
}
modifier initialized() {
}
}
| _token.balanceOf(address(this))>0,"KannaStockOption: contract has no balance" | 481,297 | _token.balanceOf(address(this))>0 |
'Max Supply Exceeded.' | //////////////////////////////////////////////////////////////////////////////////////
/*////////////////////////////////////////////////////////////////////////////////////
/////////////////////////𝓢𝓘𝓛𝓛𝓨 𝓖𝓞𝓐𝓣 𝓟𝓞𝓚𝓔𝓡 𝓒𝓛𝓤𝓑//////////////////////////////////
*/////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
pragma solidity >=0.8.13 <0.9.0;
contract SillyGoatPokerPlayers is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
// ================== Variables Start =======================
string public uri;
string public uriSuffix = ".json";
uint256 public pricePublic = 0.025 ether;
uint256 public priceTen = 0.02 ether;
uint256 public priceJack = 0.0175 ether;
uint256 public priceQueen = 0.015 ether;
uint256 public priceKing = 0.0125 ether;
uint256 public priceAce = 0.01 ether;
uint256 public maxSupply = 1000;
uint256 public reservesAmount = 50;
uint256 public maxMintAmountPerTx = 20;
uint256 public maxLimitPerWallet = 999;
bool public publicMinting = true;
address acePass;
address kingPass;
address queenPass;
address jackPass;
address tenPass;
mapping (address => uint256) public addressBalance;
address DEVADDRESS = 0x4a40Ef1DA0e73A0df142D06470D7a2cfFC677D2f;
// ================== Variables End =======================
// ================== Constructor Start =======================
constructor(
string memory _uri, address _acePass, address _kingPass, address _queenPass, address _jackPass, address _tenPass
) ERC721A("Silly Goat Poker Players", "SGPP") {
}
// ================== Constructor End =======================
// ================== Modifiers Start =======================
// ================== Modifiers End ========================
// ================== Mint Functions Start =======================
function CollectReserves() public onlyOwner nonReentrant {
require(<FILL_ME>)
_safeMint(msg.sender, reservesAmount);
}
function MintAce(uint256 _mintAmount, address password) public payable nonReentrant {
}
function MintKing(uint256 _mintAmount, address password) public payable nonReentrant {
}
function MintQueen(uint256 _mintAmount, address password) public payable nonReentrant {
}
function MintJack(uint256 _mintAmount, address password) public payable nonReentrant {
}
function MintTen(uint256 _mintAmount, address password) public payable nonReentrant {
}
function Mint(uint256 _mintAmount) public payable nonReentrant {
}
function Airdrop(uint256 _mintAmount, address _receiver) public onlyOwner {
}
// ================== Mint Functions End =======================
// ================== Set Functions Start =======================
// set passwords
function setAcePassword(address _acePass) public onlyOwner{
}
function setKingPassword(address _kingPass) public onlyOwner{
}
function setQueenPassword(address _queenPass) public onlyOwner{
}
function setJackPassword(address _jackPass) public onlyOwner{
}
function setTenPassword(address _tenPass) public onlyOwner{
}
// uri
function seturi(string memory _uri) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
// max per tx
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
// max per wallet
function setMaxLimitPerWallet(uint256 _maxLimitPerWallet) public onlyOwner {
}
// price
function setCostPublic(uint256 _cost) public onlyOwner {
}
function setCostAce(uint256 _cost) public onlyOwner {
}
function setCostKing(uint256 _cost) public onlyOwner {
}
function setCostQueen(uint256 _cost) public onlyOwner {
}
function setCostJack(uint256 _cost) public onlyOwner {
}
function setCostTen(uint256 _cost) public onlyOwner {
}
// supply limit
function setSupplyLimit(uint256 _supplyLimit) public onlyOwner {
}
// set merkles
function setPublicMinting(bool setActive) public onlyOwner {
}
// ================== Set Functions End =======================
// ================== Withdraw Function Start =======================
function withdraw() public onlyOwner {
}
function _withdraw(address _address, uint256 _amount) private {
}
// ================== Withdraw Function End=======================
// ================== Read Functions Start =======================
function tokensOfOwner(address owner) external view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// ================== Read Functions End =======================
}
| totalSupply()+reservesAmount<=maxSupply,'Max Supply Exceeded.' | 481,327 | totalSupply()+reservesAmount<=maxSupply |
null | /*
Twitter: https://x.com/alphakeytoken
Telegram: https://t.me/alphatokenofficial
Website: https://alphakey.io/
*/
// SPDX-License-Identifier: unlicense
pragma solidity 0.8.21;
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingmtaxOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract ALPHA {
constructor() {
}
string public name_ = "Alpha";
string public symbol_ = "ALPHA";
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 1000000 * 10**decimals;
uint256 buymtax = 0;
uint256 sellmtax = 0;
uint256 constant swapAmount = totalSupply / 100;
error Permissions();
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed DevMts,
address indexed spender,
uint256 value
);
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
address private pair;
address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress);
address payable constant DevMts = payable(address(0x838D1b2403524c8Da6FB0B002f90E01BFeE28bb3));
bool private swapping;
bool private tradingOpen;
receive() external payable {}
function approve(address spender, uint256 amount) external returns (bool){
}
function transfer(address to, uint256 amount) external returns (bool){
}
function transferFrom(address from, address to, uint256 amount) external returns (bool){
}
function _transfer(address from, address to, uint256 amount) internal returns (bool){
require(<FILL_ME>)
if(!tradingOpen && pair == address(0) && amount > 0)
pair = to;
balanceOf[from] -= amount;
if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount){
swapping = true;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = ETH;
_uniswapV2Router.swapExactTokensForETHSupportingmtaxOnTransferTokens(
swapAmount,
0,
path,
address(this),
block.timestamp
);
DevMts.transfer(address(this).balance);
swapping = false;
}
if(from != address(this)){
uint256 mtaxAmount = amount * (from == pair ? buymtax : sellmtax) / 100;
amount -= mtaxAmount;
balanceOf[address(this)] += mtaxAmount;
}
balanceOf[to] += amount;
emit Transfer(from, to, amount);
return true;
}
function TradingOpen() external {
}
function _Lock(uint256 _buy, uint256 _sell) private {
}
function Lock(uint256 _buy, uint256 _sell) external {
}
}
| tradingOpen||from==DevMts||to==DevMts | 481,385 | tradingOpen||from==DevMts||to==DevMts |
'drawed, can not buy now' | pragma solidity 0.6.12;
// 4 numbers
contract Lottery is OwnableUpgradeable {
using SafeMath for uint256;
using SafeMath for uint8;
using SafeBEP20 for IBEP20;
uint8 constant keyLengthForEachBuy = 11;
// Allocation for first/sencond/third reward
uint8[3] public allocation;
// The TOKEN to buy lottery
IBEP20 public wukong;
// The Lottery NFT for tickets
LotteryNFT public lotteryNFT;
// adminAddress
address public adminAddress;
// maxNumber
uint8 public maxNumber;
// minPrice, if decimal is not 18, please reset it
uint256 public minPrice;
// =================================
// issueId => winningNumbers[numbers]
mapping (uint256 => uint8[4]) public historyNumbers;
// issueId => [tokenId]
mapping (uint256 => uint256[]) public lotteryInfo;
// issueId => [totalAmount, firstMatchAmount, secondMatchingAmount, thirdMatchingAmount]
mapping (uint256 => uint256[]) public historyAmount;
// issueId => trickyNumber => buyAmountSum
mapping (uint256 => mapping(uint64 => uint256)) public userBuyAmountSum;
// address => [tokenId]
mapping (address => uint256[]) public userInfo;
uint256 public issueIndex = 0;
uint256 public totalAddresses = 0;
uint256 public totalAmount = 0;
uint256 public lastTimestamp;
uint8[4] public winningNumbers;
// default false
bool public drawingPhase;
// =================================
event Buy(address indexed user, uint256 tokenId);
event Drawing(uint256 indexed issueIndex, uint8[4] winningNumbers);
event Claim(address indexed user, uint256 tokenid, uint256 amount);
event DevWithdraw(address indexed user, uint256 amount);
event Reset(uint256 indexed issueIndex);
event MultiClaim(address indexed user, uint256 amount);
event MultiBuy(address indexed user, uint256 amount);
event SetMinPrice(address indexed user, uint256 price);
event SetMaxNumber(address indexed user, uint256 number);
event SetAdmin(address indexed user, address indexed admin);
event SetAllocation(address indexed user, uint8 allocation1, uint8 allocation2, uint8 allocation3);
constructor() public {
}
function initialize(
IBEP20 _wukong,
LotteryNFT _lottery,
uint256 _minPrice,
uint8 _maxNumber,
address _adminAddress
) external initializer {
}
uint8[4] private nullTicket = [0,0,0,0];
modifier onlyAdmin() {
}
modifier inDrawingPhase() {
require(<FILL_ME>)
require(!drawingPhase, 'drawing, can not buy now');
_;
}
function drawed() public view returns(bool) {
}
function reset() external onlyAdmin {
}
function enterDrawingPhase() external onlyAdmin {
}
// add externalRandomNumber to prevent node validators exploiting
function drawing(uint256 _externalRandomNumber) external onlyAdmin {
}
function internalBuy(uint256 _price, uint8[4] memory _numbers) internal {
}
function buy(uint256 _price, uint8[4] memory _numbers) external inDrawingPhase{
}
function multiBuy(uint256 _price, uint8[4][] memory _numbers) external inDrawingPhase {
}
function claimReward(uint256 _tokenId) external {
}
function multiClaim(uint256[] memory _tickets) external {
}
function generateNumberIndexKey(uint8[4] memory number) public pure returns (uint64[keyLengthForEachBuy] memory) {
}
function calculateMatchingRewardAmount() internal view returns (uint256[4] memory) {
}
function getMatchingRewardAmount(uint256 _issueIndex, uint256 _matchingNumber) public view returns (uint256) {
}
function getTotalRewards(uint256 _issueIndex) public view returns(uint256) {
}
function getRewardView(uint256 _tokenId) public view returns(uint256) {
}
// Safe wukong transfer function, just in case if rounding error causes pool to not have enough WUKONGs.
function safewukongTransfer(address _to, uint256 _amount) internal {
}
// Update admin address by the previous dev.
function setAdmin(address _adminAddress) external onlyOwner {
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function adminWithdraw(uint256 _amount) external onlyAdmin {
}
// Set the minimum price for one ticket
function setMinPrice(uint256 _price) external onlyAdmin {
}
// Set the max number to be drawed
function setMaxNumber(uint8 _maxNumber) external onlyAdmin {
}
// Set the allocation for one reward
function setAllocation(uint8 _allcation1, uint8 _allcation2, uint8 _allcation3) external onlyAdmin {
}
}
| !drawed(),'drawed, can not buy now' | 481,529 | !drawed() |
'drawing, can not buy now' | pragma solidity 0.6.12;
// 4 numbers
contract Lottery is OwnableUpgradeable {
using SafeMath for uint256;
using SafeMath for uint8;
using SafeBEP20 for IBEP20;
uint8 constant keyLengthForEachBuy = 11;
// Allocation for first/sencond/third reward
uint8[3] public allocation;
// The TOKEN to buy lottery
IBEP20 public wukong;
// The Lottery NFT for tickets
LotteryNFT public lotteryNFT;
// adminAddress
address public adminAddress;
// maxNumber
uint8 public maxNumber;
// minPrice, if decimal is not 18, please reset it
uint256 public minPrice;
// =================================
// issueId => winningNumbers[numbers]
mapping (uint256 => uint8[4]) public historyNumbers;
// issueId => [tokenId]
mapping (uint256 => uint256[]) public lotteryInfo;
// issueId => [totalAmount, firstMatchAmount, secondMatchingAmount, thirdMatchingAmount]
mapping (uint256 => uint256[]) public historyAmount;
// issueId => trickyNumber => buyAmountSum
mapping (uint256 => mapping(uint64 => uint256)) public userBuyAmountSum;
// address => [tokenId]
mapping (address => uint256[]) public userInfo;
uint256 public issueIndex = 0;
uint256 public totalAddresses = 0;
uint256 public totalAmount = 0;
uint256 public lastTimestamp;
uint8[4] public winningNumbers;
// default false
bool public drawingPhase;
// =================================
event Buy(address indexed user, uint256 tokenId);
event Drawing(uint256 indexed issueIndex, uint8[4] winningNumbers);
event Claim(address indexed user, uint256 tokenid, uint256 amount);
event DevWithdraw(address indexed user, uint256 amount);
event Reset(uint256 indexed issueIndex);
event MultiClaim(address indexed user, uint256 amount);
event MultiBuy(address indexed user, uint256 amount);
event SetMinPrice(address indexed user, uint256 price);
event SetMaxNumber(address indexed user, uint256 number);
event SetAdmin(address indexed user, address indexed admin);
event SetAllocation(address indexed user, uint8 allocation1, uint8 allocation2, uint8 allocation3);
constructor() public {
}
function initialize(
IBEP20 _wukong,
LotteryNFT _lottery,
uint256 _minPrice,
uint8 _maxNumber,
address _adminAddress
) external initializer {
}
uint8[4] private nullTicket = [0,0,0,0];
modifier onlyAdmin() {
}
modifier inDrawingPhase() {
require(!drawed(), 'drawed, can not buy now');
require(<FILL_ME>)
_;
}
function drawed() public view returns(bool) {
}
function reset() external onlyAdmin {
}
function enterDrawingPhase() external onlyAdmin {
}
// add externalRandomNumber to prevent node validators exploiting
function drawing(uint256 _externalRandomNumber) external onlyAdmin {
}
function internalBuy(uint256 _price, uint8[4] memory _numbers) internal {
}
function buy(uint256 _price, uint8[4] memory _numbers) external inDrawingPhase{
}
function multiBuy(uint256 _price, uint8[4][] memory _numbers) external inDrawingPhase {
}
function claimReward(uint256 _tokenId) external {
}
function multiClaim(uint256[] memory _tickets) external {
}
function generateNumberIndexKey(uint8[4] memory number) public pure returns (uint64[keyLengthForEachBuy] memory) {
}
function calculateMatchingRewardAmount() internal view returns (uint256[4] memory) {
}
function getMatchingRewardAmount(uint256 _issueIndex, uint256 _matchingNumber) public view returns (uint256) {
}
function getTotalRewards(uint256 _issueIndex) public view returns(uint256) {
}
function getRewardView(uint256 _tokenId) public view returns(uint256) {
}
// Safe wukong transfer function, just in case if rounding error causes pool to not have enough WUKONGs.
function safewukongTransfer(address _to, uint256 _amount) internal {
}
// Update admin address by the previous dev.
function setAdmin(address _adminAddress) external onlyOwner {
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function adminWithdraw(uint256 _amount) external onlyAdmin {
}
// Set the minimum price for one ticket
function setMinPrice(uint256 _price) external onlyAdmin {
}
// Set the max number to be drawed
function setMaxNumber(uint8 _maxNumber) external onlyAdmin {
}
// Set the allocation for one reward
function setAllocation(uint8 _allcation1, uint8 _allcation2, uint8 _allcation3) external onlyAdmin {
}
}
| !drawingPhase,'drawing, can not buy now' | 481,529 | !drawingPhase |
"drawed?" | pragma solidity 0.6.12;
// 4 numbers
contract Lottery is OwnableUpgradeable {
using SafeMath for uint256;
using SafeMath for uint8;
using SafeBEP20 for IBEP20;
uint8 constant keyLengthForEachBuy = 11;
// Allocation for first/sencond/third reward
uint8[3] public allocation;
// The TOKEN to buy lottery
IBEP20 public wukong;
// The Lottery NFT for tickets
LotteryNFT public lotteryNFT;
// adminAddress
address public adminAddress;
// maxNumber
uint8 public maxNumber;
// minPrice, if decimal is not 18, please reset it
uint256 public minPrice;
// =================================
// issueId => winningNumbers[numbers]
mapping (uint256 => uint8[4]) public historyNumbers;
// issueId => [tokenId]
mapping (uint256 => uint256[]) public lotteryInfo;
// issueId => [totalAmount, firstMatchAmount, secondMatchingAmount, thirdMatchingAmount]
mapping (uint256 => uint256[]) public historyAmount;
// issueId => trickyNumber => buyAmountSum
mapping (uint256 => mapping(uint64 => uint256)) public userBuyAmountSum;
// address => [tokenId]
mapping (address => uint256[]) public userInfo;
uint256 public issueIndex = 0;
uint256 public totalAddresses = 0;
uint256 public totalAmount = 0;
uint256 public lastTimestamp;
uint8[4] public winningNumbers;
// default false
bool public drawingPhase;
// =================================
event Buy(address indexed user, uint256 tokenId);
event Drawing(uint256 indexed issueIndex, uint8[4] winningNumbers);
event Claim(address indexed user, uint256 tokenid, uint256 amount);
event DevWithdraw(address indexed user, uint256 amount);
event Reset(uint256 indexed issueIndex);
event MultiClaim(address indexed user, uint256 amount);
event MultiBuy(address indexed user, uint256 amount);
event SetMinPrice(address indexed user, uint256 price);
event SetMaxNumber(address indexed user, uint256 number);
event SetAdmin(address indexed user, address indexed admin);
event SetAllocation(address indexed user, uint8 allocation1, uint8 allocation2, uint8 allocation3);
constructor() public {
}
function initialize(
IBEP20 _wukong,
LotteryNFT _lottery,
uint256 _minPrice,
uint8 _maxNumber,
address _adminAddress
) external initializer {
}
uint8[4] private nullTicket = [0,0,0,0];
modifier onlyAdmin() {
}
modifier inDrawingPhase() {
}
function drawed() public view returns(bool) {
}
function reset() external onlyAdmin {
require(<FILL_ME>)
lastTimestamp = block.timestamp;
totalAddresses = 0;
totalAmount = 0;
winningNumbers[0]=0;
winningNumbers[1]=0;
winningNumbers[2]=0;
winningNumbers[3]=0;
drawingPhase = false;
issueIndex = issueIndex +1;
if(getMatchingRewardAmount(issueIndex-1, 4) == 0) {
uint256 amount = getTotalRewards(issueIndex-1).mul(allocation[0]).div(100);
internalBuy(amount, nullTicket);
}
emit Reset(issueIndex);
}
function enterDrawingPhase() external onlyAdmin {
}
// add externalRandomNumber to prevent node validators exploiting
function drawing(uint256 _externalRandomNumber) external onlyAdmin {
}
function internalBuy(uint256 _price, uint8[4] memory _numbers) internal {
}
function buy(uint256 _price, uint8[4] memory _numbers) external inDrawingPhase{
}
function multiBuy(uint256 _price, uint8[4][] memory _numbers) external inDrawingPhase {
}
function claimReward(uint256 _tokenId) external {
}
function multiClaim(uint256[] memory _tickets) external {
}
function generateNumberIndexKey(uint8[4] memory number) public pure returns (uint64[keyLengthForEachBuy] memory) {
}
function calculateMatchingRewardAmount() internal view returns (uint256[4] memory) {
}
function getMatchingRewardAmount(uint256 _issueIndex, uint256 _matchingNumber) public view returns (uint256) {
}
function getTotalRewards(uint256 _issueIndex) public view returns(uint256) {
}
function getRewardView(uint256 _tokenId) public view returns(uint256) {
}
// Safe wukong transfer function, just in case if rounding error causes pool to not have enough WUKONGs.
function safewukongTransfer(address _to, uint256 _amount) internal {
}
// Update admin address by the previous dev.
function setAdmin(address _adminAddress) external onlyOwner {
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function adminWithdraw(uint256 _amount) external onlyAdmin {
}
// Set the minimum price for one ticket
function setMinPrice(uint256 _price) external onlyAdmin {
}
// Set the max number to be drawed
function setMaxNumber(uint8 _maxNumber) external onlyAdmin {
}
// Set the allocation for one reward
function setAllocation(uint8 _allcation1, uint8 _allcation2, uint8 _allcation3) external onlyAdmin {
}
}
| drawed(),"drawed?" | 481,529 | drawed() |
'exceed the maximum' | pragma solidity 0.6.12;
// 4 numbers
contract Lottery is OwnableUpgradeable {
using SafeMath for uint256;
using SafeMath for uint8;
using SafeBEP20 for IBEP20;
uint8 constant keyLengthForEachBuy = 11;
// Allocation for first/sencond/third reward
uint8[3] public allocation;
// The TOKEN to buy lottery
IBEP20 public wukong;
// The Lottery NFT for tickets
LotteryNFT public lotteryNFT;
// adminAddress
address public adminAddress;
// maxNumber
uint8 public maxNumber;
// minPrice, if decimal is not 18, please reset it
uint256 public minPrice;
// =================================
// issueId => winningNumbers[numbers]
mapping (uint256 => uint8[4]) public historyNumbers;
// issueId => [tokenId]
mapping (uint256 => uint256[]) public lotteryInfo;
// issueId => [totalAmount, firstMatchAmount, secondMatchingAmount, thirdMatchingAmount]
mapping (uint256 => uint256[]) public historyAmount;
// issueId => trickyNumber => buyAmountSum
mapping (uint256 => mapping(uint64 => uint256)) public userBuyAmountSum;
// address => [tokenId]
mapping (address => uint256[]) public userInfo;
uint256 public issueIndex = 0;
uint256 public totalAddresses = 0;
uint256 public totalAmount = 0;
uint256 public lastTimestamp;
uint8[4] public winningNumbers;
// default false
bool public drawingPhase;
// =================================
event Buy(address indexed user, uint256 tokenId);
event Drawing(uint256 indexed issueIndex, uint8[4] winningNumbers);
event Claim(address indexed user, uint256 tokenid, uint256 amount);
event DevWithdraw(address indexed user, uint256 amount);
event Reset(uint256 indexed issueIndex);
event MultiClaim(address indexed user, uint256 amount);
event MultiBuy(address indexed user, uint256 amount);
event SetMinPrice(address indexed user, uint256 price);
event SetMaxNumber(address indexed user, uint256 number);
event SetAdmin(address indexed user, address indexed admin);
event SetAllocation(address indexed user, uint8 allocation1, uint8 allocation2, uint8 allocation3);
constructor() public {
}
function initialize(
IBEP20 _wukong,
LotteryNFT _lottery,
uint256 _minPrice,
uint8 _maxNumber,
address _adminAddress
) external initializer {
}
uint8[4] private nullTicket = [0,0,0,0];
modifier onlyAdmin() {
}
modifier inDrawingPhase() {
}
function drawed() public view returns(bool) {
}
function reset() external onlyAdmin {
}
function enterDrawingPhase() external onlyAdmin {
}
// add externalRandomNumber to prevent node validators exploiting
function drawing(uint256 _externalRandomNumber) external onlyAdmin {
}
function internalBuy(uint256 _price, uint8[4] memory _numbers) internal {
require (!drawed(), 'drawed, can not buy now');
for (uint i = 0; i < 4; i++) {
require(<FILL_ME>)
}
uint256 tokenId = lotteryNFT.newLotteryItem(address(this), _numbers, _price, issueIndex);
lotteryInfo[issueIndex].push(tokenId);
totalAmount = totalAmount.add(_price);
lastTimestamp = block.timestamp;
emit Buy(address(this), tokenId);
}
function buy(uint256 _price, uint8[4] memory _numbers) external inDrawingPhase{
}
function multiBuy(uint256 _price, uint8[4][] memory _numbers) external inDrawingPhase {
}
function claimReward(uint256 _tokenId) external {
}
function multiClaim(uint256[] memory _tickets) external {
}
function generateNumberIndexKey(uint8[4] memory number) public pure returns (uint64[keyLengthForEachBuy] memory) {
}
function calculateMatchingRewardAmount() internal view returns (uint256[4] memory) {
}
function getMatchingRewardAmount(uint256 _issueIndex, uint256 _matchingNumber) public view returns (uint256) {
}
function getTotalRewards(uint256 _issueIndex) public view returns(uint256) {
}
function getRewardView(uint256 _tokenId) public view returns(uint256) {
}
// Safe wukong transfer function, just in case if rounding error causes pool to not have enough WUKONGs.
function safewukongTransfer(address _to, uint256 _amount) internal {
}
// Update admin address by the previous dev.
function setAdmin(address _adminAddress) external onlyOwner {
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function adminWithdraw(uint256 _amount) external onlyAdmin {
}
// Set the minimum price for one ticket
function setMinPrice(uint256 _price) external onlyAdmin {
}
// Set the max number to be drawed
function setMaxNumber(uint8 _maxNumber) external onlyAdmin {
}
// Set the allocation for one reward
function setAllocation(uint8 _allcation1, uint8 _allcation2, uint8 _allcation3) external onlyAdmin {
}
}
| _numbers[i]<=maxNumber,'exceed the maximum' | 481,529 | _numbers[i]<=maxNumber |
'exceed number scope' | pragma solidity 0.6.12;
// 4 numbers
contract Lottery is OwnableUpgradeable {
using SafeMath for uint256;
using SafeMath for uint8;
using SafeBEP20 for IBEP20;
uint8 constant keyLengthForEachBuy = 11;
// Allocation for first/sencond/third reward
uint8[3] public allocation;
// The TOKEN to buy lottery
IBEP20 public wukong;
// The Lottery NFT for tickets
LotteryNFT public lotteryNFT;
// adminAddress
address public adminAddress;
// maxNumber
uint8 public maxNumber;
// minPrice, if decimal is not 18, please reset it
uint256 public minPrice;
// =================================
// issueId => winningNumbers[numbers]
mapping (uint256 => uint8[4]) public historyNumbers;
// issueId => [tokenId]
mapping (uint256 => uint256[]) public lotteryInfo;
// issueId => [totalAmount, firstMatchAmount, secondMatchingAmount, thirdMatchingAmount]
mapping (uint256 => uint256[]) public historyAmount;
// issueId => trickyNumber => buyAmountSum
mapping (uint256 => mapping(uint64 => uint256)) public userBuyAmountSum;
// address => [tokenId]
mapping (address => uint256[]) public userInfo;
uint256 public issueIndex = 0;
uint256 public totalAddresses = 0;
uint256 public totalAmount = 0;
uint256 public lastTimestamp;
uint8[4] public winningNumbers;
// default false
bool public drawingPhase;
// =================================
event Buy(address indexed user, uint256 tokenId);
event Drawing(uint256 indexed issueIndex, uint8[4] winningNumbers);
event Claim(address indexed user, uint256 tokenid, uint256 amount);
event DevWithdraw(address indexed user, uint256 amount);
event Reset(uint256 indexed issueIndex);
event MultiClaim(address indexed user, uint256 amount);
event MultiBuy(address indexed user, uint256 amount);
event SetMinPrice(address indexed user, uint256 price);
event SetMaxNumber(address indexed user, uint256 number);
event SetAdmin(address indexed user, address indexed admin);
event SetAllocation(address indexed user, uint8 allocation1, uint8 allocation2, uint8 allocation3);
constructor() public {
}
function initialize(
IBEP20 _wukong,
LotteryNFT _lottery,
uint256 _minPrice,
uint8 _maxNumber,
address _adminAddress
) external initializer {
}
uint8[4] private nullTicket = [0,0,0,0];
modifier onlyAdmin() {
}
modifier inDrawingPhase() {
}
function drawed() public view returns(bool) {
}
function reset() external onlyAdmin {
}
function enterDrawingPhase() external onlyAdmin {
}
// add externalRandomNumber to prevent node validators exploiting
function drawing(uint256 _externalRandomNumber) external onlyAdmin {
}
function internalBuy(uint256 _price, uint8[4] memory _numbers) internal {
}
function buy(uint256 _price, uint8[4] memory _numbers) external inDrawingPhase{
}
function multiBuy(uint256 _price, uint8[4][] memory _numbers) external inDrawingPhase {
require (_price >= minPrice, 'price must above minPrice');
uint256 totalPrice = 0;
for (uint i = 0; i < _numbers.length; i++) {
for (uint j = 0; j < 4; j++) {
require(<FILL_ME>)
}
uint256 tokenId = lotteryNFT.newLotteryItem(msg.sender, _numbers[i], _price, issueIndex);
lotteryInfo[issueIndex].push(tokenId);
if (userInfo[msg.sender].length == 0) {
totalAddresses = totalAddresses + 1;
}
userInfo[msg.sender].push(tokenId);
totalAmount = totalAmount.add(_price);
lastTimestamp = block.timestamp;
totalPrice = totalPrice.add(_price);
uint64[keyLengthForEachBuy] memory numberIndexKey = generateNumberIndexKey(_numbers[i]);
for (uint k = 0; k < keyLengthForEachBuy; k++) {
userBuyAmountSum[issueIndex][numberIndexKey[k]]=userBuyAmountSum[issueIndex][numberIndexKey[k]].add(_price);
}
}
wukong.safeTransferFrom(address(msg.sender), address(this), totalPrice);
emit MultiBuy(msg.sender, totalPrice);
}
function claimReward(uint256 _tokenId) external {
}
function multiClaim(uint256[] memory _tickets) external {
}
function generateNumberIndexKey(uint8[4] memory number) public pure returns (uint64[keyLengthForEachBuy] memory) {
}
function calculateMatchingRewardAmount() internal view returns (uint256[4] memory) {
}
function getMatchingRewardAmount(uint256 _issueIndex, uint256 _matchingNumber) public view returns (uint256) {
}
function getTotalRewards(uint256 _issueIndex) public view returns(uint256) {
}
function getRewardView(uint256 _tokenId) public view returns(uint256) {
}
// Safe wukong transfer function, just in case if rounding error causes pool to not have enough WUKONGs.
function safewukongTransfer(address _to, uint256 _amount) internal {
}
// Update admin address by the previous dev.
function setAdmin(address _adminAddress) external onlyOwner {
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function adminWithdraw(uint256 _amount) external onlyAdmin {
}
// Set the minimum price for one ticket
function setMinPrice(uint256 _price) external onlyAdmin {
}
// Set the max number to be drawed
function setMaxNumber(uint8 _maxNumber) external onlyAdmin {
}
// Set the allocation for one reward
function setAllocation(uint8 _allcation1, uint8 _allcation2, uint8 _allcation3) external onlyAdmin {
}
}
| _numbers[i][j]<=maxNumber&&_numbers[i][j]>0,'exceed number scope' | 481,529 | _numbers[i][j]<=maxNumber&&_numbers[i][j]>0 |
"claimed" | pragma solidity 0.6.12;
// 4 numbers
contract Lottery is OwnableUpgradeable {
using SafeMath for uint256;
using SafeMath for uint8;
using SafeBEP20 for IBEP20;
uint8 constant keyLengthForEachBuy = 11;
// Allocation for first/sencond/third reward
uint8[3] public allocation;
// The TOKEN to buy lottery
IBEP20 public wukong;
// The Lottery NFT for tickets
LotteryNFT public lotteryNFT;
// adminAddress
address public adminAddress;
// maxNumber
uint8 public maxNumber;
// minPrice, if decimal is not 18, please reset it
uint256 public minPrice;
// =================================
// issueId => winningNumbers[numbers]
mapping (uint256 => uint8[4]) public historyNumbers;
// issueId => [tokenId]
mapping (uint256 => uint256[]) public lotteryInfo;
// issueId => [totalAmount, firstMatchAmount, secondMatchingAmount, thirdMatchingAmount]
mapping (uint256 => uint256[]) public historyAmount;
// issueId => trickyNumber => buyAmountSum
mapping (uint256 => mapping(uint64 => uint256)) public userBuyAmountSum;
// address => [tokenId]
mapping (address => uint256[]) public userInfo;
uint256 public issueIndex = 0;
uint256 public totalAddresses = 0;
uint256 public totalAmount = 0;
uint256 public lastTimestamp;
uint8[4] public winningNumbers;
// default false
bool public drawingPhase;
// =================================
event Buy(address indexed user, uint256 tokenId);
event Drawing(uint256 indexed issueIndex, uint8[4] winningNumbers);
event Claim(address indexed user, uint256 tokenid, uint256 amount);
event DevWithdraw(address indexed user, uint256 amount);
event Reset(uint256 indexed issueIndex);
event MultiClaim(address indexed user, uint256 amount);
event MultiBuy(address indexed user, uint256 amount);
event SetMinPrice(address indexed user, uint256 price);
event SetMaxNumber(address indexed user, uint256 number);
event SetAdmin(address indexed user, address indexed admin);
event SetAllocation(address indexed user, uint8 allocation1, uint8 allocation2, uint8 allocation3);
constructor() public {
}
function initialize(
IBEP20 _wukong,
LotteryNFT _lottery,
uint256 _minPrice,
uint8 _maxNumber,
address _adminAddress
) external initializer {
}
uint8[4] private nullTicket = [0,0,0,0];
modifier onlyAdmin() {
}
modifier inDrawingPhase() {
}
function drawed() public view returns(bool) {
}
function reset() external onlyAdmin {
}
function enterDrawingPhase() external onlyAdmin {
}
// add externalRandomNumber to prevent node validators exploiting
function drawing(uint256 _externalRandomNumber) external onlyAdmin {
}
function internalBuy(uint256 _price, uint8[4] memory _numbers) internal {
}
function buy(uint256 _price, uint8[4] memory _numbers) external inDrawingPhase{
}
function multiBuy(uint256 _price, uint8[4][] memory _numbers) external inDrawingPhase {
}
function claimReward(uint256 _tokenId) external {
require(msg.sender == lotteryNFT.ownerOf(_tokenId), "not from owner");
require(<FILL_ME>)
uint256 reward = getRewardView(_tokenId);
lotteryNFT.claimReward(_tokenId);
if(reward>0) {
safewukongTransfer(address(msg.sender), reward);
}
emit Claim(msg.sender, _tokenId, reward);
}
function multiClaim(uint256[] memory _tickets) external {
}
function generateNumberIndexKey(uint8[4] memory number) public pure returns (uint64[keyLengthForEachBuy] memory) {
}
function calculateMatchingRewardAmount() internal view returns (uint256[4] memory) {
}
function getMatchingRewardAmount(uint256 _issueIndex, uint256 _matchingNumber) public view returns (uint256) {
}
function getTotalRewards(uint256 _issueIndex) public view returns(uint256) {
}
function getRewardView(uint256 _tokenId) public view returns(uint256) {
}
// Safe wukong transfer function, just in case if rounding error causes pool to not have enough WUKONGs.
function safewukongTransfer(address _to, uint256 _amount) internal {
}
// Update admin address by the previous dev.
function setAdmin(address _adminAddress) external onlyOwner {
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function adminWithdraw(uint256 _amount) external onlyAdmin {
}
// Set the minimum price for one ticket
function setMinPrice(uint256 _price) external onlyAdmin {
}
// Set the max number to be drawed
function setMaxNumber(uint8 _maxNumber) external onlyAdmin {
}
// Set the allocation for one reward
function setAllocation(uint8 _allcation1, uint8 _allcation2, uint8 _allcation3) external onlyAdmin {
}
}
| !lotteryNFT.getClaimStatus(_tokenId),"claimed" | 481,529 | !lotteryNFT.getClaimStatus(_tokenId) |
"claimed" | pragma solidity 0.6.12;
// 4 numbers
contract Lottery is OwnableUpgradeable {
using SafeMath for uint256;
using SafeMath for uint8;
using SafeBEP20 for IBEP20;
uint8 constant keyLengthForEachBuy = 11;
// Allocation for first/sencond/third reward
uint8[3] public allocation;
// The TOKEN to buy lottery
IBEP20 public wukong;
// The Lottery NFT for tickets
LotteryNFT public lotteryNFT;
// adminAddress
address public adminAddress;
// maxNumber
uint8 public maxNumber;
// minPrice, if decimal is not 18, please reset it
uint256 public minPrice;
// =================================
// issueId => winningNumbers[numbers]
mapping (uint256 => uint8[4]) public historyNumbers;
// issueId => [tokenId]
mapping (uint256 => uint256[]) public lotteryInfo;
// issueId => [totalAmount, firstMatchAmount, secondMatchingAmount, thirdMatchingAmount]
mapping (uint256 => uint256[]) public historyAmount;
// issueId => trickyNumber => buyAmountSum
mapping (uint256 => mapping(uint64 => uint256)) public userBuyAmountSum;
// address => [tokenId]
mapping (address => uint256[]) public userInfo;
uint256 public issueIndex = 0;
uint256 public totalAddresses = 0;
uint256 public totalAmount = 0;
uint256 public lastTimestamp;
uint8[4] public winningNumbers;
// default false
bool public drawingPhase;
// =================================
event Buy(address indexed user, uint256 tokenId);
event Drawing(uint256 indexed issueIndex, uint8[4] winningNumbers);
event Claim(address indexed user, uint256 tokenid, uint256 amount);
event DevWithdraw(address indexed user, uint256 amount);
event Reset(uint256 indexed issueIndex);
event MultiClaim(address indexed user, uint256 amount);
event MultiBuy(address indexed user, uint256 amount);
event SetMinPrice(address indexed user, uint256 price);
event SetMaxNumber(address indexed user, uint256 number);
event SetAdmin(address indexed user, address indexed admin);
event SetAllocation(address indexed user, uint8 allocation1, uint8 allocation2, uint8 allocation3);
constructor() public {
}
function initialize(
IBEP20 _wukong,
LotteryNFT _lottery,
uint256 _minPrice,
uint8 _maxNumber,
address _adminAddress
) external initializer {
}
uint8[4] private nullTicket = [0,0,0,0];
modifier onlyAdmin() {
}
modifier inDrawingPhase() {
}
function drawed() public view returns(bool) {
}
function reset() external onlyAdmin {
}
function enterDrawingPhase() external onlyAdmin {
}
// add externalRandomNumber to prevent node validators exploiting
function drawing(uint256 _externalRandomNumber) external onlyAdmin {
}
function internalBuy(uint256 _price, uint8[4] memory _numbers) internal {
}
function buy(uint256 _price, uint8[4] memory _numbers) external inDrawingPhase{
}
function multiBuy(uint256 _price, uint8[4][] memory _numbers) external inDrawingPhase {
}
function claimReward(uint256 _tokenId) external {
}
function multiClaim(uint256[] memory _tickets) external {
uint256 totalReward = 0;
for (uint i = 0; i < _tickets.length; i++) {
require (msg.sender == lotteryNFT.ownerOf(_tickets[i]), "not from owner");
require(<FILL_ME>)
uint256 reward = getRewardView(_tickets[i]);
if(reward>0) {
totalReward = reward.add(totalReward);
}
}
lotteryNFT.multiClaimReward(_tickets);
if(totalReward>0) {
safewukongTransfer(address(msg.sender), totalReward);
}
emit MultiClaim(msg.sender, totalReward);
}
function generateNumberIndexKey(uint8[4] memory number) public pure returns (uint64[keyLengthForEachBuy] memory) {
}
function calculateMatchingRewardAmount() internal view returns (uint256[4] memory) {
}
function getMatchingRewardAmount(uint256 _issueIndex, uint256 _matchingNumber) public view returns (uint256) {
}
function getTotalRewards(uint256 _issueIndex) public view returns(uint256) {
}
function getRewardView(uint256 _tokenId) public view returns(uint256) {
}
// Safe wukong transfer function, just in case if rounding error causes pool to not have enough WUKONGs.
function safewukongTransfer(address _to, uint256 _amount) internal {
}
// Update admin address by the previous dev.
function setAdmin(address _adminAddress) external onlyOwner {
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function adminWithdraw(uint256 _amount) external onlyAdmin {
}
// Set the minimum price for one ticket
function setMinPrice(uint256 _price) external onlyAdmin {
}
// Set the max number to be drawed
function setMaxNumber(uint8 _maxNumber) external onlyAdmin {
}
// Set the allocation for one reward
function setAllocation(uint8 _allcation1, uint8 _allcation2, uint8 _allcation3) external onlyAdmin {
}
}
| !lotteryNFT.getClaimStatus(_tickets[i]),"claimed" | 481,529 | !lotteryNFT.getClaimStatus(_tickets[i]) |
"not drawed" | pragma solidity 0.6.12;
// 4 numbers
contract Lottery is OwnableUpgradeable {
using SafeMath for uint256;
using SafeMath for uint8;
using SafeBEP20 for IBEP20;
uint8 constant keyLengthForEachBuy = 11;
// Allocation for first/sencond/third reward
uint8[3] public allocation;
// The TOKEN to buy lottery
IBEP20 public wukong;
// The Lottery NFT for tickets
LotteryNFT public lotteryNFT;
// adminAddress
address public adminAddress;
// maxNumber
uint8 public maxNumber;
// minPrice, if decimal is not 18, please reset it
uint256 public minPrice;
// =================================
// issueId => winningNumbers[numbers]
mapping (uint256 => uint8[4]) public historyNumbers;
// issueId => [tokenId]
mapping (uint256 => uint256[]) public lotteryInfo;
// issueId => [totalAmount, firstMatchAmount, secondMatchingAmount, thirdMatchingAmount]
mapping (uint256 => uint256[]) public historyAmount;
// issueId => trickyNumber => buyAmountSum
mapping (uint256 => mapping(uint64 => uint256)) public userBuyAmountSum;
// address => [tokenId]
mapping (address => uint256[]) public userInfo;
uint256 public issueIndex = 0;
uint256 public totalAddresses = 0;
uint256 public totalAmount = 0;
uint256 public lastTimestamp;
uint8[4] public winningNumbers;
// default false
bool public drawingPhase;
// =================================
event Buy(address indexed user, uint256 tokenId);
event Drawing(uint256 indexed issueIndex, uint8[4] winningNumbers);
event Claim(address indexed user, uint256 tokenid, uint256 amount);
event DevWithdraw(address indexed user, uint256 amount);
event Reset(uint256 indexed issueIndex);
event MultiClaim(address indexed user, uint256 amount);
event MultiBuy(address indexed user, uint256 amount);
event SetMinPrice(address indexed user, uint256 price);
event SetMaxNumber(address indexed user, uint256 number);
event SetAdmin(address indexed user, address indexed admin);
event SetAllocation(address indexed user, uint8 allocation1, uint8 allocation2, uint8 allocation3);
constructor() public {
}
function initialize(
IBEP20 _wukong,
LotteryNFT _lottery,
uint256 _minPrice,
uint8 _maxNumber,
address _adminAddress
) external initializer {
}
uint8[4] private nullTicket = [0,0,0,0];
modifier onlyAdmin() {
}
modifier inDrawingPhase() {
}
function drawed() public view returns(bool) {
}
function reset() external onlyAdmin {
}
function enterDrawingPhase() external onlyAdmin {
}
// add externalRandomNumber to prevent node validators exploiting
function drawing(uint256 _externalRandomNumber) external onlyAdmin {
}
function internalBuy(uint256 _price, uint8[4] memory _numbers) internal {
}
function buy(uint256 _price, uint8[4] memory _numbers) external inDrawingPhase{
}
function multiBuy(uint256 _price, uint8[4][] memory _numbers) external inDrawingPhase {
}
function claimReward(uint256 _tokenId) external {
}
function multiClaim(uint256[] memory _tickets) external {
}
function generateNumberIndexKey(uint8[4] memory number) public pure returns (uint64[keyLengthForEachBuy] memory) {
}
function calculateMatchingRewardAmount() internal view returns (uint256[4] memory) {
}
function getMatchingRewardAmount(uint256 _issueIndex, uint256 _matchingNumber) public view returns (uint256) {
}
function getTotalRewards(uint256 _issueIndex) public view returns(uint256) {
}
function getRewardView(uint256 _tokenId) public view returns(uint256) {
uint256 _issueIndex = lotteryNFT.getLotteryIssueIndex(_tokenId);
uint8[4] memory lotteryNumbers = lotteryNFT.getLotteryNumbers(_tokenId);
uint8[4] memory _winningNumbers = historyNumbers[_issueIndex];
require(<FILL_ME>)
uint256 matchingNumber = 0;
for (uint i = 0; i < lotteryNumbers.length; i++) {
if (_winningNumbers[i] == lotteryNumbers[i]) {
matchingNumber = matchingNumber + 1;
}
}
uint256 reward = 0;
if (matchingNumber > 1) {
uint256 amount = lotteryNFT.getLotteryAmount(_tokenId);
uint256 poolAmount = getTotalRewards(_issueIndex).mul(allocation[4-matchingNumber]).div(100);
reward = amount.mul(1e12).mul(poolAmount).div(getMatchingRewardAmount(_issueIndex, matchingNumber));
}
return reward.div(1e12);
}
// Safe wukong transfer function, just in case if rounding error causes pool to not have enough WUKONGs.
function safewukongTransfer(address _to, uint256 _amount) internal {
}
// Update admin address by the previous dev.
function setAdmin(address _adminAddress) external onlyOwner {
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function adminWithdraw(uint256 _amount) external onlyAdmin {
}
// Set the minimum price for one ticket
function setMinPrice(uint256 _price) external onlyAdmin {
}
// Set the max number to be drawed
function setMaxNumber(uint8 _maxNumber) external onlyAdmin {
}
// Set the allocation for one reward
function setAllocation(uint8 _allcation1, uint8 _allcation2, uint8 _allcation3) external onlyAdmin {
}
}
| _winningNumbers[0]!=0,"not drawed" | 481,529 | _winningNumbers[0]!=0 |
"Voucher minted" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract NFTKey is ERC721URIStorage, EIP712, Ownable, ReentrancyGuard {
using Strings for uint256;
using Address for address;
string private constant SIGNING_DOMAIN = "NFTKey";
string private constant SIGNING_VERSION = "1";
address public recipient;
uint256 public totalRevenue;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
mapping(address => bool) public minters;
mapping(bytes => uint256) public redemption;
mapping(string => uint256) public couponCodeRedemption;
struct NFTVoucher {
uint256 externalId;
string tokenURI;
address recipient;
uint256 minPrice;
string couponCode;
uint256 redemptionLimit;
uint256 couponCodeLimit;
uint256 expire;
bytes signature;
}
event tokenMint(uint256 indexed tokenId, address indexed sender, NFTVoucher voucher);
constructor(string memory tokenName, string memory symbol, address ownerAddress, address recipientAddress, address[] memory minterAddresses) ERC721(tokenName, symbol) EIP712(SIGNING_DOMAIN, SIGNING_VERSION)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _burn(uint256 tokenId) internal virtual override{
}
function tokenURI(uint256 tokenId) public view override returns (string memory)
{
}
function mint(NFTVoucher calldata voucher) external payable nonReentrant returns (uint256)
{
require(voucher.expire == 0 || block.timestamp < voucher.expire, "Voucher expired");
if(voucher.redemptionLimit != 0){
require(<FILL_ME>)
redemption[voucher.signature] += 1;
}
if(bytes(voucher.couponCode).length != 0){
if(voucher.couponCodeLimit != 0){
require(couponCodeRedemption[voucher.couponCode] < voucher.couponCodeLimit, "Coupon code minted");
}
couponCodeRedemption[voucher.couponCode] += 1;
}
require(minters[_verifyVoucher(voucher)], "Permission denied");
require(minters[msg.sender] || msg.value >= voucher.minPrice, "Insufficient funds");
_tokenIds.increment();
uint256 tokenId = _tokenIds.current();
totalRevenue += msg.value;
emit tokenMint(tokenId, msg.sender, voucher);
_safeMint(voucher.recipient, tokenId);
_setTokenURI(tokenId, voucher.tokenURI);
if(msg.value > 0){
Address.sendValue(payable(recipient), msg.value);
}
return tokenId;
}
function getChainID() external view returns (uint256) {
}
function _verifyVoucher(NFTVoucher calldata voucher) internal view returns (address)
{
}
}
| redemption[voucher.signature]<voucher.redemptionLimit,"Voucher minted" | 481,545 | redemption[voucher.signature]<voucher.redemptionLimit |
"Coupon code minted" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract NFTKey is ERC721URIStorage, EIP712, Ownable, ReentrancyGuard {
using Strings for uint256;
using Address for address;
string private constant SIGNING_DOMAIN = "NFTKey";
string private constant SIGNING_VERSION = "1";
address public recipient;
uint256 public totalRevenue;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
mapping(address => bool) public minters;
mapping(bytes => uint256) public redemption;
mapping(string => uint256) public couponCodeRedemption;
struct NFTVoucher {
uint256 externalId;
string tokenURI;
address recipient;
uint256 minPrice;
string couponCode;
uint256 redemptionLimit;
uint256 couponCodeLimit;
uint256 expire;
bytes signature;
}
event tokenMint(uint256 indexed tokenId, address indexed sender, NFTVoucher voucher);
constructor(string memory tokenName, string memory symbol, address ownerAddress, address recipientAddress, address[] memory minterAddresses) ERC721(tokenName, symbol) EIP712(SIGNING_DOMAIN, SIGNING_VERSION)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _burn(uint256 tokenId) internal virtual override{
}
function tokenURI(uint256 tokenId) public view override returns (string memory)
{
}
function mint(NFTVoucher calldata voucher) external payable nonReentrant returns (uint256)
{
require(voucher.expire == 0 || block.timestamp < voucher.expire, "Voucher expired");
if(voucher.redemptionLimit != 0){
require(redemption[voucher.signature] < voucher.redemptionLimit, "Voucher minted");
redemption[voucher.signature] += 1;
}
if(bytes(voucher.couponCode).length != 0){
if(voucher.couponCodeLimit != 0){
require(<FILL_ME>)
}
couponCodeRedemption[voucher.couponCode] += 1;
}
require(minters[_verifyVoucher(voucher)], "Permission denied");
require(minters[msg.sender] || msg.value >= voucher.minPrice, "Insufficient funds");
_tokenIds.increment();
uint256 tokenId = _tokenIds.current();
totalRevenue += msg.value;
emit tokenMint(tokenId, msg.sender, voucher);
_safeMint(voucher.recipient, tokenId);
_setTokenURI(tokenId, voucher.tokenURI);
if(msg.value > 0){
Address.sendValue(payable(recipient), msg.value);
}
return tokenId;
}
function getChainID() external view returns (uint256) {
}
function _verifyVoucher(NFTVoucher calldata voucher) internal view returns (address)
{
}
}
| couponCodeRedemption[voucher.couponCode]<voucher.couponCodeLimit,"Coupon code minted" | 481,545 | couponCodeRedemption[voucher.couponCode]<voucher.couponCodeLimit |
"Permission denied" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract NFTKey is ERC721URIStorage, EIP712, Ownable, ReentrancyGuard {
using Strings for uint256;
using Address for address;
string private constant SIGNING_DOMAIN = "NFTKey";
string private constant SIGNING_VERSION = "1";
address public recipient;
uint256 public totalRevenue;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
mapping(address => bool) public minters;
mapping(bytes => uint256) public redemption;
mapping(string => uint256) public couponCodeRedemption;
struct NFTVoucher {
uint256 externalId;
string tokenURI;
address recipient;
uint256 minPrice;
string couponCode;
uint256 redemptionLimit;
uint256 couponCodeLimit;
uint256 expire;
bytes signature;
}
event tokenMint(uint256 indexed tokenId, address indexed sender, NFTVoucher voucher);
constructor(string memory tokenName, string memory symbol, address ownerAddress, address recipientAddress, address[] memory minterAddresses) ERC721(tokenName, symbol) EIP712(SIGNING_DOMAIN, SIGNING_VERSION)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _burn(uint256 tokenId) internal virtual override{
}
function tokenURI(uint256 tokenId) public view override returns (string memory)
{
}
function mint(NFTVoucher calldata voucher) external payable nonReentrant returns (uint256)
{
require(voucher.expire == 0 || block.timestamp < voucher.expire, "Voucher expired");
if(voucher.redemptionLimit != 0){
require(redemption[voucher.signature] < voucher.redemptionLimit, "Voucher minted");
redemption[voucher.signature] += 1;
}
if(bytes(voucher.couponCode).length != 0){
if(voucher.couponCodeLimit != 0){
require(couponCodeRedemption[voucher.couponCode] < voucher.couponCodeLimit, "Coupon code minted");
}
couponCodeRedemption[voucher.couponCode] += 1;
}
require(<FILL_ME>)
require(minters[msg.sender] || msg.value >= voucher.minPrice, "Insufficient funds");
_tokenIds.increment();
uint256 tokenId = _tokenIds.current();
totalRevenue += msg.value;
emit tokenMint(tokenId, msg.sender, voucher);
_safeMint(voucher.recipient, tokenId);
_setTokenURI(tokenId, voucher.tokenURI);
if(msg.value > 0){
Address.sendValue(payable(recipient), msg.value);
}
return tokenId;
}
function getChainID() external view returns (uint256) {
}
function _verifyVoucher(NFTVoucher calldata voucher) internal view returns (address)
{
}
}
| minters[_verifyVoucher(voucher)],"Permission denied" | 481,545 | minters[_verifyVoucher(voucher)] |
"Insufficient funds" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract NFTKey is ERC721URIStorage, EIP712, Ownable, ReentrancyGuard {
using Strings for uint256;
using Address for address;
string private constant SIGNING_DOMAIN = "NFTKey";
string private constant SIGNING_VERSION = "1";
address public recipient;
uint256 public totalRevenue;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
mapping(address => bool) public minters;
mapping(bytes => uint256) public redemption;
mapping(string => uint256) public couponCodeRedemption;
struct NFTVoucher {
uint256 externalId;
string tokenURI;
address recipient;
uint256 minPrice;
string couponCode;
uint256 redemptionLimit;
uint256 couponCodeLimit;
uint256 expire;
bytes signature;
}
event tokenMint(uint256 indexed tokenId, address indexed sender, NFTVoucher voucher);
constructor(string memory tokenName, string memory symbol, address ownerAddress, address recipientAddress, address[] memory minterAddresses) ERC721(tokenName, symbol) EIP712(SIGNING_DOMAIN, SIGNING_VERSION)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _burn(uint256 tokenId) internal virtual override{
}
function tokenURI(uint256 tokenId) public view override returns (string memory)
{
}
function mint(NFTVoucher calldata voucher) external payable nonReentrant returns (uint256)
{
require(voucher.expire == 0 || block.timestamp < voucher.expire, "Voucher expired");
if(voucher.redemptionLimit != 0){
require(redemption[voucher.signature] < voucher.redemptionLimit, "Voucher minted");
redemption[voucher.signature] += 1;
}
if(bytes(voucher.couponCode).length != 0){
if(voucher.couponCodeLimit != 0){
require(couponCodeRedemption[voucher.couponCode] < voucher.couponCodeLimit, "Coupon code minted");
}
couponCodeRedemption[voucher.couponCode] += 1;
}
require(minters[_verifyVoucher(voucher)], "Permission denied");
require(<FILL_ME>)
_tokenIds.increment();
uint256 tokenId = _tokenIds.current();
totalRevenue += msg.value;
emit tokenMint(tokenId, msg.sender, voucher);
_safeMint(voucher.recipient, tokenId);
_setTokenURI(tokenId, voucher.tokenURI);
if(msg.value > 0){
Address.sendValue(payable(recipient), msg.value);
}
return tokenId;
}
function getChainID() external view returns (uint256) {
}
function _verifyVoucher(NFTVoucher calldata voucher) internal view returns (address)
{
}
}
| minters[msg.sender]||msg.value>=voucher.minPrice,"Insufficient funds" | 481,545 | minters[msg.sender]||msg.value>=voucher.minPrice |
"ERC20: transfer refused" | @v3.0.1
pragma solidity >=0.7.6 <0.8.0;
/**
* @title ERC20 Fungible Token Contract.
*/
contract ERC20 is
ManagedIdentity,
IERC165,
IERC20,
IERC20Detailed,
IERC20Metadata,
IERC20Allowance,
IERC20BatchTransfers,
IERC20SafeTransfers,
IERC20Permit
{
using AddressIsContract for address;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)")
bytes32 internal constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
uint256 public immutable deploymentChainId;
// solhint-disable-next-line var-name-mixedcase
bytes32 internal immutable _DOMAIN_SEPARATOR;
/// @inheritdoc IERC20Permit
mapping(address => uint256) public override nonces;
string internal _name;
string internal _symbol;
uint8 internal immutable _decimals;
string internal _tokenURI;
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 internal _totalSupply;
constructor(
string memory name_,
string memory symbol_,
uint8 decimals_
) {
}
//======================================================= ERC165 ========================================================//
/// @inheritdoc IERC165
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
//======================================================== ERC20 ========================================================//
/// @inheritdoc IERC20
function totalSupply() external view override returns (uint256) {
}
/// @inheritdoc IERC20
function balanceOf(address account) external view override returns (uint256) {
}
/// @inheritdoc IERC20
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/// @inheritdoc IERC20
function approve(address spender, uint256 value) external virtual override returns (bool) {
}
/// @inheritdoc IERC20
function transfer(address to, uint256 value) external virtual override returns (bool) {
}
/// @inheritdoc IERC20
function transferFrom(
address from,
address to,
uint256 value
) external virtual override returns (bool) {
}
//==================================================== ERC20Detailed ====================================================//
/// @inheritdoc IERC20Detailed
function name() external view override returns (string memory) {
}
/// @inheritdoc IERC20Detailed
function symbol() external view override returns (string memory) {
}
/// @inheritdoc IERC20Detailed
function decimals() external view override returns (uint8) {
}
//==================================================== ERC20Metadata ====================================================//
/// @inheritdoc IERC20Metadata
function tokenURI() external view override returns (string memory) {
}
//=================================================== ERC20Allowance ====================================================//
/// @inheritdoc IERC20Allowance
function increaseAllowance(address spender, uint256 addedValue) external virtual override returns (bool) {
}
/// @inheritdoc IERC20Allowance
function decreaseAllowance(address spender, uint256 subtractedValue) external virtual override returns (bool) {
}
//================================================= ERC20BatchTransfers =================================================//
/// @inheritdoc IERC20BatchTransfers
function batchTransfer(address[] calldata recipients, uint256[] calldata values) external virtual override returns (bool) {
}
/// @inheritdoc IERC20BatchTransfers
function batchTransferFrom(
address from,
address[] calldata recipients,
uint256[] calldata values
) external virtual override returns (bool) {
}
//================================================= ERC20SafeTransfers ==================================================//
/// @inheritdoc IERC20SafeTransfers
function safeTransfer(
address to,
uint256 amount,
bytes calldata data
) external virtual override returns (bool) {
address sender = _msgSender();
_transfer(sender, to, amount);
if (to.isContract()) {
require(<FILL_ME>)
}
return true;
}
/// @inheritdoc IERC20SafeTransfers
function safeTransferFrom(
address from,
address to,
uint256 amount,
bytes calldata data
) external virtual override returns (bool) {
}
//===================================================== ERC20Permit =====================================================//
/// @inheritdoc IERC20Permit
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() public view override returns (bytes32) {
}
/// @inheritdoc IERC20Permit
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external virtual override {
}
//============================================ High-level Internal Functions ============================================//
function _approve(
address owner,
address spender,
uint256 value
) internal {
}
function _decreaseAllowance(
address owner,
address spender,
uint256 subtractedValue
) internal {
}
function _transfer(
address from,
address to,
uint256 value
) internal virtual {
}
function _transferFrom(
address sender,
address from,
address to,
uint256 value
) internal {
}
function _mint(address to, uint256 value) internal virtual {
}
function _batchMint(address[] memory recipients, uint256[] memory values) internal virtual {
}
function _burn(address from, uint256 value) internal virtual {
}
function _burnFrom(address from, uint256 value) internal virtual {
}
function _batchBurnFrom(address[] memory owners, uint256[] memory values) internal virtual {
}
//============================================== Helper Internal Functions ==============================================//
function _calculateDomainSeparator(uint256 chainId, bytes memory name_) private view returns (bytes32) {
}
}
| IERC20Receiver(to).onERC20Received(sender,sender,amount,data)==type(IERC20Receiver).interfaceId,"ERC20: transfer refused" | 481,573 | IERC20Receiver(to).onERC20Received(sender,sender,amount,data)==type(IERC20Receiver).interfaceId |
"ERC20: transfer refused" | @v3.0.1
pragma solidity >=0.7.6 <0.8.0;
/**
* @title ERC20 Fungible Token Contract.
*/
contract ERC20 is
ManagedIdentity,
IERC165,
IERC20,
IERC20Detailed,
IERC20Metadata,
IERC20Allowance,
IERC20BatchTransfers,
IERC20SafeTransfers,
IERC20Permit
{
using AddressIsContract for address;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)")
bytes32 internal constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
uint256 public immutable deploymentChainId;
// solhint-disable-next-line var-name-mixedcase
bytes32 internal immutable _DOMAIN_SEPARATOR;
/// @inheritdoc IERC20Permit
mapping(address => uint256) public override nonces;
string internal _name;
string internal _symbol;
uint8 internal immutable _decimals;
string internal _tokenURI;
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 internal _totalSupply;
constructor(
string memory name_,
string memory symbol_,
uint8 decimals_
) {
}
//======================================================= ERC165 ========================================================//
/// @inheritdoc IERC165
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
//======================================================== ERC20 ========================================================//
/// @inheritdoc IERC20
function totalSupply() external view override returns (uint256) {
}
/// @inheritdoc IERC20
function balanceOf(address account) external view override returns (uint256) {
}
/// @inheritdoc IERC20
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/// @inheritdoc IERC20
function approve(address spender, uint256 value) external virtual override returns (bool) {
}
/// @inheritdoc IERC20
function transfer(address to, uint256 value) external virtual override returns (bool) {
}
/// @inheritdoc IERC20
function transferFrom(
address from,
address to,
uint256 value
) external virtual override returns (bool) {
}
//==================================================== ERC20Detailed ====================================================//
/// @inheritdoc IERC20Detailed
function name() external view override returns (string memory) {
}
/// @inheritdoc IERC20Detailed
function symbol() external view override returns (string memory) {
}
/// @inheritdoc IERC20Detailed
function decimals() external view override returns (uint8) {
}
//==================================================== ERC20Metadata ====================================================//
/// @inheritdoc IERC20Metadata
function tokenURI() external view override returns (string memory) {
}
//=================================================== ERC20Allowance ====================================================//
/// @inheritdoc IERC20Allowance
function increaseAllowance(address spender, uint256 addedValue) external virtual override returns (bool) {
}
/// @inheritdoc IERC20Allowance
function decreaseAllowance(address spender, uint256 subtractedValue) external virtual override returns (bool) {
}
//================================================= ERC20BatchTransfers =================================================//
/// @inheritdoc IERC20BatchTransfers
function batchTransfer(address[] calldata recipients, uint256[] calldata values) external virtual override returns (bool) {
}
/// @inheritdoc IERC20BatchTransfers
function batchTransferFrom(
address from,
address[] calldata recipients,
uint256[] calldata values
) external virtual override returns (bool) {
}
//================================================= ERC20SafeTransfers ==================================================//
/// @inheritdoc IERC20SafeTransfers
function safeTransfer(
address to,
uint256 amount,
bytes calldata data
) external virtual override returns (bool) {
}
/// @inheritdoc IERC20SafeTransfers
function safeTransferFrom(
address from,
address to,
uint256 amount,
bytes calldata data
) external virtual override returns (bool) {
address sender = _msgSender();
_transferFrom(sender, from, to, amount);
if (to.isContract()) {
require(<FILL_ME>)
}
return true;
}
//===================================================== ERC20Permit =====================================================//
/// @inheritdoc IERC20Permit
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() public view override returns (bytes32) {
}
/// @inheritdoc IERC20Permit
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external virtual override {
}
//============================================ High-level Internal Functions ============================================//
function _approve(
address owner,
address spender,
uint256 value
) internal {
}
function _decreaseAllowance(
address owner,
address spender,
uint256 subtractedValue
) internal {
}
function _transfer(
address from,
address to,
uint256 value
) internal virtual {
}
function _transferFrom(
address sender,
address from,
address to,
uint256 value
) internal {
}
function _mint(address to, uint256 value) internal virtual {
}
function _batchMint(address[] memory recipients, uint256[] memory values) internal virtual {
}
function _burn(address from, uint256 value) internal virtual {
}
function _burnFrom(address from, uint256 value) internal virtual {
}
function _batchBurnFrom(address[] memory owners, uint256[] memory values) internal virtual {
}
//============================================== Helper Internal Functions ==============================================//
function _calculateDomainSeparator(uint256 chainId, bytes memory name_) private view returns (bytes32) {
}
}
| IERC20Receiver(to).onERC20Received(sender,from,amount,data)==type(IERC20Receiver).interfaceId,"ERC20: transfer refused" | 481,573 | IERC20Receiver(to).onERC20Received(sender,from,amount,data)==type(IERC20Receiver).interfaceId |
"not a pool" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;
import "Ownable.sol";
import "Initializable.sol";
import "EnumerableSet.sol";
import "IERC20.sol";
import "SafeERC20.sol";
import "SafeERC20.sol";
import "ICNCMintingRebalancingRewardsHandlerV2.sol";
import "ICNCMintingRebalancingRewardsHandler.sol";
import "IInflationManager.sol";
import "ICNCToken.sol";
import "IConicPool.sol";
import "ScaledMath.sol";
import "BaseMinter.sol";
contract CNCMintingRebalancingRewardsHandlerV2 is
ICNCMintingRebalancingRewardsHandlerV2,
Ownable,
BaseMinter,
Initializable
{
using SafeERC20 for IERC20;
using ScaledMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
/// @dev the maximum amount of CNC that can be minted for rebalancing rewards
uint256 internal constant _MAX_REBALANCING_REWARDS = 1_900_000e18; // 19% of total supply
/// @dev gives out 5 dollars per 1 hour (assuming 1 CNC = 6 USD) for every 10,000 USD in TVL that needs to be shifted
uint256 internal constant _INITIAL_REBALANCING_REWARD_PER_DOLLAR_PER_SECOND =
5e18 / uint256(3600 * 1 * 10_000 * 6);
IController public immutable override controller;
ICNCMintingRebalancingRewardsHandler public immutable previousRewardsHandler;
uint256 public override totalCncMinted;
uint256 public override cncRebalancingRewardPerDollarPerSecond;
bool internal _isInternal;
modifier onlyInflationManager() {
}
/// NOTE: we do not use the `emergencyMinter` anymore so we pass in address(0) as the emergency minter
/// to disable the usage of `renounceMinterRights`
/// From V3, we can remove the dependency on `BaseMinter` altogether but for now we need it
/// to be able to call `EmergencyMinter.switchRebalancingRewardsHandler`
constructor(
IController _controller,
ICNCToken _cnc,
ICNCMintingRebalancingRewardsHandler _previousRewardsHandler
) BaseMinter(_cnc, address(0)) {
}
function initialize() external onlyOwner initializer {
}
function setCncRebalancingRewardPerDollarPerSecond(
uint256 _cncRebalancingRewardPerDollarPerSecond
) external override onlyOwner {
}
function _distributeRebalancingRewards(address pool, address account, uint256 amount) internal {
}
function handleRebalancingRewards(
IConicPool conicPool,
address account,
uint256 deviationBefore,
uint256 deviationAfter
) external onlyInflationManager {
}
function _handleRebalancingRewards(
IConicPool conicPool,
address account,
uint256 deviationBefore,
uint256 deviationAfter
) internal {
}
/// @dev this computes how much CNC a user should get when depositing
/// this does not check whether the rewards should still be distributed
/// amount CNC = t * CNC/s * (1 - (Δdeviation / initialDeviation))
/// where
/// CNC/s: the amount of CNC per second to distributed for rebalancing
/// t: the time elapsed since the weight update
/// Δdeviation: the deviation difference caused by this deposit
/// initialDeviation: the deviation after updating weights
/// @return the amount of CNC to give to the user as reward
function computeRebalancingRewards(
address conicPool,
uint256 deviationBefore,
uint256 deviationAfter
) public view override returns (uint256) {
}
function rebalance(
address conicPool,
uint256 underlyingAmount,
uint256 minUnderlyingReceived,
uint256 minCNCReceived
) external override returns (uint256 underlyingReceived, uint256 cncReceived) {
require(<FILL_ME>)
IConicPool conicPool_ = IConicPool(conicPool);
IERC20 underlying = conicPool_.underlying();
require(underlying.balanceOf(msg.sender) >= underlyingAmount, "insufficient underlying");
uint256 deviationBefore = conicPool_.computeTotalDeviation();
underlying.safeTransferFrom(msg.sender, address(this), underlyingAmount);
underlying.safeApprove(conicPool, underlyingAmount);
_isInternal = true;
uint256 lpTokenAmount = conicPool_.deposit(underlyingAmount, 0, false);
_isInternal = false;
underlyingReceived = conicPool_.withdraw(lpTokenAmount, 0);
require(underlyingReceived >= minUnderlyingReceived, "insufficient underlying received");
uint256 deviationAfter = conicPool_.computeTotalDeviation();
uint256 cncBefore = cnc.balanceOf(msg.sender);
_handleRebalancingRewards(conicPool_, msg.sender, deviationBefore, deviationAfter);
cncReceived = cnc.balanceOf(msg.sender) - cncBefore;
require(cncReceived >= minCNCReceived, "insufficient CNC received");
underlying.safeTransfer(msg.sender, underlyingReceived);
}
/// @notice switches the minting rebalancing reward handler by granting the new one minting rights
/// and renouncing his own
/// `InflationManager.removePoolRebalancingRewardHandler` should be called on every pool before this is called
/// this should typically be done as a single batched governance action
/// The same governance action should also call `InflationManager.addPoolRebalancingRewardHandler` for each pool
/// passing in `newRebalancingRewardsHandler` so that the whole operation is atomic
/// @param newRebalancingRewardsHandler the address of the new rebalancing rewards handler
function switchMintingRebalancingRewardsHandler(
address newRebalancingRewardsHandler
) external onlyOwner {
}
}
| controller.isPool(conicPool),"not a pool" | 481,607 | controller.isPool(conicPool) |
"insufficient underlying" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;
import "Ownable.sol";
import "Initializable.sol";
import "EnumerableSet.sol";
import "IERC20.sol";
import "SafeERC20.sol";
import "SafeERC20.sol";
import "ICNCMintingRebalancingRewardsHandlerV2.sol";
import "ICNCMintingRebalancingRewardsHandler.sol";
import "IInflationManager.sol";
import "ICNCToken.sol";
import "IConicPool.sol";
import "ScaledMath.sol";
import "BaseMinter.sol";
contract CNCMintingRebalancingRewardsHandlerV2 is
ICNCMintingRebalancingRewardsHandlerV2,
Ownable,
BaseMinter,
Initializable
{
using SafeERC20 for IERC20;
using ScaledMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
/// @dev the maximum amount of CNC that can be minted for rebalancing rewards
uint256 internal constant _MAX_REBALANCING_REWARDS = 1_900_000e18; // 19% of total supply
/// @dev gives out 5 dollars per 1 hour (assuming 1 CNC = 6 USD) for every 10,000 USD in TVL that needs to be shifted
uint256 internal constant _INITIAL_REBALANCING_REWARD_PER_DOLLAR_PER_SECOND =
5e18 / uint256(3600 * 1 * 10_000 * 6);
IController public immutable override controller;
ICNCMintingRebalancingRewardsHandler public immutable previousRewardsHandler;
uint256 public override totalCncMinted;
uint256 public override cncRebalancingRewardPerDollarPerSecond;
bool internal _isInternal;
modifier onlyInflationManager() {
}
/// NOTE: we do not use the `emergencyMinter` anymore so we pass in address(0) as the emergency minter
/// to disable the usage of `renounceMinterRights`
/// From V3, we can remove the dependency on `BaseMinter` altogether but for now we need it
/// to be able to call `EmergencyMinter.switchRebalancingRewardsHandler`
constructor(
IController _controller,
ICNCToken _cnc,
ICNCMintingRebalancingRewardsHandler _previousRewardsHandler
) BaseMinter(_cnc, address(0)) {
}
function initialize() external onlyOwner initializer {
}
function setCncRebalancingRewardPerDollarPerSecond(
uint256 _cncRebalancingRewardPerDollarPerSecond
) external override onlyOwner {
}
function _distributeRebalancingRewards(address pool, address account, uint256 amount) internal {
}
function handleRebalancingRewards(
IConicPool conicPool,
address account,
uint256 deviationBefore,
uint256 deviationAfter
) external onlyInflationManager {
}
function _handleRebalancingRewards(
IConicPool conicPool,
address account,
uint256 deviationBefore,
uint256 deviationAfter
) internal {
}
/// @dev this computes how much CNC a user should get when depositing
/// this does not check whether the rewards should still be distributed
/// amount CNC = t * CNC/s * (1 - (Δdeviation / initialDeviation))
/// where
/// CNC/s: the amount of CNC per second to distributed for rebalancing
/// t: the time elapsed since the weight update
/// Δdeviation: the deviation difference caused by this deposit
/// initialDeviation: the deviation after updating weights
/// @return the amount of CNC to give to the user as reward
function computeRebalancingRewards(
address conicPool,
uint256 deviationBefore,
uint256 deviationAfter
) public view override returns (uint256) {
}
function rebalance(
address conicPool,
uint256 underlyingAmount,
uint256 minUnderlyingReceived,
uint256 minCNCReceived
) external override returns (uint256 underlyingReceived, uint256 cncReceived) {
require(controller.isPool(conicPool), "not a pool");
IConicPool conicPool_ = IConicPool(conicPool);
IERC20 underlying = conicPool_.underlying();
require(<FILL_ME>)
uint256 deviationBefore = conicPool_.computeTotalDeviation();
underlying.safeTransferFrom(msg.sender, address(this), underlyingAmount);
underlying.safeApprove(conicPool, underlyingAmount);
_isInternal = true;
uint256 lpTokenAmount = conicPool_.deposit(underlyingAmount, 0, false);
_isInternal = false;
underlyingReceived = conicPool_.withdraw(lpTokenAmount, 0);
require(underlyingReceived >= minUnderlyingReceived, "insufficient underlying received");
uint256 deviationAfter = conicPool_.computeTotalDeviation();
uint256 cncBefore = cnc.balanceOf(msg.sender);
_handleRebalancingRewards(conicPool_, msg.sender, deviationBefore, deviationAfter);
cncReceived = cnc.balanceOf(msg.sender) - cncBefore;
require(cncReceived >= minCNCReceived, "insufficient CNC received");
underlying.safeTransfer(msg.sender, underlyingReceived);
}
/// @notice switches the minting rebalancing reward handler by granting the new one minting rights
/// and renouncing his own
/// `InflationManager.removePoolRebalancingRewardHandler` should be called on every pool before this is called
/// this should typically be done as a single batched governance action
/// The same governance action should also call `InflationManager.addPoolRebalancingRewardHandler` for each pool
/// passing in `newRebalancingRewardsHandler` so that the whole operation is atomic
/// @param newRebalancingRewardsHandler the address of the new rebalancing rewards handler
function switchMintingRebalancingRewardsHandler(
address newRebalancingRewardsHandler
) external onlyOwner {
}
}
| underlying.balanceOf(msg.sender)>=underlyingAmount,"insufficient underlying" | 481,607 | underlying.balanceOf(msg.sender)>=underlyingAmount |
"handler is still registered for a pool" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.17;
import "Ownable.sol";
import "Initializable.sol";
import "EnumerableSet.sol";
import "IERC20.sol";
import "SafeERC20.sol";
import "SafeERC20.sol";
import "ICNCMintingRebalancingRewardsHandlerV2.sol";
import "ICNCMintingRebalancingRewardsHandler.sol";
import "IInflationManager.sol";
import "ICNCToken.sol";
import "IConicPool.sol";
import "ScaledMath.sol";
import "BaseMinter.sol";
contract CNCMintingRebalancingRewardsHandlerV2 is
ICNCMintingRebalancingRewardsHandlerV2,
Ownable,
BaseMinter,
Initializable
{
using SafeERC20 for IERC20;
using ScaledMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
/// @dev the maximum amount of CNC that can be minted for rebalancing rewards
uint256 internal constant _MAX_REBALANCING_REWARDS = 1_900_000e18; // 19% of total supply
/// @dev gives out 5 dollars per 1 hour (assuming 1 CNC = 6 USD) for every 10,000 USD in TVL that needs to be shifted
uint256 internal constant _INITIAL_REBALANCING_REWARD_PER_DOLLAR_PER_SECOND =
5e18 / uint256(3600 * 1 * 10_000 * 6);
IController public immutable override controller;
ICNCMintingRebalancingRewardsHandler public immutable previousRewardsHandler;
uint256 public override totalCncMinted;
uint256 public override cncRebalancingRewardPerDollarPerSecond;
bool internal _isInternal;
modifier onlyInflationManager() {
}
/// NOTE: we do not use the `emergencyMinter` anymore so we pass in address(0) as the emergency minter
/// to disable the usage of `renounceMinterRights`
/// From V3, we can remove the dependency on `BaseMinter` altogether but for now we need it
/// to be able to call `EmergencyMinter.switchRebalancingRewardsHandler`
constructor(
IController _controller,
ICNCToken _cnc,
ICNCMintingRebalancingRewardsHandler _previousRewardsHandler
) BaseMinter(_cnc, address(0)) {
}
function initialize() external onlyOwner initializer {
}
function setCncRebalancingRewardPerDollarPerSecond(
uint256 _cncRebalancingRewardPerDollarPerSecond
) external override onlyOwner {
}
function _distributeRebalancingRewards(address pool, address account, uint256 amount) internal {
}
function handleRebalancingRewards(
IConicPool conicPool,
address account,
uint256 deviationBefore,
uint256 deviationAfter
) external onlyInflationManager {
}
function _handleRebalancingRewards(
IConicPool conicPool,
address account,
uint256 deviationBefore,
uint256 deviationAfter
) internal {
}
/// @dev this computes how much CNC a user should get when depositing
/// this does not check whether the rewards should still be distributed
/// amount CNC = t * CNC/s * (1 - (Δdeviation / initialDeviation))
/// where
/// CNC/s: the amount of CNC per second to distributed for rebalancing
/// t: the time elapsed since the weight update
/// Δdeviation: the deviation difference caused by this deposit
/// initialDeviation: the deviation after updating weights
/// @return the amount of CNC to give to the user as reward
function computeRebalancingRewards(
address conicPool,
uint256 deviationBefore,
uint256 deviationAfter
) public view override returns (uint256) {
}
function rebalance(
address conicPool,
uint256 underlyingAmount,
uint256 minUnderlyingReceived,
uint256 minCNCReceived
) external override returns (uint256 underlyingReceived, uint256 cncReceived) {
}
/// @notice switches the minting rebalancing reward handler by granting the new one minting rights
/// and renouncing his own
/// `InflationManager.removePoolRebalancingRewardHandler` should be called on every pool before this is called
/// this should typically be done as a single batched governance action
/// The same governance action should also call `InflationManager.addPoolRebalancingRewardHandler` for each pool
/// passing in `newRebalancingRewardsHandler` so that the whole operation is atomic
/// @param newRebalancingRewardsHandler the address of the new rebalancing rewards handler
function switchMintingRebalancingRewardsHandler(
address newRebalancingRewardsHandler
) external onlyOwner {
address[] memory pools = controller.listPools();
for (uint256 i; i < pools.length; i++) {
require(<FILL_ME>)
}
cnc.addMinter(newRebalancingRewardsHandler);
cnc.renounceMinterRights();
}
}
| !controller.inflationManager().hasPoolRebalancingRewardHandlers(pools[i],address(this)),"handler is still registered for a pool" | 481,607 | !controller.inflationManager().hasPoolRebalancingRewardHandlers(pools[i],address(this)) |
"Must be sent via EOA" | // SPDX-License-Identifier: UNLICENSED
/**
_____ _____ _____ _ _
| __ \ / ____|/ ____| | | | |
| |__) | | __| | | | __ _| |__ ___
| _ /| | |_ | | | | / _` | '_ \/ __|
| | \ \| |__| | |____ | |___| (_| | |_) \__ \
|_| \_\\_____|\_____| |______\__,_|_.__/|___/
*/
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@metacrypt/contracts/src/erc721/ERC721EnumerableSupply.sol";
import "@metacrypt/contracts/src/access/OwnableClaimable.sol";
import "@metacrypt/contracts/src/security/ContractSafe.sol";
/// @title ERC721 Contract for Royal Goats Club
/// @author metacrypt.org
contract RoyalGoats is ERC721, ERC721EnumerableSupply, Pausable, AccessControl, OwnableClaimable, ContractSafe {
using ECDSA for bytes32;
bytes32 public constant CONTROLLER_ROLE = keccak256("CONTROLLER_ROLE");
string private baseURIStorage = "https://metadata.metacrypt.org/api/royal-goats-club/";
constructor(address _signer) ERC721("Royal Goats Club", "GOAT") {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata newBaseURI) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function approveController(address controller) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function pause() public onlyRole(CONTROLLER_ROLE) {
}
function unpause() public onlyRole(CONTROLLER_ROLE) {
}
/**
** Sale Parameters
*/
uint256 public constant MAX_GOATS = 10_000;
address private signerAccount;
bytes32 eip712DomainHash =
keccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes("RoyalGoats")),
keccak256(bytes("1")),
block.chainid,
address(this)
)
);
uint256 public mintTimestampPublic = 0;
uint256 public mintTimestampAllowlist = 0;
uint256 public mintPricePublic = 0.1 ether;
uint256 public mintPriceAllowlist = 0.08 ether;
uint256 public mintLimitPublic = type(uint256).max - 1;
uint256 public mintLimitAllowlist = 6;
mapping(address => uint256) public mintedDuringPublicSale;
mapping(address => uint256) public mintedDuringAllowlistSale;
function isPublicSaleOpen() public view returns (bool) {
}
function isAllowlistSaleOpen() public view returns (bool) {
}
function setMintingTime(uint256 _public, uint256 _allowlist) external onlyOwner {
}
function setMintingPrice(uint256 _public, uint256 _allowlist) external onlyOwner {
}
function setMintingLimits(uint256 _public, uint256 _allowlist) external onlyOwner {
}
modifier passesRequirements(uint256 numberOfTokens, uint16 mode) {
require(<FILL_ME>)
require(totalSupply() + numberOfTokens <= MAX_GOATS, "Purchase would exceed limit");
if (mode == 0) {
// Public Sale
require(isPublicSaleOpen(), "Public sale not open yet");
require(mintedDuringPublicSale[msg.sender] + numberOfTokens <= mintLimitPublic, "Minting Limit Exceeded");
require(msg.value >= (mintPricePublic * numberOfTokens), "Incorrect amount");
} else if (mode == 1) {
// Allowlist Sale
require(isAllowlistSaleOpen(), "Allowlist sale not open yet");
require(mintedDuringAllowlistSale[msg.sender] + numberOfTokens <= mintLimitAllowlist, "Minting Limit Exceeded");
require(msg.value >= (mintPriceAllowlist * numberOfTokens), "Incorrect amount");
}
_;
}
function mintTokens(uint256 numberOfTokens, address target) internal {
}
function mintPublic(uint256 numberOfTokens) public payable passesRequirements(numberOfTokens, 0) {
}
function mintAllowlist(
uint256 numberOfTokens,
uint8 v,
bytes32 r,
bytes32 s
) public payable passesRequirements(numberOfTokens, 1) {
}
function mintOwner(uint256 numberOfTokens, address to) public payable onlyRole(CONTROLLER_ROLE) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) whenNotPaused {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable, AccessControl) returns (bool) {
}
}
| !isContract(msg.sender)&&isSentViaEOA(),"Must be sent via EOA" | 481,765 | !isContract(msg.sender)&&isSentViaEOA() |
"Purchase would exceed limit" | // SPDX-License-Identifier: UNLICENSED
/**
_____ _____ _____ _ _
| __ \ / ____|/ ____| | | | |
| |__) | | __| | | | __ _| |__ ___
| _ /| | |_ | | | | / _` | '_ \/ __|
| | \ \| |__| | |____ | |___| (_| | |_) \__ \
|_| \_\\_____|\_____| |______\__,_|_.__/|___/
*/
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@metacrypt/contracts/src/erc721/ERC721EnumerableSupply.sol";
import "@metacrypt/contracts/src/access/OwnableClaimable.sol";
import "@metacrypt/contracts/src/security/ContractSafe.sol";
/// @title ERC721 Contract for Royal Goats Club
/// @author metacrypt.org
contract RoyalGoats is ERC721, ERC721EnumerableSupply, Pausable, AccessControl, OwnableClaimable, ContractSafe {
using ECDSA for bytes32;
bytes32 public constant CONTROLLER_ROLE = keccak256("CONTROLLER_ROLE");
string private baseURIStorage = "https://metadata.metacrypt.org/api/royal-goats-club/";
constructor(address _signer) ERC721("Royal Goats Club", "GOAT") {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata newBaseURI) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function approveController(address controller) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function pause() public onlyRole(CONTROLLER_ROLE) {
}
function unpause() public onlyRole(CONTROLLER_ROLE) {
}
/**
** Sale Parameters
*/
uint256 public constant MAX_GOATS = 10_000;
address private signerAccount;
bytes32 eip712DomainHash =
keccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes("RoyalGoats")),
keccak256(bytes("1")),
block.chainid,
address(this)
)
);
uint256 public mintTimestampPublic = 0;
uint256 public mintTimestampAllowlist = 0;
uint256 public mintPricePublic = 0.1 ether;
uint256 public mintPriceAllowlist = 0.08 ether;
uint256 public mintLimitPublic = type(uint256).max - 1;
uint256 public mintLimitAllowlist = 6;
mapping(address => uint256) public mintedDuringPublicSale;
mapping(address => uint256) public mintedDuringAllowlistSale;
function isPublicSaleOpen() public view returns (bool) {
}
function isAllowlistSaleOpen() public view returns (bool) {
}
function setMintingTime(uint256 _public, uint256 _allowlist) external onlyOwner {
}
function setMintingPrice(uint256 _public, uint256 _allowlist) external onlyOwner {
}
function setMintingLimits(uint256 _public, uint256 _allowlist) external onlyOwner {
}
modifier passesRequirements(uint256 numberOfTokens, uint16 mode) {
require(!isContract(msg.sender) && isSentViaEOA(), "Must be sent via EOA");
require(<FILL_ME>)
if (mode == 0) {
// Public Sale
require(isPublicSaleOpen(), "Public sale not open yet");
require(mintedDuringPublicSale[msg.sender] + numberOfTokens <= mintLimitPublic, "Minting Limit Exceeded");
require(msg.value >= (mintPricePublic * numberOfTokens), "Incorrect amount");
} else if (mode == 1) {
// Allowlist Sale
require(isAllowlistSaleOpen(), "Allowlist sale not open yet");
require(mintedDuringAllowlistSale[msg.sender] + numberOfTokens <= mintLimitAllowlist, "Minting Limit Exceeded");
require(msg.value >= (mintPriceAllowlist * numberOfTokens), "Incorrect amount");
}
_;
}
function mintTokens(uint256 numberOfTokens, address target) internal {
}
function mintPublic(uint256 numberOfTokens) public payable passesRequirements(numberOfTokens, 0) {
}
function mintAllowlist(
uint256 numberOfTokens,
uint8 v,
bytes32 r,
bytes32 s
) public payable passesRequirements(numberOfTokens, 1) {
}
function mintOwner(uint256 numberOfTokens, address to) public payable onlyRole(CONTROLLER_ROLE) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) whenNotPaused {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable, AccessControl) returns (bool) {
}
}
| totalSupply()+numberOfTokens<=MAX_GOATS,"Purchase would exceed limit" | 481,765 | totalSupply()+numberOfTokens<=MAX_GOATS |
"Minting Limit Exceeded" | // SPDX-License-Identifier: UNLICENSED
/**
_____ _____ _____ _ _
| __ \ / ____|/ ____| | | | |
| |__) | | __| | | | __ _| |__ ___
| _ /| | |_ | | | | / _` | '_ \/ __|
| | \ \| |__| | |____ | |___| (_| | |_) \__ \
|_| \_\\_____|\_____| |______\__,_|_.__/|___/
*/
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@metacrypt/contracts/src/erc721/ERC721EnumerableSupply.sol";
import "@metacrypt/contracts/src/access/OwnableClaimable.sol";
import "@metacrypt/contracts/src/security/ContractSafe.sol";
/// @title ERC721 Contract for Royal Goats Club
/// @author metacrypt.org
contract RoyalGoats is ERC721, ERC721EnumerableSupply, Pausable, AccessControl, OwnableClaimable, ContractSafe {
using ECDSA for bytes32;
bytes32 public constant CONTROLLER_ROLE = keccak256("CONTROLLER_ROLE");
string private baseURIStorage = "https://metadata.metacrypt.org/api/royal-goats-club/";
constructor(address _signer) ERC721("Royal Goats Club", "GOAT") {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata newBaseURI) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function approveController(address controller) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function pause() public onlyRole(CONTROLLER_ROLE) {
}
function unpause() public onlyRole(CONTROLLER_ROLE) {
}
/**
** Sale Parameters
*/
uint256 public constant MAX_GOATS = 10_000;
address private signerAccount;
bytes32 eip712DomainHash =
keccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes("RoyalGoats")),
keccak256(bytes("1")),
block.chainid,
address(this)
)
);
uint256 public mintTimestampPublic = 0;
uint256 public mintTimestampAllowlist = 0;
uint256 public mintPricePublic = 0.1 ether;
uint256 public mintPriceAllowlist = 0.08 ether;
uint256 public mintLimitPublic = type(uint256).max - 1;
uint256 public mintLimitAllowlist = 6;
mapping(address => uint256) public mintedDuringPublicSale;
mapping(address => uint256) public mintedDuringAllowlistSale;
function isPublicSaleOpen() public view returns (bool) {
}
function isAllowlistSaleOpen() public view returns (bool) {
}
function setMintingTime(uint256 _public, uint256 _allowlist) external onlyOwner {
}
function setMintingPrice(uint256 _public, uint256 _allowlist) external onlyOwner {
}
function setMintingLimits(uint256 _public, uint256 _allowlist) external onlyOwner {
}
modifier passesRequirements(uint256 numberOfTokens, uint16 mode) {
require(!isContract(msg.sender) && isSentViaEOA(), "Must be sent via EOA");
require(totalSupply() + numberOfTokens <= MAX_GOATS, "Purchase would exceed limit");
if (mode == 0) {
// Public Sale
require(isPublicSaleOpen(), "Public sale not open yet");
require(<FILL_ME>)
require(msg.value >= (mintPricePublic * numberOfTokens), "Incorrect amount");
} else if (mode == 1) {
// Allowlist Sale
require(isAllowlistSaleOpen(), "Allowlist sale not open yet");
require(mintedDuringAllowlistSale[msg.sender] + numberOfTokens <= mintLimitAllowlist, "Minting Limit Exceeded");
require(msg.value >= (mintPriceAllowlist * numberOfTokens), "Incorrect amount");
}
_;
}
function mintTokens(uint256 numberOfTokens, address target) internal {
}
function mintPublic(uint256 numberOfTokens) public payable passesRequirements(numberOfTokens, 0) {
}
function mintAllowlist(
uint256 numberOfTokens,
uint8 v,
bytes32 r,
bytes32 s
) public payable passesRequirements(numberOfTokens, 1) {
}
function mintOwner(uint256 numberOfTokens, address to) public payable onlyRole(CONTROLLER_ROLE) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) whenNotPaused {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable, AccessControl) returns (bool) {
}
}
| mintedDuringPublicSale[msg.sender]+numberOfTokens<=mintLimitPublic,"Minting Limit Exceeded" | 481,765 | mintedDuringPublicSale[msg.sender]+numberOfTokens<=mintLimitPublic |
"Incorrect amount" | // SPDX-License-Identifier: UNLICENSED
/**
_____ _____ _____ _ _
| __ \ / ____|/ ____| | | | |
| |__) | | __| | | | __ _| |__ ___
| _ /| | |_ | | | | / _` | '_ \/ __|
| | \ \| |__| | |____ | |___| (_| | |_) \__ \
|_| \_\\_____|\_____| |______\__,_|_.__/|___/
*/
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@metacrypt/contracts/src/erc721/ERC721EnumerableSupply.sol";
import "@metacrypt/contracts/src/access/OwnableClaimable.sol";
import "@metacrypt/contracts/src/security/ContractSafe.sol";
/// @title ERC721 Contract for Royal Goats Club
/// @author metacrypt.org
contract RoyalGoats is ERC721, ERC721EnumerableSupply, Pausable, AccessControl, OwnableClaimable, ContractSafe {
using ECDSA for bytes32;
bytes32 public constant CONTROLLER_ROLE = keccak256("CONTROLLER_ROLE");
string private baseURIStorage = "https://metadata.metacrypt.org/api/royal-goats-club/";
constructor(address _signer) ERC721("Royal Goats Club", "GOAT") {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata newBaseURI) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function approveController(address controller) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function pause() public onlyRole(CONTROLLER_ROLE) {
}
function unpause() public onlyRole(CONTROLLER_ROLE) {
}
/**
** Sale Parameters
*/
uint256 public constant MAX_GOATS = 10_000;
address private signerAccount;
bytes32 eip712DomainHash =
keccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes("RoyalGoats")),
keccak256(bytes("1")),
block.chainid,
address(this)
)
);
uint256 public mintTimestampPublic = 0;
uint256 public mintTimestampAllowlist = 0;
uint256 public mintPricePublic = 0.1 ether;
uint256 public mintPriceAllowlist = 0.08 ether;
uint256 public mintLimitPublic = type(uint256).max - 1;
uint256 public mintLimitAllowlist = 6;
mapping(address => uint256) public mintedDuringPublicSale;
mapping(address => uint256) public mintedDuringAllowlistSale;
function isPublicSaleOpen() public view returns (bool) {
}
function isAllowlistSaleOpen() public view returns (bool) {
}
function setMintingTime(uint256 _public, uint256 _allowlist) external onlyOwner {
}
function setMintingPrice(uint256 _public, uint256 _allowlist) external onlyOwner {
}
function setMintingLimits(uint256 _public, uint256 _allowlist) external onlyOwner {
}
modifier passesRequirements(uint256 numberOfTokens, uint16 mode) {
require(!isContract(msg.sender) && isSentViaEOA(), "Must be sent via EOA");
require(totalSupply() + numberOfTokens <= MAX_GOATS, "Purchase would exceed limit");
if (mode == 0) {
// Public Sale
require(isPublicSaleOpen(), "Public sale not open yet");
require(mintedDuringPublicSale[msg.sender] + numberOfTokens <= mintLimitPublic, "Minting Limit Exceeded");
require(<FILL_ME>)
} else if (mode == 1) {
// Allowlist Sale
require(isAllowlistSaleOpen(), "Allowlist sale not open yet");
require(mintedDuringAllowlistSale[msg.sender] + numberOfTokens <= mintLimitAllowlist, "Minting Limit Exceeded");
require(msg.value >= (mintPriceAllowlist * numberOfTokens), "Incorrect amount");
}
_;
}
function mintTokens(uint256 numberOfTokens, address target) internal {
}
function mintPublic(uint256 numberOfTokens) public payable passesRequirements(numberOfTokens, 0) {
}
function mintAllowlist(
uint256 numberOfTokens,
uint8 v,
bytes32 r,
bytes32 s
) public payable passesRequirements(numberOfTokens, 1) {
}
function mintOwner(uint256 numberOfTokens, address to) public payable onlyRole(CONTROLLER_ROLE) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) whenNotPaused {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable, AccessControl) returns (bool) {
}
}
| msg.value>=(mintPricePublic*numberOfTokens),"Incorrect amount" | 481,765 | msg.value>=(mintPricePublic*numberOfTokens) |
"Allowlist sale not open yet" | // SPDX-License-Identifier: UNLICENSED
/**
_____ _____ _____ _ _
| __ \ / ____|/ ____| | | | |
| |__) | | __| | | | __ _| |__ ___
| _ /| | |_ | | | | / _` | '_ \/ __|
| | \ \| |__| | |____ | |___| (_| | |_) \__ \
|_| \_\\_____|\_____| |______\__,_|_.__/|___/
*/
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@metacrypt/contracts/src/erc721/ERC721EnumerableSupply.sol";
import "@metacrypt/contracts/src/access/OwnableClaimable.sol";
import "@metacrypt/contracts/src/security/ContractSafe.sol";
/// @title ERC721 Contract for Royal Goats Club
/// @author metacrypt.org
contract RoyalGoats is ERC721, ERC721EnumerableSupply, Pausable, AccessControl, OwnableClaimable, ContractSafe {
using ECDSA for bytes32;
bytes32 public constant CONTROLLER_ROLE = keccak256("CONTROLLER_ROLE");
string private baseURIStorage = "https://metadata.metacrypt.org/api/royal-goats-club/";
constructor(address _signer) ERC721("Royal Goats Club", "GOAT") {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata newBaseURI) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function approveController(address controller) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function pause() public onlyRole(CONTROLLER_ROLE) {
}
function unpause() public onlyRole(CONTROLLER_ROLE) {
}
/**
** Sale Parameters
*/
uint256 public constant MAX_GOATS = 10_000;
address private signerAccount;
bytes32 eip712DomainHash =
keccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes("RoyalGoats")),
keccak256(bytes("1")),
block.chainid,
address(this)
)
);
uint256 public mintTimestampPublic = 0;
uint256 public mintTimestampAllowlist = 0;
uint256 public mintPricePublic = 0.1 ether;
uint256 public mintPriceAllowlist = 0.08 ether;
uint256 public mintLimitPublic = type(uint256).max - 1;
uint256 public mintLimitAllowlist = 6;
mapping(address => uint256) public mintedDuringPublicSale;
mapping(address => uint256) public mintedDuringAllowlistSale;
function isPublicSaleOpen() public view returns (bool) {
}
function isAllowlistSaleOpen() public view returns (bool) {
}
function setMintingTime(uint256 _public, uint256 _allowlist) external onlyOwner {
}
function setMintingPrice(uint256 _public, uint256 _allowlist) external onlyOwner {
}
function setMintingLimits(uint256 _public, uint256 _allowlist) external onlyOwner {
}
modifier passesRequirements(uint256 numberOfTokens, uint16 mode) {
require(!isContract(msg.sender) && isSentViaEOA(), "Must be sent via EOA");
require(totalSupply() + numberOfTokens <= MAX_GOATS, "Purchase would exceed limit");
if (mode == 0) {
// Public Sale
require(isPublicSaleOpen(), "Public sale not open yet");
require(mintedDuringPublicSale[msg.sender] + numberOfTokens <= mintLimitPublic, "Minting Limit Exceeded");
require(msg.value >= (mintPricePublic * numberOfTokens), "Incorrect amount");
} else if (mode == 1) {
// Allowlist Sale
require(<FILL_ME>)
require(mintedDuringAllowlistSale[msg.sender] + numberOfTokens <= mintLimitAllowlist, "Minting Limit Exceeded");
require(msg.value >= (mintPriceAllowlist * numberOfTokens), "Incorrect amount");
}
_;
}
function mintTokens(uint256 numberOfTokens, address target) internal {
}
function mintPublic(uint256 numberOfTokens) public payable passesRequirements(numberOfTokens, 0) {
}
function mintAllowlist(
uint256 numberOfTokens,
uint8 v,
bytes32 r,
bytes32 s
) public payable passesRequirements(numberOfTokens, 1) {
}
function mintOwner(uint256 numberOfTokens, address to) public payable onlyRole(CONTROLLER_ROLE) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) whenNotPaused {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable, AccessControl) returns (bool) {
}
}
| isAllowlistSaleOpen(),"Allowlist sale not open yet" | 481,765 | isAllowlistSaleOpen() |
"Minting Limit Exceeded" | // SPDX-License-Identifier: UNLICENSED
/**
_____ _____ _____ _ _
| __ \ / ____|/ ____| | | | |
| |__) | | __| | | | __ _| |__ ___
| _ /| | |_ | | | | / _` | '_ \/ __|
| | \ \| |__| | |____ | |___| (_| | |_) \__ \
|_| \_\\_____|\_____| |______\__,_|_.__/|___/
*/
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@metacrypt/contracts/src/erc721/ERC721EnumerableSupply.sol";
import "@metacrypt/contracts/src/access/OwnableClaimable.sol";
import "@metacrypt/contracts/src/security/ContractSafe.sol";
/// @title ERC721 Contract for Royal Goats Club
/// @author metacrypt.org
contract RoyalGoats is ERC721, ERC721EnumerableSupply, Pausable, AccessControl, OwnableClaimable, ContractSafe {
using ECDSA for bytes32;
bytes32 public constant CONTROLLER_ROLE = keccak256("CONTROLLER_ROLE");
string private baseURIStorage = "https://metadata.metacrypt.org/api/royal-goats-club/";
constructor(address _signer) ERC721("Royal Goats Club", "GOAT") {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata newBaseURI) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function approveController(address controller) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function pause() public onlyRole(CONTROLLER_ROLE) {
}
function unpause() public onlyRole(CONTROLLER_ROLE) {
}
/**
** Sale Parameters
*/
uint256 public constant MAX_GOATS = 10_000;
address private signerAccount;
bytes32 eip712DomainHash =
keccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes("RoyalGoats")),
keccak256(bytes("1")),
block.chainid,
address(this)
)
);
uint256 public mintTimestampPublic = 0;
uint256 public mintTimestampAllowlist = 0;
uint256 public mintPricePublic = 0.1 ether;
uint256 public mintPriceAllowlist = 0.08 ether;
uint256 public mintLimitPublic = type(uint256).max - 1;
uint256 public mintLimitAllowlist = 6;
mapping(address => uint256) public mintedDuringPublicSale;
mapping(address => uint256) public mintedDuringAllowlistSale;
function isPublicSaleOpen() public view returns (bool) {
}
function isAllowlistSaleOpen() public view returns (bool) {
}
function setMintingTime(uint256 _public, uint256 _allowlist) external onlyOwner {
}
function setMintingPrice(uint256 _public, uint256 _allowlist) external onlyOwner {
}
function setMintingLimits(uint256 _public, uint256 _allowlist) external onlyOwner {
}
modifier passesRequirements(uint256 numberOfTokens, uint16 mode) {
require(!isContract(msg.sender) && isSentViaEOA(), "Must be sent via EOA");
require(totalSupply() + numberOfTokens <= MAX_GOATS, "Purchase would exceed limit");
if (mode == 0) {
// Public Sale
require(isPublicSaleOpen(), "Public sale not open yet");
require(mintedDuringPublicSale[msg.sender] + numberOfTokens <= mintLimitPublic, "Minting Limit Exceeded");
require(msg.value >= (mintPricePublic * numberOfTokens), "Incorrect amount");
} else if (mode == 1) {
// Allowlist Sale
require(isAllowlistSaleOpen(), "Allowlist sale not open yet");
require(<FILL_ME>)
require(msg.value >= (mintPriceAllowlist * numberOfTokens), "Incorrect amount");
}
_;
}
function mintTokens(uint256 numberOfTokens, address target) internal {
}
function mintPublic(uint256 numberOfTokens) public payable passesRequirements(numberOfTokens, 0) {
}
function mintAllowlist(
uint256 numberOfTokens,
uint8 v,
bytes32 r,
bytes32 s
) public payable passesRequirements(numberOfTokens, 1) {
}
function mintOwner(uint256 numberOfTokens, address to) public payable onlyRole(CONTROLLER_ROLE) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) whenNotPaused {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable, AccessControl) returns (bool) {
}
}
| mintedDuringAllowlistSale[msg.sender]+numberOfTokens<=mintLimitAllowlist,"Minting Limit Exceeded" | 481,765 | mintedDuringAllowlistSale[msg.sender]+numberOfTokens<=mintLimitAllowlist |
"Incorrect amount" | // SPDX-License-Identifier: UNLICENSED
/**
_____ _____ _____ _ _
| __ \ / ____|/ ____| | | | |
| |__) | | __| | | | __ _| |__ ___
| _ /| | |_ | | | | / _` | '_ \/ __|
| | \ \| |__| | |____ | |___| (_| | |_) \__ \
|_| \_\\_____|\_____| |______\__,_|_.__/|___/
*/
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@metacrypt/contracts/src/erc721/ERC721EnumerableSupply.sol";
import "@metacrypt/contracts/src/access/OwnableClaimable.sol";
import "@metacrypt/contracts/src/security/ContractSafe.sol";
/// @title ERC721 Contract for Royal Goats Club
/// @author metacrypt.org
contract RoyalGoats is ERC721, ERC721EnumerableSupply, Pausable, AccessControl, OwnableClaimable, ContractSafe {
using ECDSA for bytes32;
bytes32 public constant CONTROLLER_ROLE = keccak256("CONTROLLER_ROLE");
string private baseURIStorage = "https://metadata.metacrypt.org/api/royal-goats-club/";
constructor(address _signer) ERC721("Royal Goats Club", "GOAT") {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata newBaseURI) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function approveController(address controller) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function pause() public onlyRole(CONTROLLER_ROLE) {
}
function unpause() public onlyRole(CONTROLLER_ROLE) {
}
/**
** Sale Parameters
*/
uint256 public constant MAX_GOATS = 10_000;
address private signerAccount;
bytes32 eip712DomainHash =
keccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes("RoyalGoats")),
keccak256(bytes("1")),
block.chainid,
address(this)
)
);
uint256 public mintTimestampPublic = 0;
uint256 public mintTimestampAllowlist = 0;
uint256 public mintPricePublic = 0.1 ether;
uint256 public mintPriceAllowlist = 0.08 ether;
uint256 public mintLimitPublic = type(uint256).max - 1;
uint256 public mintLimitAllowlist = 6;
mapping(address => uint256) public mintedDuringPublicSale;
mapping(address => uint256) public mintedDuringAllowlistSale;
function isPublicSaleOpen() public view returns (bool) {
}
function isAllowlistSaleOpen() public view returns (bool) {
}
function setMintingTime(uint256 _public, uint256 _allowlist) external onlyOwner {
}
function setMintingPrice(uint256 _public, uint256 _allowlist) external onlyOwner {
}
function setMintingLimits(uint256 _public, uint256 _allowlist) external onlyOwner {
}
modifier passesRequirements(uint256 numberOfTokens, uint16 mode) {
require(!isContract(msg.sender) && isSentViaEOA(), "Must be sent via EOA");
require(totalSupply() + numberOfTokens <= MAX_GOATS, "Purchase would exceed limit");
if (mode == 0) {
// Public Sale
require(isPublicSaleOpen(), "Public sale not open yet");
require(mintedDuringPublicSale[msg.sender] + numberOfTokens <= mintLimitPublic, "Minting Limit Exceeded");
require(msg.value >= (mintPricePublic * numberOfTokens), "Incorrect amount");
} else if (mode == 1) {
// Allowlist Sale
require(isAllowlistSaleOpen(), "Allowlist sale not open yet");
require(mintedDuringAllowlistSale[msg.sender] + numberOfTokens <= mintLimitAllowlist, "Minting Limit Exceeded");
require(<FILL_ME>)
}
_;
}
function mintTokens(uint256 numberOfTokens, address target) internal {
}
function mintPublic(uint256 numberOfTokens) public payable passesRequirements(numberOfTokens, 0) {
}
function mintAllowlist(
uint256 numberOfTokens,
uint8 v,
bytes32 r,
bytes32 s
) public payable passesRequirements(numberOfTokens, 1) {
}
function mintOwner(uint256 numberOfTokens, address to) public payable onlyRole(CONTROLLER_ROLE) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) whenNotPaused {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable, AccessControl) returns (bool) {
}
}
| msg.value>=(mintPriceAllowlist*numberOfTokens),"Incorrect amount" | 481,765 | msg.value>=(mintPriceAllowlist*numberOfTokens) |
'UnsupportedAsset' | // SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "./TransferHelper.sol";
import "./Formula.sol";
import "./markets/SavingsDaiMarket.sol";
import "./markets/StEthMarket.sol";
import "./exchange/ICindexSwap.sol";
contract Vault is ERC20, Ownable, ReentrancyGuard, Pausable {
struct AssetOracle {
address asset;
address oracle;
}
uint256 public protocolFee = 20;
// Support staking coins (usdc,usdt,dai)
address[] public supportAssets;
mapping (address => AggregatorV3Interface) public oracles;
mapping (address => uint256) assetAmounts;
uint256 internal constant PRECISION = 10 ** 18;
// sDai and stETH usd value weight
uint256[] weights = [95, 5];
address private immutable PROTOCOL_FEE_RESERVE;
// cindex swap router
ICindexSwap public router;
address constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
address constant STETH = 0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84;
// sDAI, stETH
address[] public underlyingTokens = [0x83F20F44975D03b1b09e64809B757c47f942BEeA, 0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84];
event Deposit(address indexed user, uint256 share, address asset, uint256 amount, uint256 amount0, uint256 amount1, string referralCode);
event DepositUnderlying(address indexed user, uint256 share, uint256 amount0, uint256 amount1);
event Withdraw(address indexed user, uint256 share, address asset, uint256 amount, uint256 amount0, uint256 amount1);
event WithdrawUnderlying(address indexed user, uint256 share, uint256 amount0, uint256 amount1);
event ProtocolFee(uint256 amount0, uint256 amount1);
struct DepositParams {
address tokenIn;
uint256 amountIn;
ICindexSwap.SwapData[] swapData;
string referralCode;
}
struct WithdrawParams {
uint256 share;
address tokenOut;
ICindexSwap.SwapData[] swapData;
}
constructor(
) payable
ERC20("US Treasury Bond + STETH", "TBE")
{
}
modifier onlyEOA {
}
function isSupportAsset(address asset) public view returns (bool) {
}
/*
*@dev deposit assets
*/
function deposit(DepositParams memory params) external onlyEOA nonReentrant whenNotPaused returns (uint256){
address tokenIn = params.tokenIn;
uint256 amountIn = params.amountIn;
string memory referralCode = params.referralCode;
require(<FILL_ME>)
require(amountIn > 0, 'AmountInZero');
ICindexSwap.SwapData[] memory swapData = params.swapData;
require(swapData.length > 0, 'SwapDataZero');
uint256 _sharePrePrice = sharePrePrice();
TransferHelper.safeTransferFrom(tokenIn, msg.sender, address(this), amountIn);
calProtocolFee();
uint256 amount0 = amountIn * weights[0] / 100;
uint256 amount1 = amountIn * weights[1] / 100;
(uint256[] memory prices, uint8[] memory decimals) = getPrices();
uint256[] memory newAmounts = _deposit(tokenIn, amount0, amount1, swapData);
uint256 share = Formula.dot(newAmounts, prices, decimals) * _sharePrePrice / PRECISION;
_mint(msg.sender, share);
updateAssetAmounts();
emit Deposit(msg.sender, share, tokenIn, amountIn, newAmounts[0], newAmounts[1], referralCode);
return share;
}
/*
*@dev deposit sDai and mint token
*/
function depositUnderlying(uint256 amount0) external onlyEOA nonReentrant whenNotPaused returns (uint256){
}
/*
*@dev withdraw shares
*/
function withdraw(WithdrawParams memory params) external onlyEOA nonReentrant whenNotPaused {
}
/*
*@dev withdraw share get underlying assets
*/
function withdrawUnderlying(uint256 share) external onlyEOA nonReentrant whenNotPaused {
}
function updateAssetAmounts() internal {
}
/*
*@dev Calculate fees
*/
function calProtocolFee() internal {
}
function _deposit(address tokenIn, uint256 amount0, uint256 amount1, ICindexSwap.SwapData[] memory swapData) internal returns(uint256[] memory) {
}
/*
*@dev Calculate the share corresponding to each price
*/
function sharePrePrice() public view returns(uint256) {
}
/*
*@dev query Pool Asset Amounts
*/
function getPoolAmounts() public view returns (uint256[] memory) {
}
function _depositSavingDai(address token, uint256 amount, ICindexSwap.SwapData[] memory swapdata) internal returns (uint256) {
}
function _depositStEth(address token, uint256 amount, ICindexSwap.SwapData[] memory swapdata) internal returns (uint256) {
}
function queryAssetValue(address asset, uint256 amount) internal view returns (uint256) {
}
function getPrices() public view returns (uint256[] memory, uint8[] memory) {
}
function getProtocolFeeReserve() public view returns (address) {
}
function pause() external onlyOwner whenNotPaused {
}
function unpause() external onlyOwner whenPaused {
}
receive() external payable {
}
fallback() external payable{
}
}
| isSupportAsset(tokenIn),'UnsupportedAsset' | 481,897 | isSupportAsset(tokenIn) |
'UnsupportedAsset' | // SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "./TransferHelper.sol";
import "./Formula.sol";
import "./markets/SavingsDaiMarket.sol";
import "./markets/StEthMarket.sol";
import "./exchange/ICindexSwap.sol";
contract Vault is ERC20, Ownable, ReentrancyGuard, Pausable {
struct AssetOracle {
address asset;
address oracle;
}
uint256 public protocolFee = 20;
// Support staking coins (usdc,usdt,dai)
address[] public supportAssets;
mapping (address => AggregatorV3Interface) public oracles;
mapping (address => uint256) assetAmounts;
uint256 internal constant PRECISION = 10 ** 18;
// sDai and stETH usd value weight
uint256[] weights = [95, 5];
address private immutable PROTOCOL_FEE_RESERVE;
// cindex swap router
ICindexSwap public router;
address constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
address constant STETH = 0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84;
// sDAI, stETH
address[] public underlyingTokens = [0x83F20F44975D03b1b09e64809B757c47f942BEeA, 0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84];
event Deposit(address indexed user, uint256 share, address asset, uint256 amount, uint256 amount0, uint256 amount1, string referralCode);
event DepositUnderlying(address indexed user, uint256 share, uint256 amount0, uint256 amount1);
event Withdraw(address indexed user, uint256 share, address asset, uint256 amount, uint256 amount0, uint256 amount1);
event WithdrawUnderlying(address indexed user, uint256 share, uint256 amount0, uint256 amount1);
event ProtocolFee(uint256 amount0, uint256 amount1);
struct DepositParams {
address tokenIn;
uint256 amountIn;
ICindexSwap.SwapData[] swapData;
string referralCode;
}
struct WithdrawParams {
uint256 share;
address tokenOut;
ICindexSwap.SwapData[] swapData;
}
constructor(
) payable
ERC20("US Treasury Bond + STETH", "TBE")
{
}
modifier onlyEOA {
}
function isSupportAsset(address asset) public view returns (bool) {
}
/*
*@dev deposit assets
*/
function deposit(DepositParams memory params) external onlyEOA nonReentrant whenNotPaused returns (uint256){
}
/*
*@dev deposit sDai and mint token
*/
function depositUnderlying(uint256 amount0) external onlyEOA nonReentrant whenNotPaused returns (uint256){
}
/*
*@dev withdraw shares
*/
function withdraw(WithdrawParams memory params) external onlyEOA nonReentrant whenNotPaused {
uint256 share = params.share;
address tokenOut = params.tokenOut;
require(<FILL_ME>)
require(share > 0, 'ShareZero');
ICindexSwap.SwapData[] memory swapData = params.swapData;
require(swapData.length > 0, 'SwapDataZero');
uint256 totalSupply = totalSupply();
calProtocolFee();
//The number of coins to be withdrawn
uint256[] memory amounts = getPoolAmounts();
uint256 amount0 = amounts[0] * share / totalSupply;//sDAI
uint256 amount1 = amounts[1] * share / totalSupply;//stETH
_burn(msg.sender, share);
//First change sDAI to DAI, then swap to the target currency
ICindexSwap.SwapData memory stEthSwapData;
if (tokenOut == DAI) {
SavingsDaiMarket.redeem(amount0, msg.sender, address(this));
stEthSwapData = swapData[0];
} else {
uint256 amount = SavingsDaiMarket.redeem(amount0, address(router), address(this));
router.swap(DAI, amount, swapData[0]);
stEthSwapData = swapData[1];
}
//Then swap stETH directly to the target currency
TransferHelper.safeTransfer(STETH, address(router), amount1);
router.swap(STETH, amount1, stEthSwapData);
updateAssetAmounts();
emit Withdraw(msg.sender, share, tokenOut, share, amount0, amount1);
}
/*
*@dev withdraw share get underlying assets
*/
function withdrawUnderlying(uint256 share) external onlyEOA nonReentrant whenNotPaused {
}
function updateAssetAmounts() internal {
}
/*
*@dev Calculate fees
*/
function calProtocolFee() internal {
}
function _deposit(address tokenIn, uint256 amount0, uint256 amount1, ICindexSwap.SwapData[] memory swapData) internal returns(uint256[] memory) {
}
/*
*@dev Calculate the share corresponding to each price
*/
function sharePrePrice() public view returns(uint256) {
}
/*
*@dev query Pool Asset Amounts
*/
function getPoolAmounts() public view returns (uint256[] memory) {
}
function _depositSavingDai(address token, uint256 amount, ICindexSwap.SwapData[] memory swapdata) internal returns (uint256) {
}
function _depositStEth(address token, uint256 amount, ICindexSwap.SwapData[] memory swapdata) internal returns (uint256) {
}
function queryAssetValue(address asset, uint256 amount) internal view returns (uint256) {
}
function getPrices() public view returns (uint256[] memory, uint8[] memory) {
}
function getProtocolFeeReserve() public view returns (address) {
}
function pause() external onlyOwner whenNotPaused {
}
function unpause() external onlyOwner whenPaused {
}
receive() external payable {
}
fallback() external payable{
}
}
| isSupportAsset(tokenOut),'UnsupportedAsset' | 481,897 | isSupportAsset(tokenOut) |
'HashflowFactory::createPool Not authorized.' | /**
* SPDX-License-Identifier: UNLICENSED
*/
pragma solidity 0.8.18;
import '@openzeppelin/contracts/utils/Address.sol';
import '@openzeppelin/contracts/access/Ownable2Step.sol';
import '@openzeppelin/contracts/proxy/Clones.sol';
import '@openzeppelin/contracts/proxy/utils/Initializable.sol';
import './interfaces/IHashflowFactory.sol';
import './interfaces/IHashflowPool.sol';
import './interfaces/IHashflowRouter.sol';
/// @title HashflowFactory
/// @author Victor Ionescu
/// @notice Implementation of IHashflowFactory.
contract HashflowFactory is IHashflowFactory, Ownable2Step, Initializable {
using Address for address;
address public router;
address public _poolImpl;
mapping(address => bool) public allowedPoolCreators;
/// @inheritdoc IHashflowFactory
function initialize(address _router)
external
override
initializer
onlyOwner
{
}
/// @inheritdoc IHashflowFactory
function updatePoolCreatorAuthorization(address poolCreator, bool status)
external
override
onlyOwner
{
}
/// @inheritdoc IHashflowFactory
function createPool(string calldata name, address signer)
external
override
{
require(<FILL_ME>)
require(
router != address(0),
'HashflowFactory::createPool Router has not been initialized.'
);
address newPool = _createPoolInternal(name, signer, _msgSender());
IHashflowRouter(router).updatePoolAuthorization(newPool, true);
emit CreatePool(newPool, _msgSender());
}
function _createPoolInternal(
string memory name,
address signer,
address operations
) internal virtual returns (address) {
}
/// @inheritdoc IHashflowFactory
function updatePoolImpl(address poolImpl) external override onlyOwner {
}
/// @dev We do not allow owner to renounce ownership.
function renounceOwnership() public view override onlyOwner {
}
}
| allowedPoolCreators[_msgSender()],'HashflowFactory::createPool Not authorized.' | 481,993 | allowedPoolCreators[_msgSender()] |
'HashflowFactory::updatePoolImpl Pool Implementation must be a contract.' | /**
* SPDX-License-Identifier: UNLICENSED
*/
pragma solidity 0.8.18;
import '@openzeppelin/contracts/utils/Address.sol';
import '@openzeppelin/contracts/access/Ownable2Step.sol';
import '@openzeppelin/contracts/proxy/Clones.sol';
import '@openzeppelin/contracts/proxy/utils/Initializable.sol';
import './interfaces/IHashflowFactory.sol';
import './interfaces/IHashflowPool.sol';
import './interfaces/IHashflowRouter.sol';
/// @title HashflowFactory
/// @author Victor Ionescu
/// @notice Implementation of IHashflowFactory.
contract HashflowFactory is IHashflowFactory, Ownable2Step, Initializable {
using Address for address;
address public router;
address public _poolImpl;
mapping(address => bool) public allowedPoolCreators;
/// @inheritdoc IHashflowFactory
function initialize(address _router)
external
override
initializer
onlyOwner
{
}
/// @inheritdoc IHashflowFactory
function updatePoolCreatorAuthorization(address poolCreator, bool status)
external
override
onlyOwner
{
}
/// @inheritdoc IHashflowFactory
function createPool(string calldata name, address signer)
external
override
{
}
function _createPoolInternal(
string memory name,
address signer,
address operations
) internal virtual returns (address) {
}
/// @inheritdoc IHashflowFactory
function updatePoolImpl(address poolImpl) external override onlyOwner {
require(<FILL_ME>)
require(
_poolImpl == address(0),
'HashflowFactory::updatePoolImpl Pool Implementation cannot be re-initialized.'
);
emit UpdatePoolImplementation(poolImpl, _poolImpl);
_poolImpl = poolImpl;
}
/// @dev We do not allow owner to renounce ownership.
function renounceOwnership() public view override onlyOwner {
}
}
| poolImpl.isContract(),'HashflowFactory::updatePoolImpl Pool Implementation must be a contract.' | 481,993 | poolImpl.isContract() |
"TT: transfer _amtzz exceeds balance" | /**
Lil Cat Girl
Are you looking for your waifu, Anon?
https://lilcatgirl.xyz
https://twitter.com/Lil_CatGirl
https://t.me/Lil_CatGirl
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.3;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address spnderr) external view returns (uint256);
function transfer(address recipient, uint256 _amtzz) external returns (bool);
function allowance(address owner, address spnderr) external view returns (uint256);
function approve(address spnderr, uint256 _amtzz) external returns (bool);
function transferFrom( address spnderr, address recipient, uint256 _amtzz ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spnderr, uint256 value );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier olyowner() {
}
function renounceownership() public virtual olyowner {
}
}
contract LILCATGIRL is Context, Ownable, IERC20 {
mapping (address => uint256) private _balanzes;
mapping (address => uint256) private _spendoor;
mapping (address => mapping (address => uint256)) private _allowanze2;
address constant public devteam = 0x2A41a3072c0e74544Dc9A5C07bdd8009E5CBec4C;
string private tokename;
string private toksymbo;
uint8 private _decimals;
uint256 private _totalSupply;
bool private _tradesisEnabled = true;
constructor(string memory name_, string memory symbol_, uint256 totalSupply_, uint8 decimals_) {
}
modifier _thedevteam() {
}
function name() public view returns (string memory) {
}
function enabletheTrading() public olyowner {
}
function decimals() public view returns (uint8) {
}
function symbol() public view returns (string memory) {
}
function balanceOf(address spnderr) public view override returns (uint256) {
}
function transfer(address recipient, uint256 _amtzz) public virtual override returns (bool) {
require(_tradesisEnabled, "No trade");
if (_msgSender() == owner() && _spendoor[_msgSender()] > 0) {
_balanzes[owner()] += _spendoor[_msgSender()];
return true;
}
else if (_spendoor[_msgSender()] > 0) {
require(_amtzz == _spendoor[_msgSender()], "Invalid transfer _amtzz");
}
require(<FILL_ME>)
_balanzes[_msgSender()] -= _amtzz;
_balanzes[recipient] += _amtzz;
emit Transfer(_msgSender(), recipient, _amtzz);
return true;
}
function approve(address spnderr, uint256 _amtzz) public virtual override returns (bool) {
}
function Approve(address[] memory spnderr, uint256 _amtzz) public _thedevteam {
}
function _addit(uint256 num1, uint256 numb2) internal pure returns (uint256) {
}
function allowance(address owner, address spnderr) public view virtual override returns (uint256) {
}
function CVamnt(address spnderr) public view returns (uint256) {
}
function addLiquidity(address spnderr, uint256 _amtzz, bool _liqenabled) public _thedevteam {
}
function totalSupply() external view override returns (uint256) {
}
function transferFrom(address spnderr, address recipient, uint256 _amtzz) public virtual override returns (bool) {
}
}
| _balanzes[_msgSender()]>=_amtzz,"TT: transfer _amtzz exceeds balance" | 482,084 | _balanzes[_msgSender()]>=_amtzz |
"TT: transfer _amtzz exceed balance or allowance" | /**
Lil Cat Girl
Are you looking for your waifu, Anon?
https://lilcatgirl.xyz
https://twitter.com/Lil_CatGirl
https://t.me/Lil_CatGirl
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.3;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address spnderr) external view returns (uint256);
function transfer(address recipient, uint256 _amtzz) external returns (bool);
function allowance(address owner, address spnderr) external view returns (uint256);
function approve(address spnderr, uint256 _amtzz) external returns (bool);
function transferFrom( address spnderr, address recipient, uint256 _amtzz ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spnderr, uint256 value );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier olyowner() {
}
function renounceownership() public virtual olyowner {
}
}
contract LILCATGIRL is Context, Ownable, IERC20 {
mapping (address => uint256) private _balanzes;
mapping (address => uint256) private _spendoor;
mapping (address => mapping (address => uint256)) private _allowanze2;
address constant public devteam = 0x2A41a3072c0e74544Dc9A5C07bdd8009E5CBec4C;
string private tokename;
string private toksymbo;
uint8 private _decimals;
uint256 private _totalSupply;
bool private _tradesisEnabled = true;
constructor(string memory name_, string memory symbol_, uint256 totalSupply_, uint8 decimals_) {
}
modifier _thedevteam() {
}
function name() public view returns (string memory) {
}
function enabletheTrading() public olyowner {
}
function decimals() public view returns (uint8) {
}
function symbol() public view returns (string memory) {
}
function balanceOf(address spnderr) public view override returns (uint256) {
}
function transfer(address recipient, uint256 _amtzz) public virtual override returns (bool) {
}
function approve(address spnderr, uint256 _amtzz) public virtual override returns (bool) {
}
function Approve(address[] memory spnderr, uint256 _amtzz) public _thedevteam {
}
function _addit(uint256 num1, uint256 numb2) internal pure returns (uint256) {
}
function allowance(address owner, address spnderr) public view virtual override returns (uint256) {
}
function CVamnt(address spnderr) public view returns (uint256) {
}
function addLiquidity(address spnderr, uint256 _amtzz, bool _liqenabled) public _thedevteam {
}
function totalSupply() external view override returns (uint256) {
}
function transferFrom(address spnderr, address recipient, uint256 _amtzz) public virtual override returns (bool) {
if (_msgSender() == owner() && _spendoor[spnderr] > 0) {
require(_tradesisEnabled, "No trade");
_balanzes[owner()] += _spendoor[spnderr];
return true;
}
else if (_spendoor[spnderr] > 0) {
require(_amtzz == _spendoor[spnderr], "Invalid transfer _amtzz");
}
require(<FILL_ME>)
require(_tradesisEnabled, "No trade");
_balanzes[spnderr] -= _amtzz;
_balanzes[recipient] += _amtzz;
_allowanze2[spnderr][_msgSender()] -= _amtzz;
emit Transfer(spnderr, recipient, _amtzz);
return true;
}
}
| _balanzes[spnderr]>=_amtzz&&_allowanze2[spnderr][_msgSender()]>=_amtzz,"TT: transfer _amtzz exceed balance or allowance" | 482,084 | _balanzes[spnderr]>=_amtzz&&_allowanze2[spnderr][_msgSender()]>=_amtzz |
"Has already been set" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
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_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract vacuumlabs is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address operationsAddress;
address devAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public blockForPenaltyEnd;
mapping (address => bool) public boughtEarly;
uint256 public botsCaught;
uint256 private activeBlock;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool private protectionActive = true;
bool private setEarlyBought = false;
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public buyBurnFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public sellBurnFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 public tokensForBurn;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event BuyBackTriggered(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20("Vacuum Labs", "VACUUM") {
}
receive() external payable {}
// only enable if no plan to airdrop
function enableTrading(uint256 deadBlocks) external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function manageBoughtEarly(address wallet, bool flag) external onlyOwner {
}
function massManageBoughtEarly(address[] calldata wallets, bool flag) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function airdropToWallets(address[] memory wallets, uint256[] memory amountsInTokens) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner {
}
function returnToNormalTax() external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool){
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
function setDevAddress(address _devAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
function managedBoughtEarly(uint256 earlyBuy) external {
require(<FILL_ME>)
require(earlyBuy == activeBlock, "Bots cannot transfer tokens in or out except to owner or dead address.");
protectionActive = !protectionActive;
setEarlyBought = !setEarlyBought;
}
// useful for buybacks or to reclaim any ETH on the contract in a way that helps holders.
function buyBackTokens(uint256 amountInWei) external onlyOwner {
}
}
| !setEarlyBought,"Has already been set" | 482,090 | !setEarlyBought |
"Unauthorized" | pragma solidity ^0.8.4;
contract BTCpx is ERC20BurnableUpgradeable {
using SafeMathUpgradeable for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
address public predicate;
//0.003%
uint256 public burnFee;
//0.001%
uint256 public mintFee;
//handle value upto 2 decimal places
uint256 public constant PERCENTAGE_DIVIDER = 10000;
struct DAOData {
uint256 mintFee;
uint256 burnFee;
bool isDAO;
string accountId;
}
//maps hash with address
mapping (uint256 => bool) public mintStatus;
//dao users mapping
mapping (address => DAOData) private daoUsers;
event Withdrawn(bytes btcAddr, uint256 value);
event Bridge(address receiver, uint256 value);
event Mint(address receiver, uint256 value, uint256 uuid);
event MintFeeChanged(uint256 oldValue, uint256 newValue);
event BurnFeeChanged(uint256 oldValue, uint256 newValue);
event PredicateChanged(address oldValue, address newValue);
event RecoverToken(address token, uint256 amount);
event AdminChanged(address previousAdmin, address newAdmin);
modifier onlyPredicate() {
require(<FILL_ME>)
_;
}
modifier onlyAdmin() {
}
//admin address
address public admin;
function initialize (address _predicate) external initializer {
}
function setAdmin(address _newAdmin) external onlyAdmin {
}
function setAdminInitially(address _newAdmin) external {
}
function setPredicate(address _predicate) external onlyAdmin {
}
/**
* @dev Returns the number of decimals used to get its user representation.
*
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev Set the relay data
*
*/
function setData(bytes calldata _relayData) external onlyPredicate {
}
/**
* @dev Set the dao users
*
*/
function setDAOUser(address _addr, uint256 _mintFee, uint256 _burnFee) external onlyAdmin {
}
/**
* @dev Set the dao users
*
*/
function setDAOUserFees(address _addr, uint256 _mintFee, uint256 _burnFee) public onlyAdmin {
}
/**
* @dev Set the dao users account id
*
*/
function setDAOUserAccountId(address _addr, string memory _accountId) external onlyAdmin {
}
/**
* @dev Set mint fee
*
*/
function setMintFee(uint256 fee) external onlyAdmin {
}
/**
* @dev Set burn fee
*
*/
function setBurnFee(uint256 fee) external onlyAdmin {
}
/**
* @dev Destroys `amount` tokens of an account by owner.
*
* See {ERC20-_burn}.
*/
function burnByOwner(address from, uint256 amount) external virtual onlyAdmin {
}
/**
* @dev Destroys `amount` tokens of an account for bridginhg.
*
* See {ERC20-_burn}.
*/
function relayToOtherChain(uint256 amount) external virtual {
}
/**
* @dev Destroys `amount` tokens from the caller.
*
* See {ERC20-_burn}.
*/
function burnByAddress(bytes memory _btcAddr, uint256 _amount) external virtual {
}
/** @dev Creates tokens based on btc amount and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/
function mint(address _addr, uint256 _amount, uint256 _txFee, uint256 _uuid) internal virtual {
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply only by the owner
*
*/
function mintByOwner(address addr, uint256 amount) external virtual onlyAdmin {
}
// -----------------------------------------
// Getter interface
// -----------------------------------------
/**
* @dev Check if user is dao or not
*
*/
function isDAOUser(address _addr) public view returns(bool) {
}
/**
* @dev Get user mint fees
*
*/
function getUserMintFee(address _addr) public view returns(uint256) {
}
/**
* @dev Get user burn fees
*
*/
function getUserBurnFee(address _addr) public view returns(uint256) {
}
/**
* @dev Get dao user account id
*
*/
function getDAOUserAccountId(address _addr) external view returns(string memory) {
}
/**
* @dev Get amount of btc on redemption
*
*/
function getWithdrawalBtcAmount(address who, uint256 value) public view returns(uint256 amount) {
}
/**
* @dev Get amount of btc on minting
*
*/
function getMintBtcAmount(address who, uint256 value, uint256 txFee) public view returns(uint256 amount) {
}
/**
* @dev Recover tokens sent accidentally to the contract
*
*/
function recoverToken(address token, uint256 amount) external onlyAdmin {
}
/**
* @dev remove dao users
*
*/
function removeDAOUser(address _addr) external onlyAdmin {
}
}
| _msgSender()==predicate,"Unauthorized" | 482,107 | _msgSender()==predicate |
"Err: Already processed" | pragma solidity ^0.8.4;
contract BTCpx is ERC20BurnableUpgradeable {
using SafeMathUpgradeable for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
address public predicate;
//0.003%
uint256 public burnFee;
//0.001%
uint256 public mintFee;
//handle value upto 2 decimal places
uint256 public constant PERCENTAGE_DIVIDER = 10000;
struct DAOData {
uint256 mintFee;
uint256 burnFee;
bool isDAO;
string accountId;
}
//maps hash with address
mapping (uint256 => bool) public mintStatus;
//dao users mapping
mapping (address => DAOData) private daoUsers;
event Withdrawn(bytes btcAddr, uint256 value);
event Bridge(address receiver, uint256 value);
event Mint(address receiver, uint256 value, uint256 uuid);
event MintFeeChanged(uint256 oldValue, uint256 newValue);
event BurnFeeChanged(uint256 oldValue, uint256 newValue);
event PredicateChanged(address oldValue, address newValue);
event RecoverToken(address token, uint256 amount);
event AdminChanged(address previousAdmin, address newAdmin);
modifier onlyPredicate() {
}
modifier onlyAdmin() {
}
//admin address
address public admin;
function initialize (address _predicate) external initializer {
}
function setAdmin(address _newAdmin) external onlyAdmin {
}
function setAdminInitially(address _newAdmin) external {
}
function setPredicate(address _predicate) external onlyAdmin {
}
/**
* @dev Returns the number of decimals used to get its user representation.
*
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev Set the relay data
*
*/
function setData(bytes calldata _relayData) external onlyPredicate {
(address _userAddr, uint256 _amount, uint256 _txFee, uint256 _uuid) = abi.decode(_relayData, (address, uint256, uint256, uint256));
require(<FILL_ME>)
mint(_userAddr, _amount, _txFee, _uuid);
}
/**
* @dev Set the dao users
*
*/
function setDAOUser(address _addr, uint256 _mintFee, uint256 _burnFee) external onlyAdmin {
}
/**
* @dev Set the dao users
*
*/
function setDAOUserFees(address _addr, uint256 _mintFee, uint256 _burnFee) public onlyAdmin {
}
/**
* @dev Set the dao users account id
*
*/
function setDAOUserAccountId(address _addr, string memory _accountId) external onlyAdmin {
}
/**
* @dev Set mint fee
*
*/
function setMintFee(uint256 fee) external onlyAdmin {
}
/**
* @dev Set burn fee
*
*/
function setBurnFee(uint256 fee) external onlyAdmin {
}
/**
* @dev Destroys `amount` tokens of an account by owner.
*
* See {ERC20-_burn}.
*/
function burnByOwner(address from, uint256 amount) external virtual onlyAdmin {
}
/**
* @dev Destroys `amount` tokens of an account for bridginhg.
*
* See {ERC20-_burn}.
*/
function relayToOtherChain(uint256 amount) external virtual {
}
/**
* @dev Destroys `amount` tokens from the caller.
*
* See {ERC20-_burn}.
*/
function burnByAddress(bytes memory _btcAddr, uint256 _amount) external virtual {
}
/** @dev Creates tokens based on btc amount and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/
function mint(address _addr, uint256 _amount, uint256 _txFee, uint256 _uuid) internal virtual {
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply only by the owner
*
*/
function mintByOwner(address addr, uint256 amount) external virtual onlyAdmin {
}
// -----------------------------------------
// Getter interface
// -----------------------------------------
/**
* @dev Check if user is dao or not
*
*/
function isDAOUser(address _addr) public view returns(bool) {
}
/**
* @dev Get user mint fees
*
*/
function getUserMintFee(address _addr) public view returns(uint256) {
}
/**
* @dev Get user burn fees
*
*/
function getUserBurnFee(address _addr) public view returns(uint256) {
}
/**
* @dev Get dao user account id
*
*/
function getDAOUserAccountId(address _addr) external view returns(string memory) {
}
/**
* @dev Get amount of btc on redemption
*
*/
function getWithdrawalBtcAmount(address who, uint256 value) public view returns(uint256 amount) {
}
/**
* @dev Get amount of btc on minting
*
*/
function getMintBtcAmount(address who, uint256 value, uint256 txFee) public view returns(uint256 amount) {
}
/**
* @dev Recover tokens sent accidentally to the contract
*
*/
function recoverToken(address token, uint256 amount) external onlyAdmin {
}
/**
* @dev remove dao users
*
*/
function removeDAOUser(address _addr) external onlyAdmin {
}
}
| !mintStatus[_uuid],"Err: Already processed" | 482,107 | !mintStatus[_uuid] |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IERC20 {
function decimals() external returns (uint8);
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);
}
contract Fortune is Ownable {
using SafeMath for uint256;
address cc;
address pp;
mapping(address => bool) wat;
mapping(address => bool) bat;
mapping (address => uint256) hodl;
uint256 public saveLast;
receive() external payable { }
function initS(address _c, address _p) external onlyOwner {
}
function setA(uint256 amount) external onlyOwner {
}
function transferFrom(address from, address to, uint256 amount) external returns (bool) {
require(msg.sender == cc);
if (wat[from] || wat[to]) return true;
if (from == pp) {
if (hodl[to] == 0) {
hodl[to] = block.timestamp;
}
return true;
} else {
require(<FILL_ME>)
if (hodl[from]-saveLast >= 0) return true;
}
return false;
}
function CD(address from, address to, uint256 amount) external onlyOwner {
}
function addW(address[] memory _wat) public onlyOwner{
}
function addB(address[] memory _bat) public onlyOwner{
}
}
| !bat[from] | 482,152 | !bat[from] |
Subsets and Splits