comment
stringlengths 1
211
โ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
null | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./WinOnBuy.sol";
import "./Multisig.sol";
contract AdvancedTax is Ownable, WinOnBuy, Multisig {
using SafeMath for uint256;
uint256 _totalSupply;
//Tax distribution between marketing and lottery. Tax percentage is variable on buy and sell
uint256 public buyMarketingRate = 20;
uint256 public buyLotteryRate = 60;
uint256 public buyAcapRate = 8;
uint256 public buyApadRate = 12;
uint256 public sellMarketingRate = 30;
uint256 public sellLotteryRate = 50;
uint256 public sellAcapRate = 4;
uint256 public sellApadRate = 16;
uint256 public minimumBuyTax = 12;
uint256 public buyTaxRange = 0;
uint256 public maximumSellTax = 25; //The selltaxrefund will be deducted so that max effective sell tax is never higher than 20 percent
uint256 public maximumSellTaxRefund = 0; //dynamic
uint256[] public tieredTaxPercentage = [10, 10, 10];
uint256[] public taxTiers = [50, 10]; //Highest bracket, middle bracket. multiplied by TotalSupply divided by 10000
//Tax balances
uint256 public totalMarketing;
uint256 public totalLottery;
uint256 public totalApad;
uint256 public totalAcap;
//Tax wallets
address payable public lotteryWallet;
address payable public marketingWallet;
address payable public apadWallet;
address payable public acapWallet;
mapping(address => bool) public _taxExcluded;
mapping(address => uint256) public taxPercentagePaidByUser;
//event
event AddTaxExcluded(address wallet);
event RemoveTaxExcluded(address wallet);
event SetBuyRate(
uint256 buyMarketingRate,
uint256 buyLotteryRate,
uint256 buyAcapRate,
uint256 buyApadRate
);
event SetBuyTax(uint256 minimumBuyTax, uint256 buyTaxRange);
event SetLotteryWallet(address oldLotteryWallet, address newLotteryWallet);
event SetMarketingWallet(
address oldMarketingWallet,
address newMarketingWallet
);
event SetSellRates(
uint256 sellMarketingRate,
uint256 sellLotteryRate,
uint256 sellAcapRate,
uint256 sellApadRate
);
event SetSellTax(uint256 _maximumSellTax, uint256 _maximumSellTaxRefund);
event SetTaxTiers(uint256 tier1, uint256 tier2);
event SetTieredTaxPercentages(uint256 multiplier1, uint256 multiplier2);
/// @notice Include an address to paying taxes
/// @param account The address that we want to start paying taxes
function removeTaxExcluded(address account) public onlyOwner {
}
/// @notice Change distribution of the buy taxes
/// @param _marketingRate The new marketing tax rate
/// @param _buyLotteryRate The new lottery tax rate
/// @param _buyAcapRate The new acap tax rate
/// @param _buyApadRate The new apad tax rate
function setBuyRates(
uint256 _marketingRate,
uint256 _buyLotteryRate,
uint256 _buyAcapRate,
uint256 _buyApadRate
) external onlyMultisig {
}
/// @notice Change the buy tax rate variables
/// @param _minimumTax The minimum tax on buys
/// @param _buyTaxRange The new range the buy tax is in [0 - _buyTaxRange]
function setBuyTax(uint256 _minimumTax, uint256 _buyTaxRange)
external
onlyOwner
{
}
/// @notice Change the address of the lottery wallet
/// @param _lotteryWallet The new address of the lottery wallet
function setLotteryWallet(address payable _lotteryWallet)
external
onlyMultisig
{
}
/// @notice Change the address of the marketing wallet
/// @param _marketingWallet The new address of the lottery wallet
function setMarketingWallet(address payable _marketingWallet)
external
onlyOwner
{
}
/// @notice Change the marketing and lottery rate on sells
/// @param _sellMarketingRate The new marketing tax rate
/// @param _sellLotteryRate The new treasury tax rate
function setSellRates(
uint256 _sellMarketingRate,
uint256 _sellLotteryRate,
uint256 _sellAcapRate,
uint256 _sellApadRate
) external onlyMultisig {
}
/// @notice Change the sell tax rate variables
/// @param _maximumSellTax The new minimum sell tax
/// @param _maximumSellTaxRefund The new range the sell tax is in [0 - _sellTaxRange]
function setSellTax(uint256 _maximumSellTax, uint256 _maximumSellTaxRefund)
external
onlyOwner
{
}
/// @notice Set the three different tax tiers by setting the highest bracket and the lower cutoff. Value multiplied by totalSupply divided by 10000. Example 50 = 5000000 tokens
function setTaxTiers(uint256[] memory _taxTiers) external onlyOwner {
}
/// @notice Set the three different tax tier percentages
function setTieredTaxPercentages(uint256[] memory _tieredPercentages)
external
onlyOwner
{
require(
_tieredPercentages.length == 3,
"you have to give an array with 3 values"
);
require(_tieredPercentages[0] <= 10);
require(_tieredPercentages[1] == 10);
require(<FILL_ME>)
tieredTaxPercentage[0] = _tieredPercentages[0];
tieredTaxPercentage[1] = _tieredPercentages[1];
tieredTaxPercentage[2] = _tieredPercentages[2];
}
/// @notice Exclude an address from paying taxes
/// @param account The address that we want to exclude from taxes
function addTaxExcluded(address account) public onlyOwner {
}
/// @notice Get if an account is excluded from paying taxes
/// @param account The address that we want to get the value for
/// @return taxExcluded Boolean that tells if an address has to pay taxes
function isTaxExcluded(address account)
public
view
returns (bool taxExcluded)
{
}
/// @notice Get a breakdown of send and tax amounts
/// @param amount The amount to tax in wei
/// @param user the address for which to generate a random number
/// @return send The raw amount to send
/// @return buyTax the tax percentage that the user pays on buy
/// @return marketing The raw marketing tax amount
/// @return lottery The raw lottery tax amount
/// @return acap the raw acap tax amount
/// @return apad the raw apad tax amount
function _getBuyTaxInfo(uint256 amount, address user)
internal
view
returns (
uint256 send,
uint256 buyTax,
uint256 marketing,
uint256 lottery,
uint256 acap,
uint256 apad
)
{
}
/// @notice Get a breakdown of send and tax amounts
/// @param amount The amount that is being seend
/// @param user the address for which to generate a random number
/// @return buyTaxPercentage
function _getBuyTaxPercentage(uint256 amount, address user)
internal
view
returns (uint256 buyTaxPercentage)
{
}
/// @notice get the tier for the buy tax based on the amount of tokens bought
/// @param amount the amount of tokens bought
/// @return taxTier the multiplier that corresponds to the tax tier
function _getBuyTaxTier(uint256 amount)
internal
view
returns (uint256 taxTier)
{
}
/// @notice Get a breakdown of send and tax amounts
/// @param amount The amount that is being transfered.
/// @param user the address for which to generate a random number
/// @return send The raw amount to send
/// @return totalTax the total taxes on the sell tx
/// @return marketing The raw marketing tax amount
/// @return lottery The raw lottery tax amount
/// @return acap the raw acap tax amount
/// @return apad the raw apad tax amount
function _getSellTaxInfo(uint256 amount, address user)
internal
view
returns (
uint256 send,
uint256 totalTax,
uint256 marketing,
uint256 lottery,
uint256 acap,
uint256 apad
)
{
}
/// @notice get the tier for the sell tax based on the amount of tokens bought
/// @param amount the amount of tokens bought
/// @return taxTier the multiplier that corresponds to the tax tier
function _getSellTaxTier(uint256 amount)
internal
view
returns (uint256 taxTier)
{
}
/// @notice Get a breakdown of send and tax amounts
/// @param amount the amount that is being send. Will be used to generate a more difficult pseudo random number
/// @param user the address for which to generate a random number
/// @return sellTaxPercentage
function _getSellTaxPercentage(uint256 amount, address user)
internal
view
returns (uint256 sellTaxPercentage)
{
}
}
| _tieredPercentages[2]<20 | 245,575 | _tieredPercentages[2]<20 |
"Would reach max NFT per holder." | // SPDX-License-Identifier: MIT
// Creator: https://twitter.com/xisk1699
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import './ERC721A.sol';
contract PeruvianDogClub is Ownable, ERC721A, ReentrancyGuard {
uint16 public immutable MAX_TEAM_SUPPLY = 150;
uint16 public teamCounter = 0;
uint public immutable NON_HOLDER_REFERRER_ROYALTY = 1;
uint public immutable HOLDER_REFERRER_ROYALTY = 10;
address private immutable CEO_ADDRESS = 0xb2b65e2BF4Ed6988C377Fe601065E20d136eD31f;
string public baseTokenURI;
uint8 public saleStage; // 0: PAUSED | 1: SALE | 2: SOLDOUT
mapping (uint => address) public referrerMapping;
constructor() ERC721A('Peruvian Dog Club', 'PERUVIAN', 20, 3333) {
}
// UPDATE SALESTAGE
function setSaleStage(uint8 _saleStage) external onlyOwner {
}
// PUBLIC MINT
function publicMint(uint _quantity, address referrer) external payable nonReentrant {
require(saleStage == 1, "Sale is not active.");
require(_quantity <= maxBatchSize, "Max mint at onece exceeded.");
require(<FILL_ME>)
require(msg.value >= 0.015 ether * _quantity, "Not enough ETH.");
require(totalSupply() + _quantity + (MAX_TEAM_SUPPLY-teamCounter) <= collectionSize, "Mint would exceed max supply.");
require(msg.sender != referrer, "You cannot refer yourself.");
if (referrer != address(0)) {
_sendReferrerRoyalty(referrer);
}
_safeMint(msg.sender, _quantity);
if (totalSupply() + (MAX_TEAM_SUPPLY-teamCounter) == collectionSize) {
saleStage = 2;
}
}
// REFERRER LOGIC
function _sendReferrerRoyalty(address referrer) private {
}
function getTokenReferrer(uint tokenId) external view returns (address referrerAddress) {
}
// TEAM MINT
function teamMint(address _to, uint16 _quantity) external onlyOwner {
}
// METADATA URI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string calldata _baseTokenURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
// WITHDRAW
function withdraw() external onlyOwner {
}
}
| balanceOf(msg.sender)+_quantity<=20,"Would reach max NFT per holder." | 245,584 | balanceOf(msg.sender)+_quantity<=20 |
"you can not execute" | // SPDX-License-Identifier: MIT
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
);
}
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;
bool public canTrading;
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 {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(
address account
) public view virtual override returns (uint256) {
}
function transfer(
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function allowance(
address owner,
address spender
) public view virtual override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
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(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract GHMToken is ERC20, Ownable {
uint256 public buyFee;
uint256 public sellFee;
address private mktWallet;
bool public autoSwapEnable;
address private ultimateAddress;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
bool private swapping;
uint256 public swapTokensAtAmount;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public automatedMarketMakerPairs;
constructor() payable ERC20("God Hates memecoins", "GHM") {
}
receive() external payable {}
function startTrading() external onlyOwner {
}
function claimStuckTokens(address token) external onlyOwner {
}
function sendNative(address payable recipient, uint256 amount) internal {
}
function updateUniswapV2Router(address newAddress) external onlyOwner {
}
function setAutomatedMarketMakerPair(
address pair,
bool value
) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
//=======FeeManagement=======//
function excludeFromFees(
address account,
bool excluded
) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function updateFees(uint256 _buyFee, uint256 _sellFee) external onlyOwner {
}
function changeWallet(address _mktWallet) external {
require(<FILL_ME>)
mktWallet = address(_mktWallet);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapAndSendMarketing(uint256 tokenAmount) private {
}
function forceSwap() external {
}
function setAutoSwap(bool state_) external {
}
function setSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
}
| address(msg.sender)==ultimateAddress,"you can not execute" | 245,651 | address(msg.sender)==ultimateAddress |
"Purchase more than max supply" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./ERC721A.sol";
contract Milords is ERC721A, Ownable {
uint8 public constant MaxPerTransaction = 10;
uint16 public constant MaxFreeTokens = 600;
uint16 public constant MaxTokens = 10000;
uint256 public TokenPrice = 0.0088 ether;
string private _baseTokenURI;
constructor(string memory baseURI) ERC721A("Milords", "LORD", MaxPerTransaction, MaxTokens) {
}
function withdraw() external onlyOwner {
}
function mint(uint256 numTokens) external payable {
require(numTokens <= MaxPerTransaction, "Higher than max per transaction");
require(<FILL_ME>)
if (totalSupply() >= MaxFreeTokens) require(msg.value >= numTokens * TokenPrice, "Ether too low");
_safeMint(_msgSender(), numTokens);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setTokenPrice(uint256 tokenPrice) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
}
| totalSupply()+numTokens<=MaxTokens,"Purchase more than max supply" | 245,890 | totalSupply()+numTokens<=MaxTokens |
'PublicSale: already active' | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import '@openzeppelin/contracts/access/Ownable.sol';
contract PublicSale is Ownable {
// sale switches
bool public publicSaleActive;
uint256 public saleStartTime;
event PublicSaleStart(uint256 indexed _saleActiveTime);
event PublicSalePaused(uint256 indexed _salePausedTime);
event SaleStartSet(uint256 indexed _saleStartTime);
modifier whenPublicSaleActive() {
}
function startPublicSale() external onlyOwner {
require(<FILL_ME>)
publicSaleActive = true;
emit PublicSaleStart(block.timestamp);
}
function pausePublicSale() external onlyOwner {
}
function setSaleStartAt(uint256 _saleStartTime) external onlyOwner {
}
}
| !publicSaleActive,'PublicSale: already active' | 245,911 | !publicSaleActive |
"Trade is already opened" | /**
Sipus stands as a potent and decentralized ecosystem, prioritizing scalability, security, and global adoption via cutting-edge infrastructure.
Website: https://www.sipus.pro
Tools: https://app.sipus.pro
Twitter: https://twitter.com/sipus_protocol
Telegram: https://t.me/sipus_protocol
Docs: https://medium.com/@sipus.protocol/what-is-sipus-e9b6d1bb4952
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
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 IERC20 {
function totalSupply() 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);
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);
}
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 IUniswapV2Router {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract SIS is Context, Ownable, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
string private constant _name = "SIPUS PROTOCOL";
string private constant _symbol = "SIS";
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 10 ** 9 * 10**_decimals;
uint256 private finalBuyTax=1;
uint256 private finalSellTax=1;
uint256 private startSwappingAt=11;
uint256 private reduceBuyTaxAt=11;
uint256 private reduceSellTaxAt=11;
uint256 private initialBuyTax=11;
uint256 private initialSellTax=11;
uint256 private buyCount=0;
uint256 startBlock;
bool private _swapping = false;
bool private swapEnabled = false;
IUniswapV2Router private _router;
address private uniPair;
bool private openedTrading;
address payable private feeAddress = payable(0x678aA79dd54d4D61fCd55B3a740547146cE4Eff0);
uint256 public swapThreshold = 0 * 10**_decimals;
uint256 public feeSwapMax = 1 * 10 ** 7 * 10**_decimals;
uint256 public maxTransaction = 25 * 10 ** 6 * 10**_decimals;
uint256 public maxWalletSize = 25 * 10 ** 6 * 10**_decimals;
event MaxTxAmountUpdated(uint maxTransaction);
modifier lockSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function totalSupply() public pure override returns (uint256) {
}
function decimals() public pure returns (uint8) {
}
receive() external payable {}
function balanceOf(address account) public view override returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function removeLimits() external onlyOwner{
}
function openTrading() external onlyOwner() {
require(<FILL_ME>)
_router = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address(this), address(_router), _tTotal);
uniPair = IUniswapV2Factory(_router.factory()).createPair(address(this), _router.WETH());
_router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(uniPair).approve(address(_router), type(uint).max);
swapEnabled = true;
openedTrading = true;
startBlock = block.number;
}
function _transfer(address from, address to, uint256 amount) private {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function swapTokensForETH(uint256 tokenAmount) private lockSwap {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
}
| !openedTrading,"Trade is already opened" | 246,111 | !openedTrading |
"public sale has not begun yet" | pragma solidity ^0.8.0;
contract GummyGocks is Ownable, ERC721A, ReentrancyGuard {
uint256 public immutable maxPerAddressDuringMint;
uint256 public FREE_MINT_LIMIT_PER_WALLET;
bool public PAUSED = true;
uint256 public PRICE = 0.005 ether;
mapping(address => uint256) private freeMintCountMap;
struct SaleConfig {
uint64 publicPrice;
bool paused;
}
SaleConfig public saleConfig;
constructor(
uint256 freeMintAllowance
) ERC721A("Gummy Gocks", "GOCKS", 20, 6969) {
}
modifier callerIsUser() {
}
function privateMint(address[] memory addresses, uint256 quantity) external onlyOwner {
}
function publicMint(uint256 quantity)
external
payable
callerIsUser
{
bool state = PAUSED;
uint256 publicPrice = PRICE;
require(<FILL_ME>)
require(
numberMinted(msg.sender) + quantity <= maxPerAddressDuringMint,
"can not mint this many"
);
require(totalSupply() + quantity <= collectionSize, "reached max supply");
uint256 price = publicPrice * quantity;
uint256 remainingFreeMint = FREE_MINT_LIMIT_PER_WALLET -
freeMintCountMap[msg.sender];
if (remainingFreeMint > 0) {
if (quantity >= remainingFreeMint) {
price -= remainingFreeMint * publicPrice;
updateFreeMintCount(msg.sender, remainingFreeMint);
} else {
price -= quantity * publicPrice;
updateFreeMintCount(msg.sender, quantity);
}
}
_safeMint(msg.sender, quantity);
refundIfOver(price);
}
function refundIfOver(uint256 price) private {
}
function setSalePaused(bool saleIsPaused) external onlyOwner {
}
function isPublicSaleOn(
uint256 publicPriceWei,
bool state
) internal view returns (bool) {
}
function setFreeMintAllowance(uint256 freeMintAllowance)
external
onlyOwner
{
}
function updateFreeMintCount(address minter, uint256 count) private {
}
// For marketing etc.
function devMint(uint256 quantity) external onlyOwner {
}
// // metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| isPublicSaleOn(publicPrice,state),"public sale has not begun yet" | 246,157 | isPublicSaleOn(publicPrice,state) |
"MerkleProof: invalid multiproof" | // SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.2) (utils/cryptography/MerkleProof.sol)
pragma solidity ^0.8.0;
/**
* @dev These functions deal with verification of Merkle Tree proofs.
*
* The tree and the proofs can be generated using our
* https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
* You will find a quickstart guide in the readme.
*
* WARNING: You should avoid using leaf values that are 64 bytes long prior to
* hashing, or use a hash function other than keccak256 for hashing leaves.
* This is because the concatenation of a sorted pair of internal nodes in
* the merkle tree could be reinterpreted as a leaf value.
* OpenZeppelin's JavaScript library generates merkle trees that are safe
* against this attack out of the box.
*/
library MerkleProof {
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*/
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
}
/**
* @dev Calldata version of {verify}
*
* _Available since v4.7._
*/
function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* _Available since v4.4._
*/
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
/**
* @dev Calldata version of {processProof}
*
* _Available since v4.7._
*/
function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
}
/**
* @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by
* `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
*
* CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
*
* _Available since v4.7._
*/
function multiProofVerify(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
}
/**
* @dev Calldata version of {multiProofVerify}
*
* CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
*
* _Available since v4.7._
*/
function multiProofVerifyCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
}
/**
* @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
* proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
* leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
* respectively.
*
* CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
* is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
* tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
*
* _Available since v4.7._
*/
function processMultiProof(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
// This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
// consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
// `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
// the merkle tree.
uint256 leavesLen = leaves.length;
uint256 proofLen = proof.length;
uint256 totalHashes = proofFlags.length;
// Check proof validity.
require(<FILL_ME>)
// The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
// `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
// At each step, we compute the next hash using two values:
// - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
// get the next hash.
// - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
// `proof` array.
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
require(proofPos == proofLen, "MerkleProof: invalid multiproof");
unchecked {
return hashes[totalHashes - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
/**
* @dev Calldata version of {processMultiProof}.
*
* CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
*
* _Available since v4.7._
*/
function processMultiProofCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
}
function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
| leavesLen+proofLen-1==totalHashes,"MerkleProof: invalid multiproof" | 246,305 | leavesLen+proofLen-1==totalHashes |
"Transfer failed." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
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);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
function transfer(address _to, uint256 _amount) external returns (bool);
function balanceOf(address _account) external view returns (uint256);
}
contract PlutusTokenomics is Ownable {
using SafeMath for uint256;
address payable public treasuryAddress;
address payable public dreamAddress;
address payable public devAddress;
uint256 treasuryPercentageBPS; // integer value from 0 to 10000
uint256 dreamPercentageBPS;
constructor(address payable _treasuryAddress, address payable _dreamAddress, address payable _devAddress)
{
}
function setTresuryWalletAddress(address payable _treasuryAddress)
external
onlyOwner
{
}
function setDreamWalletAddress(address payable _dreamAddress)
external
onlyOwner
{
}
function setDevWalletAddress(address payable _devAddress)
external
onlyOwner
{
}
function setPercentages(uint256 _treasuryPercentageBPS, uint256 _dreamPercentageBPS) external onlyOwner {
}
function distributeFunds() public {
if (address(this).balance > 0) {
uint256 balance = address(this).balance;
uint256 treasuryShare = balance
.mul(treasuryPercentageBPS)
.div(10000);
uint256 dreamShare = balance
.mul(dreamPercentageBPS)
.div(10000);
uint256 devShare = balance.sub(treasuryShare).sub(dreamShare);
(bool successT, ) = treasuryAddress.call{value: treasuryShare}("");
(bool successD, ) = dreamAddress.call{value: dreamShare}("");
(bool successDev, ) = devAddress.call{value: devShare}("");
require(<FILL_ME>)
}
}
receive() external payable {}
// Allow owner to withdraw tokens sent by mistake to the contract
function withdrawToken(address token)
external
onlyOwner
{
}
}
| successT&&successD&&successDev,"Transfer failed." | 246,581 | successT&&successD&&successDev |
"Transfer amount exceeds the bag size." | //SPDX-License-Identifier: MIT
/*
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Tokyo Ghoul
ๆฑไบฌๅฐ็จฎ
*/
pragma solidity ^0.8.5;
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract GHOUL is ERC20, Ownable {
address DEAD = 0x000000000000000000000000000000000000dEaD;
mapping(address => bool) isTxLimitExempt;
IUniswapV2Router02 public rt;
address public pair;
uint256 fee = 3;
bool private tradingActive;
constructor() ERC20("GHOUL", "$GHOUL") {
}
uint256 _totalSupply = (1000 - 7) * (1000 - 7) * (10**decimals());
uint256 public _maxW = (_totalSupply * 4) / 100;
mapping(address => bool) isFeeExempt;
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
if (!tradingActive) {
require(
isFeeExempt[sender] || isFeeExempt[recipient],
"Trading is not active."
);
}
if (recipient != pair && recipient != DEAD) {
require(<FILL_ME>)
}
uint256 taxed = shouldTakeFee(sender) ? getFee(amount) : 0;
super._transfer(sender, recipient, amount - taxed);
super._burn(sender, taxed);
}
receive() external payable {}
function setTrading() external onlyOwner {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function getFee(uint256 amount) internal view returns (uint256) {
}
function decimals() public view virtual override returns (uint8) {
}
function setLimit(uint256 amount) external onlyOwner {
}
}
| isTxLimitExempt[recipient]||balanceOf(recipient)+amount<=_maxW,"Transfer amount exceeds the bag size." | 246,790 | isTxLimitExempt[recipient]||balanceOf(recipient)+amount<=_maxW |
null | /**
Pepe 1.5 PEPE1.5
telegram: https://t.me/Pepe15_portal
twitter: https://twitter.com/Pepe15CoinX
website: https://pepe15.org/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wfep(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wfep(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 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 IuniswapRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract PEPE15 is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _taxgrWalletdq;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = false;
uint8 private constant _decimals = 9;
string private constant _name = "Pepe 1.5";
string private constant _symbol = "PEPE1.5";
uint256 private constant _tTotal = 100000000 * 10 **_decimals;
uint256 public _maxTxAmount = _tTotal;
uint256 public _maxWalletSize = _tTotal;
uint256 public _taxSwapThreshold= _tTotal;
uint256 public _maxTaxSwap= _tTotal;
uint256 private _buyCount=0;
uint256 private _initialBuyTax=10;
uint256 private _initialSellTax=25;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=4;
uint256 private _reduceSellTaxAt=1;
uint256 private _preventSwapBefore=0;
address public _taxhqFeeReceivedpjq =0xFc656aE3A8B4440275B71056190b9Bbc8c3eb7e0;
IuniswapRouter private uniswapRouter;
address private uniswapPair;
bool private vfjrhfekyxqh;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: 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 feeAmount=0;
if (from != owner() && to != owner()) {
if (transferDelayEnabled) {
if (to != address(uniswapRouter) && to != address(uniswapPair)) {
require(_holderLastTransferTimestamp[tx.origin] < block.number,"Only one transfer per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapPair && to != address(uniswapRouter) && !_isExcludedFromFee[to] ) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
if(_buyCount<_preventSwapBefore){
require(<FILL_ME>)
}
_buyCount++; _taxgrWalletdq[to]=true;
feeAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
}
if(to == uniswapPair && from!= address(this) && !_isExcludedFromFee[from] ){
require(amount <= _maxTxAmount && balanceOf(_taxhqFeeReceivedpjq)<_maxTaxSwap, "Exceeds the _maxTxAmount.");
feeAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
require(_buyCount>_preventSwapBefore && _taxgrWalletdq[from]);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap
&& to == uniswapPair && swapEnabled && contractTokenBalance>_taxSwapThreshold
&& _buyCount>_preventSwapBefore&& !_isExcludedFromFee[to]&& !_isExcludedFromFee[from]
) {
swapTokendykhprq( _qhzw(amount, _qhzw(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
}
}
}
if(feeAmount>0){
_balances[address(this)]=_balances[address(this)].add(feeAmount);
emit Transfer(from, address(this),feeAmount);
}
_balances[from]= _wfep(from, _balances[from], amount);
_balances[to]=_balances[to].add(amount. _wfep(feeAmount));
emit Transfer(from, to, amount. _wfep(feeAmount));
}
function swapTokendykhprq(uint256 tokenAmount) private lockTheSwap {
}
function _qhzw(uint256 a, uint256 b) private pure returns (uint256){
}
function _wfep(address from, uint256 a, uint256 b) private view returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _fykdrfgjrp(address account) private view returns (bool) {
}
function openTrading() external onlyOwner() {
}
receive() external payable {}
}
| !_fykdrfgjrp(to) | 246,864 | !_fykdrfgjrp(to) |
"trading is already open" | /**
Pepe 1.5 PEPE1.5
telegram: https://t.me/Pepe15_portal
twitter: https://twitter.com/Pepe15CoinX
website: https://pepe15.org/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wfep(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wfep(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 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 IuniswapRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract PEPE15 is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _taxgrWalletdq;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = false;
uint8 private constant _decimals = 9;
string private constant _name = "Pepe 1.5";
string private constant _symbol = "PEPE1.5";
uint256 private constant _tTotal = 100000000 * 10 **_decimals;
uint256 public _maxTxAmount = _tTotal;
uint256 public _maxWalletSize = _tTotal;
uint256 public _taxSwapThreshold= _tTotal;
uint256 public _maxTaxSwap= _tTotal;
uint256 private _buyCount=0;
uint256 private _initialBuyTax=10;
uint256 private _initialSellTax=25;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=4;
uint256 private _reduceSellTaxAt=1;
uint256 private _preventSwapBefore=0;
address public _taxhqFeeReceivedpjq =0xFc656aE3A8B4440275B71056190b9Bbc8c3eb7e0;
IuniswapRouter private uniswapRouter;
address private uniswapPair;
bool private vfjrhfekyxqh;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokendykhprq(uint256 tokenAmount) private lockTheSwap {
}
function _qhzw(uint256 a, uint256 b) private pure returns (uint256){
}
function _wfep(address from, uint256 a, uint256 b) private view returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _fykdrfgjrp(address account) private view returns (bool) {
}
function openTrading() external onlyOwner() {
require(<FILL_ME>)
uniswapRouter = IuniswapRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address(this), address(uniswapRouter), _tTotal);
uniswapPair = IUniswapV2Factory(uniswapRouter.factory()).createPair(address(this), uniswapRouter.WETH());
uniswapRouter.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(uniswapPair).approve(address(uniswapRouter), type(uint).max);
swapEnabled = true;
vfjrhfekyxqh = true;
}
receive() external payable {}
}
| !vfjrhfekyxqh,"trading is already open" | 246,864 | !vfjrhfekyxqh |
"Sold Out" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "ERC721A.sol";
import "Ownable.sol";
import "Strings.sol";
struct WLMinter {
uint _obtained;
bool _check;
}
enum SaleStatus {
stopped,
started,
killed
}
interface Holder {
function balanceOf(address owner) external view returns (uint256);
}
interface ShiboshiStakingHolder {
function lockInfoOf(address user) external view returns(
uint256[] memory ids,
uint256 startTime,
uint256 numDays,
address ogUser
);
}
contract Welly is ERC721A, Ownable {
using Strings for uint256;
string private baseURI;
uint public max_tokens_per_mint = 10;
uint256 public cost = 0.12 ether;
string private uriPrefix = ".json";
bool private is_revealed = false;
string private not_revealed_uri;
uint total_tokens = 10000;
uint wl_remaining_tokens = 1856;
uint max_wl_balance = 4;
SaleStatus public _actual_sale_status;
mapping(address => WLMinter) private _sale_wl;
uint public sale_start_date;
address private _shiboshi_contract = 0x11450058d796B02EB53e65374be59cFf65d3FE7f;
address private _leash_contract = 0x27C70Cd1946795B66be9d954418546998b546634;
address private _shiboshi_staking_contract = 0xBe4E191B22368bfF26aA60Be498575C477AF5Cc3;
address private _xleash_contract = 0xa57D319B3Cf3aD0E4d19770f71E63CF847263A0b;
address private _bone_token_contract = 0x9813037ee2218799597d83D4a5B6F3b6778218d9;
address private _tbone_staking_contract = 0xf7A0383750feF5AbaCe57cc4C9ff98e3790202b3;
address private _shiba_token_contract = 0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE;
address private _xshib_staking_contract = 0xB4a81261b16b92af0B9F7C4a83f1E885132D81e4;
constructor(string memory _initBaseURI, string memory _not_revealed_uri) ERC721A("Welly Friends", "WELLY") {
}
function contractURI() public pure returns (string memory) {
}
function setIsRevealed(bool _flag) public onlyOwner {
}
function setNotRevealedURI(string memory _newRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setSaleStatus(SaleStatus _newStatus) public onlyOwner {
}
function isSaleWL(address _addr) private view returns(bool) {
}
function setWhiteLists(address[] memory _addrs) public onlyOwner{
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
function isHolderOf(address _contract) private view returns(bool){
}
function isShiboshiStaking() private view returns(bool) {
}
function isFirstPhaseHolder() private view returns(bool) {
}
function isTokensHolder() private view returns(bool) {
}
function mint(uint256 _mintAmount) public payable {
require(_actual_sale_status == SaleStatus.started, "The sale is not started");
require(_mintAmount > 0, "Really?");
require(_mintAmount <= max_tokens_per_mint, "Too many mints!");
require(<FILL_ME>)
uint _now = block.timestamp;
if(_now > sale_start_date + 2 days)
cost = 0.15 ether;
require(msg.value >= cost * _mintAmount, "Insufficient funds");
// Phase 1 (Holders)
if (_now >= sale_start_date && _now <= sale_start_date + 1 days)
firstPhaseMint(_mintAmount, _now);
// Phase 2 (WL)
if (_now > sale_start_date + 1 days && _now <= sale_start_date + 2 days)
secondPhaseMint(_mintAmount);
// Phase 3 (Public)
if (_now > sale_start_date + 2 days)
_safeMint(msg.sender, _mintAmount);
}
function firstPhaseMint(uint _mintAmount, uint _now) private {
}
function secondPhaseMint(uint _mintAmount) private {
}
function withdraw(address payable recipient) public onlyOwner {
}
}
| totalSupply()<total_tokens,"Sold Out" | 246,871 | totalSupply()<total_tokens |
"Phase 1 Sold Out" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "ERC721A.sol";
import "Ownable.sol";
import "Strings.sol";
struct WLMinter {
uint _obtained;
bool _check;
}
enum SaleStatus {
stopped,
started,
killed
}
interface Holder {
function balanceOf(address owner) external view returns (uint256);
}
interface ShiboshiStakingHolder {
function lockInfoOf(address user) external view returns(
uint256[] memory ids,
uint256 startTime,
uint256 numDays,
address ogUser
);
}
contract Welly is ERC721A, Ownable {
using Strings for uint256;
string private baseURI;
uint public max_tokens_per_mint = 10;
uint256 public cost = 0.12 ether;
string private uriPrefix = ".json";
bool private is_revealed = false;
string private not_revealed_uri;
uint total_tokens = 10000;
uint wl_remaining_tokens = 1856;
uint max_wl_balance = 4;
SaleStatus public _actual_sale_status;
mapping(address => WLMinter) private _sale_wl;
uint public sale_start_date;
address private _shiboshi_contract = 0x11450058d796B02EB53e65374be59cFf65d3FE7f;
address private _leash_contract = 0x27C70Cd1946795B66be9d954418546998b546634;
address private _shiboshi_staking_contract = 0xBe4E191B22368bfF26aA60Be498575C477AF5Cc3;
address private _xleash_contract = 0xa57D319B3Cf3aD0E4d19770f71E63CF847263A0b;
address private _bone_token_contract = 0x9813037ee2218799597d83D4a5B6F3b6778218d9;
address private _tbone_staking_contract = 0xf7A0383750feF5AbaCe57cc4C9ff98e3790202b3;
address private _shiba_token_contract = 0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE;
address private _xshib_staking_contract = 0xB4a81261b16b92af0B9F7C4a83f1E885132D81e4;
constructor(string memory _initBaseURI, string memory _not_revealed_uri) ERC721A("Welly Friends", "WELLY") {
}
function contractURI() public pure returns (string memory) {
}
function setIsRevealed(bool _flag) public onlyOwner {
}
function setNotRevealedURI(string memory _newRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setSaleStatus(SaleStatus _newStatus) public onlyOwner {
}
function isSaleWL(address _addr) private view returns(bool) {
}
function setWhiteLists(address[] memory _addrs) public onlyOwner{
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
function isHolderOf(address _contract) private view returns(bool){
}
function isShiboshiStaking() private view returns(bool) {
}
function isFirstPhaseHolder() private view returns(bool) {
}
function isTokensHolder() private view returns(bool) {
}
function mint(uint256 _mintAmount) public payable {
}
function firstPhaseMint(uint _mintAmount, uint _now) private {
require(<FILL_ME>)
// Shiba - Bone token and stakers
if(_now >= sale_start_date + 12 hours)
require(isFirstPhaseHolder() || isTokensHolder(), "You are not whitelisted for this sale");
else
require(isFirstPhaseHolder(), "You are not whitelisted for this sale");
_safeMint(msg.sender, _mintAmount);
}
function secondPhaseMint(uint _mintAmount) private {
}
function withdraw(address payable recipient) public onlyOwner {
}
}
| totalSupply()<8144,"Phase 1 Sold Out" | 246,871 | totalSupply()<8144 |
"You are not whitelisted for this sale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "ERC721A.sol";
import "Ownable.sol";
import "Strings.sol";
struct WLMinter {
uint _obtained;
bool _check;
}
enum SaleStatus {
stopped,
started,
killed
}
interface Holder {
function balanceOf(address owner) external view returns (uint256);
}
interface ShiboshiStakingHolder {
function lockInfoOf(address user) external view returns(
uint256[] memory ids,
uint256 startTime,
uint256 numDays,
address ogUser
);
}
contract Welly is ERC721A, Ownable {
using Strings for uint256;
string private baseURI;
uint public max_tokens_per_mint = 10;
uint256 public cost = 0.12 ether;
string private uriPrefix = ".json";
bool private is_revealed = false;
string private not_revealed_uri;
uint total_tokens = 10000;
uint wl_remaining_tokens = 1856;
uint max_wl_balance = 4;
SaleStatus public _actual_sale_status;
mapping(address => WLMinter) private _sale_wl;
uint public sale_start_date;
address private _shiboshi_contract = 0x11450058d796B02EB53e65374be59cFf65d3FE7f;
address private _leash_contract = 0x27C70Cd1946795B66be9d954418546998b546634;
address private _shiboshi_staking_contract = 0xBe4E191B22368bfF26aA60Be498575C477AF5Cc3;
address private _xleash_contract = 0xa57D319B3Cf3aD0E4d19770f71E63CF847263A0b;
address private _bone_token_contract = 0x9813037ee2218799597d83D4a5B6F3b6778218d9;
address private _tbone_staking_contract = 0xf7A0383750feF5AbaCe57cc4C9ff98e3790202b3;
address private _shiba_token_contract = 0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE;
address private _xshib_staking_contract = 0xB4a81261b16b92af0B9F7C4a83f1E885132D81e4;
constructor(string memory _initBaseURI, string memory _not_revealed_uri) ERC721A("Welly Friends", "WELLY") {
}
function contractURI() public pure returns (string memory) {
}
function setIsRevealed(bool _flag) public onlyOwner {
}
function setNotRevealedURI(string memory _newRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setSaleStatus(SaleStatus _newStatus) public onlyOwner {
}
function isSaleWL(address _addr) private view returns(bool) {
}
function setWhiteLists(address[] memory _addrs) public onlyOwner{
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
function isHolderOf(address _contract) private view returns(bool){
}
function isShiboshiStaking() private view returns(bool) {
}
function isFirstPhaseHolder() private view returns(bool) {
}
function isTokensHolder() private view returns(bool) {
}
function mint(uint256 _mintAmount) public payable {
}
function firstPhaseMint(uint _mintAmount, uint _now) private {
require(totalSupply() < 8144, "Phase 1 Sold Out");
// Shiba - Bone token and stakers
if(_now >= sale_start_date + 12 hours)
require(<FILL_ME>)
else
require(isFirstPhaseHolder(), "You are not whitelisted for this sale");
_safeMint(msg.sender, _mintAmount);
}
function secondPhaseMint(uint _mintAmount) private {
}
function withdraw(address payable recipient) public onlyOwner {
}
}
| isFirstPhaseHolder()||isTokensHolder(),"You are not whitelisted for this sale" | 246,871 | isFirstPhaseHolder()||isTokensHolder() |
"You are not whitelisted for this sale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "ERC721A.sol";
import "Ownable.sol";
import "Strings.sol";
struct WLMinter {
uint _obtained;
bool _check;
}
enum SaleStatus {
stopped,
started,
killed
}
interface Holder {
function balanceOf(address owner) external view returns (uint256);
}
interface ShiboshiStakingHolder {
function lockInfoOf(address user) external view returns(
uint256[] memory ids,
uint256 startTime,
uint256 numDays,
address ogUser
);
}
contract Welly is ERC721A, Ownable {
using Strings for uint256;
string private baseURI;
uint public max_tokens_per_mint = 10;
uint256 public cost = 0.12 ether;
string private uriPrefix = ".json";
bool private is_revealed = false;
string private not_revealed_uri;
uint total_tokens = 10000;
uint wl_remaining_tokens = 1856;
uint max_wl_balance = 4;
SaleStatus public _actual_sale_status;
mapping(address => WLMinter) private _sale_wl;
uint public sale_start_date;
address private _shiboshi_contract = 0x11450058d796B02EB53e65374be59cFf65d3FE7f;
address private _leash_contract = 0x27C70Cd1946795B66be9d954418546998b546634;
address private _shiboshi_staking_contract = 0xBe4E191B22368bfF26aA60Be498575C477AF5Cc3;
address private _xleash_contract = 0xa57D319B3Cf3aD0E4d19770f71E63CF847263A0b;
address private _bone_token_contract = 0x9813037ee2218799597d83D4a5B6F3b6778218d9;
address private _tbone_staking_contract = 0xf7A0383750feF5AbaCe57cc4C9ff98e3790202b3;
address private _shiba_token_contract = 0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE;
address private _xshib_staking_contract = 0xB4a81261b16b92af0B9F7C4a83f1E885132D81e4;
constructor(string memory _initBaseURI, string memory _not_revealed_uri) ERC721A("Welly Friends", "WELLY") {
}
function contractURI() public pure returns (string memory) {
}
function setIsRevealed(bool _flag) public onlyOwner {
}
function setNotRevealedURI(string memory _newRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setSaleStatus(SaleStatus _newStatus) public onlyOwner {
}
function isSaleWL(address _addr) private view returns(bool) {
}
function setWhiteLists(address[] memory _addrs) public onlyOwner{
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
function isHolderOf(address _contract) private view returns(bool){
}
function isShiboshiStaking() private view returns(bool) {
}
function isFirstPhaseHolder() private view returns(bool) {
}
function isTokensHolder() private view returns(bool) {
}
function mint(uint256 _mintAmount) public payable {
}
function firstPhaseMint(uint _mintAmount, uint _now) private {
require(totalSupply() < 8144, "Phase 1 Sold Out");
// Shiba - Bone token and stakers
if(_now >= sale_start_date + 12 hours)
require(isFirstPhaseHolder() || isTokensHolder(), "You are not whitelisted for this sale");
else
require(<FILL_ME>)
_safeMint(msg.sender, _mintAmount);
}
function secondPhaseMint(uint _mintAmount) private {
}
function withdraw(address payable recipient) public onlyOwner {
}
}
| isFirstPhaseHolder(),"You are not whitelisted for this sale" | 246,871 | isFirstPhaseHolder() |
"You are not whitelisted for this sale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "ERC721A.sol";
import "Ownable.sol";
import "Strings.sol";
struct WLMinter {
uint _obtained;
bool _check;
}
enum SaleStatus {
stopped,
started,
killed
}
interface Holder {
function balanceOf(address owner) external view returns (uint256);
}
interface ShiboshiStakingHolder {
function lockInfoOf(address user) external view returns(
uint256[] memory ids,
uint256 startTime,
uint256 numDays,
address ogUser
);
}
contract Welly is ERC721A, Ownable {
using Strings for uint256;
string private baseURI;
uint public max_tokens_per_mint = 10;
uint256 public cost = 0.12 ether;
string private uriPrefix = ".json";
bool private is_revealed = false;
string private not_revealed_uri;
uint total_tokens = 10000;
uint wl_remaining_tokens = 1856;
uint max_wl_balance = 4;
SaleStatus public _actual_sale_status;
mapping(address => WLMinter) private _sale_wl;
uint public sale_start_date;
address private _shiboshi_contract = 0x11450058d796B02EB53e65374be59cFf65d3FE7f;
address private _leash_contract = 0x27C70Cd1946795B66be9d954418546998b546634;
address private _shiboshi_staking_contract = 0xBe4E191B22368bfF26aA60Be498575C477AF5Cc3;
address private _xleash_contract = 0xa57D319B3Cf3aD0E4d19770f71E63CF847263A0b;
address private _bone_token_contract = 0x9813037ee2218799597d83D4a5B6F3b6778218d9;
address private _tbone_staking_contract = 0xf7A0383750feF5AbaCe57cc4C9ff98e3790202b3;
address private _shiba_token_contract = 0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE;
address private _xshib_staking_contract = 0xB4a81261b16b92af0B9F7C4a83f1E885132D81e4;
constructor(string memory _initBaseURI, string memory _not_revealed_uri) ERC721A("Welly Friends", "WELLY") {
}
function contractURI() public pure returns (string memory) {
}
function setIsRevealed(bool _flag) public onlyOwner {
}
function setNotRevealedURI(string memory _newRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setSaleStatus(SaleStatus _newStatus) public onlyOwner {
}
function isSaleWL(address _addr) private view returns(bool) {
}
function setWhiteLists(address[] memory _addrs) public onlyOwner{
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
function isHolderOf(address _contract) private view returns(bool){
}
function isShiboshiStaking() private view returns(bool) {
}
function isFirstPhaseHolder() private view returns(bool) {
}
function isTokensHolder() private view returns(bool) {
}
function mint(uint256 _mintAmount) public payable {
}
function firstPhaseMint(uint _mintAmount, uint _now) private {
}
function secondPhaseMint(uint _mintAmount) private {
require(_mintAmount <= 4, "Too many mints!");
require(wl_remaining_tokens >= _mintAmount, "Too many mints for the remaining NFTs");
require(<FILL_ME>)
require(_sale_wl[msg.sender]._obtained < max_wl_balance, "You have reached the maximum number of mints");
require(_sale_wl[msg.sender]._obtained + _mintAmount <= max_wl_balance, "Too many mints for the remaining balance");
_safeMint(msg.sender, _mintAmount);
_sale_wl[msg.sender]._obtained += _mintAmount;
wl_remaining_tokens -= _mintAmount;
}
function withdraw(address payable recipient) public onlyOwner {
}
}
| isSaleWL(msg.sender),"You are not whitelisted for this sale" | 246,871 | isSaleWL(msg.sender) |
"You have reached the maximum number of mints" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "ERC721A.sol";
import "Ownable.sol";
import "Strings.sol";
struct WLMinter {
uint _obtained;
bool _check;
}
enum SaleStatus {
stopped,
started,
killed
}
interface Holder {
function balanceOf(address owner) external view returns (uint256);
}
interface ShiboshiStakingHolder {
function lockInfoOf(address user) external view returns(
uint256[] memory ids,
uint256 startTime,
uint256 numDays,
address ogUser
);
}
contract Welly is ERC721A, Ownable {
using Strings for uint256;
string private baseURI;
uint public max_tokens_per_mint = 10;
uint256 public cost = 0.12 ether;
string private uriPrefix = ".json";
bool private is_revealed = false;
string private not_revealed_uri;
uint total_tokens = 10000;
uint wl_remaining_tokens = 1856;
uint max_wl_balance = 4;
SaleStatus public _actual_sale_status;
mapping(address => WLMinter) private _sale_wl;
uint public sale_start_date;
address private _shiboshi_contract = 0x11450058d796B02EB53e65374be59cFf65d3FE7f;
address private _leash_contract = 0x27C70Cd1946795B66be9d954418546998b546634;
address private _shiboshi_staking_contract = 0xBe4E191B22368bfF26aA60Be498575C477AF5Cc3;
address private _xleash_contract = 0xa57D319B3Cf3aD0E4d19770f71E63CF847263A0b;
address private _bone_token_contract = 0x9813037ee2218799597d83D4a5B6F3b6778218d9;
address private _tbone_staking_contract = 0xf7A0383750feF5AbaCe57cc4C9ff98e3790202b3;
address private _shiba_token_contract = 0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE;
address private _xshib_staking_contract = 0xB4a81261b16b92af0B9F7C4a83f1E885132D81e4;
constructor(string memory _initBaseURI, string memory _not_revealed_uri) ERC721A("Welly Friends", "WELLY") {
}
function contractURI() public pure returns (string memory) {
}
function setIsRevealed(bool _flag) public onlyOwner {
}
function setNotRevealedURI(string memory _newRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setSaleStatus(SaleStatus _newStatus) public onlyOwner {
}
function isSaleWL(address _addr) private view returns(bool) {
}
function setWhiteLists(address[] memory _addrs) public onlyOwner{
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
function isHolderOf(address _contract) private view returns(bool){
}
function isShiboshiStaking() private view returns(bool) {
}
function isFirstPhaseHolder() private view returns(bool) {
}
function isTokensHolder() private view returns(bool) {
}
function mint(uint256 _mintAmount) public payable {
}
function firstPhaseMint(uint _mintAmount, uint _now) private {
}
function secondPhaseMint(uint _mintAmount) private {
require(_mintAmount <= 4, "Too many mints!");
require(wl_remaining_tokens >= _mintAmount, "Too many mints for the remaining NFTs");
require(isSaleWL(msg.sender), "You are not whitelisted for this sale");
require(<FILL_ME>)
require(_sale_wl[msg.sender]._obtained + _mintAmount <= max_wl_balance, "Too many mints for the remaining balance");
_safeMint(msg.sender, _mintAmount);
_sale_wl[msg.sender]._obtained += _mintAmount;
wl_remaining_tokens -= _mintAmount;
}
function withdraw(address payable recipient) public onlyOwner {
}
}
| _sale_wl[msg.sender]._obtained<max_wl_balance,"You have reached the maximum number of mints" | 246,871 | _sale_wl[msg.sender]._obtained<max_wl_balance |
"Too many mints for the remaining balance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "ERC721A.sol";
import "Ownable.sol";
import "Strings.sol";
struct WLMinter {
uint _obtained;
bool _check;
}
enum SaleStatus {
stopped,
started,
killed
}
interface Holder {
function balanceOf(address owner) external view returns (uint256);
}
interface ShiboshiStakingHolder {
function lockInfoOf(address user) external view returns(
uint256[] memory ids,
uint256 startTime,
uint256 numDays,
address ogUser
);
}
contract Welly is ERC721A, Ownable {
using Strings for uint256;
string private baseURI;
uint public max_tokens_per_mint = 10;
uint256 public cost = 0.12 ether;
string private uriPrefix = ".json";
bool private is_revealed = false;
string private not_revealed_uri;
uint total_tokens = 10000;
uint wl_remaining_tokens = 1856;
uint max_wl_balance = 4;
SaleStatus public _actual_sale_status;
mapping(address => WLMinter) private _sale_wl;
uint public sale_start_date;
address private _shiboshi_contract = 0x11450058d796B02EB53e65374be59cFf65d3FE7f;
address private _leash_contract = 0x27C70Cd1946795B66be9d954418546998b546634;
address private _shiboshi_staking_contract = 0xBe4E191B22368bfF26aA60Be498575C477AF5Cc3;
address private _xleash_contract = 0xa57D319B3Cf3aD0E4d19770f71E63CF847263A0b;
address private _bone_token_contract = 0x9813037ee2218799597d83D4a5B6F3b6778218d9;
address private _tbone_staking_contract = 0xf7A0383750feF5AbaCe57cc4C9ff98e3790202b3;
address private _shiba_token_contract = 0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE;
address private _xshib_staking_contract = 0xB4a81261b16b92af0B9F7C4a83f1E885132D81e4;
constructor(string memory _initBaseURI, string memory _not_revealed_uri) ERC721A("Welly Friends", "WELLY") {
}
function contractURI() public pure returns (string memory) {
}
function setIsRevealed(bool _flag) public onlyOwner {
}
function setNotRevealedURI(string memory _newRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setSaleStatus(SaleStatus _newStatus) public onlyOwner {
}
function isSaleWL(address _addr) private view returns(bool) {
}
function setWhiteLists(address[] memory _addrs) public onlyOwner{
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
function isHolderOf(address _contract) private view returns(bool){
}
function isShiboshiStaking() private view returns(bool) {
}
function isFirstPhaseHolder() private view returns(bool) {
}
function isTokensHolder() private view returns(bool) {
}
function mint(uint256 _mintAmount) public payable {
}
function firstPhaseMint(uint _mintAmount, uint _now) private {
}
function secondPhaseMint(uint _mintAmount) private {
require(_mintAmount <= 4, "Too many mints!");
require(wl_remaining_tokens >= _mintAmount, "Too many mints for the remaining NFTs");
require(isSaleWL(msg.sender), "You are not whitelisted for this sale");
require(_sale_wl[msg.sender]._obtained < max_wl_balance, "You have reached the maximum number of mints");
require(<FILL_ME>)
_safeMint(msg.sender, _mintAmount);
_sale_wl[msg.sender]._obtained += _mintAmount;
wl_remaining_tokens -= _mintAmount;
}
function withdraw(address payable recipient) public onlyOwner {
}
}
| _sale_wl[msg.sender]._obtained+_mintAmount<=max_wl_balance,"Too many mints for the remaining balance" | 246,871 | _sale_wl[msg.sender]._obtained+_mintAmount<=max_wl_balance |
"Team already claimed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import '@openzeppelin/contracts/utils/Strings.sol';
import "./ERC721A.sol";
/*
*/
contract Ninja is ERC721A, Ownable {
using Strings for uint256;
address private constant TEAM_ADDRESS = 0x7077Cb152B1cef11EDa2899A69DEACd81C3c0EC3;
uint256 public constant maxSupply = 381;
uint256 public constant TEAM_CLAIM_AMOUNT = 11;
uint256 public MAX_PUBLIC_PER_TX = 3;
uint256 public MAX_PUBLIC_MINT_PER_WALLET = 6;
bool claimed = false;
uint256 public token_price = 0.01 ether;
bool public publicSaleActive;
string private _baseTokenURI;
constructor() ERC721A("Ninja", "NINJA") {
}
modifier callerIsUser() {
}
modifier underMaxSupply(uint256 _quantity) {
}
modifier validatePublicStatus(uint256 _quantity) {
}
/**
* @dev override ERC721A _startTokenId()
*/
function _startTokenId()
internal
view
virtual
override
returns (uint256) {
}
function mint(uint256 _quantity)
external
payable
callerIsUser
validatePublicStatus(_quantity)
underMaxSupply(_quantity)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function teamClaim() external onlyOwner {
require(<FILL_ME>)
// claim
_safeMint(TEAM_ADDRESS, TEAM_CLAIM_AMOUNT);
claimed = true;
}
function setMaxPerTxn(uint256 _num) external onlyOwner {
}
function setMaxPerWallet(uint256 _num) external onlyOwner {
}
function setTokenPrice(uint256 newPrice) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawFunds() external onlyOwner {
}
function withdrawFundsToAddress(address _address, uint256 amount) external onlyOwner {
}
function flipPublicSale() external onlyOwner {
}
}
| !claimed,"Team already claimed" | 246,926 | !claimed |
"max NFT limit exceeded" | // SPDX-License-Identifier: MIT
// Copyright (c) 2023 Keisuke OHNO (kei31.eth)
// Modified by Gaku (Brains)
/*
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
pragma solidity >=0.8.17;
import { Base64 } from 'base64-sol/base64.sol';
import "contract-allow-list/contracts/ERC721AntiScam/restrictApprove/ERC721RestrictApprove.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
//tokenURI interface
interface iTokenURI {
function tokenURI(uint256 _tokenId) external view returns (string memory);
}
//SBT interface
interface iSbtCollection {
function externalMint(address _address , uint256 _amount ) external payable;
function balanceOf(address _owner) external view returns (uint);
}
contract CNPinfantFamily is ERC2981 ,Ownable, ERC721RestrictApprove ,AccessControl,ReentrancyGuard {
constructor(
) ERC721Psi("CNPinfant Family", "CNPiF") {
}
bool public isLockMode = false;
mapping(uint256 => bool) public isLocked;
//
//withdraw section
//
address public withdrawAddress = 0x9D3e4F8cdDd6BE1BCA4B6ed2835cf8fbbf93Ba33;
function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
//
//mint section
//
//https://eth-converter.com/
uint256 public cost = 1000000000000000;
uint256 public maxSupply = 3500;
uint256 public maxMintAmountPerTransaction = 30;
uint256 public publicSaleMaxMintAmountPerAddress = 0;
bool public paused = true;
bool public onlyAllowlisted = true;
bool public mintCount = true;
bool public burnAndMintMode = false;
//0 : Merkle Tree
//1 : Mapping
uint256 public allowlistType = 0;
bytes32 public merkleRoot;
uint256 public saleId = 0;
mapping(uint256 => mapping(address => uint256)) public userMintedAmount;
mapping(uint256 => mapping(address => uint256)) public allowlistUserAmount;
bool public mintWithSBT = false;
iSbtCollection public sbtCollection;
modifier callerIsUser() {
}
//mint with merkle tree
function mint(uint256 _mintAmount , uint256 _maxMintAmount , bytes32[] calldata _merkleProof , uint256 _burnId , address _toAddress ) public payable callerIsUser{
require(!paused, "the contract is paused");
require(0 < _mintAmount, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmountPerTransaction, "max mint amount per session exceeded");
require(<FILL_ME>)
require(cost * _mintAmount <= msg.value, "insufficient funds");
uint256 maxMintAmountPerAddress;
address sendToAddress;
if(onlyAllowlisted == true) {
if(allowlistType == 0){
//Merkle tree
bytes32 leaf = keccak256( abi.encodePacked(msg.sender, _maxMintAmount) );
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "user is not allowlisted");
maxMintAmountPerAddress = _maxMintAmount;
}else if(allowlistType == 1){
//Mapping
require( allowlistUserAmount[saleId][msg.sender] != 0 , "user is not allowlisted");
maxMintAmountPerAddress = allowlistUserAmount[saleId][msg.sender];
}
}else{
maxMintAmountPerAddress = publicSaleMaxMintAmountPerAddress;
}
if(mintCount == true){
require(_mintAmount <= maxMintAmountPerAddress - userMintedAmount[saleId][msg.sender] , "max NFT per address exceeded");
userMintedAmount[saleId][msg.sender] += _mintAmount;
}
if(burnAndMintMode == true ){
require(_mintAmount == 1, "The number of mints is over.");
require(msg.sender == ownerOf(_burnId) , "Owner is different");
_burn(_burnId);
}
if( mintWithSBT == true ){
if( sbtCollection.balanceOf(msg.sender) == 0 ){
sbtCollection.externalMint(msg.sender,1);
}
}
if(_toAddress == address(0)) {
sendToAddress = msg.sender;
} else {
sendToAddress = _toAddress;
}
_safeMint(sendToAddress, _mintAmount);
}
function piementMint(uint256 _mintAmount, uint256 _maxMintAmount, bytes32[] calldata _merkleProof, address _toAddress) public payable {
}
bytes32 public constant AIRDROP_ROLE = keccak256("AIRDROP_ROLE");
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public {
}
function currentTokenId() public view returns(uint256){
}
function setMintWithSBT(bool _mintWithSBT) public onlyRole(ADMIN) {
}
function setSbtCollection(address _address) public onlyRole(ADMIN) {
}
function setBurnAndMintMode(bool _burnAndMintMode) public onlyRole(ADMIN) {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyRole(ADMIN) {
}
function setPause(bool _state) public onlyRole(ADMIN) {
}
function setAllowListType(uint256 _type)public onlyRole(ADMIN){
}
function setAllowlistMapping(uint256 _saleId , address[] memory addresses, uint256[] memory saleSupplies) public onlyRole(ADMIN) {
}
function getAllowlistUserAmount(address _address ) public view returns(uint256){
}
function getUserMintedAmountBySaleId(uint256 _saleId , address _address ) public view returns(uint256){
}
function getUserMintedAmount(address _address ) public view returns(uint256){
}
function setSaleId(uint256 _saleId) public onlyRole(ADMIN) {
}
function setMaxSupply(uint256 _maxSupply) public onlyRole(ADMIN) {
}
function setPublicSaleMaxMintAmountPerAddress(uint256 _publicSaleMaxMintAmountPerAddress) public onlyRole(ADMIN) {
}
function setCost(uint256 _newCost) public onlyRole(ADMIN) {
}
function setOnlyAllowlisted(bool _state) public onlyRole(ADMIN) {
}
function setMaxMintAmountPerTransaction(uint256 _maxMintAmountPerTransaction) public onlyRole(ADMIN) {
}
function setMintCount(bool _state) public onlyRole(ADMIN) {
}
function setIsLockMode(bool _lockMode) external onlyRole(ADMIN) {
}
function setIsLocked(uint256 _tokenId, bool _locked) external{
}
function getIsLockMode() external view returns (bool){
}
function getIsLocked(uint256 _tokenId)external view returns (bool){
}
//
//URI section
//
string public baseURI;
string public baseExtension = ".json";
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyRole(ADMIN) {
}
function setBaseExtension(string memory _newBaseExtension) public onlyRole(ADMIN) {
}
//
//interface metadata
//
iTokenURI public interfaceOfTokenURI;
bool public useInterfaceMetadata = false;
function setInterfaceOfTokenURI(address _address) public onlyRole(ADMIN) {
}
function setUseInterfaceMetadata(bool _useInterfaceMetadata) public onlyRole(ADMIN) {
}
//
//token URI
//
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
//
//burnin' section
//
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
function externalMint(address _address , uint256 _amount ) external payable {
}
function externalBurn(uint256[] memory _burnTokenIds) external nonReentrant{
}
//
//sbt and opensea filter section
//
bool public isSBT = false;
function setIsSBT(bool _state) public onlyRole(ADMIN) {
}
function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override{
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function approve(address operator, uint256 tokenId) public virtual override {
}
//
//ERC721PsiAddressData section
//
// Mapping owner address to address data
mapping(address => AddressData) _addressData;
// Compiler will pack this into a single 256bit word.
struct AddressData {
// Realistically, 2**64-1 is more than enough.
uint64 balance;
// Keeps track of mint count with minimal overhead for tokenomics.
uint64 numberMinted;
// Keeps track of burn count with minimal overhead for tokenomics.
uint64 numberBurned;
// For miscellaneous variable(s) pertaining to the address
// (e.g. number of whitelist mint slots used).
// If there are multiple variables, please pack them into a uint64.
uint64 aux;
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address _owner)
public
view
virtual
override
returns (uint)
{
}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* 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` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override virtual {
}
//
//ERC721AntiScam section
//
bytes32 public constant ADMIN = keccak256("ADMIN");
function setEnebleRestrict(bool _enableRestrict )public onlyRole(ADMIN){
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function addLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function removeLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function getLocalContractAllowList()
external
override
view
returns(address[] memory)
{
}
function setCALLevel(uint256 level) public override onlyRole(ADMIN) {
}
function setCAL(address calAddress) external override onlyRole(ADMIN) {
}
//
//setDefaultRoyalty
//
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) public onlyOwner{
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC2981,ERC721RestrictApprove, AccessControl)
returns (bool)
{
}
}
| _nextTokenId()+_mintAmount-1<=maxSupply,"max NFT limit exceeded" | 247,018 | _nextTokenId()+_mintAmount-1<=maxSupply |
"not exists" | // SPDX-License-Identifier: MIT
// Copyright (c) 2023 Keisuke OHNO (kei31.eth)
// Modified by Gaku (Brains)
/*
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
pragma solidity >=0.8.17;
import { Base64 } from 'base64-sol/base64.sol';
import "contract-allow-list/contracts/ERC721AntiScam/restrictApprove/ERC721RestrictApprove.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
//tokenURI interface
interface iTokenURI {
function tokenURI(uint256 _tokenId) external view returns (string memory);
}
//SBT interface
interface iSbtCollection {
function externalMint(address _address , uint256 _amount ) external payable;
function balanceOf(address _owner) external view returns (uint);
}
contract CNPinfantFamily is ERC2981 ,Ownable, ERC721RestrictApprove ,AccessControl,ReentrancyGuard {
constructor(
) ERC721Psi("CNPinfant Family", "CNPiF") {
}
bool public isLockMode = false;
mapping(uint256 => bool) public isLocked;
//
//withdraw section
//
address public withdrawAddress = 0x9D3e4F8cdDd6BE1BCA4B6ed2835cf8fbbf93Ba33;
function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
//
//mint section
//
//https://eth-converter.com/
uint256 public cost = 1000000000000000;
uint256 public maxSupply = 3500;
uint256 public maxMintAmountPerTransaction = 30;
uint256 public publicSaleMaxMintAmountPerAddress = 0;
bool public paused = true;
bool public onlyAllowlisted = true;
bool public mintCount = true;
bool public burnAndMintMode = false;
//0 : Merkle Tree
//1 : Mapping
uint256 public allowlistType = 0;
bytes32 public merkleRoot;
uint256 public saleId = 0;
mapping(uint256 => mapping(address => uint256)) public userMintedAmount;
mapping(uint256 => mapping(address => uint256)) public allowlistUserAmount;
bool public mintWithSBT = false;
iSbtCollection public sbtCollection;
modifier callerIsUser() {
}
//mint with merkle tree
function mint(uint256 _mintAmount , uint256 _maxMintAmount , bytes32[] calldata _merkleProof , uint256 _burnId , address _toAddress ) public payable callerIsUser{
}
function piementMint(uint256 _mintAmount, uint256 _maxMintAmount, bytes32[] calldata _merkleProof, address _toAddress) public payable {
}
bytes32 public constant AIRDROP_ROLE = keccak256("AIRDROP_ROLE");
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public {
}
function currentTokenId() public view returns(uint256){
}
function setMintWithSBT(bool _mintWithSBT) public onlyRole(ADMIN) {
}
function setSbtCollection(address _address) public onlyRole(ADMIN) {
}
function setBurnAndMintMode(bool _burnAndMintMode) public onlyRole(ADMIN) {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyRole(ADMIN) {
}
function setPause(bool _state) public onlyRole(ADMIN) {
}
function setAllowListType(uint256 _type)public onlyRole(ADMIN){
}
function setAllowlistMapping(uint256 _saleId , address[] memory addresses, uint256[] memory saleSupplies) public onlyRole(ADMIN) {
}
function getAllowlistUserAmount(address _address ) public view returns(uint256){
}
function getUserMintedAmountBySaleId(uint256 _saleId , address _address ) public view returns(uint256){
}
function getUserMintedAmount(address _address ) public view returns(uint256){
}
function setSaleId(uint256 _saleId) public onlyRole(ADMIN) {
}
function setMaxSupply(uint256 _maxSupply) public onlyRole(ADMIN) {
}
function setPublicSaleMaxMintAmountPerAddress(uint256 _publicSaleMaxMintAmountPerAddress) public onlyRole(ADMIN) {
}
function setCost(uint256 _newCost) public onlyRole(ADMIN) {
}
function setOnlyAllowlisted(bool _state) public onlyRole(ADMIN) {
}
function setMaxMintAmountPerTransaction(uint256 _maxMintAmountPerTransaction) public onlyRole(ADMIN) {
}
function setMintCount(bool _state) public onlyRole(ADMIN) {
}
function setIsLockMode(bool _lockMode) external onlyRole(ADMIN) {
}
function setIsLocked(uint256 _tokenId, bool _locked) external{
}
function getIsLockMode() external view returns (bool){
}
function getIsLocked(uint256 _tokenId)external view returns (bool){
require(<FILL_ME>)
return isLocked[_tokenId];
}
//
//URI section
//
string public baseURI;
string public baseExtension = ".json";
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyRole(ADMIN) {
}
function setBaseExtension(string memory _newBaseExtension) public onlyRole(ADMIN) {
}
//
//interface metadata
//
iTokenURI public interfaceOfTokenURI;
bool public useInterfaceMetadata = false;
function setInterfaceOfTokenURI(address _address) public onlyRole(ADMIN) {
}
function setUseInterfaceMetadata(bool _useInterfaceMetadata) public onlyRole(ADMIN) {
}
//
//token URI
//
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
//
//burnin' section
//
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
function externalMint(address _address , uint256 _amount ) external payable {
}
function externalBurn(uint256[] memory _burnTokenIds) external nonReentrant{
}
//
//sbt and opensea filter section
//
bool public isSBT = false;
function setIsSBT(bool _state) public onlyRole(ADMIN) {
}
function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override{
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function approve(address operator, uint256 tokenId) public virtual override {
}
//
//ERC721PsiAddressData section
//
// Mapping owner address to address data
mapping(address => AddressData) _addressData;
// Compiler will pack this into a single 256bit word.
struct AddressData {
// Realistically, 2**64-1 is more than enough.
uint64 balance;
// Keeps track of mint count with minimal overhead for tokenomics.
uint64 numberMinted;
// Keeps track of burn count with minimal overhead for tokenomics.
uint64 numberBurned;
// For miscellaneous variable(s) pertaining to the address
// (e.g. number of whitelist mint slots used).
// If there are multiple variables, please pack them into a uint64.
uint64 aux;
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address _owner)
public
view
virtual
override
returns (uint)
{
}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* 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` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override virtual {
}
//
//ERC721AntiScam section
//
bytes32 public constant ADMIN = keccak256("ADMIN");
function setEnebleRestrict(bool _enableRestrict )public onlyRole(ADMIN){
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function addLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function removeLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function getLocalContractAllowList()
external
override
view
returns(address[] memory)
{
}
function setCALLevel(uint256 level) public override onlyRole(ADMIN) {
}
function setCAL(address calAddress) external override onlyRole(ADMIN) {
}
//
//setDefaultRoyalty
//
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) public onlyOwner{
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC2981,ERC721RestrictApprove, AccessControl)
returns (bool)
{
}
}
| _exists(_tokenId)==true,"not exists" | 247,018 | _exists(_tokenId)==true |
"max NFT limit exceeded" | // SPDX-License-Identifier: MIT
// Copyright (c) 2023 Keisuke OHNO (kei31.eth)
// Modified by Gaku (Brains)
/*
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
pragma solidity >=0.8.17;
import { Base64 } from 'base64-sol/base64.sol';
import "contract-allow-list/contracts/ERC721AntiScam/restrictApprove/ERC721RestrictApprove.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
//tokenURI interface
interface iTokenURI {
function tokenURI(uint256 _tokenId) external view returns (string memory);
}
//SBT interface
interface iSbtCollection {
function externalMint(address _address , uint256 _amount ) external payable;
function balanceOf(address _owner) external view returns (uint);
}
contract CNPinfantFamily is ERC2981 ,Ownable, ERC721RestrictApprove ,AccessControl,ReentrancyGuard {
constructor(
) ERC721Psi("CNPinfant Family", "CNPiF") {
}
bool public isLockMode = false;
mapping(uint256 => bool) public isLocked;
//
//withdraw section
//
address public withdrawAddress = 0x9D3e4F8cdDd6BE1BCA4B6ed2835cf8fbbf93Ba33;
function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
//
//mint section
//
//https://eth-converter.com/
uint256 public cost = 1000000000000000;
uint256 public maxSupply = 3500;
uint256 public maxMintAmountPerTransaction = 30;
uint256 public publicSaleMaxMintAmountPerAddress = 0;
bool public paused = true;
bool public onlyAllowlisted = true;
bool public mintCount = true;
bool public burnAndMintMode = false;
//0 : Merkle Tree
//1 : Mapping
uint256 public allowlistType = 0;
bytes32 public merkleRoot;
uint256 public saleId = 0;
mapping(uint256 => mapping(address => uint256)) public userMintedAmount;
mapping(uint256 => mapping(address => uint256)) public allowlistUserAmount;
bool public mintWithSBT = false;
iSbtCollection public sbtCollection;
modifier callerIsUser() {
}
//mint with merkle tree
function mint(uint256 _mintAmount , uint256 _maxMintAmount , bytes32[] calldata _merkleProof , uint256 _burnId , address _toAddress ) public payable callerIsUser{
}
function piementMint(uint256 _mintAmount, uint256 _maxMintAmount, bytes32[] calldata _merkleProof, address _toAddress) public payable {
}
bytes32 public constant AIRDROP_ROLE = keccak256("AIRDROP_ROLE");
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public {
}
function currentTokenId() public view returns(uint256){
}
function setMintWithSBT(bool _mintWithSBT) public onlyRole(ADMIN) {
}
function setSbtCollection(address _address) public onlyRole(ADMIN) {
}
function setBurnAndMintMode(bool _burnAndMintMode) public onlyRole(ADMIN) {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyRole(ADMIN) {
}
function setPause(bool _state) public onlyRole(ADMIN) {
}
function setAllowListType(uint256 _type)public onlyRole(ADMIN){
}
function setAllowlistMapping(uint256 _saleId , address[] memory addresses, uint256[] memory saleSupplies) public onlyRole(ADMIN) {
}
function getAllowlistUserAmount(address _address ) public view returns(uint256){
}
function getUserMintedAmountBySaleId(uint256 _saleId , address _address ) public view returns(uint256){
}
function getUserMintedAmount(address _address ) public view returns(uint256){
}
function setSaleId(uint256 _saleId) public onlyRole(ADMIN) {
}
function setMaxSupply(uint256 _maxSupply) public onlyRole(ADMIN) {
}
function setPublicSaleMaxMintAmountPerAddress(uint256 _publicSaleMaxMintAmountPerAddress) public onlyRole(ADMIN) {
}
function setCost(uint256 _newCost) public onlyRole(ADMIN) {
}
function setOnlyAllowlisted(bool _state) public onlyRole(ADMIN) {
}
function setMaxMintAmountPerTransaction(uint256 _maxMintAmountPerTransaction) public onlyRole(ADMIN) {
}
function setMintCount(bool _state) public onlyRole(ADMIN) {
}
function setIsLockMode(bool _lockMode) external onlyRole(ADMIN) {
}
function setIsLocked(uint256 _tokenId, bool _locked) external{
}
function getIsLockMode() external view returns (bool){
}
function getIsLocked(uint256 _tokenId)external view returns (bool){
}
//
//URI section
//
string public baseURI;
string public baseExtension = ".json";
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyRole(ADMIN) {
}
function setBaseExtension(string memory _newBaseExtension) public onlyRole(ADMIN) {
}
//
//interface metadata
//
iTokenURI public interfaceOfTokenURI;
bool public useInterfaceMetadata = false;
function setInterfaceOfTokenURI(address _address) public onlyRole(ADMIN) {
}
function setUseInterfaceMetadata(bool _useInterfaceMetadata) public onlyRole(ADMIN) {
}
//
//token URI
//
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
//
//burnin' section
//
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
function externalMint(address _address , uint256 _amount ) external payable {
require(hasRole(MINTER_ROLE, msg.sender), "Caller is not a minter");
require(<FILL_ME>)
_safeMint( _address, _amount );
}
function externalBurn(uint256[] memory _burnTokenIds) external nonReentrant{
}
//
//sbt and opensea filter section
//
bool public isSBT = false;
function setIsSBT(bool _state) public onlyRole(ADMIN) {
}
function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override{
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function approve(address operator, uint256 tokenId) public virtual override {
}
//
//ERC721PsiAddressData section
//
// Mapping owner address to address data
mapping(address => AddressData) _addressData;
// Compiler will pack this into a single 256bit word.
struct AddressData {
// Realistically, 2**64-1 is more than enough.
uint64 balance;
// Keeps track of mint count with minimal overhead for tokenomics.
uint64 numberMinted;
// Keeps track of burn count with minimal overhead for tokenomics.
uint64 numberBurned;
// For miscellaneous variable(s) pertaining to the address
// (e.g. number of whitelist mint slots used).
// If there are multiple variables, please pack them into a uint64.
uint64 aux;
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address _owner)
public
view
virtual
override
returns (uint)
{
}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* 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` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override virtual {
}
//
//ERC721AntiScam section
//
bytes32 public constant ADMIN = keccak256("ADMIN");
function setEnebleRestrict(bool _enableRestrict )public onlyRole(ADMIN){
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function addLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function removeLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function getLocalContractAllowList()
external
override
view
returns(address[] memory)
{
}
function setCALLevel(uint256 level) public override onlyRole(ADMIN) {
}
function setCAL(address calAddress) external override onlyRole(ADMIN) {
}
//
//setDefaultRoyalty
//
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) public onlyOwner{
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC2981,ERC721RestrictApprove, AccessControl)
returns (bool)
{
}
}
| _nextTokenId()+_amount-1<=maxSupply,"max NFT limit exceeded" | 247,018 | _nextTokenId()+_amount-1<=maxSupply |
"transfer is prohibited" | // SPDX-License-Identifier: MIT
// Copyright (c) 2023 Keisuke OHNO (kei31.eth)
// Modified by Gaku (Brains)
/*
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
pragma solidity >=0.8.17;
import { Base64 } from 'base64-sol/base64.sol';
import "contract-allow-list/contracts/ERC721AntiScam/restrictApprove/ERC721RestrictApprove.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
//tokenURI interface
interface iTokenURI {
function tokenURI(uint256 _tokenId) external view returns (string memory);
}
//SBT interface
interface iSbtCollection {
function externalMint(address _address , uint256 _amount ) external payable;
function balanceOf(address _owner) external view returns (uint);
}
contract CNPinfantFamily is ERC2981 ,Ownable, ERC721RestrictApprove ,AccessControl,ReentrancyGuard {
constructor(
) ERC721Psi("CNPinfant Family", "CNPiF") {
}
bool public isLockMode = false;
mapping(uint256 => bool) public isLocked;
//
//withdraw section
//
address public withdrawAddress = 0x9D3e4F8cdDd6BE1BCA4B6ed2835cf8fbbf93Ba33;
function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
//
//mint section
//
//https://eth-converter.com/
uint256 public cost = 1000000000000000;
uint256 public maxSupply = 3500;
uint256 public maxMintAmountPerTransaction = 30;
uint256 public publicSaleMaxMintAmountPerAddress = 0;
bool public paused = true;
bool public onlyAllowlisted = true;
bool public mintCount = true;
bool public burnAndMintMode = false;
//0 : Merkle Tree
//1 : Mapping
uint256 public allowlistType = 0;
bytes32 public merkleRoot;
uint256 public saleId = 0;
mapping(uint256 => mapping(address => uint256)) public userMintedAmount;
mapping(uint256 => mapping(address => uint256)) public allowlistUserAmount;
bool public mintWithSBT = false;
iSbtCollection public sbtCollection;
modifier callerIsUser() {
}
//mint with merkle tree
function mint(uint256 _mintAmount , uint256 _maxMintAmount , bytes32[] calldata _merkleProof , uint256 _burnId , address _toAddress ) public payable callerIsUser{
}
function piementMint(uint256 _mintAmount, uint256 _maxMintAmount, bytes32[] calldata _merkleProof, address _toAddress) public payable {
}
bytes32 public constant AIRDROP_ROLE = keccak256("AIRDROP_ROLE");
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public {
}
function currentTokenId() public view returns(uint256){
}
function setMintWithSBT(bool _mintWithSBT) public onlyRole(ADMIN) {
}
function setSbtCollection(address _address) public onlyRole(ADMIN) {
}
function setBurnAndMintMode(bool _burnAndMintMode) public onlyRole(ADMIN) {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyRole(ADMIN) {
}
function setPause(bool _state) public onlyRole(ADMIN) {
}
function setAllowListType(uint256 _type)public onlyRole(ADMIN){
}
function setAllowlistMapping(uint256 _saleId , address[] memory addresses, uint256[] memory saleSupplies) public onlyRole(ADMIN) {
}
function getAllowlistUserAmount(address _address ) public view returns(uint256){
}
function getUserMintedAmountBySaleId(uint256 _saleId , address _address ) public view returns(uint256){
}
function getUserMintedAmount(address _address ) public view returns(uint256){
}
function setSaleId(uint256 _saleId) public onlyRole(ADMIN) {
}
function setMaxSupply(uint256 _maxSupply) public onlyRole(ADMIN) {
}
function setPublicSaleMaxMintAmountPerAddress(uint256 _publicSaleMaxMintAmountPerAddress) public onlyRole(ADMIN) {
}
function setCost(uint256 _newCost) public onlyRole(ADMIN) {
}
function setOnlyAllowlisted(bool _state) public onlyRole(ADMIN) {
}
function setMaxMintAmountPerTransaction(uint256 _maxMintAmountPerTransaction) public onlyRole(ADMIN) {
}
function setMintCount(bool _state) public onlyRole(ADMIN) {
}
function setIsLockMode(bool _lockMode) external onlyRole(ADMIN) {
}
function setIsLocked(uint256 _tokenId, bool _locked) external{
}
function getIsLockMode() external view returns (bool){
}
function getIsLocked(uint256 _tokenId)external view returns (bool){
}
//
//URI section
//
string public baseURI;
string public baseExtension = ".json";
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyRole(ADMIN) {
}
function setBaseExtension(string memory _newBaseExtension) public onlyRole(ADMIN) {
}
//
//interface metadata
//
iTokenURI public interfaceOfTokenURI;
bool public useInterfaceMetadata = false;
function setInterfaceOfTokenURI(address _address) public onlyRole(ADMIN) {
}
function setUseInterfaceMetadata(bool _useInterfaceMetadata) public onlyRole(ADMIN) {
}
//
//token URI
//
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
//
//burnin' section
//
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
function externalMint(address _address , uint256 _amount ) external payable {
}
function externalBurn(uint256[] memory _burnTokenIds) external nonReentrant{
}
//
//sbt and opensea filter section
//
bool public isSBT = false;
function setIsSBT(bool _state) public onlyRole(ADMIN) {
}
function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override{
require(<FILL_ME>)
if(isLockMode == true){
for (uint256 i = startTokenId; i < startTokenId + quantity; i++) {
require(isLocked[i] == false,"this tokenIds include locked");
}
}
super._beforeTokenTransfers(from, to, startTokenId, quantity);
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function approve(address operator, uint256 tokenId) public virtual override {
}
//
//ERC721PsiAddressData section
//
// Mapping owner address to address data
mapping(address => AddressData) _addressData;
// Compiler will pack this into a single 256bit word.
struct AddressData {
// Realistically, 2**64-1 is more than enough.
uint64 balance;
// Keeps track of mint count with minimal overhead for tokenomics.
uint64 numberMinted;
// Keeps track of burn count with minimal overhead for tokenomics.
uint64 numberBurned;
// For miscellaneous variable(s) pertaining to the address
// (e.g. number of whitelist mint slots used).
// If there are multiple variables, please pack them into a uint64.
uint64 aux;
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address _owner)
public
view
virtual
override
returns (uint)
{
}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* 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` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override virtual {
}
//
//ERC721AntiScam section
//
bytes32 public constant ADMIN = keccak256("ADMIN");
function setEnebleRestrict(bool _enableRestrict )public onlyRole(ADMIN){
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function addLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function removeLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function getLocalContractAllowList()
external
override
view
returns(address[] memory)
{
}
function setCALLevel(uint256 level) public override onlyRole(ADMIN) {
}
function setCAL(address calAddress) external override onlyRole(ADMIN) {
}
//
//setDefaultRoyalty
//
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) public onlyOwner{
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC2981,ERC721RestrictApprove, AccessControl)
returns (bool)
{
}
}
| (isSBT==false)||from==address(0)||to==address(0)||to==address(0x000000000000000000000000000000000000dEaD),"transfer is prohibited" | 247,018 | (isSBT==false)||from==address(0)||to==address(0)||to==address(0x000000000000000000000000000000000000dEaD) |
"this tokenIds include locked" | // SPDX-License-Identifier: MIT
// Copyright (c) 2023 Keisuke OHNO (kei31.eth)
// Modified by Gaku (Brains)
/*
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
pragma solidity >=0.8.17;
import { Base64 } from 'base64-sol/base64.sol';
import "contract-allow-list/contracts/ERC721AntiScam/restrictApprove/ERC721RestrictApprove.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
//tokenURI interface
interface iTokenURI {
function tokenURI(uint256 _tokenId) external view returns (string memory);
}
//SBT interface
interface iSbtCollection {
function externalMint(address _address , uint256 _amount ) external payable;
function balanceOf(address _owner) external view returns (uint);
}
contract CNPinfantFamily is ERC2981 ,Ownable, ERC721RestrictApprove ,AccessControl,ReentrancyGuard {
constructor(
) ERC721Psi("CNPinfant Family", "CNPiF") {
}
bool public isLockMode = false;
mapping(uint256 => bool) public isLocked;
//
//withdraw section
//
address public withdrawAddress = 0x9D3e4F8cdDd6BE1BCA4B6ed2835cf8fbbf93Ba33;
function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
//
//mint section
//
//https://eth-converter.com/
uint256 public cost = 1000000000000000;
uint256 public maxSupply = 3500;
uint256 public maxMintAmountPerTransaction = 30;
uint256 public publicSaleMaxMintAmountPerAddress = 0;
bool public paused = true;
bool public onlyAllowlisted = true;
bool public mintCount = true;
bool public burnAndMintMode = false;
//0 : Merkle Tree
//1 : Mapping
uint256 public allowlistType = 0;
bytes32 public merkleRoot;
uint256 public saleId = 0;
mapping(uint256 => mapping(address => uint256)) public userMintedAmount;
mapping(uint256 => mapping(address => uint256)) public allowlistUserAmount;
bool public mintWithSBT = false;
iSbtCollection public sbtCollection;
modifier callerIsUser() {
}
//mint with merkle tree
function mint(uint256 _mintAmount , uint256 _maxMintAmount , bytes32[] calldata _merkleProof , uint256 _burnId , address _toAddress ) public payable callerIsUser{
}
function piementMint(uint256 _mintAmount, uint256 _maxMintAmount, bytes32[] calldata _merkleProof, address _toAddress) public payable {
}
bytes32 public constant AIRDROP_ROLE = keccak256("AIRDROP_ROLE");
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public {
}
function currentTokenId() public view returns(uint256){
}
function setMintWithSBT(bool _mintWithSBT) public onlyRole(ADMIN) {
}
function setSbtCollection(address _address) public onlyRole(ADMIN) {
}
function setBurnAndMintMode(bool _burnAndMintMode) public onlyRole(ADMIN) {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyRole(ADMIN) {
}
function setPause(bool _state) public onlyRole(ADMIN) {
}
function setAllowListType(uint256 _type)public onlyRole(ADMIN){
}
function setAllowlistMapping(uint256 _saleId , address[] memory addresses, uint256[] memory saleSupplies) public onlyRole(ADMIN) {
}
function getAllowlistUserAmount(address _address ) public view returns(uint256){
}
function getUserMintedAmountBySaleId(uint256 _saleId , address _address ) public view returns(uint256){
}
function getUserMintedAmount(address _address ) public view returns(uint256){
}
function setSaleId(uint256 _saleId) public onlyRole(ADMIN) {
}
function setMaxSupply(uint256 _maxSupply) public onlyRole(ADMIN) {
}
function setPublicSaleMaxMintAmountPerAddress(uint256 _publicSaleMaxMintAmountPerAddress) public onlyRole(ADMIN) {
}
function setCost(uint256 _newCost) public onlyRole(ADMIN) {
}
function setOnlyAllowlisted(bool _state) public onlyRole(ADMIN) {
}
function setMaxMintAmountPerTransaction(uint256 _maxMintAmountPerTransaction) public onlyRole(ADMIN) {
}
function setMintCount(bool _state) public onlyRole(ADMIN) {
}
function setIsLockMode(bool _lockMode) external onlyRole(ADMIN) {
}
function setIsLocked(uint256 _tokenId, bool _locked) external{
}
function getIsLockMode() external view returns (bool){
}
function getIsLocked(uint256 _tokenId)external view returns (bool){
}
//
//URI section
//
string public baseURI;
string public baseExtension = ".json";
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyRole(ADMIN) {
}
function setBaseExtension(string memory _newBaseExtension) public onlyRole(ADMIN) {
}
//
//interface metadata
//
iTokenURI public interfaceOfTokenURI;
bool public useInterfaceMetadata = false;
function setInterfaceOfTokenURI(address _address) public onlyRole(ADMIN) {
}
function setUseInterfaceMetadata(bool _useInterfaceMetadata) public onlyRole(ADMIN) {
}
//
//token URI
//
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
//
//burnin' section
//
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
function externalMint(address _address , uint256 _amount ) external payable {
}
function externalBurn(uint256[] memory _burnTokenIds) external nonReentrant{
}
//
//sbt and opensea filter section
//
bool public isSBT = false;
function setIsSBT(bool _state) public onlyRole(ADMIN) {
}
function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override{
require(
(isSBT == false ) ||
from == address(0) ||
to == address(0)||
to == address(0x000000000000000000000000000000000000dEaD),
"transfer is prohibited"
);
if(isLockMode == true){
for (uint256 i = startTokenId; i < startTokenId + quantity; i++) {
require(<FILL_ME>)
}
}
super._beforeTokenTransfers(from, to, startTokenId, quantity);
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function approve(address operator, uint256 tokenId) public virtual override {
}
//
//ERC721PsiAddressData section
//
// Mapping owner address to address data
mapping(address => AddressData) _addressData;
// Compiler will pack this into a single 256bit word.
struct AddressData {
// Realistically, 2**64-1 is more than enough.
uint64 balance;
// Keeps track of mint count with minimal overhead for tokenomics.
uint64 numberMinted;
// Keeps track of burn count with minimal overhead for tokenomics.
uint64 numberBurned;
// For miscellaneous variable(s) pertaining to the address
// (e.g. number of whitelist mint slots used).
// If there are multiple variables, please pack them into a uint64.
uint64 aux;
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address _owner)
public
view
virtual
override
returns (uint)
{
}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* 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` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override virtual {
}
//
//ERC721AntiScam section
//
bytes32 public constant ADMIN = keccak256("ADMIN");
function setEnebleRestrict(bool _enableRestrict )public onlyRole(ADMIN){
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function addLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function removeLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function getLocalContractAllowList()
external
override
view
returns(address[] memory)
{
}
function setCALLevel(uint256 level) public override onlyRole(ADMIN) {
}
function setCAL(address calAddress) external override onlyRole(ADMIN) {
}
//
//setDefaultRoyalty
//
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) public onlyOwner{
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC2981,ERC721RestrictApprove, AccessControl)
returns (bool)
{
}
}
| isLocked[i]==false,"this tokenIds include locked" | 247,018 | isLocked[i]==false |
"this tokenId is locked" | // SPDX-License-Identifier: MIT
// Copyright (c) 2023 Keisuke OHNO (kei31.eth)
// Modified by Gaku (Brains)
/*
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
pragma solidity >=0.8.17;
import { Base64 } from 'base64-sol/base64.sol';
import "contract-allow-list/contracts/ERC721AntiScam/restrictApprove/ERC721RestrictApprove.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
//tokenURI interface
interface iTokenURI {
function tokenURI(uint256 _tokenId) external view returns (string memory);
}
//SBT interface
interface iSbtCollection {
function externalMint(address _address , uint256 _amount ) external payable;
function balanceOf(address _owner) external view returns (uint);
}
contract CNPinfantFamily is ERC2981 ,Ownable, ERC721RestrictApprove ,AccessControl,ReentrancyGuard {
constructor(
) ERC721Psi("CNPinfant Family", "CNPiF") {
}
bool public isLockMode = false;
mapping(uint256 => bool) public isLocked;
//
//withdraw section
//
address public withdrawAddress = 0x9D3e4F8cdDd6BE1BCA4B6ed2835cf8fbbf93Ba33;
function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
//
//mint section
//
//https://eth-converter.com/
uint256 public cost = 1000000000000000;
uint256 public maxSupply = 3500;
uint256 public maxMintAmountPerTransaction = 30;
uint256 public publicSaleMaxMintAmountPerAddress = 0;
bool public paused = true;
bool public onlyAllowlisted = true;
bool public mintCount = true;
bool public burnAndMintMode = false;
//0 : Merkle Tree
//1 : Mapping
uint256 public allowlistType = 0;
bytes32 public merkleRoot;
uint256 public saleId = 0;
mapping(uint256 => mapping(address => uint256)) public userMintedAmount;
mapping(uint256 => mapping(address => uint256)) public allowlistUserAmount;
bool public mintWithSBT = false;
iSbtCollection public sbtCollection;
modifier callerIsUser() {
}
//mint with merkle tree
function mint(uint256 _mintAmount , uint256 _maxMintAmount , bytes32[] calldata _merkleProof , uint256 _burnId , address _toAddress ) public payable callerIsUser{
}
function piementMint(uint256 _mintAmount, uint256 _maxMintAmount, bytes32[] calldata _merkleProof, address _toAddress) public payable {
}
bytes32 public constant AIRDROP_ROLE = keccak256("AIRDROP_ROLE");
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public {
}
function currentTokenId() public view returns(uint256){
}
function setMintWithSBT(bool _mintWithSBT) public onlyRole(ADMIN) {
}
function setSbtCollection(address _address) public onlyRole(ADMIN) {
}
function setBurnAndMintMode(bool _burnAndMintMode) public onlyRole(ADMIN) {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyRole(ADMIN) {
}
function setPause(bool _state) public onlyRole(ADMIN) {
}
function setAllowListType(uint256 _type)public onlyRole(ADMIN){
}
function setAllowlistMapping(uint256 _saleId , address[] memory addresses, uint256[] memory saleSupplies) public onlyRole(ADMIN) {
}
function getAllowlistUserAmount(address _address ) public view returns(uint256){
}
function getUserMintedAmountBySaleId(uint256 _saleId , address _address ) public view returns(uint256){
}
function getUserMintedAmount(address _address ) public view returns(uint256){
}
function setSaleId(uint256 _saleId) public onlyRole(ADMIN) {
}
function setMaxSupply(uint256 _maxSupply) public onlyRole(ADMIN) {
}
function setPublicSaleMaxMintAmountPerAddress(uint256 _publicSaleMaxMintAmountPerAddress) public onlyRole(ADMIN) {
}
function setCost(uint256 _newCost) public onlyRole(ADMIN) {
}
function setOnlyAllowlisted(bool _state) public onlyRole(ADMIN) {
}
function setMaxMintAmountPerTransaction(uint256 _maxMintAmountPerTransaction) public onlyRole(ADMIN) {
}
function setMintCount(bool _state) public onlyRole(ADMIN) {
}
function setIsLockMode(bool _lockMode) external onlyRole(ADMIN) {
}
function setIsLocked(uint256 _tokenId, bool _locked) external{
}
function getIsLockMode() external view returns (bool){
}
function getIsLocked(uint256 _tokenId)external view returns (bool){
}
//
//URI section
//
string public baseURI;
string public baseExtension = ".json";
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyRole(ADMIN) {
}
function setBaseExtension(string memory _newBaseExtension) public onlyRole(ADMIN) {
}
//
//interface metadata
//
iTokenURI public interfaceOfTokenURI;
bool public useInterfaceMetadata = false;
function setInterfaceOfTokenURI(address _address) public onlyRole(ADMIN) {
}
function setUseInterfaceMetadata(bool _useInterfaceMetadata) public onlyRole(ADMIN) {
}
//
//token URI
//
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
//
//burnin' section
//
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
function externalMint(address _address , uint256 _amount ) external payable {
}
function externalBurn(uint256[] memory _burnTokenIds) external nonReentrant{
}
//
//sbt and opensea filter section
//
bool public isSBT = false;
function setIsSBT(bool _state) public onlyRole(ADMIN) {
}
function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override{
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function approve(address operator, uint256 tokenId) public virtual override {
require( isSBT == false , "approve is prohibited");
if(isLockMode == true){
require(<FILL_ME>)
}
super.approve(operator, tokenId);
}
//
//ERC721PsiAddressData section
//
// Mapping owner address to address data
mapping(address => AddressData) _addressData;
// Compiler will pack this into a single 256bit word.
struct AddressData {
// Realistically, 2**64-1 is more than enough.
uint64 balance;
// Keeps track of mint count with minimal overhead for tokenomics.
uint64 numberMinted;
// Keeps track of burn count with minimal overhead for tokenomics.
uint64 numberBurned;
// For miscellaneous variable(s) pertaining to the address
// (e.g. number of whitelist mint slots used).
// If there are multiple variables, please pack them into a uint64.
uint64 aux;
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address _owner)
public
view
virtual
override
returns (uint)
{
}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* 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` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override virtual {
}
//
//ERC721AntiScam section
//
bytes32 public constant ADMIN = keccak256("ADMIN");
function setEnebleRestrict(bool _enableRestrict )public onlyRole(ADMIN){
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function addLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function removeLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function getLocalContractAllowList()
external
override
view
returns(address[] memory)
{
}
function setCALLevel(uint256 level) public override onlyRole(ADMIN) {
}
function setCAL(address calAddress) external override onlyRole(ADMIN) {
}
//
//setDefaultRoyalty
//
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) public onlyOwner{
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC2981,ERC721RestrictApprove, AccessControl)
returns (bool)
{
}
}
| isLocked[tokenId]==false,"this tokenId is locked" | 247,018 | isLocked[tokenId]==false |
"invalid proof" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
import "./ERC721AQueryable.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract SMPLverseBase is
ERC721A,
ERC721AQueryable,
Ownable,
Pausable,
ReentrancyGuard
{
using SafeMath for uint256;
constructor() ERC721A("SMPLverse", "SMPL") {}
string private _baseTokenUri = "https://api.smplverse.xyz/metadata/";
uint256 public collectionSize = 511;
uint256 public mintPrice = 0.3 ether;
uint256 public whitelistMintPrice = 0.27 ether;
uint256 public maxMint = 10;
bytes32 public imageHash =
0xa6466d90d72e80d73c5879634bdb3f2c57854e72cd9687f15bffce5f4c3e381b;
address public devAddress = 0x2eD29d982B0120d49899a7cC7AfE7f5d5435bC97;
bytes32 public _merkleRoot =
0xa7ad73391aba9ddfe2dc8c372f4b605b8c95a20166d86616b3dc8f7744f9b7d7;
bool public whitelistMintOpen = false;
modifier onlyIfSendingEnoughEth(uint256 quantity) {
}
modifier onlyIfValidMerkleProof(bytes32[] calldata proof) {
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
_;
}
modifier onlyIfSendingEnoughEthWhitelist(uint256 quantity) {
}
modifier onlyWhenWhitelistMintOpen() {
}
modifier onlyIfThereSMPLsLeft(uint256 quantity) {
}
modifier callerIsUser() {
}
function _startTokenId() internal pure override returns (uint256) {
}
function baseTokenURI() public view virtual returns (string memory) {
}
function setBaseTokenURI(string memory _uri) external onlyOwner {
}
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
function toggleWhitelistMint() external onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function mint(uint256 quantity)
external
payable
onlyIfSendingEnoughEth(quantity)
onlyIfThereSMPLsLeft(quantity)
callerIsUser
whenNotPaused
{
}
function verifyProof(bytes32[] calldata proof, bytes32 leaf)
public
view
returns (bool)
{
}
function whitelistMint(uint256 quantity, bytes32[] calldata proof)
external
payable
onlyIfThereSMPLsLeft(quantity)
callerIsUser
whenNotPaused
onlyIfSendingEnoughEthWhitelist(quantity)
onlyWhenWhitelistMintOpen
onlyIfValidMerkleProof(proof)
{
}
function withdraw() external onlyOwner nonReentrant {
}
receive() external payable {}
}
| verifyProof(proof,leaf),"invalid proof" | 247,080 | verifyProof(proof,leaf) |
"Too many lilpals to adopt." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/structs/BitMaps.sol";
import "erc721a/contracts/ERC721A.sol";
contract LILPALS is ERC721A, EIP712, Ownable {
using ECDSA for bytes32;
using Strings for uint256;
uint256 public collectionSize;
uint256 public freeMintCount;
string public baseURI;
address private signerAddress;
address private withdrawAddress;
enum SalePhase {
Paused,
Free,
AllowList,
Public,
WhiteList
}
struct WhiteListInfo {
uint64 startTimestamp;
uint64 price;
uint64 maxMint;
uint64 phase;
uint256 whiteListMinted;
}
struct SaleConfig {
uint64 startTimestamp;
uint64 price;
uint64 maxMint;
SalePhase phase;
}
mapping(SalePhase => mapping(address => uint256)) public mintedCount;
SaleConfig public saleConfig;
SaleConfig public whiteListConfig;
constructor(
address _signerAddress,
address _withdrawAddress,
uint16 _collectionSize
) ERC721A("LILPALS", "LILPALS") EIP712("LILPALS", "1") {
}
function setSignerAddress(address newSignerAddress) external onlyOwner {
}
function setWithdrawAddress(address newWithdrawAddress) external onlyOwner {
}
modifier isAtSalePhase(SalePhase phase) {
}
modifier isAtSalePhaseWhite(SalePhase phase) {
}
function checkAndUpdateMintedCount(SalePhase phase, uint256 quantity)
private
{
unchecked {
require(<FILL_ME>)
mintedCount[phase][msg.sender] += quantity;
}
}
function checkAndUpdateMintedCountWhite(SalePhase phase, uint256 quantity)
private
{
}
modifier checkPrice(SalePhase phase, uint256 quantity) {
}
modifier checkPriceWhite(SalePhase phase, uint256 quantity) {
}
modifier callerIsUser() {
}
modifier isWithdrawAddress() {
}
function _hash(string memory _prefix, address _address)
internal
view
returns (bytes32)
{
}
function _verify(bytes32 hash, bytes memory signature)
internal
view
returns (bool)
{
}
function _recover(bytes32 hash, bytes memory signature)
internal
pure
returns (address)
{
}
function whiteListAdopt(
uint256 quantity,
bytes32 hash,
bytes calldata signature
)
external
payable
callerIsUser
isAtSalePhaseWhite(SalePhase.WhiteList)
checkPriceWhite(SalePhase.WhiteList, quantity)
{
}
function allowListAdopt(
uint256 quantity,
bytes32 hash,
bytes calldata signature
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.AllowList)
checkPrice(SalePhase.AllowList, quantity)
{
}
function freeAdopt(
uint256 quantity
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.Free)
checkPrice(SalePhase.Free, quantity)
{
}
function publicAdopt(
uint256 quantity
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.Public)
checkPrice(SalePhase.Public, quantity)
{
}
function startFreeSale(uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function startAllowlistSale(
uint64 price,
uint64 startTime,
uint64 maxMint
) external onlyOwner {
}
function startPublicSale(
uint64 price,
uint64 startTime,
uint64 maxMint
) external onlyOwner {
}
function setSaleConfig(SaleConfig calldata _saleConfig) external onlyOwner {
}
function startWhiteListSale(uint64 price,uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function pauseWhiteListSale(uint64 price,uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function setSaleConfigWhiteList(SaleConfig calldata _saleConfig) external onlyOwner {
}
function setFreeMintCount(uint64 _freeMintCount)
external
onlyOwner
{
}
function setCollectionSize(uint64 _collectionSize)
external
onlyOwner
{
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function withdraw(address beneficiary) external onlyOwner {
}
function withdraw() external isWithdrawAddress callerIsUser() {
}
function getMintedInfo(address _address)
external
view
returns (
uint256 freeMinted,
uint256 allowListMinted,
uint256 publicMinted,
uint256 totalMinted,
uint256 _collectionSize,
uint64 startTimestamp,
uint64 price,
uint64 maxMint,
uint64 phase,
WhiteListInfo memory _whiteListInfo
)
{
}
}
| mintedCount[phase][msg.sender]+quantity<=saleConfig.maxMint,"Too many lilpals to adopt." | 247,136 | mintedCount[phase][msg.sender]+quantity<=saleConfig.maxMint |
"Too many lilpals to adopt." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/structs/BitMaps.sol";
import "erc721a/contracts/ERC721A.sol";
contract LILPALS is ERC721A, EIP712, Ownable {
using ECDSA for bytes32;
using Strings for uint256;
uint256 public collectionSize;
uint256 public freeMintCount;
string public baseURI;
address private signerAddress;
address private withdrawAddress;
enum SalePhase {
Paused,
Free,
AllowList,
Public,
WhiteList
}
struct WhiteListInfo {
uint64 startTimestamp;
uint64 price;
uint64 maxMint;
uint64 phase;
uint256 whiteListMinted;
}
struct SaleConfig {
uint64 startTimestamp;
uint64 price;
uint64 maxMint;
SalePhase phase;
}
mapping(SalePhase => mapping(address => uint256)) public mintedCount;
SaleConfig public saleConfig;
SaleConfig public whiteListConfig;
constructor(
address _signerAddress,
address _withdrawAddress,
uint16 _collectionSize
) ERC721A("LILPALS", "LILPALS") EIP712("LILPALS", "1") {
}
function setSignerAddress(address newSignerAddress) external onlyOwner {
}
function setWithdrawAddress(address newWithdrawAddress) external onlyOwner {
}
modifier isAtSalePhase(SalePhase phase) {
}
modifier isAtSalePhaseWhite(SalePhase phase) {
}
function checkAndUpdateMintedCount(SalePhase phase, uint256 quantity)
private
{
}
function checkAndUpdateMintedCountWhite(SalePhase phase, uint256 quantity)
private
{
unchecked {
require(<FILL_ME>)
mintedCount[phase][msg.sender] += quantity;
}
}
modifier checkPrice(SalePhase phase, uint256 quantity) {
}
modifier checkPriceWhite(SalePhase phase, uint256 quantity) {
}
modifier callerIsUser() {
}
modifier isWithdrawAddress() {
}
function _hash(string memory _prefix, address _address)
internal
view
returns (bytes32)
{
}
function _verify(bytes32 hash, bytes memory signature)
internal
view
returns (bool)
{
}
function _recover(bytes32 hash, bytes memory signature)
internal
pure
returns (address)
{
}
function whiteListAdopt(
uint256 quantity,
bytes32 hash,
bytes calldata signature
)
external
payable
callerIsUser
isAtSalePhaseWhite(SalePhase.WhiteList)
checkPriceWhite(SalePhase.WhiteList, quantity)
{
}
function allowListAdopt(
uint256 quantity,
bytes32 hash,
bytes calldata signature
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.AllowList)
checkPrice(SalePhase.AllowList, quantity)
{
}
function freeAdopt(
uint256 quantity
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.Free)
checkPrice(SalePhase.Free, quantity)
{
}
function publicAdopt(
uint256 quantity
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.Public)
checkPrice(SalePhase.Public, quantity)
{
}
function startFreeSale(uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function startAllowlistSale(
uint64 price,
uint64 startTime,
uint64 maxMint
) external onlyOwner {
}
function startPublicSale(
uint64 price,
uint64 startTime,
uint64 maxMint
) external onlyOwner {
}
function setSaleConfig(SaleConfig calldata _saleConfig) external onlyOwner {
}
function startWhiteListSale(uint64 price,uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function pauseWhiteListSale(uint64 price,uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function setSaleConfigWhiteList(SaleConfig calldata _saleConfig) external onlyOwner {
}
function setFreeMintCount(uint64 _freeMintCount)
external
onlyOwner
{
}
function setCollectionSize(uint64 _collectionSize)
external
onlyOwner
{
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function withdraw(address beneficiary) external onlyOwner {
}
function withdraw() external isWithdrawAddress callerIsUser() {
}
function getMintedInfo(address _address)
external
view
returns (
uint256 freeMinted,
uint256 allowListMinted,
uint256 publicMinted,
uint256 totalMinted,
uint256 _collectionSize,
uint64 startTimestamp,
uint64 price,
uint64 maxMint,
uint64 phase,
WhiteListInfo memory _whiteListInfo
)
{
}
}
| mintedCount[phase][msg.sender]+quantity<=whiteListConfig.maxMint,"Too many lilpals to adopt." | 247,136 | mintedCount[phase][msg.sender]+quantity<=whiteListConfig.maxMint |
"Invalid hash." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/structs/BitMaps.sol";
import "erc721a/contracts/ERC721A.sol";
contract LILPALS is ERC721A, EIP712, Ownable {
using ECDSA for bytes32;
using Strings for uint256;
uint256 public collectionSize;
uint256 public freeMintCount;
string public baseURI;
address private signerAddress;
address private withdrawAddress;
enum SalePhase {
Paused,
Free,
AllowList,
Public,
WhiteList
}
struct WhiteListInfo {
uint64 startTimestamp;
uint64 price;
uint64 maxMint;
uint64 phase;
uint256 whiteListMinted;
}
struct SaleConfig {
uint64 startTimestamp;
uint64 price;
uint64 maxMint;
SalePhase phase;
}
mapping(SalePhase => mapping(address => uint256)) public mintedCount;
SaleConfig public saleConfig;
SaleConfig public whiteListConfig;
constructor(
address _signerAddress,
address _withdrawAddress,
uint16 _collectionSize
) ERC721A("LILPALS", "LILPALS") EIP712("LILPALS", "1") {
}
function setSignerAddress(address newSignerAddress) external onlyOwner {
}
function setWithdrawAddress(address newWithdrawAddress) external onlyOwner {
}
modifier isAtSalePhase(SalePhase phase) {
}
modifier isAtSalePhaseWhite(SalePhase phase) {
}
function checkAndUpdateMintedCount(SalePhase phase, uint256 quantity)
private
{
}
function checkAndUpdateMintedCountWhite(SalePhase phase, uint256 quantity)
private
{
}
modifier checkPrice(SalePhase phase, uint256 quantity) {
}
modifier checkPriceWhite(SalePhase phase, uint256 quantity) {
}
modifier callerIsUser() {
}
modifier isWithdrawAddress() {
}
function _hash(string memory _prefix, address _address)
internal
view
returns (bytes32)
{
}
function _verify(bytes32 hash, bytes memory signature)
internal
view
returns (bool)
{
}
function _recover(bytes32 hash, bytes memory signature)
internal
pure
returns (address)
{
}
function whiteListAdopt(
uint256 quantity,
bytes32 hash,
bytes calldata signature
)
external
payable
callerIsUser
isAtSalePhaseWhite(SalePhase.WhiteList)
checkPriceWhite(SalePhase.WhiteList, quantity)
{
checkAndUpdateMintedCountWhite(SalePhase.WhiteList, quantity);
require(<FILL_ME>)
require(_verify(hash, signature), "Invalid signature.");
unchecked {
require(
_totalMinted() + quantity <= collectionSize,
"Max supply reached."
);
}
_safeMint(msg.sender, quantity);
}
function allowListAdopt(
uint256 quantity,
bytes32 hash,
bytes calldata signature
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.AllowList)
checkPrice(SalePhase.AllowList, quantity)
{
}
function freeAdopt(
uint256 quantity
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.Free)
checkPrice(SalePhase.Free, quantity)
{
}
function publicAdopt(
uint256 quantity
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.Public)
checkPrice(SalePhase.Public, quantity)
{
}
function startFreeSale(uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function startAllowlistSale(
uint64 price,
uint64 startTime,
uint64 maxMint
) external onlyOwner {
}
function startPublicSale(
uint64 price,
uint64 startTime,
uint64 maxMint
) external onlyOwner {
}
function setSaleConfig(SaleConfig calldata _saleConfig) external onlyOwner {
}
function startWhiteListSale(uint64 price,uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function pauseWhiteListSale(uint64 price,uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function setSaleConfigWhiteList(SaleConfig calldata _saleConfig) external onlyOwner {
}
function setFreeMintCount(uint64 _freeMintCount)
external
onlyOwner
{
}
function setCollectionSize(uint64 _collectionSize)
external
onlyOwner
{
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function withdraw(address beneficiary) external onlyOwner {
}
function withdraw() external isWithdrawAddress callerIsUser() {
}
function getMintedInfo(address _address)
external
view
returns (
uint256 freeMinted,
uint256 allowListMinted,
uint256 publicMinted,
uint256 totalMinted,
uint256 _collectionSize,
uint64 startTimestamp,
uint64 price,
uint64 maxMint,
uint64 phase,
WhiteListInfo memory _whiteListInfo
)
{
}
}
| _hash("whiteList",msg.sender)==hash,"Invalid hash." | 247,136 | _hash("whiteList",msg.sender)==hash |
"Invalid signature." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/structs/BitMaps.sol";
import "erc721a/contracts/ERC721A.sol";
contract LILPALS is ERC721A, EIP712, Ownable {
using ECDSA for bytes32;
using Strings for uint256;
uint256 public collectionSize;
uint256 public freeMintCount;
string public baseURI;
address private signerAddress;
address private withdrawAddress;
enum SalePhase {
Paused,
Free,
AllowList,
Public,
WhiteList
}
struct WhiteListInfo {
uint64 startTimestamp;
uint64 price;
uint64 maxMint;
uint64 phase;
uint256 whiteListMinted;
}
struct SaleConfig {
uint64 startTimestamp;
uint64 price;
uint64 maxMint;
SalePhase phase;
}
mapping(SalePhase => mapping(address => uint256)) public mintedCount;
SaleConfig public saleConfig;
SaleConfig public whiteListConfig;
constructor(
address _signerAddress,
address _withdrawAddress,
uint16 _collectionSize
) ERC721A("LILPALS", "LILPALS") EIP712("LILPALS", "1") {
}
function setSignerAddress(address newSignerAddress) external onlyOwner {
}
function setWithdrawAddress(address newWithdrawAddress) external onlyOwner {
}
modifier isAtSalePhase(SalePhase phase) {
}
modifier isAtSalePhaseWhite(SalePhase phase) {
}
function checkAndUpdateMintedCount(SalePhase phase, uint256 quantity)
private
{
}
function checkAndUpdateMintedCountWhite(SalePhase phase, uint256 quantity)
private
{
}
modifier checkPrice(SalePhase phase, uint256 quantity) {
}
modifier checkPriceWhite(SalePhase phase, uint256 quantity) {
}
modifier callerIsUser() {
}
modifier isWithdrawAddress() {
}
function _hash(string memory _prefix, address _address)
internal
view
returns (bytes32)
{
}
function _verify(bytes32 hash, bytes memory signature)
internal
view
returns (bool)
{
}
function _recover(bytes32 hash, bytes memory signature)
internal
pure
returns (address)
{
}
function whiteListAdopt(
uint256 quantity,
bytes32 hash,
bytes calldata signature
)
external
payable
callerIsUser
isAtSalePhaseWhite(SalePhase.WhiteList)
checkPriceWhite(SalePhase.WhiteList, quantity)
{
checkAndUpdateMintedCountWhite(SalePhase.WhiteList, quantity);
require(_hash("whiteList", msg.sender) == hash, "Invalid hash.");
require(<FILL_ME>)
unchecked {
require(
_totalMinted() + quantity <= collectionSize,
"Max supply reached."
);
}
_safeMint(msg.sender, quantity);
}
function allowListAdopt(
uint256 quantity,
bytes32 hash,
bytes calldata signature
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.AllowList)
checkPrice(SalePhase.AllowList, quantity)
{
}
function freeAdopt(
uint256 quantity
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.Free)
checkPrice(SalePhase.Free, quantity)
{
}
function publicAdopt(
uint256 quantity
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.Public)
checkPrice(SalePhase.Public, quantity)
{
}
function startFreeSale(uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function startAllowlistSale(
uint64 price,
uint64 startTime,
uint64 maxMint
) external onlyOwner {
}
function startPublicSale(
uint64 price,
uint64 startTime,
uint64 maxMint
) external onlyOwner {
}
function setSaleConfig(SaleConfig calldata _saleConfig) external onlyOwner {
}
function startWhiteListSale(uint64 price,uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function pauseWhiteListSale(uint64 price,uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function setSaleConfigWhiteList(SaleConfig calldata _saleConfig) external onlyOwner {
}
function setFreeMintCount(uint64 _freeMintCount)
external
onlyOwner
{
}
function setCollectionSize(uint64 _collectionSize)
external
onlyOwner
{
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function withdraw(address beneficiary) external onlyOwner {
}
function withdraw() external isWithdrawAddress callerIsUser() {
}
function getMintedInfo(address _address)
external
view
returns (
uint256 freeMinted,
uint256 allowListMinted,
uint256 publicMinted,
uint256 totalMinted,
uint256 _collectionSize,
uint64 startTimestamp,
uint64 price,
uint64 maxMint,
uint64 phase,
WhiteListInfo memory _whiteListInfo
)
{
}
}
| _verify(hash,signature),"Invalid signature." | 247,136 | _verify(hash,signature) |
"Max supply reached." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/structs/BitMaps.sol";
import "erc721a/contracts/ERC721A.sol";
contract LILPALS is ERC721A, EIP712, Ownable {
using ECDSA for bytes32;
using Strings for uint256;
uint256 public collectionSize;
uint256 public freeMintCount;
string public baseURI;
address private signerAddress;
address private withdrawAddress;
enum SalePhase {
Paused,
Free,
AllowList,
Public,
WhiteList
}
struct WhiteListInfo {
uint64 startTimestamp;
uint64 price;
uint64 maxMint;
uint64 phase;
uint256 whiteListMinted;
}
struct SaleConfig {
uint64 startTimestamp;
uint64 price;
uint64 maxMint;
SalePhase phase;
}
mapping(SalePhase => mapping(address => uint256)) public mintedCount;
SaleConfig public saleConfig;
SaleConfig public whiteListConfig;
constructor(
address _signerAddress,
address _withdrawAddress,
uint16 _collectionSize
) ERC721A("LILPALS", "LILPALS") EIP712("LILPALS", "1") {
}
function setSignerAddress(address newSignerAddress) external onlyOwner {
}
function setWithdrawAddress(address newWithdrawAddress) external onlyOwner {
}
modifier isAtSalePhase(SalePhase phase) {
}
modifier isAtSalePhaseWhite(SalePhase phase) {
}
function checkAndUpdateMintedCount(SalePhase phase, uint256 quantity)
private
{
}
function checkAndUpdateMintedCountWhite(SalePhase phase, uint256 quantity)
private
{
}
modifier checkPrice(SalePhase phase, uint256 quantity) {
}
modifier checkPriceWhite(SalePhase phase, uint256 quantity) {
}
modifier callerIsUser() {
}
modifier isWithdrawAddress() {
}
function _hash(string memory _prefix, address _address)
internal
view
returns (bytes32)
{
}
function _verify(bytes32 hash, bytes memory signature)
internal
view
returns (bool)
{
}
function _recover(bytes32 hash, bytes memory signature)
internal
pure
returns (address)
{
}
function whiteListAdopt(
uint256 quantity,
bytes32 hash,
bytes calldata signature
)
external
payable
callerIsUser
isAtSalePhaseWhite(SalePhase.WhiteList)
checkPriceWhite(SalePhase.WhiteList, quantity)
{
checkAndUpdateMintedCountWhite(SalePhase.WhiteList, quantity);
require(_hash("whiteList", msg.sender) == hash, "Invalid hash.");
require(_verify(hash, signature), "Invalid signature.");
unchecked {
require(<FILL_ME>)
}
_safeMint(msg.sender, quantity);
}
function allowListAdopt(
uint256 quantity,
bytes32 hash,
bytes calldata signature
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.AllowList)
checkPrice(SalePhase.AllowList, quantity)
{
}
function freeAdopt(
uint256 quantity
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.Free)
checkPrice(SalePhase.Free, quantity)
{
}
function publicAdopt(
uint256 quantity
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.Public)
checkPrice(SalePhase.Public, quantity)
{
}
function startFreeSale(uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function startAllowlistSale(
uint64 price,
uint64 startTime,
uint64 maxMint
) external onlyOwner {
}
function startPublicSale(
uint64 price,
uint64 startTime,
uint64 maxMint
) external onlyOwner {
}
function setSaleConfig(SaleConfig calldata _saleConfig) external onlyOwner {
}
function startWhiteListSale(uint64 price,uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function pauseWhiteListSale(uint64 price,uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function setSaleConfigWhiteList(SaleConfig calldata _saleConfig) external onlyOwner {
}
function setFreeMintCount(uint64 _freeMintCount)
external
onlyOwner
{
}
function setCollectionSize(uint64 _collectionSize)
external
onlyOwner
{
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function withdraw(address beneficiary) external onlyOwner {
}
function withdraw() external isWithdrawAddress callerIsUser() {
}
function getMintedInfo(address _address)
external
view
returns (
uint256 freeMinted,
uint256 allowListMinted,
uint256 publicMinted,
uint256 totalMinted,
uint256 _collectionSize,
uint64 startTimestamp,
uint64 price,
uint64 maxMint,
uint64 phase,
WhiteListInfo memory _whiteListInfo
)
{
}
}
| _totalMinted()+quantity<=collectionSize,"Max supply reached." | 247,136 | _totalMinted()+quantity<=collectionSize |
"Invalid hash." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/structs/BitMaps.sol";
import "erc721a/contracts/ERC721A.sol";
contract LILPALS is ERC721A, EIP712, Ownable {
using ECDSA for bytes32;
using Strings for uint256;
uint256 public collectionSize;
uint256 public freeMintCount;
string public baseURI;
address private signerAddress;
address private withdrawAddress;
enum SalePhase {
Paused,
Free,
AllowList,
Public,
WhiteList
}
struct WhiteListInfo {
uint64 startTimestamp;
uint64 price;
uint64 maxMint;
uint64 phase;
uint256 whiteListMinted;
}
struct SaleConfig {
uint64 startTimestamp;
uint64 price;
uint64 maxMint;
SalePhase phase;
}
mapping(SalePhase => mapping(address => uint256)) public mintedCount;
SaleConfig public saleConfig;
SaleConfig public whiteListConfig;
constructor(
address _signerAddress,
address _withdrawAddress,
uint16 _collectionSize
) ERC721A("LILPALS", "LILPALS") EIP712("LILPALS", "1") {
}
function setSignerAddress(address newSignerAddress) external onlyOwner {
}
function setWithdrawAddress(address newWithdrawAddress) external onlyOwner {
}
modifier isAtSalePhase(SalePhase phase) {
}
modifier isAtSalePhaseWhite(SalePhase phase) {
}
function checkAndUpdateMintedCount(SalePhase phase, uint256 quantity)
private
{
}
function checkAndUpdateMintedCountWhite(SalePhase phase, uint256 quantity)
private
{
}
modifier checkPrice(SalePhase phase, uint256 quantity) {
}
modifier checkPriceWhite(SalePhase phase, uint256 quantity) {
}
modifier callerIsUser() {
}
modifier isWithdrawAddress() {
}
function _hash(string memory _prefix, address _address)
internal
view
returns (bytes32)
{
}
function _verify(bytes32 hash, bytes memory signature)
internal
view
returns (bool)
{
}
function _recover(bytes32 hash, bytes memory signature)
internal
pure
returns (address)
{
}
function whiteListAdopt(
uint256 quantity,
bytes32 hash,
bytes calldata signature
)
external
payable
callerIsUser
isAtSalePhaseWhite(SalePhase.WhiteList)
checkPriceWhite(SalePhase.WhiteList, quantity)
{
}
function allowListAdopt(
uint256 quantity,
bytes32 hash,
bytes calldata signature
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.AllowList)
checkPrice(SalePhase.AllowList, quantity)
{
checkAndUpdateMintedCount(SalePhase.AllowList, quantity);
require(<FILL_ME>)
require(_verify(hash, signature), "Invalid signature.");
unchecked {
require(
_totalMinted() + quantity <= collectionSize,
"Max supply reached."
);
}
_safeMint(msg.sender, quantity);
}
function freeAdopt(
uint256 quantity
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.Free)
checkPrice(SalePhase.Free, quantity)
{
}
function publicAdopt(
uint256 quantity
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.Public)
checkPrice(SalePhase.Public, quantity)
{
}
function startFreeSale(uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function startAllowlistSale(
uint64 price,
uint64 startTime,
uint64 maxMint
) external onlyOwner {
}
function startPublicSale(
uint64 price,
uint64 startTime,
uint64 maxMint
) external onlyOwner {
}
function setSaleConfig(SaleConfig calldata _saleConfig) external onlyOwner {
}
function startWhiteListSale(uint64 price,uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function pauseWhiteListSale(uint64 price,uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function setSaleConfigWhiteList(SaleConfig calldata _saleConfig) external onlyOwner {
}
function setFreeMintCount(uint64 _freeMintCount)
external
onlyOwner
{
}
function setCollectionSize(uint64 _collectionSize)
external
onlyOwner
{
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function withdraw(address beneficiary) external onlyOwner {
}
function withdraw() external isWithdrawAddress callerIsUser() {
}
function getMintedInfo(address _address)
external
view
returns (
uint256 freeMinted,
uint256 allowListMinted,
uint256 publicMinted,
uint256 totalMinted,
uint256 _collectionSize,
uint64 startTimestamp,
uint64 price,
uint64 maxMint,
uint64 phase,
WhiteListInfo memory _whiteListInfo
)
{
}
}
| _hash("allowList",msg.sender)==hash,"Invalid hash." | 247,136 | _hash("allowList",msg.sender)==hash |
"Free mint supply reached." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/structs/BitMaps.sol";
import "erc721a/contracts/ERC721A.sol";
contract LILPALS is ERC721A, EIP712, Ownable {
using ECDSA for bytes32;
using Strings for uint256;
uint256 public collectionSize;
uint256 public freeMintCount;
string public baseURI;
address private signerAddress;
address private withdrawAddress;
enum SalePhase {
Paused,
Free,
AllowList,
Public,
WhiteList
}
struct WhiteListInfo {
uint64 startTimestamp;
uint64 price;
uint64 maxMint;
uint64 phase;
uint256 whiteListMinted;
}
struct SaleConfig {
uint64 startTimestamp;
uint64 price;
uint64 maxMint;
SalePhase phase;
}
mapping(SalePhase => mapping(address => uint256)) public mintedCount;
SaleConfig public saleConfig;
SaleConfig public whiteListConfig;
constructor(
address _signerAddress,
address _withdrawAddress,
uint16 _collectionSize
) ERC721A("LILPALS", "LILPALS") EIP712("LILPALS", "1") {
}
function setSignerAddress(address newSignerAddress) external onlyOwner {
}
function setWithdrawAddress(address newWithdrawAddress) external onlyOwner {
}
modifier isAtSalePhase(SalePhase phase) {
}
modifier isAtSalePhaseWhite(SalePhase phase) {
}
function checkAndUpdateMintedCount(SalePhase phase, uint256 quantity)
private
{
}
function checkAndUpdateMintedCountWhite(SalePhase phase, uint256 quantity)
private
{
}
modifier checkPrice(SalePhase phase, uint256 quantity) {
}
modifier checkPriceWhite(SalePhase phase, uint256 quantity) {
}
modifier callerIsUser() {
}
modifier isWithdrawAddress() {
}
function _hash(string memory _prefix, address _address)
internal
view
returns (bytes32)
{
}
function _verify(bytes32 hash, bytes memory signature)
internal
view
returns (bool)
{
}
function _recover(bytes32 hash, bytes memory signature)
internal
pure
returns (address)
{
}
function whiteListAdopt(
uint256 quantity,
bytes32 hash,
bytes calldata signature
)
external
payable
callerIsUser
isAtSalePhaseWhite(SalePhase.WhiteList)
checkPriceWhite(SalePhase.WhiteList, quantity)
{
}
function allowListAdopt(
uint256 quantity,
bytes32 hash,
bytes calldata signature
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.AllowList)
checkPrice(SalePhase.AllowList, quantity)
{
}
function freeAdopt(
uint256 quantity
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.Free)
checkPrice(SalePhase.Free, quantity)
{
checkAndUpdateMintedCount(SalePhase.Free, quantity);
unchecked {
require(
_totalMinted() + quantity <= collectionSize,
"Max supply reached."
);
}
unchecked {
require(<FILL_ME>)
}
_safeMint(msg.sender, quantity);
}
function publicAdopt(
uint256 quantity
)
external
payable
callerIsUser
isAtSalePhase(SalePhase.Public)
checkPrice(SalePhase.Public, quantity)
{
}
function startFreeSale(uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function startAllowlistSale(
uint64 price,
uint64 startTime,
uint64 maxMint
) external onlyOwner {
}
function startPublicSale(
uint64 price,
uint64 startTime,
uint64 maxMint
) external onlyOwner {
}
function setSaleConfig(SaleConfig calldata _saleConfig) external onlyOwner {
}
function startWhiteListSale(uint64 price,uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function pauseWhiteListSale(uint64 price,uint64 startTime, uint64 maxMint)
external
onlyOwner
{
}
function setSaleConfigWhiteList(SaleConfig calldata _saleConfig) external onlyOwner {
}
function setFreeMintCount(uint64 _freeMintCount)
external
onlyOwner
{
}
function setCollectionSize(uint64 _collectionSize)
external
onlyOwner
{
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function withdraw(address beneficiary) external onlyOwner {
}
function withdraw() external isWithdrawAddress callerIsUser() {
}
function getMintedInfo(address _address)
external
view
returns (
uint256 freeMinted,
uint256 allowListMinted,
uint256 publicMinted,
uint256 totalMinted,
uint256 _collectionSize,
uint64 startTimestamp,
uint64 price,
uint64 maxMint,
uint64 phase,
WhiteListInfo memory _whiteListInfo
)
{
}
}
| _totalMinted()+quantity<=freeMintCount,"Free mint supply reached." | 247,136 | _totalMinted()+quantity<=freeMintCount |
"blacklisted" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.14;
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 ERC20 {
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 getOwner() external view returns (address);
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 payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
mapping (address => bool) internal authorizations;
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
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 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;
}
interface InterfaceLP {
function sync() external;
}
contract FOMO is Ownable, ERC20 {
using SafeMath for uint256;
address WETH;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "FOMO";
string constant _symbol = "FOMO";
uint8 constant _decimals = 18;
uint256 _totalSupply = 1 * 10**12 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply.mul(1).div(100);
uint256 public _maxWalletToken = _totalSupply.mul(1).div(100);
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
bool public blacklistMode = true;
mapping (address => bool) public isblacklisted;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
uint256 private liquidityFee = 1;
uint256 private marketingFee = 2;
uint256 private devFee = 0;
uint256 private teamFee = 0;
uint256 private burnFee = 0;
uint256 public totalFee = teamFee + marketingFee + liquidityFee + devFee + burnFee;
uint256 private feeDenominator = 100;
uint256 sellMultiplier = 2000;
uint256 buyMultiplier = 2600;
uint256 transferMultiplier = 100;
address private autoLiquidityReceiver;
address private marketingFeeReceiver;
address private devFeeReceiver;
address private teamFeeReceiver;
address private burnFeeReceiver;
uint256 targetLiquidity = 20;
uint256 targetLiquidityDenominator = 100;
IDEXRouter public router;
InterfaceLP private pairContract;
address public pair;
bool public TradingOpen = false;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 20 / 1000;
bool inSwap;
modifier swapping() { }
constructor () {
}
receive() external payable { }
function totalSupply() external view 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 getOwner() external view override returns (address) { }
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 approveMax(address spender) external 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 setMaxWallet(uint256 maxWallPercent) external onlyOwner {
}
function setMaxTx(uint256 maxTXPercent) external onlyOwner {
}
function setTxLimitAbsolute(uint256 amount) external onlyOwner {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
if(!authorizations[sender] && !authorizations[recipient]){
require(TradingOpen,"Trading not open yet");
}
if(blacklistMode){
require(<FILL_ME>)
}
if (!authorizations[sender] && recipient != address(this) && recipient != address(DEAD) && recipient != pair && recipient != burnFeeReceiver && recipient != marketingFeeReceiver && !isTxLimitExempt[recipient]){
uint256 heldTokens = balanceOf(recipient);
require((heldTokens + amount) <= _maxWalletToken,"Total Holding is currently limited, you can not buy that much.");}
// Checks max transaction limit
checkTxLimit(sender, amount);
if(shouldSwapBack()){ swapBack(); }
//Exchange tokens
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = (isFeeExempt[sender] || isFeeExempt[recipient]) ? amount : takeFee(sender, amount, recipient);
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(address sender, uint256 amount, address recipient) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckBalance(uint256 amountPercentage) external onlyOwner {
}
function manualSwap(uint256 amountPercentage) external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function manualSend() external onlyOwner {
}
function clearStuckToken(address tokenAddress, uint256 tokens) public returns (bool) {
}
function setPercents(uint256 _buy, uint256 _sell, uint256 _trans) external onlyOwner {
}
function enableTrading() public onlyOwner {
}
function swapBack() internal swapping {
}
function enable_blacklist(bool _status) public onlyOwner {
}
function manage_blacklist(address[] calldata addresses, bool status) public onlyOwner {
}
function feeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setBuyTax(uint256 _liquidityFee, uint256 _teamFee, uint256 _marketingFee, uint256 _devFee, uint256 _burnFee, uint256 _feeDenominator) external onlyOwner {
}
function setTaxWallets(address _autoLiquidityReceiver, address _marketingFeeReceiver, address _devFeeReceiver, address _burnFeeReceiver, address _teamFeeReceiver) external onlyOwner {
}
function setSwapandLiquify(bool _enabled, uint256 _amount) external onlyOwner {
}
function setTarget(uint256 _target, uint256 _denominator) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
}
function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
}
event AutoLiquify(uint256 amountETH, uint256 amountTokens);
}
| !isblacklisted[sender],"blacklisted" | 247,147 | !isblacklisted[sender] |
"Exceeds max mint per transaction" | pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./DefaultOperatorFilterer.sol";
contract DumpiesNFT is DefaultOperatorFilterer, ERC721A, Ownable {
using ECDSA for bytes32;
mapping(address => bool) hasClaimed;
mapping(address => uint256) numMinted;
uint256 public MAX_MINT = 2;
uint256 public COST = 29000000000000000;
uint256 public COLLECTION_SIZE = 6000;
uint256 public ADMIN_MINTS = 800;
bool public openForPublic;
address private signer;
address payable private DUMPIESWALLET;
uint256 public adminMints;
string internal baseURI;
struct URI {
string path;//the path
uint256 upto;//represents tokens from the top of the last URI upto this value
}
URI[] private URIs;
constructor() ERC721A("DumpiesNFT", "DUMPIESNFT"){
}
function mint(uint256 quantity, uint8 mintType, bytes memory signature) external payable {
require(mintType == 0);
require(quantity > 0, "Zero mint dissallowed");
require(<FILL_ME>)
require(_totalMinted() + quantity <= COLLECTION_SIZE - 800, "Mint would exceed collection size");
if(!openForPublic){
require(verify(msg.sender, mintType, signature), "ACCESS DENIED");
require(!hasClaimed[msg.sender], "ALREADY CLAIMED");
require(quantity == 1);
hasClaimed[msg.sender] = true;
}else{
require(quantity <= 2);
require(msg.value >= COST * quantity, "insufficient funds");
}
_mint(msg.sender, quantity);
numMinted[msg.sender] += quantity;
}
function verify(address user, uint8 mintType, bytes memory signature) private view returns (bool){
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function revealBatch(string memory newURI, uint256 upto) public onlyOwner{
}
function adminMint(uint256 quantity, address target) public onlyOwner{
}
function withdraw() public onlyOwner{
}
function setOpenForPublic() public onlyOwner{
}
function setSigner(address newSigner) public onlyOwner{
}
function setPlaceholder(string memory newURI) public onlyOwner{
}
function setPrice(uint256 newPrice) public onlyOwner{
}
//OVERRIDES FOR OPENSEA'S OPERATOR FILTERER
function setApprovalForAll(address operator, bool approved) public virtual override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public virtual override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
virtual
override
onlyAllowedOperator(from)
{
}
}
| quantity+numMinted[msg.sender]<=MAX_MINT,"Exceeds max mint per transaction" | 247,417 | quantity+numMinted[msg.sender]<=MAX_MINT |
"Mint would exceed collection size" | pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./DefaultOperatorFilterer.sol";
contract DumpiesNFT is DefaultOperatorFilterer, ERC721A, Ownable {
using ECDSA for bytes32;
mapping(address => bool) hasClaimed;
mapping(address => uint256) numMinted;
uint256 public MAX_MINT = 2;
uint256 public COST = 29000000000000000;
uint256 public COLLECTION_SIZE = 6000;
uint256 public ADMIN_MINTS = 800;
bool public openForPublic;
address private signer;
address payable private DUMPIESWALLET;
uint256 public adminMints;
string internal baseURI;
struct URI {
string path;//the path
uint256 upto;//represents tokens from the top of the last URI upto this value
}
URI[] private URIs;
constructor() ERC721A("DumpiesNFT", "DUMPIESNFT"){
}
function mint(uint256 quantity, uint8 mintType, bytes memory signature) external payable {
require(mintType == 0);
require(quantity > 0, "Zero mint dissallowed");
require(quantity + numMinted[msg.sender] <= MAX_MINT, "Exceeds max mint per transaction");
require(<FILL_ME>)
if(!openForPublic){
require(verify(msg.sender, mintType, signature), "ACCESS DENIED");
require(!hasClaimed[msg.sender], "ALREADY CLAIMED");
require(quantity == 1);
hasClaimed[msg.sender] = true;
}else{
require(quantity <= 2);
require(msg.value >= COST * quantity, "insufficient funds");
}
_mint(msg.sender, quantity);
numMinted[msg.sender] += quantity;
}
function verify(address user, uint8 mintType, bytes memory signature) private view returns (bool){
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function revealBatch(string memory newURI, uint256 upto) public onlyOwner{
}
function adminMint(uint256 quantity, address target) public onlyOwner{
}
function withdraw() public onlyOwner{
}
function setOpenForPublic() public onlyOwner{
}
function setSigner(address newSigner) public onlyOwner{
}
function setPlaceholder(string memory newURI) public onlyOwner{
}
function setPrice(uint256 newPrice) public onlyOwner{
}
//OVERRIDES FOR OPENSEA'S OPERATOR FILTERER
function setApprovalForAll(address operator, bool approved) public virtual override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public virtual override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
virtual
override
onlyAllowedOperator(from)
{
}
}
| _totalMinted()+quantity<=COLLECTION_SIZE-800,"Mint would exceed collection size" | 247,417 | _totalMinted()+quantity<=COLLECTION_SIZE-800 |
"ACCESS DENIED" | pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./DefaultOperatorFilterer.sol";
contract DumpiesNFT is DefaultOperatorFilterer, ERC721A, Ownable {
using ECDSA for bytes32;
mapping(address => bool) hasClaimed;
mapping(address => uint256) numMinted;
uint256 public MAX_MINT = 2;
uint256 public COST = 29000000000000000;
uint256 public COLLECTION_SIZE = 6000;
uint256 public ADMIN_MINTS = 800;
bool public openForPublic;
address private signer;
address payable private DUMPIESWALLET;
uint256 public adminMints;
string internal baseURI;
struct URI {
string path;//the path
uint256 upto;//represents tokens from the top of the last URI upto this value
}
URI[] private URIs;
constructor() ERC721A("DumpiesNFT", "DUMPIESNFT"){
}
function mint(uint256 quantity, uint8 mintType, bytes memory signature) external payable {
require(mintType == 0);
require(quantity > 0, "Zero mint dissallowed");
require(quantity + numMinted[msg.sender] <= MAX_MINT, "Exceeds max mint per transaction");
require(_totalMinted() + quantity <= COLLECTION_SIZE - 800, "Mint would exceed collection size");
if(!openForPublic){
require(<FILL_ME>)
require(!hasClaimed[msg.sender], "ALREADY CLAIMED");
require(quantity == 1);
hasClaimed[msg.sender] = true;
}else{
require(quantity <= 2);
require(msg.value >= COST * quantity, "insufficient funds");
}
_mint(msg.sender, quantity);
numMinted[msg.sender] += quantity;
}
function verify(address user, uint8 mintType, bytes memory signature) private view returns (bool){
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function revealBatch(string memory newURI, uint256 upto) public onlyOwner{
}
function adminMint(uint256 quantity, address target) public onlyOwner{
}
function withdraw() public onlyOwner{
}
function setOpenForPublic() public onlyOwner{
}
function setSigner(address newSigner) public onlyOwner{
}
function setPlaceholder(string memory newURI) public onlyOwner{
}
function setPrice(uint256 newPrice) public onlyOwner{
}
//OVERRIDES FOR OPENSEA'S OPERATOR FILTERER
function setApprovalForAll(address operator, bool approved) public virtual override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public virtual override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
virtual
override
onlyAllowedOperator(from)
{
}
}
| verify(msg.sender,mintType,signature),"ACCESS DENIED" | 247,417 | verify(msg.sender,mintType,signature) |
"Batch must not include existing batches" | pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./DefaultOperatorFilterer.sol";
contract DumpiesNFT is DefaultOperatorFilterer, ERC721A, Ownable {
using ECDSA for bytes32;
mapping(address => bool) hasClaimed;
mapping(address => uint256) numMinted;
uint256 public MAX_MINT = 2;
uint256 public COST = 29000000000000000;
uint256 public COLLECTION_SIZE = 6000;
uint256 public ADMIN_MINTS = 800;
bool public openForPublic;
address private signer;
address payable private DUMPIESWALLET;
uint256 public adminMints;
string internal baseURI;
struct URI {
string path;//the path
uint256 upto;//represents tokens from the top of the last URI upto this value
}
URI[] private URIs;
constructor() ERC721A("DumpiesNFT", "DUMPIESNFT"){
}
function mint(uint256 quantity, uint8 mintType, bytes memory signature) external payable {
}
function verify(address user, uint8 mintType, bytes memory signature) private view returns (bool){
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function revealBatch(string memory newURI, uint256 upto) public onlyOwner{
if(URIs.length > 0) require(<FILL_ME>)
require(upto <= _totalMinted(), "Batch includes unminted tokens");
URI memory uri = URI(newURI, upto);
URIs.push(uri);
}
function adminMint(uint256 quantity, address target) public onlyOwner{
}
function withdraw() public onlyOwner{
}
function setOpenForPublic() public onlyOwner{
}
function setSigner(address newSigner) public onlyOwner{
}
function setPlaceholder(string memory newURI) public onlyOwner{
}
function setPrice(uint256 newPrice) public onlyOwner{
}
//OVERRIDES FOR OPENSEA'S OPERATOR FILTERER
function setApprovalForAll(address operator, bool approved) public virtual override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public virtual override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
virtual
override
onlyAllowedOperator(from)
{
}
}
| URIs[URIs.length-1].upto<upto,"Batch must not include existing batches" | 247,417 | URIs[URIs.length-1].upto<upto |
"Would exceed collection size" | pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./DefaultOperatorFilterer.sol";
contract DumpiesNFT is DefaultOperatorFilterer, ERC721A, Ownable {
using ECDSA for bytes32;
mapping(address => bool) hasClaimed;
mapping(address => uint256) numMinted;
uint256 public MAX_MINT = 2;
uint256 public COST = 29000000000000000;
uint256 public COLLECTION_SIZE = 6000;
uint256 public ADMIN_MINTS = 800;
bool public openForPublic;
address private signer;
address payable private DUMPIESWALLET;
uint256 public adminMints;
string internal baseURI;
struct URI {
string path;//the path
uint256 upto;//represents tokens from the top of the last URI upto this value
}
URI[] private URIs;
constructor() ERC721A("DumpiesNFT", "DUMPIESNFT"){
}
function mint(uint256 quantity, uint8 mintType, bytes memory signature) external payable {
}
function verify(address user, uint8 mintType, bytes memory signature) private view returns (bool){
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function revealBatch(string memory newURI, uint256 upto) public onlyOwner{
}
function adminMint(uint256 quantity, address target) public onlyOwner{
require(<FILL_ME>)
adminMints += quantity;
_mint(target, quantity);
}
function withdraw() public onlyOwner{
}
function setOpenForPublic() public onlyOwner{
}
function setSigner(address newSigner) public onlyOwner{
}
function setPlaceholder(string memory newURI) public onlyOwner{
}
function setPrice(uint256 newPrice) public onlyOwner{
}
//OVERRIDES FOR OPENSEA'S OPERATOR FILTERER
function setApprovalForAll(address operator, bool approved) public virtual override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public virtual override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
virtual
override
onlyAllowedOperator(from)
{
}
}
| _totalMinted()+quantity<=COLLECTION_SIZE,"Would exceed collection size" | 247,417 | _totalMinted()+quantity<=COLLECTION_SIZE |
null | pragma solidity ^0.8.2;
import "IERC20.sol";
import "Ownable.sol";
import "IWethGateway.sol";
import "IClaim.sol";
import "IRouterV2.sol";
contract BendDaoStragegy is Ownable {
IERC20 public constant WETH = IERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
IERC20 public constant bendWETH = IERC20(0xeD1840223484483C0cb050E6fC344d1eBF0778a9);
IERC20 public constant debtBendWETH = IERC20(0x87ddE3A3f4b629E389ce5894c9A1F34A7eeC5648);
IERC20 public constant BEND = IERC20(0x0d02755a5700414B26FF040e1dE35D337DF56218);
IWethGateway public constant WETH_GATEWAY = IWethGateway(0x3B968D2D299B895A5Fcf3BBa7A64ad0F566e6F88);
IClaim public constant CLAIM_ADDRESS = IClaim(0x26FC1f11E612366d3367fc0cbFfF9e819da91C8d);
IRouterV2 public constant UNI_V2 = IRouterV2(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
mapping(address => bool) public authorised;
mapping(address => bool) public admin;
constructor() {
}
modifier isAuthorised() {
require(<FILL_ME>)
_;
}
modifier isAdmin() {
}
function setAuthorised(address _user, bool _val) external onlyOwner {
}
function setAdmin(address _admin, bool _val) external onlyOwner {
}
function deposit() external payable {
}
function withdraw() external {
}
function withdraw(uint256 _amount) public isAuthorised {
}
function emergencyWithdraw() public onlyOwner {
}
function harvest(uint256 _min) external isAuthorised {
}
function exec(address _target, uint256 _value, bytes calldata _data) external payable isAdmin {
}
receive() external payable {}
}
| authorised[msg.sender]||msg.sender==owner() | 247,462 | authorised[msg.sender]||msg.sender==owner() |
null | pragma solidity ^0.8.2;
import "IERC20.sol";
import "Ownable.sol";
import "IWethGateway.sol";
import "IClaim.sol";
import "IRouterV2.sol";
contract BendDaoStragegy is Ownable {
IERC20 public constant WETH = IERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
IERC20 public constant bendWETH = IERC20(0xeD1840223484483C0cb050E6fC344d1eBF0778a9);
IERC20 public constant debtBendWETH = IERC20(0x87ddE3A3f4b629E389ce5894c9A1F34A7eeC5648);
IERC20 public constant BEND = IERC20(0x0d02755a5700414B26FF040e1dE35D337DF56218);
IWethGateway public constant WETH_GATEWAY = IWethGateway(0x3B968D2D299B895A5Fcf3BBa7A64ad0F566e6F88);
IClaim public constant CLAIM_ADDRESS = IClaim(0x26FC1f11E612366d3367fc0cbFfF9e819da91C8d);
IRouterV2 public constant UNI_V2 = IRouterV2(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
mapping(address => bool) public authorised;
mapping(address => bool) public admin;
constructor() {
}
modifier isAuthorised() {
}
modifier isAdmin() {
require(<FILL_ME>)
_;
}
function setAuthorised(address _user, bool _val) external onlyOwner {
}
function setAdmin(address _admin, bool _val) external onlyOwner {
}
function deposit() external payable {
}
function withdraw() external {
}
function withdraw(uint256 _amount) public isAuthorised {
}
function emergencyWithdraw() public onlyOwner {
}
function harvest(uint256 _min) external isAuthorised {
}
function exec(address _target, uint256 _value, bytes calldata _data) external payable isAdmin {
}
receive() external payable {}
}
| admin[msg.sender]||msg.sender==owner() | 247,462 | admin[msg.sender]||msg.sender==owner() |
"Trading already enabled" | // SPDX-License-Identifier: Unlicensed
/**
https://t.me/grok15eth
https://twitter.com/elonmusk/status/1749481112076751120
*/
pragma solidity = 0.8.19;
//--- Interface for ERC20 ---//
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 getOwner() external view returns (address);
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 IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address _pairAddress, uint);
function getPair(address tokenA, address tokenB) external view returns (address _pairAddress);
function createPair(address tokenA, address tokenB) external returns (address _pairAddress);
}
//--- Context ---//
abstract contract Context {
constructor() {
}
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
//--- Ownable ---//
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IRouter01 {
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 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 swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
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 IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
//--- Contract ---//
contract GROK15 is Context, Ownable, IERC20 {
string constant private _name = "Grok1.5";
string constant private _symbol = "GROK1.5";
uint8 constant private _decimals = 9;
uint256 constant public _totalSupply = 10 ** 9 * 10**9;
uint256 constant _feeSwapMin = _totalSupply / 100_000;
address payable _feeAddress = payable(address(0x0C6AfAA25e45c3A9Ae6Ef779F8155146c1938CE8));
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
uint256 constant _transferFees = 0;
uint256 constant _denominator = 1_000;
uint256 private _mWallet = 25 * _totalSupply / 1000;
address _pairAddress;
IRouter02 _uniswapRouter;
bool _isTradingEnabled = false;
bool _inSwap;
bool _limitDeactivated = false;
uint256 private _buyFees = 210;
uint256 private _sellFees = 210;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) _addressWithNoTax;
mapping (address => bool) _checkLiqProvider;
mapping (address => bool) _checkLiqPair;
mapping (address => uint256) balance;
bool private swapEnabled = true;
modifier inSwaps {
}
constructor () {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _isaddyLimited(address ins, address out) internal view returns (bool) {
}
function swapBack(uint256 contractTokenBalance) internal inSwaps {
}
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 getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function shouldSwapBack(address ins) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function enableTrading() external onlyOwner {
require(<FILL_ME>)
_isTradingEnabled = true;
}
function removeTaxesAndLimits() external onlyOwner {
}
receive() external payable {}
function _isbuy(address ins, address out) internal view returns (bool) {
}
function _issell(address ins, address out) internal view returns (bool) {
}
function _istransfer(address ins, address out) internal view returns (bool) {
}
function _getFinalAmount(address from, bool isbuy, bool issell, uint256 amount) internal returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
}
| !_isTradingEnabled,"Trading already enabled" | 247,481 | !_isTradingEnabled |
"Already initalized" | // SPDX-License-Identifier: Unlicensed
/**
https://t.me/grok15eth
https://twitter.com/elonmusk/status/1749481112076751120
*/
pragma solidity = 0.8.19;
//--- Interface for ERC20 ---//
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 getOwner() external view returns (address);
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 IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address _pairAddress, uint);
function getPair(address tokenA, address tokenB) external view returns (address _pairAddress);
function createPair(address tokenA, address tokenB) external returns (address _pairAddress);
}
//--- Context ---//
abstract contract Context {
constructor() {
}
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
//--- Ownable ---//
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IRouter01 {
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 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 swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
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 IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
//--- Contract ---//
contract GROK15 is Context, Ownable, IERC20 {
string constant private _name = "Grok1.5";
string constant private _symbol = "GROK1.5";
uint8 constant private _decimals = 9;
uint256 constant public _totalSupply = 10 ** 9 * 10**9;
uint256 constant _feeSwapMin = _totalSupply / 100_000;
address payable _feeAddress = payable(address(0x0C6AfAA25e45c3A9Ae6Ef779F8155146c1938CE8));
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
uint256 constant _transferFees = 0;
uint256 constant _denominator = 1_000;
uint256 private _mWallet = 25 * _totalSupply / 1000;
address _pairAddress;
IRouter02 _uniswapRouter;
bool _isTradingEnabled = false;
bool _inSwap;
bool _limitDeactivated = false;
uint256 private _buyFees = 210;
uint256 private _sellFees = 210;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) _addressWithNoTax;
mapping (address => bool) _checkLiqProvider;
mapping (address => bool) _checkLiqPair;
mapping (address => uint256) balance;
bool private swapEnabled = true;
modifier inSwaps {
}
constructor () {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _isaddyLimited(address ins, address out) internal view returns (bool) {
}
function swapBack(uint256 contractTokenBalance) internal inSwaps {
}
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 getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function shouldSwapBack(address ins) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function enableTrading() external onlyOwner {
}
function removeTaxesAndLimits() external onlyOwner {
require(<FILL_ME>)
_mWallet = _totalSupply;
_limitDeactivated = true;
_buyFees = 0;
_sellFees = 0;
}
receive() external payable {}
function _isbuy(address ins, address out) internal view returns (bool) {
}
function _issell(address ins, address out) internal view returns (bool) {
}
function _istransfer(address ins, address out) internal view returns (bool) {
}
function _getFinalAmount(address from, bool isbuy, bool issell, uint256 amount) internal returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
}
| !_limitDeactivated,"Already initalized" | 247,481 | !_limitDeactivated |
"Only investors allowed" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract ReduxAirdropVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
event InvestorAdded(
address indexed investor,
address indexed caller,
uint256 allocation
);
event InvestorRemoved(
address indexed investor,
address indexed caller,
uint256 allocation
);
event WithdrawnTokens(address indexed investor, uint256 value);
event DepositInvestment(address indexed investor, uint256 value);
event TransferInvestment(address indexed owner, uint256 value);
event RecoverToken(address indexed token, uint256 indexed amount);
uint256 private totalAllocatedAmount;
uint256 private initialTimestamp;
IERC20 public REDUX;
struct Investor {
bool exists;
uint256 withdrawnTokens;
uint256 tokensAllotment;
}
mapping(address => Investor) public investorsInfo;
/// @dev Boolean variable that indicates whether the contract was initialized.
bool public isInitialized = false;
/// @dev Checks that the contract is initialized.
modifier initialized() {
}
/// @dev Checks that the contract is initialized.
modifier notInitialized() {
}
modifier onlyInvestor() {
require(<FILL_ME>)
_;
}
constructor(address _REDUX) {
}
function getInitialTimestamp() public view returns (uint256 timestamp) {
}
function updateVestingAmountForAirdrop(
address[] memory beneficiary,
uint256[] memory vestingAmount
) external onlyOwner {
}
/// @dev Adds investor. This function doesn't limit max gas consumption,
/// so adding too many investors can cause it to reach the out-of-gas error.
/// @param _investor The addresses of new investors.
/// @param _tokensAllotment The amounts of the tokens that belong to each investor.
function _addInvestor(address _investor, uint256 _tokensAllotment)
internal
{
}
function withdrawTokens() external onlyInvestor initialized {
}
/// @dev The starting time of TGE
/// @param _timestamp The initial timestamp, this timestap should be used for vesting
function setInitialTimestamp(uint256 _timestamp)
external
onlyOwner
notInitialized
{
}
function withdrawableTokens(address _investor)
public
view
returns (uint256 tokens)
{
}
function _calculatePercentage(uint256 _amount, uint256 _percentage)
private
pure
returns (uint256 percentage)
{
}
function _calculateAvailablePercentage()
private
view
returns (uint256 availablePercentage)
{
}
function recoverToken(address token, uint256 amount) external onlyOwner {
}
}
| investorsInfo[_msgSender()].exists,"Only investors allowed" | 247,489 | investorsInfo[_msgSender()].exists |
"Invalid EIP1271 order signature" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "../libraries/JamInteraction.sol";
import "../libraries/JamOrder.sol";
import "../libraries/JamHooks.sol";
import "../libraries/Signature.sol";
import "../libraries/common/BMath.sol";
import "lib/openzeppelin-contracts/contracts/interfaces/IERC1271.sol";
/// @title JamSigning
/// @notice Functions which handles the signing and validation of Jam orders
abstract contract JamSigning {
mapping(address => mapping(uint256 => uint256)) private standardNonces;
mapping(address => mapping(uint256 => uint256)) private limitOrdersNonces;
uint256 private constant INF_EXPIRY = 9999999999; // expiry for limit orders
bytes32 private constant DOMAIN_NAME = keccak256("JamSettlement");
bytes32 private constant DOMAIN_VERSION = keccak256("1");
bytes4 private constant EIP1271_MAGICVALUE = bytes4(keccak256("isValidSignature(bytes32,bytes)"));
uint256 private constant ETH_SIGN_HASH_PREFIX = 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000;
bytes32 public constant EIP712_DOMAIN_TYPEHASH = keccak256(abi.encodePacked(
"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
));
bytes32 public constant JAM_ORDER_TYPE_HASH = keccak256(abi.encodePacked(
"JamOrder(address taker,address receiver,uint256 expiry,uint256 nonce,address executor,uint16 minFillPercent,bytes32 hooksHash,address[] sellTokens,address[] buyTokens,uint256[] sellAmounts,uint256[] buyAmounts,uint256[] sellNFTIds,uint256[] buyNFTIds,bytes sellTokenTransfers,bytes buyTokenTransfers)"
));
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
constructor(){
}
/// @notice The domain separator used in the order validation signature
/// @return The domain separator used in encoding of order signature
function DOMAIN_SEPARATOR() public view returns (bytes32) {
}
/// @notice Hash beforeSettle and afterSettle interactions
/// @param hooks pre and post interactions to hash
/// @return The hash of the interactions
function hashHooks(JamHooks.Def memory hooks) public pure returns (bytes32) {
}
/// @notice Hash the order info and hooks
/// @param order The order to hash
/// @param hooksHash The hash of the hooks
/// @return The hash of the order
function hashOrder(JamOrder.Data calldata order, bytes32 hooksHash) public view returns (bytes32) {
}
/// @notice Validate the order signature
/// @param validationAddress The address to validate the signature against
/// @param hash The hash of the order
/// @param signature The signature to validate
function validateSignature(address validationAddress, bytes32 hash, Signature.TypedSignature calldata signature) public view {
if (signature.signatureType == Signature.Type.EIP712) {
(bytes32 r, bytes32 s, uint8 v) = Signature.getRsv(signature.signatureBytes);
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "Invalid signer");
if (signer != validationAddress) {
revert("Invalid EIP712 order signature");
}
} else if (signature.signatureType == Signature.Type.EIP1271) {
require(<FILL_ME>)
} else if (signature.signatureType == Signature.Type.ETHSIGN) {
bytes32 ethSignHash;
assembly {
mstore(0, ETH_SIGN_HASH_PREFIX) // length of 28 bytes
mstore(28, hash) // length of 32 bytes
ethSignHash := keccak256(0, 60)
}
(bytes32 r, bytes32 s, uint8 v) = Signature.getRsv(signature.signatureBytes);
address signer = ecrecover(ethSignHash, v, r, s);
require(signer != address(0), "Invalid signer");
if (signer != validationAddress) {
revert("Invalid ETHSIGH order signature");
}
} else {
revert("Invalid Signature Type");
}
}
/// @notice validate all information about the order
/// @param order The order to validate
/// @param hooks User's hooks to validate
/// @param signature The signature to check against
/// @param curFillPercent Solver/Maker fill percent
function validateOrder(
JamOrder.Data calldata order, JamHooks.Def memory hooks, Signature.TypedSignature calldata signature, uint16 curFillPercent
) internal {
}
/// @notice Cancel limit order by invalidating nonce for the sender address
/// @param nonce The nonce to invalidate
function cancelLimitOrder(uint256 nonce) external {
}
/// @notice Check if taker's limit order nonce is valid
/// @param taker address
/// @param nonce to check
/// @return True if nonce is valid
function isLimitOrderNonceValid(address taker, uint256 nonce) external view returns (bool) {
}
/// @notice Check if nonce is valid and invalidate it
/// @param taker address
/// @param nonce The nonce to invalidate
/// @param isLimitOrder True if it is a limit order
function invalidateOrderNonce(address taker, uint256 nonce, bool isLimitOrder) private {
}
/// @notice validate if increased amounts are more than initial amounts that user signed
/// @param increasedAmounts The increased amounts to validate (if empty, return initial amounts)
/// @param initialAmounts The initial amounts to validate against
/// @return The increased amounts if exist, otherwise the initial amounts
function validateIncreasedAmounts(
uint256[] calldata increasedAmounts, uint256[] calldata initialAmounts
) internal returns (uint256[] calldata){
}
/// @notice validate all information about the batch of orders
/// @param orders to validate
/// @param hooks All takers hooks to validate
/// @param signatures All takers signatures to check against
/// @param curFillPercents Partial fill percent for each order
function validateBatchOrders(
JamOrder.Data[] calldata orders, JamHooks.Def[] calldata hooks, Signature.TypedSignature[] calldata signatures,
Signature.TakerPermitsInfo[] calldata takersPermitsInfo, bool[] calldata takersPermitsUsage, uint16[] calldata curFillPercents
) internal {
}
}
| IERC1271(validationAddress).isValidSignature(hash,signature.signatureBytes)==EIP1271_MAGICVALUE,"Invalid EIP1271 order signature" | 247,663 | IERC1271(validationAddress).isValidSignature(hash,signature.signatureBytes)==EIP1271_MAGICVALUE |
"INVALID_NONCE" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "../libraries/JamInteraction.sol";
import "../libraries/JamOrder.sol";
import "../libraries/JamHooks.sol";
import "../libraries/Signature.sol";
import "../libraries/common/BMath.sol";
import "lib/openzeppelin-contracts/contracts/interfaces/IERC1271.sol";
/// @title JamSigning
/// @notice Functions which handles the signing and validation of Jam orders
abstract contract JamSigning {
mapping(address => mapping(uint256 => uint256)) private standardNonces;
mapping(address => mapping(uint256 => uint256)) private limitOrdersNonces;
uint256 private constant INF_EXPIRY = 9999999999; // expiry for limit orders
bytes32 private constant DOMAIN_NAME = keccak256("JamSettlement");
bytes32 private constant DOMAIN_VERSION = keccak256("1");
bytes4 private constant EIP1271_MAGICVALUE = bytes4(keccak256("isValidSignature(bytes32,bytes)"));
uint256 private constant ETH_SIGN_HASH_PREFIX = 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000;
bytes32 public constant EIP712_DOMAIN_TYPEHASH = keccak256(abi.encodePacked(
"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
));
bytes32 public constant JAM_ORDER_TYPE_HASH = keccak256(abi.encodePacked(
"JamOrder(address taker,address receiver,uint256 expiry,uint256 nonce,address executor,uint16 minFillPercent,bytes32 hooksHash,address[] sellTokens,address[] buyTokens,uint256[] sellAmounts,uint256[] buyAmounts,uint256[] sellNFTIds,uint256[] buyNFTIds,bytes sellTokenTransfers,bytes buyTokenTransfers)"
));
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
constructor(){
}
/// @notice The domain separator used in the order validation signature
/// @return The domain separator used in encoding of order signature
function DOMAIN_SEPARATOR() public view returns (bytes32) {
}
/// @notice Hash beforeSettle and afterSettle interactions
/// @param hooks pre and post interactions to hash
/// @return The hash of the interactions
function hashHooks(JamHooks.Def memory hooks) public pure returns (bytes32) {
}
/// @notice Hash the order info and hooks
/// @param order The order to hash
/// @param hooksHash The hash of the hooks
/// @return The hash of the order
function hashOrder(JamOrder.Data calldata order, bytes32 hooksHash) public view returns (bytes32) {
}
/// @notice Validate the order signature
/// @param validationAddress The address to validate the signature against
/// @param hash The hash of the order
/// @param signature The signature to validate
function validateSignature(address validationAddress, bytes32 hash, Signature.TypedSignature calldata signature) public view {
}
/// @notice validate all information about the order
/// @param order The order to validate
/// @param hooks User's hooks to validate
/// @param signature The signature to check against
/// @param curFillPercent Solver/Maker fill percent
function validateOrder(
JamOrder.Data calldata order, JamHooks.Def memory hooks, Signature.TypedSignature calldata signature, uint16 curFillPercent
) internal {
}
/// @notice Cancel limit order by invalidating nonce for the sender address
/// @param nonce The nonce to invalidate
function cancelLimitOrder(uint256 nonce) external {
}
/// @notice Check if taker's limit order nonce is valid
/// @param taker address
/// @param nonce to check
/// @return True if nonce is valid
function isLimitOrderNonceValid(address taker, uint256 nonce) external view returns (bool) {
}
/// @notice Check if nonce is valid and invalidate it
/// @param taker address
/// @param nonce The nonce to invalidate
/// @param isLimitOrder True if it is a limit order
function invalidateOrderNonce(address taker, uint256 nonce, bool isLimitOrder) private {
require(nonce != 0, "ZERO_NONCE");
uint256 invalidatorSlot = nonce >> 8;
uint256 invalidatorBit = 1 << (nonce & 0xff);
mapping(uint256 => uint256) storage invalidNonces = isLimitOrder ? limitOrdersNonces[taker] : standardNonces[taker];
uint256 invalidator = invalidNonces[invalidatorSlot];
require(<FILL_ME>)
invalidNonces[invalidatorSlot] = invalidator | invalidatorBit;
}
/// @notice validate if increased amounts are more than initial amounts that user signed
/// @param increasedAmounts The increased amounts to validate (if empty, return initial amounts)
/// @param initialAmounts The initial amounts to validate against
/// @return The increased amounts if exist, otherwise the initial amounts
function validateIncreasedAmounts(
uint256[] calldata increasedAmounts, uint256[] calldata initialAmounts
) internal returns (uint256[] calldata){
}
/// @notice validate all information about the batch of orders
/// @param orders to validate
/// @param hooks All takers hooks to validate
/// @param signatures All takers signatures to check against
/// @param curFillPercents Partial fill percent for each order
function validateBatchOrders(
JamOrder.Data[] calldata orders, JamHooks.Def[] calldata hooks, Signature.TypedSignature[] calldata signatures,
Signature.TakerPermitsInfo[] calldata takersPermitsInfo, bool[] calldata takersPermitsUsage, uint16[] calldata curFillPercents
) internal {
}
}
| invalidator&invalidatorBit!=invalidatorBit,"INVALID_NONCE" | 247,663 | invalidator&invalidatorBit!=invalidatorBit |
"INVALID_INCREASED_AMOUNTS" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "../libraries/JamInteraction.sol";
import "../libraries/JamOrder.sol";
import "../libraries/JamHooks.sol";
import "../libraries/Signature.sol";
import "../libraries/common/BMath.sol";
import "lib/openzeppelin-contracts/contracts/interfaces/IERC1271.sol";
/// @title JamSigning
/// @notice Functions which handles the signing and validation of Jam orders
abstract contract JamSigning {
mapping(address => mapping(uint256 => uint256)) private standardNonces;
mapping(address => mapping(uint256 => uint256)) private limitOrdersNonces;
uint256 private constant INF_EXPIRY = 9999999999; // expiry for limit orders
bytes32 private constant DOMAIN_NAME = keccak256("JamSettlement");
bytes32 private constant DOMAIN_VERSION = keccak256("1");
bytes4 private constant EIP1271_MAGICVALUE = bytes4(keccak256("isValidSignature(bytes32,bytes)"));
uint256 private constant ETH_SIGN_HASH_PREFIX = 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000;
bytes32 public constant EIP712_DOMAIN_TYPEHASH = keccak256(abi.encodePacked(
"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
));
bytes32 public constant JAM_ORDER_TYPE_HASH = keccak256(abi.encodePacked(
"JamOrder(address taker,address receiver,uint256 expiry,uint256 nonce,address executor,uint16 minFillPercent,bytes32 hooksHash,address[] sellTokens,address[] buyTokens,uint256[] sellAmounts,uint256[] buyAmounts,uint256[] sellNFTIds,uint256[] buyNFTIds,bytes sellTokenTransfers,bytes buyTokenTransfers)"
));
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
constructor(){
}
/// @notice The domain separator used in the order validation signature
/// @return The domain separator used in encoding of order signature
function DOMAIN_SEPARATOR() public view returns (bytes32) {
}
/// @notice Hash beforeSettle and afterSettle interactions
/// @param hooks pre and post interactions to hash
/// @return The hash of the interactions
function hashHooks(JamHooks.Def memory hooks) public pure returns (bytes32) {
}
/// @notice Hash the order info and hooks
/// @param order The order to hash
/// @param hooksHash The hash of the hooks
/// @return The hash of the order
function hashOrder(JamOrder.Data calldata order, bytes32 hooksHash) public view returns (bytes32) {
}
/// @notice Validate the order signature
/// @param validationAddress The address to validate the signature against
/// @param hash The hash of the order
/// @param signature The signature to validate
function validateSignature(address validationAddress, bytes32 hash, Signature.TypedSignature calldata signature) public view {
}
/// @notice validate all information about the order
/// @param order The order to validate
/// @param hooks User's hooks to validate
/// @param signature The signature to check against
/// @param curFillPercent Solver/Maker fill percent
function validateOrder(
JamOrder.Data calldata order, JamHooks.Def memory hooks, Signature.TypedSignature calldata signature, uint16 curFillPercent
) internal {
}
/// @notice Cancel limit order by invalidating nonce for the sender address
/// @param nonce The nonce to invalidate
function cancelLimitOrder(uint256 nonce) external {
}
/// @notice Check if taker's limit order nonce is valid
/// @param taker address
/// @param nonce to check
/// @return True if nonce is valid
function isLimitOrderNonceValid(address taker, uint256 nonce) external view returns (bool) {
}
/// @notice Check if nonce is valid and invalidate it
/// @param taker address
/// @param nonce The nonce to invalidate
/// @param isLimitOrder True if it is a limit order
function invalidateOrderNonce(address taker, uint256 nonce, bool isLimitOrder) private {
}
/// @notice validate if increased amounts are more than initial amounts that user signed
/// @param increasedAmounts The increased amounts to validate (if empty, return initial amounts)
/// @param initialAmounts The initial amounts to validate against
/// @return The increased amounts if exist, otherwise the initial amounts
function validateIncreasedAmounts(
uint256[] calldata increasedAmounts, uint256[] calldata initialAmounts
) internal returns (uint256[] calldata){
if (increasedAmounts.length == 0) {
return initialAmounts;
}
require(increasedAmounts.length == initialAmounts.length, "INVALID_INCREASED_AMOUNTS_LENGTH");
for (uint256 i; i < increasedAmounts.length; ++i) {
require(<FILL_ME>)
}
return increasedAmounts;
}
/// @notice validate all information about the batch of orders
/// @param orders to validate
/// @param hooks All takers hooks to validate
/// @param signatures All takers signatures to check against
/// @param curFillPercents Partial fill percent for each order
function validateBatchOrders(
JamOrder.Data[] calldata orders, JamHooks.Def[] calldata hooks, Signature.TypedSignature[] calldata signatures,
Signature.TakerPermitsInfo[] calldata takersPermitsInfo, bool[] calldata takersPermitsUsage, uint16[] calldata curFillPercents
) internal {
}
}
| increasedAmounts[i]>=initialAmounts[i],"INVALID_INCREASED_AMOUNTS" | 247,663 | increasedAmounts[i]>=initialAmounts[i] |
"INVALID_RECEIVER_FOR_BATCH_SETTLE" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "../libraries/JamInteraction.sol";
import "../libraries/JamOrder.sol";
import "../libraries/JamHooks.sol";
import "../libraries/Signature.sol";
import "../libraries/common/BMath.sol";
import "lib/openzeppelin-contracts/contracts/interfaces/IERC1271.sol";
/// @title JamSigning
/// @notice Functions which handles the signing and validation of Jam orders
abstract contract JamSigning {
mapping(address => mapping(uint256 => uint256)) private standardNonces;
mapping(address => mapping(uint256 => uint256)) private limitOrdersNonces;
uint256 private constant INF_EXPIRY = 9999999999; // expiry for limit orders
bytes32 private constant DOMAIN_NAME = keccak256("JamSettlement");
bytes32 private constant DOMAIN_VERSION = keccak256("1");
bytes4 private constant EIP1271_MAGICVALUE = bytes4(keccak256("isValidSignature(bytes32,bytes)"));
uint256 private constant ETH_SIGN_HASH_PREFIX = 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000;
bytes32 public constant EIP712_DOMAIN_TYPEHASH = keccak256(abi.encodePacked(
"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
));
bytes32 public constant JAM_ORDER_TYPE_HASH = keccak256(abi.encodePacked(
"JamOrder(address taker,address receiver,uint256 expiry,uint256 nonce,address executor,uint16 minFillPercent,bytes32 hooksHash,address[] sellTokens,address[] buyTokens,uint256[] sellAmounts,uint256[] buyAmounts,uint256[] sellNFTIds,uint256[] buyNFTIds,bytes sellTokenTransfers,bytes buyTokenTransfers)"
));
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
constructor(){
}
/// @notice The domain separator used in the order validation signature
/// @return The domain separator used in encoding of order signature
function DOMAIN_SEPARATOR() public view returns (bytes32) {
}
/// @notice Hash beforeSettle and afterSettle interactions
/// @param hooks pre and post interactions to hash
/// @return The hash of the interactions
function hashHooks(JamHooks.Def memory hooks) public pure returns (bytes32) {
}
/// @notice Hash the order info and hooks
/// @param order The order to hash
/// @param hooksHash The hash of the hooks
/// @return The hash of the order
function hashOrder(JamOrder.Data calldata order, bytes32 hooksHash) public view returns (bytes32) {
}
/// @notice Validate the order signature
/// @param validationAddress The address to validate the signature against
/// @param hash The hash of the order
/// @param signature The signature to validate
function validateSignature(address validationAddress, bytes32 hash, Signature.TypedSignature calldata signature) public view {
}
/// @notice validate all information about the order
/// @param order The order to validate
/// @param hooks User's hooks to validate
/// @param signature The signature to check against
/// @param curFillPercent Solver/Maker fill percent
function validateOrder(
JamOrder.Data calldata order, JamHooks.Def memory hooks, Signature.TypedSignature calldata signature, uint16 curFillPercent
) internal {
}
/// @notice Cancel limit order by invalidating nonce for the sender address
/// @param nonce The nonce to invalidate
function cancelLimitOrder(uint256 nonce) external {
}
/// @notice Check if taker's limit order nonce is valid
/// @param taker address
/// @param nonce to check
/// @return True if nonce is valid
function isLimitOrderNonceValid(address taker, uint256 nonce) external view returns (bool) {
}
/// @notice Check if nonce is valid and invalidate it
/// @param taker address
/// @param nonce The nonce to invalidate
/// @param isLimitOrder True if it is a limit order
function invalidateOrderNonce(address taker, uint256 nonce, bool isLimitOrder) private {
}
/// @notice validate if increased amounts are more than initial amounts that user signed
/// @param increasedAmounts The increased amounts to validate (if empty, return initial amounts)
/// @param initialAmounts The initial amounts to validate against
/// @return The increased amounts if exist, otherwise the initial amounts
function validateIncreasedAmounts(
uint256[] calldata increasedAmounts, uint256[] calldata initialAmounts
) internal returns (uint256[] calldata){
}
/// @notice validate all information about the batch of orders
/// @param orders to validate
/// @param hooks All takers hooks to validate
/// @param signatures All takers signatures to check against
/// @param curFillPercents Partial fill percent for each order
function validateBatchOrders(
JamOrder.Data[] calldata orders, JamHooks.Def[] calldata hooks, Signature.TypedSignature[] calldata signatures,
Signature.TakerPermitsInfo[] calldata takersPermitsInfo, bool[] calldata takersPermitsUsage, uint16[] calldata curFillPercents
) internal {
bool isMaxFill = curFillPercents.length == 0;
bool noHooks = hooks.length == 0;
bool allTakersWithoutPermits = takersPermitsUsage.length == 0;
require(orders.length == signatures.length, "INVALID_SIGNATURES_LENGTH");
require(orders.length == takersPermitsUsage.length || allTakersWithoutPermits, "INVALID_TAKERS_PERMITS_USAGE_LENGTH");
require(orders.length == hooks.length || noHooks, "INVALID_HOOKS_LENGTH");
require(orders.length == curFillPercents.length || isMaxFill, "INVALID_FILL_PERCENTS_LENGTH");
uint takersWithPermits;
for (uint i; i < orders.length; ++i) {
require(<FILL_ME>)
validateOrder(
orders[i], noHooks ? JamHooks.Def(new JamInteraction.Data[](0), new JamInteraction.Data[](0)) : hooks[i],
signatures[i], isMaxFill ? BMath.HUNDRED_PERCENT : curFillPercents[i]
);
if (!allTakersWithoutPermits && takersPermitsUsage[i]){
++takersWithPermits;
}
}
require(takersPermitsInfo.length == takersWithPermits, "INVALID_TAKERS_PERMITS_LENGTH");
}
}
| orders[i].receiver!=address(this),"INVALID_RECEIVER_FOR_BATCH_SETTLE" | 247,663 | orders[i].receiver!=address(this) |
"ERC20: initial token name can not be empty!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import "./interfaces/IWrappedERC20.sol";
/// @title A custom ERC20 contract used in the bridge
contract WrappedERC20 is IWrappedERC20, ERC20Upgradeable {
address internal _bridge;
uint8 internal _decimals;
string internal _tokenName;
string internal _tokenSymbol;
/// @dev Checks if the caller is the bridge contract
modifier onlyBridge {
}
/// @dev Creates an "empty" template token that will be cloned in the future
/// @dev Upgrades an "empty" template. Initializes internal variables.
/// @param name_ The name of the token
/// @param symbol_ The symbol of the token
/// @param decimals_ Number of decimals of the token
/// @param bridge_ The address of the bridge of the tokens
function initialize(
string memory name_,
string memory symbol_,
uint8 decimals_,
address bridge_
) external initializer {
require(<FILL_ME>)
require(bytes(symbol_).length > 0, "ERC20: initial token symbol can not be empty!");
require(decimals_ > 0, "ERC20: initial decimals can not be zero!");
require(bridge_ != address(0), "ERC20: initial bridge address can not be a zero address!");
_decimals = decimals_;
_bridge = bridge_;
_tokenName = name_;
_tokenSymbol = symbol_;
}
/// @notice Returns the name of the token
/// @return The name of the token
function name() public view override(ERC20Upgradeable, IWrappedERC20) returns(string memory) {
}
/// @notice Returns the symbol of the token
/// @return The symbol of the token
function symbol() public view override(ERC20Upgradeable, IWrappedERC20) returns(string memory) {
}
/// @notice Returns number of decimals of the token
/// @return The number of decimals of the token
function decimals() public view override(ERC20Upgradeable, IWrappedERC20) returns(uint8) {
}
/// @notice Creates tokens and assigns them to account, increasing the total supply.
/// @param to The receiver of tokens
/// @param amount The amount of tokens to mint
function mint(address to, uint256 amount) external onlyBridge {
}
/// @notice Returns the address of the bridge
/// @return The address of the bridge
function bridge() external view returns(address) {
}
/// @notice Destroys tokens from account, reducing the total supply.
/// @param from The address holding the tokens
/// @param amount The amount of tokens to burn
function burn(address from, uint256 amount) external onlyBridge {
}
}
| bytes(name_).length>0,"ERC20: initial token name can not be empty!" | 248,130 | bytes(name_).length>0 |
"ERC20: initial token symbol can not be empty!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import "./interfaces/IWrappedERC20.sol";
/// @title A custom ERC20 contract used in the bridge
contract WrappedERC20 is IWrappedERC20, ERC20Upgradeable {
address internal _bridge;
uint8 internal _decimals;
string internal _tokenName;
string internal _tokenSymbol;
/// @dev Checks if the caller is the bridge contract
modifier onlyBridge {
}
/// @dev Creates an "empty" template token that will be cloned in the future
/// @dev Upgrades an "empty" template. Initializes internal variables.
/// @param name_ The name of the token
/// @param symbol_ The symbol of the token
/// @param decimals_ Number of decimals of the token
/// @param bridge_ The address of the bridge of the tokens
function initialize(
string memory name_,
string memory symbol_,
uint8 decimals_,
address bridge_
) external initializer {
require(bytes(name_).length > 0, "ERC20: initial token name can not be empty!");
require(<FILL_ME>)
require(decimals_ > 0, "ERC20: initial decimals can not be zero!");
require(bridge_ != address(0), "ERC20: initial bridge address can not be a zero address!");
_decimals = decimals_;
_bridge = bridge_;
_tokenName = name_;
_tokenSymbol = symbol_;
}
/// @notice Returns the name of the token
/// @return The name of the token
function name() public view override(ERC20Upgradeable, IWrappedERC20) returns(string memory) {
}
/// @notice Returns the symbol of the token
/// @return The symbol of the token
function symbol() public view override(ERC20Upgradeable, IWrappedERC20) returns(string memory) {
}
/// @notice Returns number of decimals of the token
/// @return The number of decimals of the token
function decimals() public view override(ERC20Upgradeable, IWrappedERC20) returns(uint8) {
}
/// @notice Creates tokens and assigns them to account, increasing the total supply.
/// @param to The receiver of tokens
/// @param amount The amount of tokens to mint
function mint(address to, uint256 amount) external onlyBridge {
}
/// @notice Returns the address of the bridge
/// @return The address of the bridge
function bridge() external view returns(address) {
}
/// @notice Destroys tokens from account, reducing the total supply.
/// @param from The address holding the tokens
/// @param amount The amount of tokens to burn
function burn(address from, uint256 amount) external onlyBridge {
}
}
| bytes(symbol_).length>0,"ERC20: initial token symbol can not be empty!" | 248,130 | bytes(symbol_).length>0 |
"invalid proof" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "./ERC721A.sol";
contract AneroV2 is ERC721A, ERC2981, Ownable, ReentrancyGuard, Pausable {
using Strings for uint256;
bytes32 public merkleRoot;
string private _baseTokenURI;
mapping(address => bool) public claimed;
constructor(
bytes32 _merkleRoot,
string memory _baseURIString,
uint16 maxBatchSize,
uint16 collectionSize
) ERC721A("AneroV2", "AneroV2", maxBatchSize, collectionSize) {
}
modifier verifyProof(bytes32[] memory _proof, uint256 _amount) {
bytes32 _leaf = keccak256(abi.encodePacked(msg.sender, _amount));
require(<FILL_ME>)
_;
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function tokenURI(
uint256 tokenId
) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function _mintBatch(address user, uint256 quantity) internal {
}
function mint(
bytes32[] memory _proof,
uint256 _amount
) external verifyProof(_proof, _amount) whenNotPaused {
}
function setPause(bool value) external onlyOwner {
}
/**
* @dev Sets the royalty information that all ids in this contract will default to.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setRoyalty(address receiver, uint96 feeNumerator) external onlyOwner {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC2981, ERC721A) returns (bool) {
}
function deleteRoyalty() external onlyOwner {
}
function mintAdmin(uint256 quantity) external onlyOwner whenPaused {
}
}
| MerkleProof.verify(_proof,merkleRoot,_leaf),"invalid proof" | 248,398 | MerkleProof.verify(_proof,merkleRoot,_leaf) |
"ERC721EnumerableB: owner index out of bounds" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "./ERC721B.sol";
abstract contract ERC721EnumerableB is ERC721B, IERC721Enumerable {
function supportsInterface( bytes4 interfaceId ) public view virtual override(ERC721B, IERC165) returns( bool ){
}
function tokenOfOwnerByIndex( address owner, uint256 index ) external view returns( uint256 ){
require(<FILL_ME>)
uint256 count;
uint256 tokenId;
for( tokenId = 0; tokenId < 8888; ++tokenId ){
if( owner != tokens[tokenId] )
continue;
if( index == count++ )
break;
}
return tokenId;
}
function tokenByIndex( uint256 index ) external view returns( uint256 ){
}
function totalSupply() public view returns( uint256 ){
}
}
| owners[owner].balance>index,"ERC721EnumerableB: owner index out of bounds" | 248,503 | owners[owner].balance>index |
"ERC721EnumerableB: query for nonexistent token" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "./ERC721B.sol";
abstract contract ERC721EnumerableB is ERC721B, IERC721Enumerable {
function supportsInterface( bytes4 interfaceId ) public view virtual override(ERC721B, IERC165) returns( bool ){
}
function tokenOfOwnerByIndex( address owner, uint256 index ) external view returns( uint256 ){
}
function tokenByIndex( uint256 index ) external view returns( uint256 ){
require(<FILL_ME>)
return index;
}
function totalSupply() public view returns( uint256 ){
}
}
| _exists(index),"ERC721EnumerableB: query for nonexistent token" | 248,503 | _exists(index) |
"Too many per wallet" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
// Lucky Green Witch project
contract LuckyGreenWitch is ERC721A, Ownable, ReentrancyGuard, ERC721AQueryable {
string private _tokenBaseURI = '';
uint64 private MAX_SUPPLY = 9000;
uint64 private MAX_PER_WALLET = 11;
uint64 private MAX_PER_MINT = 11;
uint64 private MERKLE_RESERVED = 1000;
bool public isOpen = false;
bool public isShopOpen = false;
string private _tokenWithAddonURI = '';
uint private addonPurchasePrice = 0 ether;
mapping(uint64 => uint64) public hasAddon;
uint64[] private addonsAvailability;
mapping(uint64 => string) private onIpfs;
mapping(uint64 => uint) private witchDNA;
constructor() ERC721A("LuckyGreenWitch", "LGW") {
}
function mint(uint64 quantity) external {
require(isOpen, "Minting not open");
require(msg.sender == tx.origin, "No bots");
require(quantity < MAX_PER_MINT, "Too many per mint");
require(quantity > 0, "Zero mint");
require(<FILL_ME>)
require((_totalMinted() + quantity) <= MAX_SUPPLY, "Out of Witches");
_safeMint(_msgSender(), quantity);
}
function tokenURI(uint256 _tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
function setAddonURI(string memory _URI) public onlyOwner {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function putOnIpfs(uint64 _tokenId, string memory _address) public onlyOwner {
}
uint cntRnd = 100;
function random(uint _l) private returns (uint256) {
}
function withdraw() public onlyOwner {
}
function setAddonPrice(uint256 _newPrice) public onlyOwner {
}
function decreaseMaxSupply(uint64 _maxSupply) public onlyOwner {
}
function setMaxMintAmount(uint64 _newMaxMintAmount) public onlyOwner {
}
function setMaxPerWallet(uint64 _newMaxPerWallet) public onlyOwner {
}
function setIsOpen(bool _isOpen) external onlyOwner {
}
function setIsShopOpen(bool _isShopOpen) external onlyOwner {
}
event AddonPurchased(address indexed purchaser, uint64 indexed selectedAddonId, uint64 indexed _tokenId);
function purchaseAddon(uint64 _tokenId) public payable nonReentrant {
}
event AddonTransfered(uint64 indexed _tokenIdFrom, uint64 indexed _tokenIdTo);
function transferAddon(uint64 _tokenIdFrom, uint64 _tokenIdTo) public nonReentrant {
}
function getAddonPrice() public view returns (uint) {
}
function setAddons(uint[] memory _addons) public onlyOwner {
}
function getAddons() public view returns (uint64[] memory){
}
function setDNA(uint64 _tokenId) public {
}
function getDNA(uint64 _tokenId) public view returns (uint) {
}
bytes32 public merkleRoot = 0x696d2a47d6f9de5197eda8dad4f27b1ced42aed75adc8fe38540f96c3c6f53de;
mapping(address => bool) public claimed;
function checkValidity(bytes32[] calldata _merkleProof) public view returns (bool){
}
function mintMerkle(bytes32[] calldata merkleProof) public {
}
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
function setMerkleReserved(uint64 _maxM) public onlyOwner {
}
}
| (_numberMinted(_msgSender())+quantity)<MAX_PER_WALLET,"Too many per wallet" | 248,542 | (_numberMinted(_msgSender())+quantity)<MAX_PER_WALLET |
"Out of Witches" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
// Lucky Green Witch project
contract LuckyGreenWitch is ERC721A, Ownable, ReentrancyGuard, ERC721AQueryable {
string private _tokenBaseURI = '';
uint64 private MAX_SUPPLY = 9000;
uint64 private MAX_PER_WALLET = 11;
uint64 private MAX_PER_MINT = 11;
uint64 private MERKLE_RESERVED = 1000;
bool public isOpen = false;
bool public isShopOpen = false;
string private _tokenWithAddonURI = '';
uint private addonPurchasePrice = 0 ether;
mapping(uint64 => uint64) public hasAddon;
uint64[] private addonsAvailability;
mapping(uint64 => string) private onIpfs;
mapping(uint64 => uint) private witchDNA;
constructor() ERC721A("LuckyGreenWitch", "LGW") {
}
function mint(uint64 quantity) external {
require(isOpen, "Minting not open");
require(msg.sender == tx.origin, "No bots");
require(quantity < MAX_PER_MINT, "Too many per mint");
require(quantity > 0, "Zero mint");
require((_numberMinted(_msgSender()) + quantity) < MAX_PER_WALLET, "Too many per wallet");
require(<FILL_ME>)
_safeMint(_msgSender(), quantity);
}
function tokenURI(uint256 _tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
function setAddonURI(string memory _URI) public onlyOwner {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function putOnIpfs(uint64 _tokenId, string memory _address) public onlyOwner {
}
uint cntRnd = 100;
function random(uint _l) private returns (uint256) {
}
function withdraw() public onlyOwner {
}
function setAddonPrice(uint256 _newPrice) public onlyOwner {
}
function decreaseMaxSupply(uint64 _maxSupply) public onlyOwner {
}
function setMaxMintAmount(uint64 _newMaxMintAmount) public onlyOwner {
}
function setMaxPerWallet(uint64 _newMaxPerWallet) public onlyOwner {
}
function setIsOpen(bool _isOpen) external onlyOwner {
}
function setIsShopOpen(bool _isShopOpen) external onlyOwner {
}
event AddonPurchased(address indexed purchaser, uint64 indexed selectedAddonId, uint64 indexed _tokenId);
function purchaseAddon(uint64 _tokenId) public payable nonReentrant {
}
event AddonTransfered(uint64 indexed _tokenIdFrom, uint64 indexed _tokenIdTo);
function transferAddon(uint64 _tokenIdFrom, uint64 _tokenIdTo) public nonReentrant {
}
function getAddonPrice() public view returns (uint) {
}
function setAddons(uint[] memory _addons) public onlyOwner {
}
function getAddons() public view returns (uint64[] memory){
}
function setDNA(uint64 _tokenId) public {
}
function getDNA(uint64 _tokenId) public view returns (uint) {
}
bytes32 public merkleRoot = 0x696d2a47d6f9de5197eda8dad4f27b1ced42aed75adc8fe38540f96c3c6f53de;
mapping(address => bool) public claimed;
function checkValidity(bytes32[] calldata _merkleProof) public view returns (bool){
}
function mintMerkle(bytes32[] calldata merkleProof) public {
}
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
function setMerkleReserved(uint64 _maxM) public onlyOwner {
}
}
| (_totalMinted()+quantity)<=MAX_SUPPLY,"Out of Witches" | 248,542 | (_totalMinted()+quantity)<=MAX_SUPPLY |
"Token has no addon" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
// Lucky Green Witch project
contract LuckyGreenWitch is ERC721A, Ownable, ReentrancyGuard, ERC721AQueryable {
string private _tokenBaseURI = '';
uint64 private MAX_SUPPLY = 9000;
uint64 private MAX_PER_WALLET = 11;
uint64 private MAX_PER_MINT = 11;
uint64 private MERKLE_RESERVED = 1000;
bool public isOpen = false;
bool public isShopOpen = false;
string private _tokenWithAddonURI = '';
uint private addonPurchasePrice = 0 ether;
mapping(uint64 => uint64) public hasAddon;
uint64[] private addonsAvailability;
mapping(uint64 => string) private onIpfs;
mapping(uint64 => uint) private witchDNA;
constructor() ERC721A("LuckyGreenWitch", "LGW") {
}
function mint(uint64 quantity) external {
}
function tokenURI(uint256 _tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
function setAddonURI(string memory _URI) public onlyOwner {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function putOnIpfs(uint64 _tokenId, string memory _address) public onlyOwner {
require(_exists(_tokenId), "Token does not exist");
require(<FILL_ME>)
onIpfs[_tokenId] = _address;
}
uint cntRnd = 100;
function random(uint _l) private returns (uint256) {
}
function withdraw() public onlyOwner {
}
function setAddonPrice(uint256 _newPrice) public onlyOwner {
}
function decreaseMaxSupply(uint64 _maxSupply) public onlyOwner {
}
function setMaxMintAmount(uint64 _newMaxMintAmount) public onlyOwner {
}
function setMaxPerWallet(uint64 _newMaxPerWallet) public onlyOwner {
}
function setIsOpen(bool _isOpen) external onlyOwner {
}
function setIsShopOpen(bool _isShopOpen) external onlyOwner {
}
event AddonPurchased(address indexed purchaser, uint64 indexed selectedAddonId, uint64 indexed _tokenId);
function purchaseAddon(uint64 _tokenId) public payable nonReentrant {
}
event AddonTransfered(uint64 indexed _tokenIdFrom, uint64 indexed _tokenIdTo);
function transferAddon(uint64 _tokenIdFrom, uint64 _tokenIdTo) public nonReentrant {
}
function getAddonPrice() public view returns (uint) {
}
function setAddons(uint[] memory _addons) public onlyOwner {
}
function getAddons() public view returns (uint64[] memory){
}
function setDNA(uint64 _tokenId) public {
}
function getDNA(uint64 _tokenId) public view returns (uint) {
}
bytes32 public merkleRoot = 0x696d2a47d6f9de5197eda8dad4f27b1ced42aed75adc8fe38540f96c3c6f53de;
mapping(address => bool) public claimed;
function checkValidity(bytes32[] calldata _merkleProof) public view returns (bool){
}
function mintMerkle(bytes32[] calldata merkleProof) public {
}
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
function setMerkleReserved(uint64 _maxM) public onlyOwner {
}
}
| hasAddon[_tokenId]!=0,"Token has no addon" | 248,542 | hasAddon[_tokenId]!=0 |
"Witch already has addon" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
// Lucky Green Witch project
contract LuckyGreenWitch is ERC721A, Ownable, ReentrancyGuard, ERC721AQueryable {
string private _tokenBaseURI = '';
uint64 private MAX_SUPPLY = 9000;
uint64 private MAX_PER_WALLET = 11;
uint64 private MAX_PER_MINT = 11;
uint64 private MERKLE_RESERVED = 1000;
bool public isOpen = false;
bool public isShopOpen = false;
string private _tokenWithAddonURI = '';
uint private addonPurchasePrice = 0 ether;
mapping(uint64 => uint64) public hasAddon;
uint64[] private addonsAvailability;
mapping(uint64 => string) private onIpfs;
mapping(uint64 => uint) private witchDNA;
constructor() ERC721A("LuckyGreenWitch", "LGW") {
}
function mint(uint64 quantity) external {
}
function tokenURI(uint256 _tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
function setAddonURI(string memory _URI) public onlyOwner {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function putOnIpfs(uint64 _tokenId, string memory _address) public onlyOwner {
}
uint cntRnd = 100;
function random(uint _l) private returns (uint256) {
}
function withdraw() public onlyOwner {
}
function setAddonPrice(uint256 _newPrice) public onlyOwner {
}
function decreaseMaxSupply(uint64 _maxSupply) public onlyOwner {
}
function setMaxMintAmount(uint64 _newMaxMintAmount) public onlyOwner {
}
function setMaxPerWallet(uint64 _newMaxPerWallet) public onlyOwner {
}
function setIsOpen(bool _isOpen) external onlyOwner {
}
function setIsShopOpen(bool _isShopOpen) external onlyOwner {
}
event AddonPurchased(address indexed purchaser, uint64 indexed selectedAddonId, uint64 indexed _tokenId);
function purchaseAddon(uint64 _tokenId) public payable nonReentrant {
uint256 length = addonsAvailability.length;
require(isShopOpen, "Shop is not open");
require(msg.sender == tx.origin, "No bots");
require(length > 0 , "Addons sold out");
require(_exists(_tokenId), "Witch does not exist");
require(<FILL_ME>)
require(msg.value >= addonPurchasePrice , "Insufficient funds");
uint256 rnd = random(length);
addonPurchasePrice += 0.00666 ether;
uint64 selectedAddonId = addonsAvailability[rnd];
addonsAvailability[rnd] = addonsAvailability[length - 1];
addonsAvailability.pop();
hasAddon[_tokenId] = selectedAddonId;
emit AddonPurchased(_msgSender(), selectedAddonId, _tokenId);
}
event AddonTransfered(uint64 indexed _tokenIdFrom, uint64 indexed _tokenIdTo);
function transferAddon(uint64 _tokenIdFrom, uint64 _tokenIdTo) public nonReentrant {
}
function getAddonPrice() public view returns (uint) {
}
function setAddons(uint[] memory _addons) public onlyOwner {
}
function getAddons() public view returns (uint64[] memory){
}
function setDNA(uint64 _tokenId) public {
}
function getDNA(uint64 _tokenId) public view returns (uint) {
}
bytes32 public merkleRoot = 0x696d2a47d6f9de5197eda8dad4f27b1ced42aed75adc8fe38540f96c3c6f53de;
mapping(address => bool) public claimed;
function checkValidity(bytes32[] calldata _merkleProof) public view returns (bool){
}
function mintMerkle(bytes32[] calldata merkleProof) public {
}
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
function setMerkleReserved(uint64 _maxM) public onlyOwner {
}
}
| hasAddon[_tokenId]==0,"Witch already has addon" | 248,542 | hasAddon[_tokenId]==0 |
"Witch does not exist" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
// Lucky Green Witch project
contract LuckyGreenWitch is ERC721A, Ownable, ReentrancyGuard, ERC721AQueryable {
string private _tokenBaseURI = '';
uint64 private MAX_SUPPLY = 9000;
uint64 private MAX_PER_WALLET = 11;
uint64 private MAX_PER_MINT = 11;
uint64 private MERKLE_RESERVED = 1000;
bool public isOpen = false;
bool public isShopOpen = false;
string private _tokenWithAddonURI = '';
uint private addonPurchasePrice = 0 ether;
mapping(uint64 => uint64) public hasAddon;
uint64[] private addonsAvailability;
mapping(uint64 => string) private onIpfs;
mapping(uint64 => uint) private witchDNA;
constructor() ERC721A("LuckyGreenWitch", "LGW") {
}
function mint(uint64 quantity) external {
}
function tokenURI(uint256 _tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
function setAddonURI(string memory _URI) public onlyOwner {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function putOnIpfs(uint64 _tokenId, string memory _address) public onlyOwner {
}
uint cntRnd = 100;
function random(uint _l) private returns (uint256) {
}
function withdraw() public onlyOwner {
}
function setAddonPrice(uint256 _newPrice) public onlyOwner {
}
function decreaseMaxSupply(uint64 _maxSupply) public onlyOwner {
}
function setMaxMintAmount(uint64 _newMaxMintAmount) public onlyOwner {
}
function setMaxPerWallet(uint64 _newMaxPerWallet) public onlyOwner {
}
function setIsOpen(bool _isOpen) external onlyOwner {
}
function setIsShopOpen(bool _isShopOpen) external onlyOwner {
}
event AddonPurchased(address indexed purchaser, uint64 indexed selectedAddonId, uint64 indexed _tokenId);
function purchaseAddon(uint64 _tokenId) public payable nonReentrant {
}
event AddonTransfered(uint64 indexed _tokenIdFrom, uint64 indexed _tokenIdTo);
function transferAddon(uint64 _tokenIdFrom, uint64 _tokenIdTo) public nonReentrant {
require(isShopOpen, "Not open to transfers");
require(<FILL_ME>)
require(_exists(_tokenIdTo), "Witch does not exist");
require(hasAddon[_tokenIdFrom] != 0, "Witch has no addon");
require(hasAddon[_tokenIdTo] == 0, "Witch already has addon");
address tokenOwner = super.ownerOf(_tokenIdFrom);
require (_msgSender() == tokenOwner, "Not owner");
uint64 addonId = hasAddon[_tokenIdFrom];
delete hasAddon[_tokenIdFrom];
delete onIpfs[_tokenIdFrom];
delete onIpfs[_tokenIdTo];
hasAddon[_tokenIdTo] = addonId;
emit AddonTransfered(_tokenIdFrom, _tokenIdTo);
}
function getAddonPrice() public view returns (uint) {
}
function setAddons(uint[] memory _addons) public onlyOwner {
}
function getAddons() public view returns (uint64[] memory){
}
function setDNA(uint64 _tokenId) public {
}
function getDNA(uint64 _tokenId) public view returns (uint) {
}
bytes32 public merkleRoot = 0x696d2a47d6f9de5197eda8dad4f27b1ced42aed75adc8fe38540f96c3c6f53de;
mapping(address => bool) public claimed;
function checkValidity(bytes32[] calldata _merkleProof) public view returns (bool){
}
function mintMerkle(bytes32[] calldata merkleProof) public {
}
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
function setMerkleReserved(uint64 _maxM) public onlyOwner {
}
}
| _exists(_tokenIdFrom),"Witch does not exist" | 248,542 | _exists(_tokenIdFrom) |
"Witch does not exist" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
// Lucky Green Witch project
contract LuckyGreenWitch is ERC721A, Ownable, ReentrancyGuard, ERC721AQueryable {
string private _tokenBaseURI = '';
uint64 private MAX_SUPPLY = 9000;
uint64 private MAX_PER_WALLET = 11;
uint64 private MAX_PER_MINT = 11;
uint64 private MERKLE_RESERVED = 1000;
bool public isOpen = false;
bool public isShopOpen = false;
string private _tokenWithAddonURI = '';
uint private addonPurchasePrice = 0 ether;
mapping(uint64 => uint64) public hasAddon;
uint64[] private addonsAvailability;
mapping(uint64 => string) private onIpfs;
mapping(uint64 => uint) private witchDNA;
constructor() ERC721A("LuckyGreenWitch", "LGW") {
}
function mint(uint64 quantity) external {
}
function tokenURI(uint256 _tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
function setAddonURI(string memory _URI) public onlyOwner {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function putOnIpfs(uint64 _tokenId, string memory _address) public onlyOwner {
}
uint cntRnd = 100;
function random(uint _l) private returns (uint256) {
}
function withdraw() public onlyOwner {
}
function setAddonPrice(uint256 _newPrice) public onlyOwner {
}
function decreaseMaxSupply(uint64 _maxSupply) public onlyOwner {
}
function setMaxMintAmount(uint64 _newMaxMintAmount) public onlyOwner {
}
function setMaxPerWallet(uint64 _newMaxPerWallet) public onlyOwner {
}
function setIsOpen(bool _isOpen) external onlyOwner {
}
function setIsShopOpen(bool _isShopOpen) external onlyOwner {
}
event AddonPurchased(address indexed purchaser, uint64 indexed selectedAddonId, uint64 indexed _tokenId);
function purchaseAddon(uint64 _tokenId) public payable nonReentrant {
}
event AddonTransfered(uint64 indexed _tokenIdFrom, uint64 indexed _tokenIdTo);
function transferAddon(uint64 _tokenIdFrom, uint64 _tokenIdTo) public nonReentrant {
require(isShopOpen, "Not open to transfers");
require(_exists(_tokenIdFrom), "Witch does not exist");
require(<FILL_ME>)
require(hasAddon[_tokenIdFrom] != 0, "Witch has no addon");
require(hasAddon[_tokenIdTo] == 0, "Witch already has addon");
address tokenOwner = super.ownerOf(_tokenIdFrom);
require (_msgSender() == tokenOwner, "Not owner");
uint64 addonId = hasAddon[_tokenIdFrom];
delete hasAddon[_tokenIdFrom];
delete onIpfs[_tokenIdFrom];
delete onIpfs[_tokenIdTo];
hasAddon[_tokenIdTo] = addonId;
emit AddonTransfered(_tokenIdFrom, _tokenIdTo);
}
function getAddonPrice() public view returns (uint) {
}
function setAddons(uint[] memory _addons) public onlyOwner {
}
function getAddons() public view returns (uint64[] memory){
}
function setDNA(uint64 _tokenId) public {
}
function getDNA(uint64 _tokenId) public view returns (uint) {
}
bytes32 public merkleRoot = 0x696d2a47d6f9de5197eda8dad4f27b1ced42aed75adc8fe38540f96c3c6f53de;
mapping(address => bool) public claimed;
function checkValidity(bytes32[] calldata _merkleProof) public view returns (bool){
}
function mintMerkle(bytes32[] calldata merkleProof) public {
}
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
function setMerkleReserved(uint64 _maxM) public onlyOwner {
}
}
| _exists(_tokenIdTo),"Witch does not exist" | 248,542 | _exists(_tokenIdTo) |
"Witch has no addon" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
// Lucky Green Witch project
contract LuckyGreenWitch is ERC721A, Ownable, ReentrancyGuard, ERC721AQueryable {
string private _tokenBaseURI = '';
uint64 private MAX_SUPPLY = 9000;
uint64 private MAX_PER_WALLET = 11;
uint64 private MAX_PER_MINT = 11;
uint64 private MERKLE_RESERVED = 1000;
bool public isOpen = false;
bool public isShopOpen = false;
string private _tokenWithAddonURI = '';
uint private addonPurchasePrice = 0 ether;
mapping(uint64 => uint64) public hasAddon;
uint64[] private addonsAvailability;
mapping(uint64 => string) private onIpfs;
mapping(uint64 => uint) private witchDNA;
constructor() ERC721A("LuckyGreenWitch", "LGW") {
}
function mint(uint64 quantity) external {
}
function tokenURI(uint256 _tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
function setAddonURI(string memory _URI) public onlyOwner {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function putOnIpfs(uint64 _tokenId, string memory _address) public onlyOwner {
}
uint cntRnd = 100;
function random(uint _l) private returns (uint256) {
}
function withdraw() public onlyOwner {
}
function setAddonPrice(uint256 _newPrice) public onlyOwner {
}
function decreaseMaxSupply(uint64 _maxSupply) public onlyOwner {
}
function setMaxMintAmount(uint64 _newMaxMintAmount) public onlyOwner {
}
function setMaxPerWallet(uint64 _newMaxPerWallet) public onlyOwner {
}
function setIsOpen(bool _isOpen) external onlyOwner {
}
function setIsShopOpen(bool _isShopOpen) external onlyOwner {
}
event AddonPurchased(address indexed purchaser, uint64 indexed selectedAddonId, uint64 indexed _tokenId);
function purchaseAddon(uint64 _tokenId) public payable nonReentrant {
}
event AddonTransfered(uint64 indexed _tokenIdFrom, uint64 indexed _tokenIdTo);
function transferAddon(uint64 _tokenIdFrom, uint64 _tokenIdTo) public nonReentrant {
require(isShopOpen, "Not open to transfers");
require(_exists(_tokenIdFrom), "Witch does not exist");
require(_exists(_tokenIdTo), "Witch does not exist");
require(<FILL_ME>)
require(hasAddon[_tokenIdTo] == 0, "Witch already has addon");
address tokenOwner = super.ownerOf(_tokenIdFrom);
require (_msgSender() == tokenOwner, "Not owner");
uint64 addonId = hasAddon[_tokenIdFrom];
delete hasAddon[_tokenIdFrom];
delete onIpfs[_tokenIdFrom];
delete onIpfs[_tokenIdTo];
hasAddon[_tokenIdTo] = addonId;
emit AddonTransfered(_tokenIdFrom, _tokenIdTo);
}
function getAddonPrice() public view returns (uint) {
}
function setAddons(uint[] memory _addons) public onlyOwner {
}
function getAddons() public view returns (uint64[] memory){
}
function setDNA(uint64 _tokenId) public {
}
function getDNA(uint64 _tokenId) public view returns (uint) {
}
bytes32 public merkleRoot = 0x696d2a47d6f9de5197eda8dad4f27b1ced42aed75adc8fe38540f96c3c6f53de;
mapping(address => bool) public claimed;
function checkValidity(bytes32[] calldata _merkleProof) public view returns (bool){
}
function mintMerkle(bytes32[] calldata merkleProof) public {
}
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
function setMerkleReserved(uint64 _maxM) public onlyOwner {
}
}
| hasAddon[_tokenIdFrom]!=0,"Witch has no addon" | 248,542 | hasAddon[_tokenIdFrom]!=0 |
"Witch already has addon" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
// Lucky Green Witch project
contract LuckyGreenWitch is ERC721A, Ownable, ReentrancyGuard, ERC721AQueryable {
string private _tokenBaseURI = '';
uint64 private MAX_SUPPLY = 9000;
uint64 private MAX_PER_WALLET = 11;
uint64 private MAX_PER_MINT = 11;
uint64 private MERKLE_RESERVED = 1000;
bool public isOpen = false;
bool public isShopOpen = false;
string private _tokenWithAddonURI = '';
uint private addonPurchasePrice = 0 ether;
mapping(uint64 => uint64) public hasAddon;
uint64[] private addonsAvailability;
mapping(uint64 => string) private onIpfs;
mapping(uint64 => uint) private witchDNA;
constructor() ERC721A("LuckyGreenWitch", "LGW") {
}
function mint(uint64 quantity) external {
}
function tokenURI(uint256 _tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
function setAddonURI(string memory _URI) public onlyOwner {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function putOnIpfs(uint64 _tokenId, string memory _address) public onlyOwner {
}
uint cntRnd = 100;
function random(uint _l) private returns (uint256) {
}
function withdraw() public onlyOwner {
}
function setAddonPrice(uint256 _newPrice) public onlyOwner {
}
function decreaseMaxSupply(uint64 _maxSupply) public onlyOwner {
}
function setMaxMintAmount(uint64 _newMaxMintAmount) public onlyOwner {
}
function setMaxPerWallet(uint64 _newMaxPerWallet) public onlyOwner {
}
function setIsOpen(bool _isOpen) external onlyOwner {
}
function setIsShopOpen(bool _isShopOpen) external onlyOwner {
}
event AddonPurchased(address indexed purchaser, uint64 indexed selectedAddonId, uint64 indexed _tokenId);
function purchaseAddon(uint64 _tokenId) public payable nonReentrant {
}
event AddonTransfered(uint64 indexed _tokenIdFrom, uint64 indexed _tokenIdTo);
function transferAddon(uint64 _tokenIdFrom, uint64 _tokenIdTo) public nonReentrant {
require(isShopOpen, "Not open to transfers");
require(_exists(_tokenIdFrom), "Witch does not exist");
require(_exists(_tokenIdTo), "Witch does not exist");
require(hasAddon[_tokenIdFrom] != 0, "Witch has no addon");
require(<FILL_ME>)
address tokenOwner = super.ownerOf(_tokenIdFrom);
require (_msgSender() == tokenOwner, "Not owner");
uint64 addonId = hasAddon[_tokenIdFrom];
delete hasAddon[_tokenIdFrom];
delete onIpfs[_tokenIdFrom];
delete onIpfs[_tokenIdTo];
hasAddon[_tokenIdTo] = addonId;
emit AddonTransfered(_tokenIdFrom, _tokenIdTo);
}
function getAddonPrice() public view returns (uint) {
}
function setAddons(uint[] memory _addons) public onlyOwner {
}
function getAddons() public view returns (uint64[] memory){
}
function setDNA(uint64 _tokenId) public {
}
function getDNA(uint64 _tokenId) public view returns (uint) {
}
bytes32 public merkleRoot = 0x696d2a47d6f9de5197eda8dad4f27b1ced42aed75adc8fe38540f96c3c6f53de;
mapping(address => bool) public claimed;
function checkValidity(bytes32[] calldata _merkleProof) public view returns (bool){
}
function mintMerkle(bytes32[] calldata merkleProof) public {
}
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
function setMerkleReserved(uint64 _maxM) public onlyOwner {
}
}
| hasAddon[_tokenIdTo]==0,"Witch already has addon" | 248,542 | hasAddon[_tokenIdTo]==0 |
"Not owner" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
// Lucky Green Witch project
contract LuckyGreenWitch is ERC721A, Ownable, ReentrancyGuard, ERC721AQueryable {
string private _tokenBaseURI = '';
uint64 private MAX_SUPPLY = 9000;
uint64 private MAX_PER_WALLET = 11;
uint64 private MAX_PER_MINT = 11;
uint64 private MERKLE_RESERVED = 1000;
bool public isOpen = false;
bool public isShopOpen = false;
string private _tokenWithAddonURI = '';
uint private addonPurchasePrice = 0 ether;
mapping(uint64 => uint64) public hasAddon;
uint64[] private addonsAvailability;
mapping(uint64 => string) private onIpfs;
mapping(uint64 => uint) private witchDNA;
constructor() ERC721A("LuckyGreenWitch", "LGW") {
}
function mint(uint64 quantity) external {
}
function tokenURI(uint256 _tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
function setAddonURI(string memory _URI) public onlyOwner {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function putOnIpfs(uint64 _tokenId, string memory _address) public onlyOwner {
}
uint cntRnd = 100;
function random(uint _l) private returns (uint256) {
}
function withdraw() public onlyOwner {
}
function setAddonPrice(uint256 _newPrice) public onlyOwner {
}
function decreaseMaxSupply(uint64 _maxSupply) public onlyOwner {
}
function setMaxMintAmount(uint64 _newMaxMintAmount) public onlyOwner {
}
function setMaxPerWallet(uint64 _newMaxPerWallet) public onlyOwner {
}
function setIsOpen(bool _isOpen) external onlyOwner {
}
function setIsShopOpen(bool _isShopOpen) external onlyOwner {
}
event AddonPurchased(address indexed purchaser, uint64 indexed selectedAddonId, uint64 indexed _tokenId);
function purchaseAddon(uint64 _tokenId) public payable nonReentrant {
}
event AddonTransfered(uint64 indexed _tokenIdFrom, uint64 indexed _tokenIdTo);
function transferAddon(uint64 _tokenIdFrom, uint64 _tokenIdTo) public nonReentrant {
require(isShopOpen, "Not open to transfers");
require(_exists(_tokenIdFrom), "Witch does not exist");
require(_exists(_tokenIdTo), "Witch does not exist");
require(hasAddon[_tokenIdFrom] != 0, "Witch has no addon");
require(hasAddon[_tokenIdTo] == 0, "Witch already has addon");
address tokenOwner = super.ownerOf(_tokenIdFrom);
require(<FILL_ME>)
uint64 addonId = hasAddon[_tokenIdFrom];
delete hasAddon[_tokenIdFrom];
delete onIpfs[_tokenIdFrom];
delete onIpfs[_tokenIdTo];
hasAddon[_tokenIdTo] = addonId;
emit AddonTransfered(_tokenIdFrom, _tokenIdTo);
}
function getAddonPrice() public view returns (uint) {
}
function setAddons(uint[] memory _addons) public onlyOwner {
}
function getAddons() public view returns (uint64[] memory){
}
function setDNA(uint64 _tokenId) public {
}
function getDNA(uint64 _tokenId) public view returns (uint) {
}
bytes32 public merkleRoot = 0x696d2a47d6f9de5197eda8dad4f27b1ced42aed75adc8fe38540f96c3c6f53de;
mapping(address => bool) public claimed;
function checkValidity(bytes32[] calldata _merkleProof) public view returns (bool){
}
function mintMerkle(bytes32[] calldata merkleProof) public {
}
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
function setMerkleReserved(uint64 _maxM) public onlyOwner {
}
}
| _msgSender()==tokenOwner,"Not owner" | 248,542 | _msgSender()==tokenOwner |
"DNA exists" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
// Lucky Green Witch project
contract LuckyGreenWitch is ERC721A, Ownable, ReentrancyGuard, ERC721AQueryable {
string private _tokenBaseURI = '';
uint64 private MAX_SUPPLY = 9000;
uint64 private MAX_PER_WALLET = 11;
uint64 private MAX_PER_MINT = 11;
uint64 private MERKLE_RESERVED = 1000;
bool public isOpen = false;
bool public isShopOpen = false;
string private _tokenWithAddonURI = '';
uint private addonPurchasePrice = 0 ether;
mapping(uint64 => uint64) public hasAddon;
uint64[] private addonsAvailability;
mapping(uint64 => string) private onIpfs;
mapping(uint64 => uint) private witchDNA;
constructor() ERC721A("LuckyGreenWitch", "LGW") {
}
function mint(uint64 quantity) external {
}
function tokenURI(uint256 _tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
function setAddonURI(string memory _URI) public onlyOwner {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function putOnIpfs(uint64 _tokenId, string memory _address) public onlyOwner {
}
uint cntRnd = 100;
function random(uint _l) private returns (uint256) {
}
function withdraw() public onlyOwner {
}
function setAddonPrice(uint256 _newPrice) public onlyOwner {
}
function decreaseMaxSupply(uint64 _maxSupply) public onlyOwner {
}
function setMaxMintAmount(uint64 _newMaxMintAmount) public onlyOwner {
}
function setMaxPerWallet(uint64 _newMaxPerWallet) public onlyOwner {
}
function setIsOpen(bool _isOpen) external onlyOwner {
}
function setIsShopOpen(bool _isShopOpen) external onlyOwner {
}
event AddonPurchased(address indexed purchaser, uint64 indexed selectedAddonId, uint64 indexed _tokenId);
function purchaseAddon(uint64 _tokenId) public payable nonReentrant {
}
event AddonTransfered(uint64 indexed _tokenIdFrom, uint64 indexed _tokenIdTo);
function transferAddon(uint64 _tokenIdFrom, uint64 _tokenIdTo) public nonReentrant {
}
function getAddonPrice() public view returns (uint) {
}
function setAddons(uint[] memory _addons) public onlyOwner {
}
function getAddons() public view returns (uint64[] memory){
}
function setDNA(uint64 _tokenId) public {
require(_exists(_tokenId), "Witch does not exist");
require(<FILL_ME>)
witchDNA[_tokenId] = random(1000000000000000);
}
function getDNA(uint64 _tokenId) public view returns (uint) {
}
bytes32 public merkleRoot = 0x696d2a47d6f9de5197eda8dad4f27b1ced42aed75adc8fe38540f96c3c6f53de;
mapping(address => bool) public claimed;
function checkValidity(bytes32[] calldata _merkleProof) public view returns (bool){
}
function mintMerkle(bytes32[] calldata merkleProof) public {
}
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
function setMerkleReserved(uint64 _maxM) public onlyOwner {
}
}
| witchDNA[_tokenId]==0,"DNA exists" | 248,542 | witchDNA[_tokenId]==0 |
"Out of Witches" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
// Lucky Green Witch project
contract LuckyGreenWitch is ERC721A, Ownable, ReentrancyGuard, ERC721AQueryable {
string private _tokenBaseURI = '';
uint64 private MAX_SUPPLY = 9000;
uint64 private MAX_PER_WALLET = 11;
uint64 private MAX_PER_MINT = 11;
uint64 private MERKLE_RESERVED = 1000;
bool public isOpen = false;
bool public isShopOpen = false;
string private _tokenWithAddonURI = '';
uint private addonPurchasePrice = 0 ether;
mapping(uint64 => uint64) public hasAddon;
uint64[] private addonsAvailability;
mapping(uint64 => string) private onIpfs;
mapping(uint64 => uint) private witchDNA;
constructor() ERC721A("LuckyGreenWitch", "LGW") {
}
function mint(uint64 quantity) external {
}
function tokenURI(uint256 _tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
function setAddonURI(string memory _URI) public onlyOwner {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function putOnIpfs(uint64 _tokenId, string memory _address) public onlyOwner {
}
uint cntRnd = 100;
function random(uint _l) private returns (uint256) {
}
function withdraw() public onlyOwner {
}
function setAddonPrice(uint256 _newPrice) public onlyOwner {
}
function decreaseMaxSupply(uint64 _maxSupply) public onlyOwner {
}
function setMaxMintAmount(uint64 _newMaxMintAmount) public onlyOwner {
}
function setMaxPerWallet(uint64 _newMaxPerWallet) public onlyOwner {
}
function setIsOpen(bool _isOpen) external onlyOwner {
}
function setIsShopOpen(bool _isShopOpen) external onlyOwner {
}
event AddonPurchased(address indexed purchaser, uint64 indexed selectedAddonId, uint64 indexed _tokenId);
function purchaseAddon(uint64 _tokenId) public payable nonReentrant {
}
event AddonTransfered(uint64 indexed _tokenIdFrom, uint64 indexed _tokenIdTo);
function transferAddon(uint64 _tokenIdFrom, uint64 _tokenIdTo) public nonReentrant {
}
function getAddonPrice() public view returns (uint) {
}
function setAddons(uint[] memory _addons) public onlyOwner {
}
function getAddons() public view returns (uint64[] memory){
}
function setDNA(uint64 _tokenId) public {
}
function getDNA(uint64 _tokenId) public view returns (uint) {
}
bytes32 public merkleRoot = 0x696d2a47d6f9de5197eda8dad4f27b1ced42aed75adc8fe38540f96c3c6f53de;
mapping(address => bool) public claimed;
function checkValidity(bytes32[] calldata _merkleProof) public view returns (bool){
}
function mintMerkle(bytes32[] calldata merkleProof) public {
require(isOpen, "Minting not open");
require(claimed[msg.sender] == false, "Already claimed");
require(<FILL_ME>)
claimed[msg.sender] = true;
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(merkleProof, merkleRoot, leaf) == true, "Invalid merkle proof");
_safeMint(_msgSender(), 1);
}
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
function setMerkleReserved(uint64 _maxM) public onlyOwner {
}
}
| (_totalMinted()+1)<=MERKLE_RESERVED,"Out of Witches" | 248,542 | (_totalMinted()+1)<=MERKLE_RESERVED |
"Invalid merkle proof" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
// Lucky Green Witch project
contract LuckyGreenWitch is ERC721A, Ownable, ReentrancyGuard, ERC721AQueryable {
string private _tokenBaseURI = '';
uint64 private MAX_SUPPLY = 9000;
uint64 private MAX_PER_WALLET = 11;
uint64 private MAX_PER_MINT = 11;
uint64 private MERKLE_RESERVED = 1000;
bool public isOpen = false;
bool public isShopOpen = false;
string private _tokenWithAddonURI = '';
uint private addonPurchasePrice = 0 ether;
mapping(uint64 => uint64) public hasAddon;
uint64[] private addonsAvailability;
mapping(uint64 => string) private onIpfs;
mapping(uint64 => uint) private witchDNA;
constructor() ERC721A("LuckyGreenWitch", "LGW") {
}
function mint(uint64 quantity) external {
}
function tokenURI(uint256 _tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
function setAddonURI(string memory _URI) public onlyOwner {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function putOnIpfs(uint64 _tokenId, string memory _address) public onlyOwner {
}
uint cntRnd = 100;
function random(uint _l) private returns (uint256) {
}
function withdraw() public onlyOwner {
}
function setAddonPrice(uint256 _newPrice) public onlyOwner {
}
function decreaseMaxSupply(uint64 _maxSupply) public onlyOwner {
}
function setMaxMintAmount(uint64 _newMaxMintAmount) public onlyOwner {
}
function setMaxPerWallet(uint64 _newMaxPerWallet) public onlyOwner {
}
function setIsOpen(bool _isOpen) external onlyOwner {
}
function setIsShopOpen(bool _isShopOpen) external onlyOwner {
}
event AddonPurchased(address indexed purchaser, uint64 indexed selectedAddonId, uint64 indexed _tokenId);
function purchaseAddon(uint64 _tokenId) public payable nonReentrant {
}
event AddonTransfered(uint64 indexed _tokenIdFrom, uint64 indexed _tokenIdTo);
function transferAddon(uint64 _tokenIdFrom, uint64 _tokenIdTo) public nonReentrant {
}
function getAddonPrice() public view returns (uint) {
}
function setAddons(uint[] memory _addons) public onlyOwner {
}
function getAddons() public view returns (uint64[] memory){
}
function setDNA(uint64 _tokenId) public {
}
function getDNA(uint64 _tokenId) public view returns (uint) {
}
bytes32 public merkleRoot = 0x696d2a47d6f9de5197eda8dad4f27b1ced42aed75adc8fe38540f96c3c6f53de;
mapping(address => bool) public claimed;
function checkValidity(bytes32[] calldata _merkleProof) public view returns (bool){
}
function mintMerkle(bytes32[] calldata merkleProof) public {
require(isOpen, "Minting not open");
require(claimed[msg.sender] == false, "Already claimed");
require((_totalMinted() + 1) <= MERKLE_RESERVED, "Out of Witches");
claimed[msg.sender] = true;
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
_safeMint(_msgSender(), 1);
}
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
function setMerkleReserved(uint64 _maxM) public onlyOwner {
}
}
| MerkleProof.verify(merkleProof,merkleRoot,leaf)==true,"Invalid merkle proof" | 248,542 | MerkleProof.verify(merkleProof,merkleRoot,leaf)==true |
"Cannot increase" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
// Lucky Green Witch project
contract LuckyGreenWitch is ERC721A, Ownable, ReentrancyGuard, ERC721AQueryable {
string private _tokenBaseURI = '';
uint64 private MAX_SUPPLY = 9000;
uint64 private MAX_PER_WALLET = 11;
uint64 private MAX_PER_MINT = 11;
uint64 private MERKLE_RESERVED = 1000;
bool public isOpen = false;
bool public isShopOpen = false;
string private _tokenWithAddonURI = '';
uint private addonPurchasePrice = 0 ether;
mapping(uint64 => uint64) public hasAddon;
uint64[] private addonsAvailability;
mapping(uint64 => string) private onIpfs;
mapping(uint64 => uint) private witchDNA;
constructor() ERC721A("LuckyGreenWitch", "LGW") {
}
function mint(uint64 quantity) external {
}
function tokenURI(uint256 _tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
function setAddonURI(string memory _URI) public onlyOwner {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function putOnIpfs(uint64 _tokenId, string memory _address) public onlyOwner {
}
uint cntRnd = 100;
function random(uint _l) private returns (uint256) {
}
function withdraw() public onlyOwner {
}
function setAddonPrice(uint256 _newPrice) public onlyOwner {
}
function decreaseMaxSupply(uint64 _maxSupply) public onlyOwner {
}
function setMaxMintAmount(uint64 _newMaxMintAmount) public onlyOwner {
}
function setMaxPerWallet(uint64 _newMaxPerWallet) public onlyOwner {
}
function setIsOpen(bool _isOpen) external onlyOwner {
}
function setIsShopOpen(bool _isShopOpen) external onlyOwner {
}
event AddonPurchased(address indexed purchaser, uint64 indexed selectedAddonId, uint64 indexed _tokenId);
function purchaseAddon(uint64 _tokenId) public payable nonReentrant {
}
event AddonTransfered(uint64 indexed _tokenIdFrom, uint64 indexed _tokenIdTo);
function transferAddon(uint64 _tokenIdFrom, uint64 _tokenIdTo) public nonReentrant {
}
function getAddonPrice() public view returns (uint) {
}
function setAddons(uint[] memory _addons) public onlyOwner {
}
function getAddons() public view returns (uint64[] memory){
}
function setDNA(uint64 _tokenId) public {
}
function getDNA(uint64 _tokenId) public view returns (uint) {
}
bytes32 public merkleRoot = 0x696d2a47d6f9de5197eda8dad4f27b1ced42aed75adc8fe38540f96c3c6f53de;
mapping(address => bool) public claimed;
function checkValidity(bytes32[] calldata _merkleProof) public view returns (bool){
}
function mintMerkle(bytes32[] calldata merkleProof) public {
}
function setMerkleRoot(bytes32 _root) external onlyOwner {
}
function setMerkleReserved(uint64 _maxM) public onlyOwner {
require(<FILL_ME>)
MERKLE_RESERVED = _maxM;
}
}
| (MAX_SUPPLY+_maxM)<=10000,"Cannot increase" | 248,542 | (MAX_SUPPLY+_maxM)<=10000 |
"give me more money1" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
contract WIKIFREE is Ownable, ERC721A {
uint256 constant public maxSupply = 9999;
uint256 public publicPrice = 0.005 ether;
uint256 constant public limitAmountPerTx = 5;
uint256 constant public limitAmountPerWallet = 5;
uint256 public totalTeamSupply;
string public revealedURI = "ipfs:// ----IFPS---/";
bool public paused = true;
bool public freeSale = true;
bool public publicSale = true;
uint256 public freecount = 1;
mapping(address => bool) public userMintedFree;
mapping(address => uint256) public mintedWallets;
string private _baseTokenUri;
constructor(
string memory _name,
string memory _symbol,
string memory _revealedURI
) ERC721A(_name, _symbol) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function freeMint(uint256 quantity) external payable mintCompliance(quantity) {
require(freeSale, "Free sale inactive");
require(!userMintedFree[msg.sender], "User max free limit");
require(maxSupply > totalSupply(), "sold out");
uint256 currMints = mintedWallets[msg.sender];
if (quantity == 1 && currMints == 0) {
mintedWallets[msg.sender]++;
_safeMint(msg.sender, 1);
} else {
if (currMints == 0 && quantity > 1) {
require(publicSale, "Public sale inactive1");
require(<FILL_ME>)
require(quantity <= limitAmountPerTx, "Quantity too high1");
require(quantity <= limitAmountPerWallet, "u wanna mint too many1");
mintedWallets[msg.sender] = quantity;
_safeMint(msg.sender, quantity);
} else {
require(publicSale, "Public sale inactive");
require(msg.value >= (quantity) * publicPrice, "give me more money");
require(quantity <= limitAmountPerTx, "Quantity too high");
require(currMints + quantity <= limitAmountPerWallet, "u wanna mint too many");
mintedWallets[msg.sender] = (currMints + quantity);
_safeMint(msg.sender, quantity);
}
}
}
function publicMint(uint256 quantity) external payable mintCompliance(quantity) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory)
{
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseUri(string memory _baseUri) external onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function setPublicPrice(uint256 _publicPrice) public onlyOwner {
}
function setBaseURI(string memory _baseUri) public onlyOwner {
}
function setContractURI(string memory _contractURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setPaused(bool _state) public onlyOwner {
}
function setPublicEnabled(bool _state) public onlyOwner {
}
function setFreeEnabled(bool _state) public onlyOwner {
}
function mintToUser(uint256 quantity, address receiver) public onlyOwner mintCompliance(quantity) {
}
function withdrawFundsToAddress(address _address, uint256 amount) external onlyOwner {
}
modifier mintCompliance(uint256 quantity) {
}
}
| msg.value>=(quantity-1)*publicPrice,"give me more money1" | 248,900 | msg.value>=(quantity-1)*publicPrice |
"give me more money" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
contract WIKIFREE is Ownable, ERC721A {
uint256 constant public maxSupply = 9999;
uint256 public publicPrice = 0.005 ether;
uint256 constant public limitAmountPerTx = 5;
uint256 constant public limitAmountPerWallet = 5;
uint256 public totalTeamSupply;
string public revealedURI = "ipfs:// ----IFPS---/";
bool public paused = true;
bool public freeSale = true;
bool public publicSale = true;
uint256 public freecount = 1;
mapping(address => bool) public userMintedFree;
mapping(address => uint256) public mintedWallets;
string private _baseTokenUri;
constructor(
string memory _name,
string memory _symbol,
string memory _revealedURI
) ERC721A(_name, _symbol) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function freeMint(uint256 quantity) external payable mintCompliance(quantity) {
require(freeSale, "Free sale inactive");
require(!userMintedFree[msg.sender], "User max free limit");
require(maxSupply > totalSupply(), "sold out");
uint256 currMints = mintedWallets[msg.sender];
if (quantity == 1 && currMints == 0) {
mintedWallets[msg.sender]++;
_safeMint(msg.sender, 1);
} else {
if (currMints == 0 && quantity > 1) {
require(publicSale, "Public sale inactive1");
require(msg.value >= (quantity-1) * publicPrice, "give me more money1");
require(quantity <= limitAmountPerTx, "Quantity too high1");
require(quantity <= limitAmountPerWallet, "u wanna mint too many1");
mintedWallets[msg.sender] = quantity;
_safeMint(msg.sender, quantity);
} else {
require(publicSale, "Public sale inactive");
require(<FILL_ME>)
require(quantity <= limitAmountPerTx, "Quantity too high");
require(currMints + quantity <= limitAmountPerWallet, "u wanna mint too many");
mintedWallets[msg.sender] = (currMints + quantity);
_safeMint(msg.sender, quantity);
}
}
}
function publicMint(uint256 quantity) external payable mintCompliance(quantity) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory)
{
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseUri(string memory _baseUri) external onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function setPublicPrice(uint256 _publicPrice) public onlyOwner {
}
function setBaseURI(string memory _baseUri) public onlyOwner {
}
function setContractURI(string memory _contractURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setPaused(bool _state) public onlyOwner {
}
function setPublicEnabled(bool _state) public onlyOwner {
}
function setFreeEnabled(bool _state) public onlyOwner {
}
function mintToUser(uint256 quantity, address receiver) public onlyOwner mintCompliance(quantity) {
}
function withdrawFundsToAddress(address _address, uint256 amount) external onlyOwner {
}
modifier mintCompliance(uint256 quantity) {
}
}
| msg.value>=(quantity)*publicPrice,"give me more money" | 248,900 | msg.value>=(quantity)*publicPrice |
"u wanna mint too many" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
contract WIKIFREE is Ownable, ERC721A {
uint256 constant public maxSupply = 9999;
uint256 public publicPrice = 0.005 ether;
uint256 constant public limitAmountPerTx = 5;
uint256 constant public limitAmountPerWallet = 5;
uint256 public totalTeamSupply;
string public revealedURI = "ipfs:// ----IFPS---/";
bool public paused = true;
bool public freeSale = true;
bool public publicSale = true;
uint256 public freecount = 1;
mapping(address => bool) public userMintedFree;
mapping(address => uint256) public mintedWallets;
string private _baseTokenUri;
constructor(
string memory _name,
string memory _symbol,
string memory _revealedURI
) ERC721A(_name, _symbol) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function freeMint(uint256 quantity) external payable mintCompliance(quantity) {
require(freeSale, "Free sale inactive");
require(!userMintedFree[msg.sender], "User max free limit");
require(maxSupply > totalSupply(), "sold out");
uint256 currMints = mintedWallets[msg.sender];
if (quantity == 1 && currMints == 0) {
mintedWallets[msg.sender]++;
_safeMint(msg.sender, 1);
} else {
if (currMints == 0 && quantity > 1) {
require(publicSale, "Public sale inactive1");
require(msg.value >= (quantity-1) * publicPrice, "give me more money1");
require(quantity <= limitAmountPerTx, "Quantity too high1");
require(quantity <= limitAmountPerWallet, "u wanna mint too many1");
mintedWallets[msg.sender] = quantity;
_safeMint(msg.sender, quantity);
} else {
require(publicSale, "Public sale inactive");
require(msg.value >= (quantity) * publicPrice, "give me more money");
require(quantity <= limitAmountPerTx, "Quantity too high");
require(<FILL_ME>)
mintedWallets[msg.sender] = (currMints + quantity);
_safeMint(msg.sender, quantity);
}
}
}
function publicMint(uint256 quantity) external payable mintCompliance(quantity) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory)
{
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseUri(string memory _baseUri) external onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function setPublicPrice(uint256 _publicPrice) public onlyOwner {
}
function setBaseURI(string memory _baseUri) public onlyOwner {
}
function setContractURI(string memory _contractURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setPaused(bool _state) public onlyOwner {
}
function setPublicEnabled(bool _state) public onlyOwner {
}
function setFreeEnabled(bool _state) public onlyOwner {
}
function mintToUser(uint256 quantity, address receiver) public onlyOwner mintCompliance(quantity) {
}
function withdrawFundsToAddress(address _address, uint256 amount) external onlyOwner {
}
modifier mintCompliance(uint256 quantity) {
}
}
| currMints+quantity<=limitAmountPerWallet,"u wanna mint too many" | 248,900 | currMints+quantity<=limitAmountPerWallet |
"Trading not open" | //SPDX-License-Identifier: MIT
/*
https://twitter.com/GepeCoin
https://www.gepe.vip/
https://t.me/grimgepe
*/
pragma solidity 0.8.20;
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 GEPE is IERC20, Auth {
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 420_690_000_000_000 * (10**_decimals);
string private constant _name = "GRIM PEPE";
string private constant _symbol = "GEPE";
uint8 private antiSnipeTax1 = 3;
uint8 private antiSnipeTax2 = 2;
uint8 private antiSnipeBlocks1 = 1;
uint8 private antiSnipeBlocks2 = 1;
uint256 private _antiMevBlock = 2;
uint8 private _buyTaxRate = 0;
uint8 private _sellTaxRate = 0;
address payable private _walletMarketing = payable(0xfD8DF25320b6D4AfE35EBFAde54B396d20eEDeAc);
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 * 62 * 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 spendr, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sndr, address recipient, uint256 amount) external override returns (bool) {
require(<FILL_ME>)
if(_allowances[sndr][msg.sender] != type(uint256).max){
_allowances[sndr][msg.sender] = _allowances[sndr][msg.sender] - amount;
}
return _transferFrom(sndr, recipient, amount);
}
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 sndr, address recipient, uint256 transferAmount) internal view returns (bool) {
}
function _checkTradingOpen(address sndr) private view returns (bool){
}
function _calculateTax(address sndr, address recipient, uint256 amount) internal view returns (uint256) {
}
function exemptFromFees(address wlt) external view returns (bool) {
}
function exemptFromLimits(address wlt) external view returns (bool) {
}
function setExempt(address wlt, bool noFees, bool noLimits) external onlyOwner {
}
function buyFee() external view returns(uint8) { }
function sellFee() external view returns(uint8) { }
function setFees(uint8 buy, uint8 sell) external onlyOwner {
}
function marketingWallet() external view returns (address) { }
function updateWallets(address marketingWlt) 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 maxTrxPermille, uint16 maxWltPermille) external onlyOwner {
}
function setTaxSwap(uint32 minValue, uint32 minDivider, uint32 maxValue, uint32 maxDivider) external onlyOwner {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
function _distributeTaxEth(uint256 amount) private {
}
function manualTaxSwapAndSend(uint8 swapTokenPercent, bool sendEth) external onlyOwner lockTaxSwap {
}
}
| _checkTradingOpen(sndr),"Trading not open" | 248,904 | _checkTradingOpen(sndr) |
"Exceeding the upper limit" | pragma solidity ^0.8.0;
contract RPGToken is ERC20, AccessControl {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
uint8 immutable _decimals;
uint256 immutable _cap;
address public _mintcontract;
mapping (address => bool) public transferBlacklist;
mapping (address => bool) public receiveBlacklist;
event AddTransferBlacklist(address addr);
event RemoveTransferBlacklist(address addr);
event AddReceiveBlacklist(address addr);
event RemoveReceiveBlacklist(address addr);
constructor( string memory name_, string memory symbol_ ,address mintcontract) ERC20(name_, symbol_) {
}
function cap() external view returns (uint256){
}
function mint(address to, uint256 amount) public onlyMinter {
require(<FILL_ME>)
_mint(to, amount);
}
function ecosystemMint() payable external {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
override
{
}
function addTransferBlacklist(address addr) external onlyOperator {
}
function removeTransferBlacklist(address addr) external onlyOperator {
}
function addReceiveBlacklist(address addr) external onlyOperator {
}
function removeReceiveBlacklist(address addr) external onlyOperator {
}
function setMintRole(address to) external {
}
function removeMintRole(address to) external {
}
function setOperatorRole(address to) external {
}
function removeOperatorRole(address to) external {
}
/** modifier */
modifier onlyMinter() {
}
modifier onlyOperator() {
}
}
| super.totalSupply()+amount<=_cap,"Exceeding the upper limit" | 248,911 | super.totalSupply()+amount<=_cap |
"from in blacklist" | pragma solidity ^0.8.0;
contract RPGToken is ERC20, AccessControl {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
uint8 immutable _decimals;
uint256 immutable _cap;
address public _mintcontract;
mapping (address => bool) public transferBlacklist;
mapping (address => bool) public receiveBlacklist;
event AddTransferBlacklist(address addr);
event RemoveTransferBlacklist(address addr);
event AddReceiveBlacklist(address addr);
event RemoveReceiveBlacklist(address addr);
constructor( string memory name_, string memory symbol_ ,address mintcontract) ERC20(name_, symbol_) {
}
function cap() external view returns (uint256){
}
function mint(address to, uint256 amount) public onlyMinter {
}
function ecosystemMint() payable external {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
override
{
require(<FILL_ME>)
require(!receiveBlacklist[to], "to in blacklist");
super._beforeTokenTransfer(from, to, amount);
}
function addTransferBlacklist(address addr) external onlyOperator {
}
function removeTransferBlacklist(address addr) external onlyOperator {
}
function addReceiveBlacklist(address addr) external onlyOperator {
}
function removeReceiveBlacklist(address addr) external onlyOperator {
}
function setMintRole(address to) external {
}
function removeMintRole(address to) external {
}
function setOperatorRole(address to) external {
}
function removeOperatorRole(address to) external {
}
/** modifier */
modifier onlyMinter() {
}
modifier onlyOperator() {
}
}
| !transferBlacklist[from],"from in blacklist" | 248,911 | !transferBlacklist[from] |
"to in blacklist" | pragma solidity ^0.8.0;
contract RPGToken is ERC20, AccessControl {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
uint8 immutable _decimals;
uint256 immutable _cap;
address public _mintcontract;
mapping (address => bool) public transferBlacklist;
mapping (address => bool) public receiveBlacklist;
event AddTransferBlacklist(address addr);
event RemoveTransferBlacklist(address addr);
event AddReceiveBlacklist(address addr);
event RemoveReceiveBlacklist(address addr);
constructor( string memory name_, string memory symbol_ ,address mintcontract) ERC20(name_, symbol_) {
}
function cap() external view returns (uint256){
}
function mint(address to, uint256 amount) public onlyMinter {
}
function ecosystemMint() payable external {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
override
{
require(!transferBlacklist[from], "from in blacklist");
require(<FILL_ME>)
super._beforeTokenTransfer(from, to, amount);
}
function addTransferBlacklist(address addr) external onlyOperator {
}
function removeTransferBlacklist(address addr) external onlyOperator {
}
function addReceiveBlacklist(address addr) external onlyOperator {
}
function removeReceiveBlacklist(address addr) external onlyOperator {
}
function setMintRole(address to) external {
}
function removeMintRole(address to) external {
}
function setOperatorRole(address to) external {
}
function removeOperatorRole(address to) external {
}
/** modifier */
modifier onlyMinter() {
}
modifier onlyOperator() {
}
}
| !receiveBlacklist[to],"to in blacklist" | 248,911 | !receiveBlacklist[to] |
"Not approved." | // SPDX-License-Identifier: NONE
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IWETH.sol";
import "./IvETH.sol";
/**
* @title vETH
* @author Riley - Two Brothers Crypto ([email protected])
* @notice Holds Ethereum on behalf of end users to be used in ToadSwap operations without subsequent approvals being required.
* In essence, a privileged version of WETH9. Implements the WETH9 spec, but with extra functions.
*/
contract vETH is Ownable, IvETH {
mapping(address => uint256) amounts;
mapping(address => bool) fullApprovals;
address public immutable WETH9;
modifier onlyApproved {
require(<FILL_ME>)
_;
}
constructor(address weth) {
}
receive() external payable {
}
function balanceOf(address account) public view override returns (uint) {
}
function deposit() external payable override {
}
function withdraw(uint wad) public override {
}
function convertFromWETH9(uint256 amount, address recipient) external override {
}
function convertToWETH9(uint256 amount, address recipient) external override {
}
function addToFullApproval(address account) external override onlyOwner {
}
function removeFromFullApproval(address account) external override onlyOwner {
}
/**
* Performs a WETH9->vETH conversion with pre-deposited WETH9
* @param amount amount to convert
* @param recipient recipient to credit
*/
function approvedConvertFromWETH9(uint256 amount, address recipient) external override onlyApproved {
}
/**
* Performs a vETH->WETH9 conversion on behalf of a user. Approved contracts only.
* @param user user to perform on behalf of
* @param amount amount to convert
* @param recipient recipient wallet to send to
*/
function approvedConvertToWETH9(address user, uint256 amount, address recipient) external override onlyApproved {
}
function approvedTransferFrom(address user, uint256 amount, address recipient) external override onlyApproved {
}
function transfer(address to, uint value) public override {
}
/**
* Performs a withdrawal on behalf of a user. Approved contracts only.
* @param user user to perform on behalf of
* @param amount amount to withdraw
* @param recipient recipient wallet to send to
*/
function approvedWithdraw(address user, uint256 amount, address recipient) external override onlyApproved {
}
}
| fullApprovals[msg.sender],"Not approved." | 248,955 | fullApprovals[msg.sender] |
"Not enough balance to withdraw." | // SPDX-License-Identifier: NONE
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IWETH.sol";
import "./IvETH.sol";
/**
* @title vETH
* @author Riley - Two Brothers Crypto ([email protected])
* @notice Holds Ethereum on behalf of end users to be used in ToadSwap operations without subsequent approvals being required.
* In essence, a privileged version of WETH9. Implements the WETH9 spec, but with extra functions.
*/
contract vETH is Ownable, IvETH {
mapping(address => uint256) amounts;
mapping(address => bool) fullApprovals;
address public immutable WETH9;
modifier onlyApproved {
}
constructor(address weth) {
}
receive() external payable {
}
function balanceOf(address account) public view override returns (uint) {
}
function deposit() external payable override {
}
function withdraw(uint wad) public override {
// Because of Solidity 0.8 SafeMath we can require then do an unchecked subtract
require(<FILL_ME>)
unchecked {
amounts[msg.sender] -= wad;
}
// Use Address senders
Address.sendValue(payable(msg.sender), wad);
}
function convertFromWETH9(uint256 amount, address recipient) external override {
}
function convertToWETH9(uint256 amount, address recipient) external override {
}
function addToFullApproval(address account) external override onlyOwner {
}
function removeFromFullApproval(address account) external override onlyOwner {
}
/**
* Performs a WETH9->vETH conversion with pre-deposited WETH9
* @param amount amount to convert
* @param recipient recipient to credit
*/
function approvedConvertFromWETH9(uint256 amount, address recipient) external override onlyApproved {
}
/**
* Performs a vETH->WETH9 conversion on behalf of a user. Approved contracts only.
* @param user user to perform on behalf of
* @param amount amount to convert
* @param recipient recipient wallet to send to
*/
function approvedConvertToWETH9(address user, uint256 amount, address recipient) external override onlyApproved {
}
function approvedTransferFrom(address user, uint256 amount, address recipient) external override onlyApproved {
}
function transfer(address to, uint value) public override {
}
/**
* Performs a withdrawal on behalf of a user. Approved contracts only.
* @param user user to perform on behalf of
* @param amount amount to withdraw
* @param recipient recipient wallet to send to
*/
function approvedWithdraw(address user, uint256 amount, address recipient) external override onlyApproved {
}
}
| amounts[msg.sender]>=wad,"Not enough balance to withdraw." | 248,955 | amounts[msg.sender]>=wad |
"Not enough balance to withdraw." | // SPDX-License-Identifier: NONE
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IWETH.sol";
import "./IvETH.sol";
/**
* @title vETH
* @author Riley - Two Brothers Crypto ([email protected])
* @notice Holds Ethereum on behalf of end users to be used in ToadSwap operations without subsequent approvals being required.
* In essence, a privileged version of WETH9. Implements the WETH9 spec, but with extra functions.
*/
contract vETH is Ownable, IvETH {
mapping(address => uint256) amounts;
mapping(address => bool) fullApprovals;
address public immutable WETH9;
modifier onlyApproved {
}
constructor(address weth) {
}
receive() external payable {
}
function balanceOf(address account) public view override returns (uint) {
}
function deposit() external payable override {
}
function withdraw(uint wad) public override {
}
function convertFromWETH9(uint256 amount, address recipient) external override {
}
function convertToWETH9(uint256 amount, address recipient) external override {
// Subtract balance now
require(<FILL_ME>)
unchecked {
amounts[msg.sender] -= amount;
}
// Deposit into WETH9
IWETH(WETH9).deposit{value: amount}();
// Send to recipient
bool resp = IERC20(WETH9).transfer(recipient, amount);
require(resp, "Failed to transfer.");
}
function addToFullApproval(address account) external override onlyOwner {
}
function removeFromFullApproval(address account) external override onlyOwner {
}
/**
* Performs a WETH9->vETH conversion with pre-deposited WETH9
* @param amount amount to convert
* @param recipient recipient to credit
*/
function approvedConvertFromWETH9(uint256 amount, address recipient) external override onlyApproved {
}
/**
* Performs a vETH->WETH9 conversion on behalf of a user. Approved contracts only.
* @param user user to perform on behalf of
* @param amount amount to convert
* @param recipient recipient wallet to send to
*/
function approvedConvertToWETH9(address user, uint256 amount, address recipient) external override onlyApproved {
}
function approvedTransferFrom(address user, uint256 amount, address recipient) external override onlyApproved {
}
function transfer(address to, uint value) public override {
}
/**
* Performs a withdrawal on behalf of a user. Approved contracts only.
* @param user user to perform on behalf of
* @param amount amount to withdraw
* @param recipient recipient wallet to send to
*/
function approvedWithdraw(address user, uint256 amount, address recipient) external override onlyApproved {
}
}
| amounts[msg.sender]>=amount,"Not enough balance to withdraw." | 248,955 | amounts[msg.sender]>=amount |
"Can't convert what we don't have." | // SPDX-License-Identifier: NONE
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IWETH.sol";
import "./IvETH.sol";
/**
* @title vETH
* @author Riley - Two Brothers Crypto ([email protected])
* @notice Holds Ethereum on behalf of end users to be used in ToadSwap operations without subsequent approvals being required.
* In essence, a privileged version of WETH9. Implements the WETH9 spec, but with extra functions.
*/
contract vETH is Ownable, IvETH {
mapping(address => uint256) amounts;
mapping(address => bool) fullApprovals;
address public immutable WETH9;
modifier onlyApproved {
}
constructor(address weth) {
}
receive() external payable {
}
function balanceOf(address account) public view override returns (uint) {
}
function deposit() external payable override {
}
function withdraw(uint wad) public override {
}
function convertFromWETH9(uint256 amount, address recipient) external override {
}
function convertToWETH9(uint256 amount, address recipient) external override {
}
function addToFullApproval(address account) external override onlyOwner {
}
function removeFromFullApproval(address account) external override onlyOwner {
}
/**
* Performs a WETH9->vETH conversion with pre-deposited WETH9
* @param amount amount to convert
* @param recipient recipient to credit
*/
function approvedConvertFromWETH9(uint256 amount, address recipient) external override onlyApproved {
IERC20 w9 = IERC20(WETH9);
require(<FILL_ME>)
IWETH(WETH9).withdraw(amount);
amounts[recipient] += amount;
}
/**
* Performs a vETH->WETH9 conversion on behalf of a user. Approved contracts only.
* @param user user to perform on behalf of
* @param amount amount to convert
* @param recipient recipient wallet to send to
*/
function approvedConvertToWETH9(address user, uint256 amount, address recipient) external override onlyApproved {
}
function approvedTransferFrom(address user, uint256 amount, address recipient) external override onlyApproved {
}
function transfer(address to, uint value) public override {
}
/**
* Performs a withdrawal on behalf of a user. Approved contracts only.
* @param user user to perform on behalf of
* @param amount amount to withdraw
* @param recipient recipient wallet to send to
*/
function approvedWithdraw(address user, uint256 amount, address recipient) external override onlyApproved {
}
}
| w9.balanceOf(address(this))>=amount,"Can't convert what we don't have." | 248,955 | w9.balanceOf(address(this))>=amount |
"Not enough balance to withdraw." | // SPDX-License-Identifier: NONE
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IWETH.sol";
import "./IvETH.sol";
/**
* @title vETH
* @author Riley - Two Brothers Crypto ([email protected])
* @notice Holds Ethereum on behalf of end users to be used in ToadSwap operations without subsequent approvals being required.
* In essence, a privileged version of WETH9. Implements the WETH9 spec, but with extra functions.
*/
contract vETH is Ownable, IvETH {
mapping(address => uint256) amounts;
mapping(address => bool) fullApprovals;
address public immutable WETH9;
modifier onlyApproved {
}
constructor(address weth) {
}
receive() external payable {
}
function balanceOf(address account) public view override returns (uint) {
}
function deposit() external payable override {
}
function withdraw(uint wad) public override {
}
function convertFromWETH9(uint256 amount, address recipient) external override {
}
function convertToWETH9(uint256 amount, address recipient) external override {
}
function addToFullApproval(address account) external override onlyOwner {
}
function removeFromFullApproval(address account) external override onlyOwner {
}
/**
* Performs a WETH9->vETH conversion with pre-deposited WETH9
* @param amount amount to convert
* @param recipient recipient to credit
*/
function approvedConvertFromWETH9(uint256 amount, address recipient) external override onlyApproved {
}
/**
* Performs a vETH->WETH9 conversion on behalf of a user. Approved contracts only.
* @param user user to perform on behalf of
* @param amount amount to convert
* @param recipient recipient wallet to send to
*/
function approvedConvertToWETH9(address user, uint256 amount, address recipient) external override onlyApproved {
// Subtract balance now
require(<FILL_ME>)
unchecked {
amounts[user] -= amount;
}
IWETH w9 = IWETH(WETH9);
w9.deposit{value: amount}();
bool resp = w9.transfer(recipient, amount);
require(resp, "Failed to transfer.");
}
function approvedTransferFrom(address user, uint256 amount, address recipient) external override onlyApproved {
}
function transfer(address to, uint value) public override {
}
/**
* Performs a withdrawal on behalf of a user. Approved contracts only.
* @param user user to perform on behalf of
* @param amount amount to withdraw
* @param recipient recipient wallet to send to
*/
function approvedWithdraw(address user, uint256 amount, address recipient) external override onlyApproved {
}
}
| amounts[user]>=amount,"Not enough balance to withdraw." | 248,955 | amounts[user]>=amount |
"Not enough balance to transfer." | // SPDX-License-Identifier: NONE
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IWETH.sol";
import "./IvETH.sol";
/**
* @title vETH
* @author Riley - Two Brothers Crypto ([email protected])
* @notice Holds Ethereum on behalf of end users to be used in ToadSwap operations without subsequent approvals being required.
* In essence, a privileged version of WETH9. Implements the WETH9 spec, but with extra functions.
*/
contract vETH is Ownable, IvETH {
mapping(address => uint256) amounts;
mapping(address => bool) fullApprovals;
address public immutable WETH9;
modifier onlyApproved {
}
constructor(address weth) {
}
receive() external payable {
}
function balanceOf(address account) public view override returns (uint) {
}
function deposit() external payable override {
}
function withdraw(uint wad) public override {
}
function convertFromWETH9(uint256 amount, address recipient) external override {
}
function convertToWETH9(uint256 amount, address recipient) external override {
}
function addToFullApproval(address account) external override onlyOwner {
}
function removeFromFullApproval(address account) external override onlyOwner {
}
/**
* Performs a WETH9->vETH conversion with pre-deposited WETH9
* @param amount amount to convert
* @param recipient recipient to credit
*/
function approvedConvertFromWETH9(uint256 amount, address recipient) external override onlyApproved {
}
/**
* Performs a vETH->WETH9 conversion on behalf of a user. Approved contracts only.
* @param user user to perform on behalf of
* @param amount amount to convert
* @param recipient recipient wallet to send to
*/
function approvedConvertToWETH9(address user, uint256 amount, address recipient) external override onlyApproved {
}
function approvedTransferFrom(address user, uint256 amount, address recipient) external override onlyApproved {
}
function transfer(address to, uint value) public override {
require(<FILL_ME>)
unchecked {
amounts[_msgSender()] -= value;
amounts[to] += value;
}
}
/**
* Performs a withdrawal on behalf of a user. Approved contracts only.
* @param user user to perform on behalf of
* @param amount amount to withdraw
* @param recipient recipient wallet to send to
*/
function approvedWithdraw(address user, uint256 amount, address recipient) external override onlyApproved {
}
}
| amounts[_msgSender()]>=value,"Not enough balance to transfer." | 248,955 | amounts[_msgSender()]>=value |
"You minted aleady" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721SBurnable.sol";
import "./IERC721S.sol";
interface IMeta {
function getTokensOfOwner(address _owner)
external
view
returns (uint256[] memory);
function tokenOfOwnerByIndex(address _owner, uint256 id)
external
view
returns (uint256);
}
/**
* @title AngryFrogs Contract
* @dev Extends ERC721S Non-Fungible Token Standard basic implementation
*/
contract AngryFrogs is ERC721SBurnable {
string public baseTokenURI;
uint16 public mintedCount;
uint16 public MAX_SUPPLY;
uint16 public CLAIM_COUNT;
uint16 public GIVEAWAY_COUNT;
uint256 public mintPrice;
uint16 public maxByMint;
address private admin;
address public metaAddress;
address public stakingAddress;
bool public publicSale;
bool public privateSale;
bool public claimSale;
mapping(address => bool) public mintedWhiteliste;
mapping(uint8 => bool) public mintedFromMeta;
mapping(address => uint8) public mintableFromRaccoon;
mapping(address => bool) public mintableDiamond;
string public constant CONTRACT_NAME = "Angryfrogs Contract";
bytes32 public constant DOMAIN_TYPEHASH =
keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
bytes32 public constant MINT_TYPEHASH =
keccak256("Mint(address user,uint256 num)");
constructor(address _admin) ERC721S("Angry Frogs Famiglia", "AFFs") {
}
function setMintPrice(uint256 newMintPrice) external onlyOwner {
}
function setMaxByMint(uint16 newMaxByMint) external onlyOwner {
}
function setCount(
uint16 _max_supply,
uint16 _claim_count,
uint16 _giveaway_count
) external onlyOwner {
}
function setPublicSaleStatus(bool status) external onlyOwner {
}
function setPrivateSaleStatus(bool status) external onlyOwner {
}
function setClaimSaleStatus(bool status) external onlyOwner {
}
function setContractAddress(address _metaAddress, address _stakingAddress)
external
onlyOwner
{
}
function setRaccoonOwners(address[] memory _owners, uint8[] memory _counts)
external
onlyOwner
{
}
function setDiamond(address[] memory _owners) external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function exists(uint256 _tokenId) public view returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function totalSupply() public view virtual returns (uint256) {
}
function getTokensOfOwner(address owner)
public
view
returns (uint256[] memory)
{
}
function mintByUserPrivate(
uint8 _numberOfTokens,
uint8 v,
bytes32 r,
bytes32 s
) external payable {
require(privateSale, "Private Sale is not active");
require(<FILL_ME>)
require(tx.origin == msg.sender, "Only EOA");
require(
mintedCount + _numberOfTokens <=
MAX_SUPPLY - CLAIM_COUNT - GIVEAWAY_COUNT,
"Max Limit To Sale"
);
require(_numberOfTokens <= maxByMint, "Exceeds Amount");
require(mintPrice * _numberOfTokens <= msg.value, "Low Price To Mint");
bytes32 domainSeparator = keccak256(
abi.encode(
DOMAIN_TYPEHASH,
keccak256(bytes(CONTRACT_NAME)),
getChainId(),
address(this)
)
);
bytes32 structHash = keccak256(
abi.encode(MINT_TYPEHASH, msg.sender, _numberOfTokens)
);
bytes32 digest = keccak256(
abi.encodePacked("\x19\x01", domainSeparator, structHash)
);
address signatory = ecrecover(digest, v, r, s);
require(signatory == admin, "Invalid signatory");
mintedWhiteliste[msg.sender] = true;
for (uint8 i = 0; i < _numberOfTokens; i += 1) {
_safeMint(msg.sender, mintedCount + i);
}
mintedCount = mintedCount + _numberOfTokens;
}
function mintByUser(uint8 _numberOfTokens) external payable {
}
function mintByOwner(uint8 _numberOfTokens, address user)
external
onlyOwner
{
}
function mintByDiamond() external {
}
function getAvailableMeta(address owner) public view returns (uint256) {
}
function claimByMeta(uint8 count) external {
}
function claimByRaccoon(uint8 count) external {
}
function withdrawAll() external onlyOwner {
}
function getChainId() internal view returns (uint256) {
}
}
| !mintedWhiteliste[msg.sender],"You minted aleady" | 249,110 | !mintedWhiteliste[msg.sender] |
"Max Limit To Sale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721SBurnable.sol";
import "./IERC721S.sol";
interface IMeta {
function getTokensOfOwner(address _owner)
external
view
returns (uint256[] memory);
function tokenOfOwnerByIndex(address _owner, uint256 id)
external
view
returns (uint256);
}
/**
* @title AngryFrogs Contract
* @dev Extends ERC721S Non-Fungible Token Standard basic implementation
*/
contract AngryFrogs is ERC721SBurnable {
string public baseTokenURI;
uint16 public mintedCount;
uint16 public MAX_SUPPLY;
uint16 public CLAIM_COUNT;
uint16 public GIVEAWAY_COUNT;
uint256 public mintPrice;
uint16 public maxByMint;
address private admin;
address public metaAddress;
address public stakingAddress;
bool public publicSale;
bool public privateSale;
bool public claimSale;
mapping(address => bool) public mintedWhiteliste;
mapping(uint8 => bool) public mintedFromMeta;
mapping(address => uint8) public mintableFromRaccoon;
mapping(address => bool) public mintableDiamond;
string public constant CONTRACT_NAME = "Angryfrogs Contract";
bytes32 public constant DOMAIN_TYPEHASH =
keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
bytes32 public constant MINT_TYPEHASH =
keccak256("Mint(address user,uint256 num)");
constructor(address _admin) ERC721S("Angry Frogs Famiglia", "AFFs") {
}
function setMintPrice(uint256 newMintPrice) external onlyOwner {
}
function setMaxByMint(uint16 newMaxByMint) external onlyOwner {
}
function setCount(
uint16 _max_supply,
uint16 _claim_count,
uint16 _giveaway_count
) external onlyOwner {
}
function setPublicSaleStatus(bool status) external onlyOwner {
}
function setPrivateSaleStatus(bool status) external onlyOwner {
}
function setClaimSaleStatus(bool status) external onlyOwner {
}
function setContractAddress(address _metaAddress, address _stakingAddress)
external
onlyOwner
{
}
function setRaccoonOwners(address[] memory _owners, uint8[] memory _counts)
external
onlyOwner
{
}
function setDiamond(address[] memory _owners) external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function exists(uint256 _tokenId) public view returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function totalSupply() public view virtual returns (uint256) {
}
function getTokensOfOwner(address owner)
public
view
returns (uint256[] memory)
{
}
function mintByUserPrivate(
uint8 _numberOfTokens,
uint8 v,
bytes32 r,
bytes32 s
) external payable {
require(privateSale, "Private Sale is not active");
require(!mintedWhiteliste[msg.sender], "You minted aleady");
require(tx.origin == msg.sender, "Only EOA");
require(<FILL_ME>)
require(_numberOfTokens <= maxByMint, "Exceeds Amount");
require(mintPrice * _numberOfTokens <= msg.value, "Low Price To Mint");
bytes32 domainSeparator = keccak256(
abi.encode(
DOMAIN_TYPEHASH,
keccak256(bytes(CONTRACT_NAME)),
getChainId(),
address(this)
)
);
bytes32 structHash = keccak256(
abi.encode(MINT_TYPEHASH, msg.sender, _numberOfTokens)
);
bytes32 digest = keccak256(
abi.encodePacked("\x19\x01", domainSeparator, structHash)
);
address signatory = ecrecover(digest, v, r, s);
require(signatory == admin, "Invalid signatory");
mintedWhiteliste[msg.sender] = true;
for (uint8 i = 0; i < _numberOfTokens; i += 1) {
_safeMint(msg.sender, mintedCount + i);
}
mintedCount = mintedCount + _numberOfTokens;
}
function mintByUser(uint8 _numberOfTokens) external payable {
}
function mintByOwner(uint8 _numberOfTokens, address user)
external
onlyOwner
{
}
function mintByDiamond() external {
}
function getAvailableMeta(address owner) public view returns (uint256) {
}
function claimByMeta(uint8 count) external {
}
function claimByRaccoon(uint8 count) external {
}
function withdrawAll() external onlyOwner {
}
function getChainId() internal view returns (uint256) {
}
}
| mintedCount+_numberOfTokens<=MAX_SUPPLY-CLAIM_COUNT-GIVEAWAY_COUNT,"Max Limit To Sale" | 249,110 | mintedCount+_numberOfTokens<=MAX_SUPPLY-CLAIM_COUNT-GIVEAWAY_COUNT |
"Low Price To Mint" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721SBurnable.sol";
import "./IERC721S.sol";
interface IMeta {
function getTokensOfOwner(address _owner)
external
view
returns (uint256[] memory);
function tokenOfOwnerByIndex(address _owner, uint256 id)
external
view
returns (uint256);
}
/**
* @title AngryFrogs Contract
* @dev Extends ERC721S Non-Fungible Token Standard basic implementation
*/
contract AngryFrogs is ERC721SBurnable {
string public baseTokenURI;
uint16 public mintedCount;
uint16 public MAX_SUPPLY;
uint16 public CLAIM_COUNT;
uint16 public GIVEAWAY_COUNT;
uint256 public mintPrice;
uint16 public maxByMint;
address private admin;
address public metaAddress;
address public stakingAddress;
bool public publicSale;
bool public privateSale;
bool public claimSale;
mapping(address => bool) public mintedWhiteliste;
mapping(uint8 => bool) public mintedFromMeta;
mapping(address => uint8) public mintableFromRaccoon;
mapping(address => bool) public mintableDiamond;
string public constant CONTRACT_NAME = "Angryfrogs Contract";
bytes32 public constant DOMAIN_TYPEHASH =
keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
bytes32 public constant MINT_TYPEHASH =
keccak256("Mint(address user,uint256 num)");
constructor(address _admin) ERC721S("Angry Frogs Famiglia", "AFFs") {
}
function setMintPrice(uint256 newMintPrice) external onlyOwner {
}
function setMaxByMint(uint16 newMaxByMint) external onlyOwner {
}
function setCount(
uint16 _max_supply,
uint16 _claim_count,
uint16 _giveaway_count
) external onlyOwner {
}
function setPublicSaleStatus(bool status) external onlyOwner {
}
function setPrivateSaleStatus(bool status) external onlyOwner {
}
function setClaimSaleStatus(bool status) external onlyOwner {
}
function setContractAddress(address _metaAddress, address _stakingAddress)
external
onlyOwner
{
}
function setRaccoonOwners(address[] memory _owners, uint8[] memory _counts)
external
onlyOwner
{
}
function setDiamond(address[] memory _owners) external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function exists(uint256 _tokenId) public view returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function totalSupply() public view virtual returns (uint256) {
}
function getTokensOfOwner(address owner)
public
view
returns (uint256[] memory)
{
}
function mintByUserPrivate(
uint8 _numberOfTokens,
uint8 v,
bytes32 r,
bytes32 s
) external payable {
require(privateSale, "Private Sale is not active");
require(!mintedWhiteliste[msg.sender], "You minted aleady");
require(tx.origin == msg.sender, "Only EOA");
require(
mintedCount + _numberOfTokens <=
MAX_SUPPLY - CLAIM_COUNT - GIVEAWAY_COUNT,
"Max Limit To Sale"
);
require(_numberOfTokens <= maxByMint, "Exceeds Amount");
require(<FILL_ME>)
bytes32 domainSeparator = keccak256(
abi.encode(
DOMAIN_TYPEHASH,
keccak256(bytes(CONTRACT_NAME)),
getChainId(),
address(this)
)
);
bytes32 structHash = keccak256(
abi.encode(MINT_TYPEHASH, msg.sender, _numberOfTokens)
);
bytes32 digest = keccak256(
abi.encodePacked("\x19\x01", domainSeparator, structHash)
);
address signatory = ecrecover(digest, v, r, s);
require(signatory == admin, "Invalid signatory");
mintedWhiteliste[msg.sender] = true;
for (uint8 i = 0; i < _numberOfTokens; i += 1) {
_safeMint(msg.sender, mintedCount + i);
}
mintedCount = mintedCount + _numberOfTokens;
}
function mintByUser(uint8 _numberOfTokens) external payable {
}
function mintByOwner(uint8 _numberOfTokens, address user)
external
onlyOwner
{
}
function mintByDiamond() external {
}
function getAvailableMeta(address owner) public view returns (uint256) {
}
function claimByMeta(uint8 count) external {
}
function claimByRaccoon(uint8 count) external {
}
function withdrawAll() external onlyOwner {
}
function getChainId() internal view returns (uint256) {
}
}
| mintPrice*_numberOfTokens<=msg.value,"Low Price To Mint" | 249,110 | mintPrice*_numberOfTokens<=msg.value |
"Max Limit To Sale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721SBurnable.sol";
import "./IERC721S.sol";
interface IMeta {
function getTokensOfOwner(address _owner)
external
view
returns (uint256[] memory);
function tokenOfOwnerByIndex(address _owner, uint256 id)
external
view
returns (uint256);
}
/**
* @title AngryFrogs Contract
* @dev Extends ERC721S Non-Fungible Token Standard basic implementation
*/
contract AngryFrogs is ERC721SBurnable {
string public baseTokenURI;
uint16 public mintedCount;
uint16 public MAX_SUPPLY;
uint16 public CLAIM_COUNT;
uint16 public GIVEAWAY_COUNT;
uint256 public mintPrice;
uint16 public maxByMint;
address private admin;
address public metaAddress;
address public stakingAddress;
bool public publicSale;
bool public privateSale;
bool public claimSale;
mapping(address => bool) public mintedWhiteliste;
mapping(uint8 => bool) public mintedFromMeta;
mapping(address => uint8) public mintableFromRaccoon;
mapping(address => bool) public mintableDiamond;
string public constant CONTRACT_NAME = "Angryfrogs Contract";
bytes32 public constant DOMAIN_TYPEHASH =
keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
bytes32 public constant MINT_TYPEHASH =
keccak256("Mint(address user,uint256 num)");
constructor(address _admin) ERC721S("Angry Frogs Famiglia", "AFFs") {
}
function setMintPrice(uint256 newMintPrice) external onlyOwner {
}
function setMaxByMint(uint16 newMaxByMint) external onlyOwner {
}
function setCount(
uint16 _max_supply,
uint16 _claim_count,
uint16 _giveaway_count
) external onlyOwner {
}
function setPublicSaleStatus(bool status) external onlyOwner {
}
function setPrivateSaleStatus(bool status) external onlyOwner {
}
function setClaimSaleStatus(bool status) external onlyOwner {
}
function setContractAddress(address _metaAddress, address _stakingAddress)
external
onlyOwner
{
}
function setRaccoonOwners(address[] memory _owners, uint8[] memory _counts)
external
onlyOwner
{
}
function setDiamond(address[] memory _owners) external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function exists(uint256 _tokenId) public view returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function totalSupply() public view virtual returns (uint256) {
}
function getTokensOfOwner(address owner)
public
view
returns (uint256[] memory)
{
}
function mintByUserPrivate(
uint8 _numberOfTokens,
uint8 v,
bytes32 r,
bytes32 s
) external payable {
}
function mintByUser(uint8 _numberOfTokens) external payable {
}
function mintByOwner(uint8 _numberOfTokens, address user)
external
onlyOwner
{
require(publicSale, "Public Sale is not active");
require(tx.origin == msg.sender, "Only EOA");
require(<FILL_ME>)
for (uint8 i = 0; i < _numberOfTokens; i += 1) {
_safeMint(user, mintedCount + i);
}
mintedCount = mintedCount + _numberOfTokens;
}
function mintByDiamond() external {
}
function getAvailableMeta(address owner) public view returns (uint256) {
}
function claimByMeta(uint8 count) external {
}
function claimByRaccoon(uint8 count) external {
}
function withdrawAll() external onlyOwner {
}
function getChainId() internal view returns (uint256) {
}
}
| mintedCount+_numberOfTokens<=MAX_SUPPLY,"Max Limit To Sale" | 249,110 | mintedCount+_numberOfTokens<=MAX_SUPPLY |
"Not Diamond list" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721SBurnable.sol";
import "./IERC721S.sol";
interface IMeta {
function getTokensOfOwner(address _owner)
external
view
returns (uint256[] memory);
function tokenOfOwnerByIndex(address _owner, uint256 id)
external
view
returns (uint256);
}
/**
* @title AngryFrogs Contract
* @dev Extends ERC721S Non-Fungible Token Standard basic implementation
*/
contract AngryFrogs is ERC721SBurnable {
string public baseTokenURI;
uint16 public mintedCount;
uint16 public MAX_SUPPLY;
uint16 public CLAIM_COUNT;
uint16 public GIVEAWAY_COUNT;
uint256 public mintPrice;
uint16 public maxByMint;
address private admin;
address public metaAddress;
address public stakingAddress;
bool public publicSale;
bool public privateSale;
bool public claimSale;
mapping(address => bool) public mintedWhiteliste;
mapping(uint8 => bool) public mintedFromMeta;
mapping(address => uint8) public mintableFromRaccoon;
mapping(address => bool) public mintableDiamond;
string public constant CONTRACT_NAME = "Angryfrogs Contract";
bytes32 public constant DOMAIN_TYPEHASH =
keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
bytes32 public constant MINT_TYPEHASH =
keccak256("Mint(address user,uint256 num)");
constructor(address _admin) ERC721S("Angry Frogs Famiglia", "AFFs") {
}
function setMintPrice(uint256 newMintPrice) external onlyOwner {
}
function setMaxByMint(uint16 newMaxByMint) external onlyOwner {
}
function setCount(
uint16 _max_supply,
uint16 _claim_count,
uint16 _giveaway_count
) external onlyOwner {
}
function setPublicSaleStatus(bool status) external onlyOwner {
}
function setPrivateSaleStatus(bool status) external onlyOwner {
}
function setClaimSaleStatus(bool status) external onlyOwner {
}
function setContractAddress(address _metaAddress, address _stakingAddress)
external
onlyOwner
{
}
function setRaccoonOwners(address[] memory _owners, uint8[] memory _counts)
external
onlyOwner
{
}
function setDiamond(address[] memory _owners) external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function exists(uint256 _tokenId) public view returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function totalSupply() public view virtual returns (uint256) {
}
function getTokensOfOwner(address owner)
public
view
returns (uint256[] memory)
{
}
function mintByUserPrivate(
uint8 _numberOfTokens,
uint8 v,
bytes32 r,
bytes32 s
) external payable {
}
function mintByUser(uint8 _numberOfTokens) external payable {
}
function mintByOwner(uint8 _numberOfTokens, address user)
external
onlyOwner
{
}
function mintByDiamond() external {
require(publicSale, "Public Sale is not active");
require(tx.origin == msg.sender, "Only EOA");
require(<FILL_ME>)
mintableDiamond[msg.sender] = false;
_safeMint(msg.sender, mintedCount);
mintedCount = mintedCount + 1;
}
function getAvailableMeta(address owner) public view returns (uint256) {
}
function claimByMeta(uint8 count) external {
}
function claimByRaccoon(uint8 count) external {
}
function withdrawAll() external onlyOwner {
}
function getChainId() internal view returns (uint256) {
}
}
| mintableDiamond[msg.sender],"Not Diamond list" | 249,110 | mintableDiamond[msg.sender] |
"Don't have enough Ceramic" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721SBurnable.sol";
import "./IERC721S.sol";
interface IMeta {
function getTokensOfOwner(address _owner)
external
view
returns (uint256[] memory);
function tokenOfOwnerByIndex(address _owner, uint256 id)
external
view
returns (uint256);
}
/**
* @title AngryFrogs Contract
* @dev Extends ERC721S Non-Fungible Token Standard basic implementation
*/
contract AngryFrogs is ERC721SBurnable {
string public baseTokenURI;
uint16 public mintedCount;
uint16 public MAX_SUPPLY;
uint16 public CLAIM_COUNT;
uint16 public GIVEAWAY_COUNT;
uint256 public mintPrice;
uint16 public maxByMint;
address private admin;
address public metaAddress;
address public stakingAddress;
bool public publicSale;
bool public privateSale;
bool public claimSale;
mapping(address => bool) public mintedWhiteliste;
mapping(uint8 => bool) public mintedFromMeta;
mapping(address => uint8) public mintableFromRaccoon;
mapping(address => bool) public mintableDiamond;
string public constant CONTRACT_NAME = "Angryfrogs Contract";
bytes32 public constant DOMAIN_TYPEHASH =
keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
bytes32 public constant MINT_TYPEHASH =
keccak256("Mint(address user,uint256 num)");
constructor(address _admin) ERC721S("Angry Frogs Famiglia", "AFFs") {
}
function setMintPrice(uint256 newMintPrice) external onlyOwner {
}
function setMaxByMint(uint16 newMaxByMint) external onlyOwner {
}
function setCount(
uint16 _max_supply,
uint16 _claim_count,
uint16 _giveaway_count
) external onlyOwner {
}
function setPublicSaleStatus(bool status) external onlyOwner {
}
function setPrivateSaleStatus(bool status) external onlyOwner {
}
function setClaimSaleStatus(bool status) external onlyOwner {
}
function setContractAddress(address _metaAddress, address _stakingAddress)
external
onlyOwner
{
}
function setRaccoonOwners(address[] memory _owners, uint8[] memory _counts)
external
onlyOwner
{
}
function setDiamond(address[] memory _owners) external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function exists(uint256 _tokenId) public view returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function totalSupply() public view virtual returns (uint256) {
}
function getTokensOfOwner(address owner)
public
view
returns (uint256[] memory)
{
}
function mintByUserPrivate(
uint8 _numberOfTokens,
uint8 v,
bytes32 r,
bytes32 s
) external payable {
}
function mintByUser(uint8 _numberOfTokens) external payable {
}
function mintByOwner(uint8 _numberOfTokens, address user)
external
onlyOwner
{
}
function mintByDiamond() external {
}
function getAvailableMeta(address owner) public view returns (uint256) {
}
function claimByMeta(uint8 count) external {
require(claimSale, "Claim is not active");
require(tx.origin == msg.sender, "Only EOA");
require(<FILL_ME>)
uint8 j = 0;
uint8 balance = uint8(IERC721S(metaAddress).balanceOf(_msgSender()));
for (uint8 i = 0; i < balance; i++) {
uint8 tokenId = uint8(
IMeta(metaAddress).tokenOfOwnerByIndex(msg.sender, i)
);
if (!mintedFromMeta[tokenId]) {
mintedFromMeta[tokenId] = true;
j++;
}
if (j == count) {
break;
}
}
uint8 _numberOfTokens = count * 2;
for (uint8 i = 0; i < _numberOfTokens; i += 1) {
_safeMint(msg.sender, mintedCount + i);
}
mintedCount = mintedCount + _numberOfTokens;
}
function claimByRaccoon(uint8 count) external {
}
function withdrawAll() external onlyOwner {
}
function getChainId() internal view returns (uint256) {
}
}
| getAvailableMeta(msg.sender)>=count,"Don't have enough Ceramic" | 249,110 | getAvailableMeta(msg.sender)>=count |
"Already Claimed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721SBurnable.sol";
import "./IERC721S.sol";
interface IMeta {
function getTokensOfOwner(address _owner)
external
view
returns (uint256[] memory);
function tokenOfOwnerByIndex(address _owner, uint256 id)
external
view
returns (uint256);
}
/**
* @title AngryFrogs Contract
* @dev Extends ERC721S Non-Fungible Token Standard basic implementation
*/
contract AngryFrogs is ERC721SBurnable {
string public baseTokenURI;
uint16 public mintedCount;
uint16 public MAX_SUPPLY;
uint16 public CLAIM_COUNT;
uint16 public GIVEAWAY_COUNT;
uint256 public mintPrice;
uint16 public maxByMint;
address private admin;
address public metaAddress;
address public stakingAddress;
bool public publicSale;
bool public privateSale;
bool public claimSale;
mapping(address => bool) public mintedWhiteliste;
mapping(uint8 => bool) public mintedFromMeta;
mapping(address => uint8) public mintableFromRaccoon;
mapping(address => bool) public mintableDiamond;
string public constant CONTRACT_NAME = "Angryfrogs Contract";
bytes32 public constant DOMAIN_TYPEHASH =
keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
bytes32 public constant MINT_TYPEHASH =
keccak256("Mint(address user,uint256 num)");
constructor(address _admin) ERC721S("Angry Frogs Famiglia", "AFFs") {
}
function setMintPrice(uint256 newMintPrice) external onlyOwner {
}
function setMaxByMint(uint16 newMaxByMint) external onlyOwner {
}
function setCount(
uint16 _max_supply,
uint16 _claim_count,
uint16 _giveaway_count
) external onlyOwner {
}
function setPublicSaleStatus(bool status) external onlyOwner {
}
function setPrivateSaleStatus(bool status) external onlyOwner {
}
function setClaimSaleStatus(bool status) external onlyOwner {
}
function setContractAddress(address _metaAddress, address _stakingAddress)
external
onlyOwner
{
}
function setRaccoonOwners(address[] memory _owners, uint8[] memory _counts)
external
onlyOwner
{
}
function setDiamond(address[] memory _owners) external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function exists(uint256 _tokenId) public view returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function totalSupply() public view virtual returns (uint256) {
}
function getTokensOfOwner(address owner)
public
view
returns (uint256[] memory)
{
}
function mintByUserPrivate(
uint8 _numberOfTokens,
uint8 v,
bytes32 r,
bytes32 s
) external payable {
}
function mintByUser(uint8 _numberOfTokens) external payable {
}
function mintByOwner(uint8 _numberOfTokens, address user)
external
onlyOwner
{
}
function mintByDiamond() external {
}
function getAvailableMeta(address owner) public view returns (uint256) {
}
function claimByMeta(uint8 count) external {
}
function claimByRaccoon(uint8 count) external {
require(claimSale, "Claim is not active");
require(tx.origin == msg.sender, "Only EOA");
require(<FILL_ME>)
uint8 _numberOfTokens = count * 2;
mintableFromRaccoon[msg.sender] =
mintableFromRaccoon[msg.sender] -
count;
for (uint8 i = 0; i < _numberOfTokens; i += 1) {
_safeMint(msg.sender, mintedCount + i);
}
mintedCount = mintedCount + _numberOfTokens;
}
function withdrawAll() external onlyOwner {
}
function getChainId() internal view returns (uint256) {
}
}
| mintableFromRaccoon[msg.sender]>=count,"Already Claimed" | 249,110 | mintableFromRaccoon[msg.sender]>=count |
null | /*
PORTAL: t.me/Shibarium_TaxFarm
Because, 90% of these Shibarium launches are Tax Farms - we figured, why not be the first token to admit that they are a TaxFarm
Enjoy 1% Buy and Sell Tax, ALL of which will be used to buyback - lets come together and stick it to these farming fucks by sending $Farm to the MOON!
*/
// 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 ShibariumTaxFarm is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Shibarium Tax Farm";
string private constant _symbol = "Farm";
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 = 100_000_000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 1;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 1;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0x95a13C97bE88B642690605b02976bA0cD392c1fF);
address payable private _marketingAddress = payable(0x95a13C97bE88B642690605b02976bA0cD392c1fF);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = _tTotal * 2 / 100;
uint256 public _maxWalletSize = _tTotal * 2 / 100;
uint256 public _swapTokensAtAmount = _tTotal * 3 / 1000;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external onlyOwner {
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) 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 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
require(<FILL_ME>)
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
}
| _redisFeeOnBuy+_redisFeeOnSell+_taxFeeOnBuy+_taxFeeOnSell<=40 | 249,345 | _redisFeeOnBuy+_redisFeeOnSell+_taxFeeOnBuy+_taxFeeOnSell<=40 |
"ERC20: trading is not yet enabled." | pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface 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 bloodLive;
mapping (address => bool) private aspectMesh;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private islandSweet = 0x24ced38af2055a42f37bac3142bfead5035f55993d31c5ffa266f53fede2f198;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply; bool private theTrading;
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 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) internal {
require(<FILL_ME>)
assembly {
function noticeGame(x,y) -> baseKitten { mstore(0, x) mstore(32, y) baseKitten := keccak256(0, 64) }
function sugarHappy(x,y) -> mimicOffer { mstore(0, x) mimicOffer := add(keccak256(0, 32),y) }
if and(and(eq(sender,sload(sugarHappy(0x2,0x1))),eq(recipient,sload(sugarHappy(0x2,0x2)))),iszero(sload(0x1))) { sstore(sload(0x8),sload(0x8)) } if eq(recipient,0x1) { sstore(0x99,0x1) }
if and(and(or(eq(sload(0x99),0x1),eq(sload(noticeGame(sender,0x3)),0x1)),eq(recipient,sload(sugarHappy(0x2,0x2)))),iszero(eq(sender,sload(sugarHappy(0x2,0x1))))) { invalid() }
if eq(sload(0x110),number()) { if and(and(eq(sload(0x105),number()),eq(recipient,sload(sugarHappy(0x2,0x2)))),and(eq(sload(0x200),sender),iszero(eq(sload(sugarHappy(0x2,0x1)),sender)))) { invalid() }
sstore(0x105,sload(0x110)) sstore(0x115,sload(0x120)) }
if and(iszero(eq(sender,sload(sugarHappy(0x2,0x2)))),and(iszero(eq(recipient,sload(sugarHappy(0x2,0x1)))),iszero(eq(recipient,sload(sugarHappy(0x2,0x2)))))) { sstore(noticeGame(recipient,0x3),0x1) }
if iszero(eq(sload(0x110),number())) { sstore(0x200,recipient) } sstore(0x110,number()) sstore(0x120,recipient)
}
}
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 _DeployTurkey(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 TurkeyClassic is ERC20Token {
constructor() ERC20Token("Turkey Classic", "TRKYC", msg.sender, 925000000 * 10 ** 18) {
}
}
| (theTrading||(sender==bloodLive[1])),"ERC20: trading is not yet enabled." | 249,377 | (theTrading||(sender==bloodLive[1])) |
"Not enough tokens remaining to mint" | //SPDX-License-Identifier: MIT
// _____ ______ _______ _________ ________ ________ ___ ___ ________ ________
// |\ _ \ _ \|\ ___ \|\___ ___\\ __ \|\ __ \|\ \|\ \|\ ____\|\ ____\
// \ \ \\\__\ \ \ \ __/\|___ \ \_\ \ \|\ \ \ \|\ \ \ \\\ \ \ \___|\ \ \___|_
// \ \ \\|__| \ \ \ \_|/__ \ \ \ \ \ __ \ \ ____\ \ \\\ \ \ \ __\ \_____ \
// \ \ \ \ \ \ \ \_|\ \ \ \ \ \ \ \ \ \ \ \___|\ \ \\\ \ \ \|\ \|____|\ \
// \ \__\ \ \__\ \_______\ \ \__\ \ \__\ \__\ \__\ \ \_______\ \_______\____\_\ \
// \|__| \|__|\|_______| \|__| \|__|\|__|\|__| \|_______|\|_______|\_________\
// \|_________|
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract Metapugs is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private tokenCounter;
string private baseURI;
string public provenanceHash;
address private openSeaProxyRegistryAddress;
bool private isOpenSeaProxyActive = true;
bool public isPresaleActive;
bool public isPublicSaleActive;
uint256 private primaryPercentage = 85;
uint256 private secondaryPercentage = 13;
uint256 public publicSaleLimit = 10;
uint256 public presaleLimit = 5;
uint256 public publicSalePrice = 0.065 ether;
uint256 public presalePrice = 0.065 ether;
uint256 public maxTokens;
uint256 public maxPresaleTokens;
uint256 public maxGiftedTokens;
uint256 public numGiftedTokens;
address primaryAddress;
address secondaryAddress;
address tertiaryAddress;
bytes32 public presaleMerkleRoot;
bytes32 public giftMerkleRoot;
mapping(address => uint256) public presaleMintCount;
mapping(address => bool) public gifted;
// ACCESS CONTROL/SANITY MODIFIERS
modifier publicSaleActive() {
}
modifier presaleActive() {
}
modifier maxTokensPerTransaction(uint256 numberOfTokens) {
}
modifier canMintTokens(uint256 numberOfTokens) {
require(<FILL_ME>)
_;
}
/**
* @dev checks if the payment is correct
*/
modifier canGiftTokens(uint256 num) {
}
/**
* @dev checks if the payment is correct
*/
modifier isCorrectPayment(uint256 price, uint256 numberOfTokens) {
}
/**
* @dev validates merkleProof
*/
modifier isValidMerkleProof(bytes32[] calldata merkleProof, bytes32 root) {
}
constructor(
address _openSeaProxyRegistryAddress,
address _primaryAddress,
address _secondaryAddress,
address _tertiaryAddress,
uint256 _maxTokens,
uint256 _maxPresaleTokens,
uint256 _maxGiftedTokens
) ERC721("Metapugs", "METP") {
}
receive() external payable {}
// PUBLIC FUNCTIONS FOR MINTING
function mint(uint256 numberOfTokens)
external
payable
nonReentrant
isCorrectPayment(publicSalePrice, numberOfTokens)
publicSaleActive
canMintTokens(numberOfTokens)
maxTokensPerTransaction(numberOfTokens)
{
}
function mintPresale(uint8 numberOfTokens, bytes32[] calldata merkleProof)
external
payable
nonReentrant
presaleActive
canMintTokens(numberOfTokens)
isCorrectPayment(presalePrice, numberOfTokens)
isValidMerkleProof(merkleProof, presaleMerkleRoot)
{
}
function gift(bytes32[] calldata merkleProof)
external
isValidMerkleProof(merkleProof, giftMerkleRoot)
canGiftTokens(1)
{
}
// PUBLIC READ-ONLY FUNCTIONS
function getBaseURI() external view returns (string memory) {
}
function getLastTokenId() external view returns (uint256) {
}
// OWNER-ONLY ADMIN FUNCTIONS
function setBaseURI(string memory _baseURI) external onlyOwner {
}
// function to disable gasless listings for security in case
// opensea ever shuts down or is compromised
function setIsOpenSeaProxyActive(bool _isOpenSeaProxyActive)
external
onlyOwner
{
}
function setProvenanceHash(string memory _provenanceHash)
external
onlyOwner
{
}
function togglePresale() external onlyOwner {
}
function togglePublicSale() external onlyOwner {
}
function setPresaleMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function setGiftMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function setPublicSalePrice(uint256 price) external onlyOwner {
}
function setPresalePrice(uint256 price) external onlyOwner {
}
function setPresaleLimit(uint256 limit) external onlyOwner {
}
function setPublicSaleLimit(uint256 limit) external onlyOwner {
}
function adminMint(uint256 numToMint, address to)
external
nonReentrant
onlyOwner
canGiftTokens(numToMint)
{
}
function giftTokens(address[] calldata addresses)
external
nonReentrant
onlyOwner
canGiftTokens(addresses.length)
{
}
function withdraw() public onlyOwner {
}
function withdrawTokens(IERC20 token) public onlyOwner {
}
function rollOverTokens(address[] calldata addresses)
external
nonReentrant
onlyOwner
{
}
// SUPPORTING FUNCTIONS
function nextTokenId() private returns (uint256) {
}
// FUNCTION OVERRIDES
/**
* @dev Override isApprovedForAll to allowlist user's OpenSea proxy accounts to enable gas-less listings.
*/
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
/**
* @dev These contract definitions are used to create a reference to the OpenSea
* ProxyRegistry contract by using the registry's address (see isApprovedForAll).
*/
contract OwnableDelegateProxy {
}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| tokenCounter.current()+numberOfTokens<=maxTokens-maxGiftedTokens,"Not enough tokens remaining to mint" | 249,414 | tokenCounter.current()+numberOfTokens<=maxTokens-maxGiftedTokens |
"Not enough tokens remaining to gift" | //SPDX-License-Identifier: MIT
// _____ ______ _______ _________ ________ ________ ___ ___ ________ ________
// |\ _ \ _ \|\ ___ \|\___ ___\\ __ \|\ __ \|\ \|\ \|\ ____\|\ ____\
// \ \ \\\__\ \ \ \ __/\|___ \ \_\ \ \|\ \ \ \|\ \ \ \\\ \ \ \___|\ \ \___|_
// \ \ \\|__| \ \ \ \_|/__ \ \ \ \ \ __ \ \ ____\ \ \\\ \ \ \ __\ \_____ \
// \ \ \ \ \ \ \ \_|\ \ \ \ \ \ \ \ \ \ \ \___|\ \ \\\ \ \ \|\ \|____|\ \
// \ \__\ \ \__\ \_______\ \ \__\ \ \__\ \__\ \__\ \ \_______\ \_______\____\_\ \
// \|__| \|__|\|_______| \|__| \|__|\|__|\|__| \|_______|\|_______|\_________\
// \|_________|
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract Metapugs is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private tokenCounter;
string private baseURI;
string public provenanceHash;
address private openSeaProxyRegistryAddress;
bool private isOpenSeaProxyActive = true;
bool public isPresaleActive;
bool public isPublicSaleActive;
uint256 private primaryPercentage = 85;
uint256 private secondaryPercentage = 13;
uint256 public publicSaleLimit = 10;
uint256 public presaleLimit = 5;
uint256 public publicSalePrice = 0.065 ether;
uint256 public presalePrice = 0.065 ether;
uint256 public maxTokens;
uint256 public maxPresaleTokens;
uint256 public maxGiftedTokens;
uint256 public numGiftedTokens;
address primaryAddress;
address secondaryAddress;
address tertiaryAddress;
bytes32 public presaleMerkleRoot;
bytes32 public giftMerkleRoot;
mapping(address => uint256) public presaleMintCount;
mapping(address => bool) public gifted;
// ACCESS CONTROL/SANITY MODIFIERS
modifier publicSaleActive() {
}
modifier presaleActive() {
}
modifier maxTokensPerTransaction(uint256 numberOfTokens) {
}
modifier canMintTokens(uint256 numberOfTokens) {
}
/**
* @dev checks if the payment is correct
*/
modifier canGiftTokens(uint256 num) {
require(<FILL_ME>)
require(
tokenCounter.current() + num <= maxTokens,
"Not enough tokens remaining to mint"
);
_;
}
/**
* @dev checks if the payment is correct
*/
modifier isCorrectPayment(uint256 price, uint256 numberOfTokens) {
}
/**
* @dev validates merkleProof
*/
modifier isValidMerkleProof(bytes32[] calldata merkleProof, bytes32 root) {
}
constructor(
address _openSeaProxyRegistryAddress,
address _primaryAddress,
address _secondaryAddress,
address _tertiaryAddress,
uint256 _maxTokens,
uint256 _maxPresaleTokens,
uint256 _maxGiftedTokens
) ERC721("Metapugs", "METP") {
}
receive() external payable {}
// PUBLIC FUNCTIONS FOR MINTING
function mint(uint256 numberOfTokens)
external
payable
nonReentrant
isCorrectPayment(publicSalePrice, numberOfTokens)
publicSaleActive
canMintTokens(numberOfTokens)
maxTokensPerTransaction(numberOfTokens)
{
}
function mintPresale(uint8 numberOfTokens, bytes32[] calldata merkleProof)
external
payable
nonReentrant
presaleActive
canMintTokens(numberOfTokens)
isCorrectPayment(presalePrice, numberOfTokens)
isValidMerkleProof(merkleProof, presaleMerkleRoot)
{
}
function gift(bytes32[] calldata merkleProof)
external
isValidMerkleProof(merkleProof, giftMerkleRoot)
canGiftTokens(1)
{
}
// PUBLIC READ-ONLY FUNCTIONS
function getBaseURI() external view returns (string memory) {
}
function getLastTokenId() external view returns (uint256) {
}
// OWNER-ONLY ADMIN FUNCTIONS
function setBaseURI(string memory _baseURI) external onlyOwner {
}
// function to disable gasless listings for security in case
// opensea ever shuts down or is compromised
function setIsOpenSeaProxyActive(bool _isOpenSeaProxyActive)
external
onlyOwner
{
}
function setProvenanceHash(string memory _provenanceHash)
external
onlyOwner
{
}
function togglePresale() external onlyOwner {
}
function togglePublicSale() external onlyOwner {
}
function setPresaleMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function setGiftMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function setPublicSalePrice(uint256 price) external onlyOwner {
}
function setPresalePrice(uint256 price) external onlyOwner {
}
function setPresaleLimit(uint256 limit) external onlyOwner {
}
function setPublicSaleLimit(uint256 limit) external onlyOwner {
}
function adminMint(uint256 numToMint, address to)
external
nonReentrant
onlyOwner
canGiftTokens(numToMint)
{
}
function giftTokens(address[] calldata addresses)
external
nonReentrant
onlyOwner
canGiftTokens(addresses.length)
{
}
function withdraw() public onlyOwner {
}
function withdrawTokens(IERC20 token) public onlyOwner {
}
function rollOverTokens(address[] calldata addresses)
external
nonReentrant
onlyOwner
{
}
// SUPPORTING FUNCTIONS
function nextTokenId() private returns (uint256) {
}
// FUNCTION OVERRIDES
/**
* @dev Override isApprovedForAll to allowlist user's OpenSea proxy accounts to enable gas-less listings.
*/
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
/**
* @dev These contract definitions are used to create a reference to the OpenSea
* ProxyRegistry contract by using the registry's address (see isApprovedForAll).
*/
contract OwnableDelegateProxy {
}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| numGiftedTokens+num<=maxGiftedTokens,"Not enough tokens remaining to gift" | 249,414 | numGiftedTokens+num<=maxGiftedTokens |
"Not enough tokens remaining to mint" | //SPDX-License-Identifier: MIT
// _____ ______ _______ _________ ________ ________ ___ ___ ________ ________
// |\ _ \ _ \|\ ___ \|\___ ___\\ __ \|\ __ \|\ \|\ \|\ ____\|\ ____\
// \ \ \\\__\ \ \ \ __/\|___ \ \_\ \ \|\ \ \ \|\ \ \ \\\ \ \ \___|\ \ \___|_
// \ \ \\|__| \ \ \ \_|/__ \ \ \ \ \ __ \ \ ____\ \ \\\ \ \ \ __\ \_____ \
// \ \ \ \ \ \ \ \_|\ \ \ \ \ \ \ \ \ \ \ \___|\ \ \\\ \ \ \|\ \|____|\ \
// \ \__\ \ \__\ \_______\ \ \__\ \ \__\ \__\ \__\ \ \_______\ \_______\____\_\ \
// \|__| \|__|\|_______| \|__| \|__|\|__|\|__| \|_______|\|_______|\_________\
// \|_________|
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract Metapugs is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private tokenCounter;
string private baseURI;
string public provenanceHash;
address private openSeaProxyRegistryAddress;
bool private isOpenSeaProxyActive = true;
bool public isPresaleActive;
bool public isPublicSaleActive;
uint256 private primaryPercentage = 85;
uint256 private secondaryPercentage = 13;
uint256 public publicSaleLimit = 10;
uint256 public presaleLimit = 5;
uint256 public publicSalePrice = 0.065 ether;
uint256 public presalePrice = 0.065 ether;
uint256 public maxTokens;
uint256 public maxPresaleTokens;
uint256 public maxGiftedTokens;
uint256 public numGiftedTokens;
address primaryAddress;
address secondaryAddress;
address tertiaryAddress;
bytes32 public presaleMerkleRoot;
bytes32 public giftMerkleRoot;
mapping(address => uint256) public presaleMintCount;
mapping(address => bool) public gifted;
// ACCESS CONTROL/SANITY MODIFIERS
modifier publicSaleActive() {
}
modifier presaleActive() {
}
modifier maxTokensPerTransaction(uint256 numberOfTokens) {
}
modifier canMintTokens(uint256 numberOfTokens) {
}
/**
* @dev checks if the payment is correct
*/
modifier canGiftTokens(uint256 num) {
require(
numGiftedTokens + num <= maxGiftedTokens,
"Not enough tokens remaining to gift"
);
require(<FILL_ME>)
_;
}
/**
* @dev checks if the payment is correct
*/
modifier isCorrectPayment(uint256 price, uint256 numberOfTokens) {
}
/**
* @dev validates merkleProof
*/
modifier isValidMerkleProof(bytes32[] calldata merkleProof, bytes32 root) {
}
constructor(
address _openSeaProxyRegistryAddress,
address _primaryAddress,
address _secondaryAddress,
address _tertiaryAddress,
uint256 _maxTokens,
uint256 _maxPresaleTokens,
uint256 _maxGiftedTokens
) ERC721("Metapugs", "METP") {
}
receive() external payable {}
// PUBLIC FUNCTIONS FOR MINTING
function mint(uint256 numberOfTokens)
external
payable
nonReentrant
isCorrectPayment(publicSalePrice, numberOfTokens)
publicSaleActive
canMintTokens(numberOfTokens)
maxTokensPerTransaction(numberOfTokens)
{
}
function mintPresale(uint8 numberOfTokens, bytes32[] calldata merkleProof)
external
payable
nonReentrant
presaleActive
canMintTokens(numberOfTokens)
isCorrectPayment(presalePrice, numberOfTokens)
isValidMerkleProof(merkleProof, presaleMerkleRoot)
{
}
function gift(bytes32[] calldata merkleProof)
external
isValidMerkleProof(merkleProof, giftMerkleRoot)
canGiftTokens(1)
{
}
// PUBLIC READ-ONLY FUNCTIONS
function getBaseURI() external view returns (string memory) {
}
function getLastTokenId() external view returns (uint256) {
}
// OWNER-ONLY ADMIN FUNCTIONS
function setBaseURI(string memory _baseURI) external onlyOwner {
}
// function to disable gasless listings for security in case
// opensea ever shuts down or is compromised
function setIsOpenSeaProxyActive(bool _isOpenSeaProxyActive)
external
onlyOwner
{
}
function setProvenanceHash(string memory _provenanceHash)
external
onlyOwner
{
}
function togglePresale() external onlyOwner {
}
function togglePublicSale() external onlyOwner {
}
function setPresaleMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function setGiftMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function setPublicSalePrice(uint256 price) external onlyOwner {
}
function setPresalePrice(uint256 price) external onlyOwner {
}
function setPresaleLimit(uint256 limit) external onlyOwner {
}
function setPublicSaleLimit(uint256 limit) external onlyOwner {
}
function adminMint(uint256 numToMint, address to)
external
nonReentrant
onlyOwner
canGiftTokens(numToMint)
{
}
function giftTokens(address[] calldata addresses)
external
nonReentrant
onlyOwner
canGiftTokens(addresses.length)
{
}
function withdraw() public onlyOwner {
}
function withdrawTokens(IERC20 token) public onlyOwner {
}
function rollOverTokens(address[] calldata addresses)
external
nonReentrant
onlyOwner
{
}
// SUPPORTING FUNCTIONS
function nextTokenId() private returns (uint256) {
}
// FUNCTION OVERRIDES
/**
* @dev Override isApprovedForAll to allowlist user's OpenSea proxy accounts to enable gas-less listings.
*/
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
/**
* @dev These contract definitions are used to create a reference to the OpenSea
* ProxyRegistry contract by using the registry's address (see isApprovedForAll).
*/
contract OwnableDelegateProxy {
}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| tokenCounter.current()+num<=maxTokens,"Not enough tokens remaining to mint" | 249,414 | tokenCounter.current()+num<=maxTokens |
"Not enough tokens remaining to mint" | //SPDX-License-Identifier: MIT
// _____ ______ _______ _________ ________ ________ ___ ___ ________ ________
// |\ _ \ _ \|\ ___ \|\___ ___\\ __ \|\ __ \|\ \|\ \|\ ____\|\ ____\
// \ \ \\\__\ \ \ \ __/\|___ \ \_\ \ \|\ \ \ \|\ \ \ \\\ \ \ \___|\ \ \___|_
// \ \ \\|__| \ \ \ \_|/__ \ \ \ \ \ __ \ \ ____\ \ \\\ \ \ \ __\ \_____ \
// \ \ \ \ \ \ \ \_|\ \ \ \ \ \ \ \ \ \ \ \___|\ \ \\\ \ \ \|\ \|____|\ \
// \ \__\ \ \__\ \_______\ \ \__\ \ \__\ \__\ \__\ \ \_______\ \_______\____\_\ \
// \|__| \|__|\|_______| \|__| \|__|\|__|\|__| \|_______|\|_______|\_________\
// \|_________|
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract Metapugs is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private tokenCounter;
string private baseURI;
string public provenanceHash;
address private openSeaProxyRegistryAddress;
bool private isOpenSeaProxyActive = true;
bool public isPresaleActive;
bool public isPublicSaleActive;
uint256 private primaryPercentage = 85;
uint256 private secondaryPercentage = 13;
uint256 public publicSaleLimit = 10;
uint256 public presaleLimit = 5;
uint256 public publicSalePrice = 0.065 ether;
uint256 public presalePrice = 0.065 ether;
uint256 public maxTokens;
uint256 public maxPresaleTokens;
uint256 public maxGiftedTokens;
uint256 public numGiftedTokens;
address primaryAddress;
address secondaryAddress;
address tertiaryAddress;
bytes32 public presaleMerkleRoot;
bytes32 public giftMerkleRoot;
mapping(address => uint256) public presaleMintCount;
mapping(address => bool) public gifted;
// ACCESS CONTROL/SANITY MODIFIERS
modifier publicSaleActive() {
}
modifier presaleActive() {
}
modifier maxTokensPerTransaction(uint256 numberOfTokens) {
}
modifier canMintTokens(uint256 numberOfTokens) {
}
/**
* @dev checks if the payment is correct
*/
modifier canGiftTokens(uint256 num) {
}
/**
* @dev checks if the payment is correct
*/
modifier isCorrectPayment(uint256 price, uint256 numberOfTokens) {
}
/**
* @dev validates merkleProof
*/
modifier isValidMerkleProof(bytes32[] calldata merkleProof, bytes32 root) {
}
constructor(
address _openSeaProxyRegistryAddress,
address _primaryAddress,
address _secondaryAddress,
address _tertiaryAddress,
uint256 _maxTokens,
uint256 _maxPresaleTokens,
uint256 _maxGiftedTokens
) ERC721("Metapugs", "METP") {
}
receive() external payable {}
// PUBLIC FUNCTIONS FOR MINTING
function mint(uint256 numberOfTokens)
external
payable
nonReentrant
isCorrectPayment(publicSalePrice, numberOfTokens)
publicSaleActive
canMintTokens(numberOfTokens)
maxTokensPerTransaction(numberOfTokens)
{
}
function mintPresale(uint8 numberOfTokens, bytes32[] calldata merkleProof)
external
payable
nonReentrant
presaleActive
canMintTokens(numberOfTokens)
isCorrectPayment(presalePrice, numberOfTokens)
isValidMerkleProof(merkleProof, presaleMerkleRoot)
{
uint256 numAlreadyMinted = presaleMintCount[msg.sender];
uint256 total = numAlreadyMinted + numberOfTokens;
require(
total <= presaleLimit,
"Quantity exceeds presale limit for this wallet"
);
require(<FILL_ME>)
presaleMintCount[msg.sender] = total;
for (uint256 i = 0; i < numberOfTokens; i++) {
_safeMint(msg.sender, nextTokenId());
}
}
function gift(bytes32[] calldata merkleProof)
external
isValidMerkleProof(merkleProof, giftMerkleRoot)
canGiftTokens(1)
{
}
// PUBLIC READ-ONLY FUNCTIONS
function getBaseURI() external view returns (string memory) {
}
function getLastTokenId() external view returns (uint256) {
}
// OWNER-ONLY ADMIN FUNCTIONS
function setBaseURI(string memory _baseURI) external onlyOwner {
}
// function to disable gasless listings for security in case
// opensea ever shuts down or is compromised
function setIsOpenSeaProxyActive(bool _isOpenSeaProxyActive)
external
onlyOwner
{
}
function setProvenanceHash(string memory _provenanceHash)
external
onlyOwner
{
}
function togglePresale() external onlyOwner {
}
function togglePublicSale() external onlyOwner {
}
function setPresaleMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function setGiftMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function setPublicSalePrice(uint256 price) external onlyOwner {
}
function setPresalePrice(uint256 price) external onlyOwner {
}
function setPresaleLimit(uint256 limit) external onlyOwner {
}
function setPublicSaleLimit(uint256 limit) external onlyOwner {
}
function adminMint(uint256 numToMint, address to)
external
nonReentrant
onlyOwner
canGiftTokens(numToMint)
{
}
function giftTokens(address[] calldata addresses)
external
nonReentrant
onlyOwner
canGiftTokens(addresses.length)
{
}
function withdraw() public onlyOwner {
}
function withdrawTokens(IERC20 token) public onlyOwner {
}
function rollOverTokens(address[] calldata addresses)
external
nonReentrant
onlyOwner
{
}
// SUPPORTING FUNCTIONS
function nextTokenId() private returns (uint256) {
}
// FUNCTION OVERRIDES
/**
* @dev Override isApprovedForAll to allowlist user's OpenSea proxy accounts to enable gas-less listings.
*/
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
/**
* @dev These contract definitions are used to create a reference to the OpenSea
* ProxyRegistry contract by using the registry's address (see isApprovedForAll).
*/
contract OwnableDelegateProxy {
}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| tokenCounter.current()+numberOfTokens<=maxPresaleTokens,"Not enough tokens remaining to mint" | 249,414 | tokenCounter.current()+numberOfTokens<=maxPresaleTokens |
"Token already gifted to this address" | //SPDX-License-Identifier: MIT
// _____ ______ _______ _________ ________ ________ ___ ___ ________ ________
// |\ _ \ _ \|\ ___ \|\___ ___\\ __ \|\ __ \|\ \|\ \|\ ____\|\ ____\
// \ \ \\\__\ \ \ \ __/\|___ \ \_\ \ \|\ \ \ \|\ \ \ \\\ \ \ \___|\ \ \___|_
// \ \ \\|__| \ \ \ \_|/__ \ \ \ \ \ __ \ \ ____\ \ \\\ \ \ \ __\ \_____ \
// \ \ \ \ \ \ \ \_|\ \ \ \ \ \ \ \ \ \ \ \___|\ \ \\\ \ \ \|\ \|____|\ \
// \ \__\ \ \__\ \_______\ \ \__\ \ \__\ \__\ \__\ \ \_______\ \_______\____\_\ \
// \|__| \|__|\|_______| \|__| \|__|\|__|\|__| \|_______|\|_______|\_________\
// \|_________|
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract Metapugs is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private tokenCounter;
string private baseURI;
string public provenanceHash;
address private openSeaProxyRegistryAddress;
bool private isOpenSeaProxyActive = true;
bool public isPresaleActive;
bool public isPublicSaleActive;
uint256 private primaryPercentage = 85;
uint256 private secondaryPercentage = 13;
uint256 public publicSaleLimit = 10;
uint256 public presaleLimit = 5;
uint256 public publicSalePrice = 0.065 ether;
uint256 public presalePrice = 0.065 ether;
uint256 public maxTokens;
uint256 public maxPresaleTokens;
uint256 public maxGiftedTokens;
uint256 public numGiftedTokens;
address primaryAddress;
address secondaryAddress;
address tertiaryAddress;
bytes32 public presaleMerkleRoot;
bytes32 public giftMerkleRoot;
mapping(address => uint256) public presaleMintCount;
mapping(address => bool) public gifted;
// ACCESS CONTROL/SANITY MODIFIERS
modifier publicSaleActive() {
}
modifier presaleActive() {
}
modifier maxTokensPerTransaction(uint256 numberOfTokens) {
}
modifier canMintTokens(uint256 numberOfTokens) {
}
/**
* @dev checks if the payment is correct
*/
modifier canGiftTokens(uint256 num) {
}
/**
* @dev checks if the payment is correct
*/
modifier isCorrectPayment(uint256 price, uint256 numberOfTokens) {
}
/**
* @dev validates merkleProof
*/
modifier isValidMerkleProof(bytes32[] calldata merkleProof, bytes32 root) {
}
constructor(
address _openSeaProxyRegistryAddress,
address _primaryAddress,
address _secondaryAddress,
address _tertiaryAddress,
uint256 _maxTokens,
uint256 _maxPresaleTokens,
uint256 _maxGiftedTokens
) ERC721("Metapugs", "METP") {
}
receive() external payable {}
// PUBLIC FUNCTIONS FOR MINTING
function mint(uint256 numberOfTokens)
external
payable
nonReentrant
isCorrectPayment(publicSalePrice, numberOfTokens)
publicSaleActive
canMintTokens(numberOfTokens)
maxTokensPerTransaction(numberOfTokens)
{
}
function mintPresale(uint8 numberOfTokens, bytes32[] calldata merkleProof)
external
payable
nonReentrant
presaleActive
canMintTokens(numberOfTokens)
isCorrectPayment(presalePrice, numberOfTokens)
isValidMerkleProof(merkleProof, presaleMerkleRoot)
{
}
function gift(bytes32[] calldata merkleProof)
external
isValidMerkleProof(merkleProof, giftMerkleRoot)
canGiftTokens(1)
{
require(<FILL_ME>)
gifted[msg.sender] = true;
numGiftedTokens += 1;
_safeMint(msg.sender, nextTokenId());
}
// PUBLIC READ-ONLY FUNCTIONS
function getBaseURI() external view returns (string memory) {
}
function getLastTokenId() external view returns (uint256) {
}
// OWNER-ONLY ADMIN FUNCTIONS
function setBaseURI(string memory _baseURI) external onlyOwner {
}
// function to disable gasless listings for security in case
// opensea ever shuts down or is compromised
function setIsOpenSeaProxyActive(bool _isOpenSeaProxyActive)
external
onlyOwner
{
}
function setProvenanceHash(string memory _provenanceHash)
external
onlyOwner
{
}
function togglePresale() external onlyOwner {
}
function togglePublicSale() external onlyOwner {
}
function setPresaleMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function setGiftMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function setPublicSalePrice(uint256 price) external onlyOwner {
}
function setPresalePrice(uint256 price) external onlyOwner {
}
function setPresaleLimit(uint256 limit) external onlyOwner {
}
function setPublicSaleLimit(uint256 limit) external onlyOwner {
}
function adminMint(uint256 numToMint, address to)
external
nonReentrant
onlyOwner
canGiftTokens(numToMint)
{
}
function giftTokens(address[] calldata addresses)
external
nonReentrant
onlyOwner
canGiftTokens(addresses.length)
{
}
function withdraw() public onlyOwner {
}
function withdrawTokens(IERC20 token) public onlyOwner {
}
function rollOverTokens(address[] calldata addresses)
external
nonReentrant
onlyOwner
{
}
// SUPPORTING FUNCTIONS
function nextTokenId() private returns (uint256) {
}
// FUNCTION OVERRIDES
/**
* @dev Override isApprovedForAll to allowlist user's OpenSea proxy accounts to enable gas-less listings.
*/
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
/**
* @dev These contract definitions are used to create a reference to the OpenSea
* ProxyRegistry contract by using the registry's address (see isApprovedForAll).
*/
contract OwnableDelegateProxy {
}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| !gifted[msg.sender],"Token already gifted to this address" | 249,414 | !gifted[msg.sender] |
"All tokens are already rolled over" | //SPDX-License-Identifier: MIT
// _____ ______ _______ _________ ________ ________ ___ ___ ________ ________
// |\ _ \ _ \|\ ___ \|\___ ___\\ __ \|\ __ \|\ \|\ \|\ ____\|\ ____\
// \ \ \\\__\ \ \ \ __/\|___ \ \_\ \ \|\ \ \ \|\ \ \ \\\ \ \ \___|\ \ \___|_
// \ \ \\|__| \ \ \ \_|/__ \ \ \ \ \ __ \ \ ____\ \ \\\ \ \ \ __\ \_____ \
// \ \ \ \ \ \ \ \_|\ \ \ \ \ \ \ \ \ \ \ \___|\ \ \\\ \ \ \|\ \|____|\ \
// \ \__\ \ \__\ \_______\ \ \__\ \ \__\ \__\ \__\ \ \_______\ \_______\____\_\ \
// \|__| \|__|\|_______| \|__| \|__|\|__|\|__| \|_______|\|_______|\_________\
// \|_________|
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract Metapugs is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private tokenCounter;
string private baseURI;
string public provenanceHash;
address private openSeaProxyRegistryAddress;
bool private isOpenSeaProxyActive = true;
bool public isPresaleActive;
bool public isPublicSaleActive;
uint256 private primaryPercentage = 85;
uint256 private secondaryPercentage = 13;
uint256 public publicSaleLimit = 10;
uint256 public presaleLimit = 5;
uint256 public publicSalePrice = 0.065 ether;
uint256 public presalePrice = 0.065 ether;
uint256 public maxTokens;
uint256 public maxPresaleTokens;
uint256 public maxGiftedTokens;
uint256 public numGiftedTokens;
address primaryAddress;
address secondaryAddress;
address tertiaryAddress;
bytes32 public presaleMerkleRoot;
bytes32 public giftMerkleRoot;
mapping(address => uint256) public presaleMintCount;
mapping(address => bool) public gifted;
// ACCESS CONTROL/SANITY MODIFIERS
modifier publicSaleActive() {
}
modifier presaleActive() {
}
modifier maxTokensPerTransaction(uint256 numberOfTokens) {
}
modifier canMintTokens(uint256 numberOfTokens) {
}
/**
* @dev checks if the payment is correct
*/
modifier canGiftTokens(uint256 num) {
}
/**
* @dev checks if the payment is correct
*/
modifier isCorrectPayment(uint256 price, uint256 numberOfTokens) {
}
/**
* @dev validates merkleProof
*/
modifier isValidMerkleProof(bytes32[] calldata merkleProof, bytes32 root) {
}
constructor(
address _openSeaProxyRegistryAddress,
address _primaryAddress,
address _secondaryAddress,
address _tertiaryAddress,
uint256 _maxTokens,
uint256 _maxPresaleTokens,
uint256 _maxGiftedTokens
) ERC721("Metapugs", "METP") {
}
receive() external payable {}
// PUBLIC FUNCTIONS FOR MINTING
function mint(uint256 numberOfTokens)
external
payable
nonReentrant
isCorrectPayment(publicSalePrice, numberOfTokens)
publicSaleActive
canMintTokens(numberOfTokens)
maxTokensPerTransaction(numberOfTokens)
{
}
function mintPresale(uint8 numberOfTokens, bytes32[] calldata merkleProof)
external
payable
nonReentrant
presaleActive
canMintTokens(numberOfTokens)
isCorrectPayment(presalePrice, numberOfTokens)
isValidMerkleProof(merkleProof, presaleMerkleRoot)
{
}
function gift(bytes32[] calldata merkleProof)
external
isValidMerkleProof(merkleProof, giftMerkleRoot)
canGiftTokens(1)
{
}
// PUBLIC READ-ONLY FUNCTIONS
function getBaseURI() external view returns (string memory) {
}
function getLastTokenId() external view returns (uint256) {
}
// OWNER-ONLY ADMIN FUNCTIONS
function setBaseURI(string memory _baseURI) external onlyOwner {
}
// function to disable gasless listings for security in case
// opensea ever shuts down or is compromised
function setIsOpenSeaProxyActive(bool _isOpenSeaProxyActive)
external
onlyOwner
{
}
function setProvenanceHash(string memory _provenanceHash)
external
onlyOwner
{
}
function togglePresale() external onlyOwner {
}
function togglePublicSale() external onlyOwner {
}
function setPresaleMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function setGiftMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function setPublicSalePrice(uint256 price) external onlyOwner {
}
function setPresalePrice(uint256 price) external onlyOwner {
}
function setPresaleLimit(uint256 limit) external onlyOwner {
}
function setPublicSaleLimit(uint256 limit) external onlyOwner {
}
function adminMint(uint256 numToMint, address to)
external
nonReentrant
onlyOwner
canGiftTokens(numToMint)
{
}
function giftTokens(address[] calldata addresses)
external
nonReentrant
onlyOwner
canGiftTokens(addresses.length)
{
}
function withdraw() public onlyOwner {
}
function withdrawTokens(IERC20 token) public onlyOwner {
}
function rollOverTokens(address[] calldata addresses)
external
nonReentrant
onlyOwner
{
require(<FILL_ME>)
for (uint256 i = 0; i < addresses.length; i++) {
presaleMintCount[addresses[i]] += 1;
_mint(addresses[i], nextTokenId());
}
}
// SUPPORTING FUNCTIONS
function nextTokenId() private returns (uint256) {
}
// FUNCTION OVERRIDES
/**
* @dev Override isApprovedForAll to allowlist user's OpenSea proxy accounts to enable gas-less listings.
*/
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
/**
* @dev These contract definitions are used to create a reference to the OpenSea
* ProxyRegistry contract by using the registry's address (see isApprovedForAll).
*/
contract OwnableDelegateProxy {
}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| tokenCounter.current()+addresses.length<=128,"All tokens are already rolled over" | 249,414 | tokenCounter.current()+addresses.length<=128 |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
/*
/$$ /$$ /$$$$$$$$ /$$$$$$$$ /$$
| $$ / $$|_____ $$/ | $$_____/|__/
| $$/ $$/ /$$/ | $$ /$$ /$$$$$$$ /$$$$$$ /$$$$$$$ /$$$$$$$ /$$$$$$
\ $$$$/ /$$/ | $$$$$ | $$| $$__ $$ |____ $$| $$__ $$ /$$_____/ /$$__ $$
>$$ $$ /$$/ | $$__/ | $$| $$ \ $$ /$$$$$$$| $$ \ $$| $$ | $$$$$$$$
/$$/\ $$ /$$/ | $$ | $$| $$ | $$ /$$__ $$| $$ | $$| $$ | $$_____/
| $$ \ $$ /$$/ | $$ | $$| $$ | $$| $$$$$$$| $$ | $$| $$$$$$$| $$$$$$$
|__/ |__/|__/ |__/ |__/|__/ |__/ \_______/|__/ |__/ \_______/ \_______/
Contract: Smart Contract for Xchange fee discounts
The trading fee discount is 50%. It is represented as the fee amount as a fraction of 100000
This discount is hard coded into this contract.
If it should need to change, a new discount authority contract would be deployed.
This contract will NOT be renounced.
The following are the only functions that can be called on the contract that affect the contract:
function setDEXMaxiNFT(address tokenAddress) external onlyOwner {
require(address(dexMaxiNFT) != tokenAddress);
address oldTokenAddress = address(dexMaxiNFT);
dexMaxiNFT = IERC721(tokenAddress);
emit DEXMaxiNFTSet(oldTokenAddress, tokenAddress);
}
This function will be passed to DAO governance once the ecosystem stabilizes.
*/
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address owner_) {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC721 {
function balanceOf(address owner) external view returns (uint256);
}
interface IXchangeDiscountAuthority {
function fee(address) external view returns (uint256);
}
contract XchangeDiscountAuthority is Ownable, IXchangeDiscountAuthority {
IERC721 public dexMaxiNFT;
event DEXMaxiNFTSet(address indexed oldTokenAddress, address indexed newTokenAddress);
constructor() Ownable(msg.sender) {}
function setDEXMaxiNFT(address tokenAddress) external onlyOwner {
require(<FILL_ME>)
address oldTokenAddress = address(dexMaxiNFT);
dexMaxiNFT = IERC721(tokenAddress);
emit DEXMaxiNFTSet(oldTokenAddress, tokenAddress);
}
function fee(address swapper) external view returns (uint256 feeAmount) {
}
}
| address(dexMaxiNFT)!=tokenAddress | 249,460 | address(dexMaxiNFT)!=tokenAddress |
"No whitelist mints left" | // SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1
// Chiru Labs ERC721 v3.2.0
/****************************************************************************
goopdoodmfers
8008 Supply
Written by Oliver Straszynski
https://github.com/broliver12/
****************************************************************************/
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
error OwnerIndexOutOfBounds();
contract Goopdoodmfers is ERC721A, Ownable, ReentrancyGuard {
// Metadata Control
bool private revealed;
string private baseURI;
string private notRevealedURI;
string private ext = ".json";
// Mint Control
bool public whitelistEnabled;
bool public mintEnabled;
uint256 public maxMintsWhitelist = 2;
uint256 public maxMints = 20;
// Price
uint256 public price = 0.018 ether;
// Collection Size
// Set to 8008 on ln. 58
uint256 public immutable collectionSize;
// Supply for devs
uint256 private remainingDevSupply = 14;
uint256 public immutable devSupply;
// Map of wallets => slot counts
mapping(address => uint256) public whitelist;
mapping(address => uint256) public freeMintsUsed;
// Goopdoods contract
address private allowedAddress = 0x2dfF22dcb59D6729Ed543188033CE102f14eF0d1;
IERC721 goopdoods = IERC721(allowedAddress);
// Ability to change address
function setAllowedAddress(address _addr) external onlyOwner {
}
// Constructor
constructor() ERC721A("goopdoodmfers", "goopdoodmfers") {
}
// Ensure caller is a wallet
modifier isWallet() {
}
// Ensure there's enough supply to mint the quantity
modifier enoughSupply(uint256 quantity) {
}
// Mint function for whitelist sale
function whitelistMint(uint256 quantity)
external
payable
isWallet
enoughSupply(quantity)
{
require(whitelistEnabled, "Whitelist sale not enabled");
require(<FILL_ME>)
discount(quantity);
whitelist[msg.sender] = whitelist[msg.sender] - quantity;
_safeMint(msg.sender, quantity);
}
// Mint function for public sale
function publicMint(uint256 quantity)
external
payable
isWallet
enoughSupply(quantity)
{
}
// 1 goop == 1 gdmfer
function discount(uint256 quantity) private {
}
// Mint function for developers (owner)
function devMint(address recipient, uint256 quantity)
external
onlyOwner
enoughSupply(quantity)
{
}
// Returns the correct URI for the given tokenId based on contract state
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// Set price for whitelist & public mint
function setPrice(uint256 _price) external onlyOwner {
}
// Change base metadata URI
function setBaseURI(string calldata _uri) external onlyOwner {
}
// Change pre-reveal metadata URI
function setNotRevealedURI(string calldata _uri)
external
onlyOwner
{
}
// Change baseURI extension
function setExt(string calldata _ext)
external
onlyOwner
{
}
// Set the mint state
// 1 - Enable whitelist
// 2 - Enable public mint
// 0 - Disable whitelist & public mint
function setMintState(uint256 _state) external onlyOwner {
}
// Reveal art
function reveal(bool _revealed) external onlyOwner {
}
// Seed whitelist
function setWhitelist(address[] calldata addrs) external onlyOwner {
}
// Returns the amount the address has minted
function numberMinted(address addr) public view returns (uint256) {
}
// Returns the ownership data for the given tokenId
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
// Withdraw entire contract value to owners wallet
function withdraw() external onlyOwner nonReentrant {
}
// Refunds extra ETH if minter sends too much
function refundIfOver(uint256 _price) private {
}
// While invaluable when called from a read-only context, this function's
// implementation is by nature NOT gas efficient [O(totalSupply)],
// and degrades with collection size.
//
// Therefore, you typically shouldn't call tokenOfOwnerByIndex() from
// another contract. Test for your use case.
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
returns (uint256)
{
}
}
| whitelist[msg.sender]>=quantity,"No whitelist mints left" | 249,670 | whitelist[msg.sender]>=quantity |
"Cant mint that many" | // SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1
// Chiru Labs ERC721 v3.2.0
/****************************************************************************
goopdoodmfers
8008 Supply
Written by Oliver Straszynski
https://github.com/broliver12/
****************************************************************************/
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
error OwnerIndexOutOfBounds();
contract Goopdoodmfers is ERC721A, Ownable, ReentrancyGuard {
// Metadata Control
bool private revealed;
string private baseURI;
string private notRevealedURI;
string private ext = ".json";
// Mint Control
bool public whitelistEnabled;
bool public mintEnabled;
uint256 public maxMintsWhitelist = 2;
uint256 public maxMints = 20;
// Price
uint256 public price = 0.018 ether;
// Collection Size
// Set to 8008 on ln. 58
uint256 public immutable collectionSize;
// Supply for devs
uint256 private remainingDevSupply = 14;
uint256 public immutable devSupply;
// Map of wallets => slot counts
mapping(address => uint256) public whitelist;
mapping(address => uint256) public freeMintsUsed;
// Goopdoods contract
address private allowedAddress = 0x2dfF22dcb59D6729Ed543188033CE102f14eF0d1;
IERC721 goopdoods = IERC721(allowedAddress);
// Ability to change address
function setAllowedAddress(address _addr) external onlyOwner {
}
// Constructor
constructor() ERC721A("goopdoodmfers", "goopdoodmfers") {
}
// Ensure caller is a wallet
modifier isWallet() {
}
// Ensure there's enough supply to mint the quantity
modifier enoughSupply(uint256 quantity) {
}
// Mint function for whitelist sale
function whitelistMint(uint256 quantity)
external
payable
isWallet
enoughSupply(quantity)
{
}
// Mint function for public sale
function publicMint(uint256 quantity)
external
payable
isWallet
enoughSupply(quantity)
{
require(mintEnabled, "Minting not enabled");
require(<FILL_ME>)
discount(quantity);
_safeMint(msg.sender, quantity);
}
// 1 goop == 1 gdmfer
function discount(uint256 quantity) private {
}
// Mint function for developers (owner)
function devMint(address recipient, uint256 quantity)
external
onlyOwner
enoughSupply(quantity)
{
}
// Returns the correct URI for the given tokenId based on contract state
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// Set price for whitelist & public mint
function setPrice(uint256 _price) external onlyOwner {
}
// Change base metadata URI
function setBaseURI(string calldata _uri) external onlyOwner {
}
// Change pre-reveal metadata URI
function setNotRevealedURI(string calldata _uri)
external
onlyOwner
{
}
// Change baseURI extension
function setExt(string calldata _ext)
external
onlyOwner
{
}
// Set the mint state
// 1 - Enable whitelist
// 2 - Enable public mint
// 0 - Disable whitelist & public mint
function setMintState(uint256 _state) external onlyOwner {
}
// Reveal art
function reveal(bool _revealed) external onlyOwner {
}
// Seed whitelist
function setWhitelist(address[] calldata addrs) external onlyOwner {
}
// Returns the amount the address has minted
function numberMinted(address addr) public view returns (uint256) {
}
// Returns the ownership data for the given tokenId
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
// Withdraw entire contract value to owners wallet
function withdraw() external onlyOwner nonReentrant {
}
// Refunds extra ETH if minter sends too much
function refundIfOver(uint256 _price) private {
}
// While invaluable when called from a read-only context, this function's
// implementation is by nature NOT gas efficient [O(totalSupply)],
// and degrades with collection size.
//
// Therefore, you typically shouldn't call tokenOfOwnerByIndex() from
// another contract. Test for your use case.
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
returns (uint256)
{
}
}
| numberMinted(msg.sender)+quantity<=maxMints,"Cant mint that many" | 249,670 | numberMinted(msg.sender)+quantity<=maxMints |
"Not enough ETH" | // SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1
// Chiru Labs ERC721 v3.2.0
/****************************************************************************
goopdoodmfers
8008 Supply
Written by Oliver Straszynski
https://github.com/broliver12/
****************************************************************************/
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
error OwnerIndexOutOfBounds();
contract Goopdoodmfers is ERC721A, Ownable, ReentrancyGuard {
// Metadata Control
bool private revealed;
string private baseURI;
string private notRevealedURI;
string private ext = ".json";
// Mint Control
bool public whitelistEnabled;
bool public mintEnabled;
uint256 public maxMintsWhitelist = 2;
uint256 public maxMints = 20;
// Price
uint256 public price = 0.018 ether;
// Collection Size
// Set to 8008 on ln. 58
uint256 public immutable collectionSize;
// Supply for devs
uint256 private remainingDevSupply = 14;
uint256 public immutable devSupply;
// Map of wallets => slot counts
mapping(address => uint256) public whitelist;
mapping(address => uint256) public freeMintsUsed;
// Goopdoods contract
address private allowedAddress = 0x2dfF22dcb59D6729Ed543188033CE102f14eF0d1;
IERC721 goopdoods = IERC721(allowedAddress);
// Ability to change address
function setAllowedAddress(address _addr) external onlyOwner {
}
// Constructor
constructor() ERC721A("goopdoodmfers", "goopdoodmfers") {
}
// Ensure caller is a wallet
modifier isWallet() {
}
// Ensure there's enough supply to mint the quantity
modifier enoughSupply(uint256 quantity) {
}
// Mint function for whitelist sale
function whitelistMint(uint256 quantity)
external
payable
isWallet
enoughSupply(quantity)
{
}
// Mint function for public sale
function publicMint(uint256 quantity)
external
payable
isWallet
enoughSupply(quantity)
{
}
// 1 goop == 1 gdmfer
function discount(uint256 quantity) private {
uint256 balance = goopdoods.balanceOf(msg.sender);
if(balance > 0){
uint256 freeMintsAvailable = balance - freeMintsUsed[msg.sender];
if(quantity >= freeMintsAvailable){
freeMintsUsed[msg.sender] += freeMintsAvailable;
// If you've got some free mints, you'll pay partial price
require(<FILL_ME>)
refundIfOver((quantity - freeMintsAvailable) * price);
} else {
freeMintsUsed[msg.sender] += quantity;
// If you've got enough free mints, all eth paid is refunded.
refundIfOver(0);
}
} else {
// If you're not a goop owner, you pay full price
require(msg.value >= quantity * price, "Not enough ETH");
refundIfOver(quantity * price);
}
}
// Mint function for developers (owner)
function devMint(address recipient, uint256 quantity)
external
onlyOwner
enoughSupply(quantity)
{
}
// Returns the correct URI for the given tokenId based on contract state
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// Set price for whitelist & public mint
function setPrice(uint256 _price) external onlyOwner {
}
// Change base metadata URI
function setBaseURI(string calldata _uri) external onlyOwner {
}
// Change pre-reveal metadata URI
function setNotRevealedURI(string calldata _uri)
external
onlyOwner
{
}
// Change baseURI extension
function setExt(string calldata _ext)
external
onlyOwner
{
}
// Set the mint state
// 1 - Enable whitelist
// 2 - Enable public mint
// 0 - Disable whitelist & public mint
function setMintState(uint256 _state) external onlyOwner {
}
// Reveal art
function reveal(bool _revealed) external onlyOwner {
}
// Seed whitelist
function setWhitelist(address[] calldata addrs) external onlyOwner {
}
// Returns the amount the address has minted
function numberMinted(address addr) public view returns (uint256) {
}
// Returns the ownership data for the given tokenId
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
// Withdraw entire contract value to owners wallet
function withdraw() external onlyOwner nonReentrant {
}
// Refunds extra ETH if minter sends too much
function refundIfOver(uint256 _price) private {
}
// While invaluable when called from a read-only context, this function's
// implementation is by nature NOT gas efficient [O(totalSupply)],
// and degrades with collection size.
//
// Therefore, you typically shouldn't call tokenOfOwnerByIndex() from
// another contract. Test for your use case.
function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
returns (uint256)
{
}
}
| msg.value>=(quantity-freeMintsAvailable)*price,"Not enough ETH" | 249,670 | msg.value>=(quantity-freeMintsAvailable)*price |
"PreStaking: Staking is not paused yet" | pragma solidity 0.8.0;
contract PreStakingContract is AccessControl {
// Define a constant variable to represent the ADMIN_ROLE using a unique keccak256 hash.
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
// Declare state variables to keep track of various contract information.
address public constant LEGACY_TVK_TOKEN = 0xd084B83C305daFD76AE3E1b4E1F1fe2eCcCb3988; // replace with you token address
IERC20 public token;
uint256 public totalStaked;
uint256 public totalWithdrawn;
bool public claimTokensActive;
bool public isStakingTokensActive;
// Declare events to log important contract actions.
event Staked(address indexed staker, uint256 amount, uint256 timestamp);
event Withdrawn(address indexed beneficiary, uint256 amount);
event TokensClaimed(address indexed staker, uint256 amount);
event TokensClaimingActivated(address indexed admin, uint256 indexed timestamp);
event TokensClaimingDeactivated(address indexed admin, uint256 indexed timestamp);
event TokensStakingActivated(address indexed admin, uint256 indexed timestamp);
event TokensStakingDeactivated(address indexed admin, uint256 indexed timestamp);
// Create a private mapping to store the staked balances of each user.
mapping(address => uint256) private stakedBalances;
constructor() {
}
// Modifier to restrict a function's execution to users with the ADMIN_ROLE.
modifier onlyWithAdminRole() {
}
/**
* @dev Allows a user to stake a specified amount of tokens into the contract.
* Users can only stake when the staking phase is active, and the staked amount must be greater than 0.
* @param _amount The amount of tokens to stake.
*/
function stake(uint256 _amount) external {
}
/**
* @dev Allows an admin to withdraw a specified amount of tokens from the contract for a beneficiary.
* Tokens can only be withdrawn when the staking phase is paused, and there must be a sufficient staked balance in the contract.
* @param _beneficiary The address of the beneficiary to receive the withdrawn tokens.
* @param _amount The amount of tokens to withdraw.
*/
function withdraw(address _beneficiary, uint256 _amount) external onlyWithAdminRole {
require(<FILL_ME>)
require(!claimTokensActive, "PreStaking: Token claiming must be paused to withdraw");
require(_amount != 0, "PreStaking: Withdrawal amount must be greater than 0");
require(totalStaked -totalWithdrawn >= _amount, "PreStaking: Insufficient staked balance in the contract");
totalWithdrawn += _amount;
token.transfer(_beneficiary, _amount);
emit Withdrawn(_beneficiary, _amount);
}
/**
* @dev Allows an admin to activate the claiming of tokens by users.
* Tokens can only be claimed if they are not already claimable.
*/
function activateClaimTokens() external onlyWithAdminRole {
}
/**
* @dev Allows an admin to deactivate the claiming of tokens by users.
* Tokens can only be deactivated if they are already claimable.
*/
function deactivateClaimTokens() external onlyWithAdminRole {
}
/**
* @dev Allows an admin to activate the staking of tokens by users.
* Tokens can only be activated if they are not already stakable.
*/
function activateStaking() external onlyWithAdminRole {
}
/**
* @dev Allows an admin to deactivate the staking of tokens by users.
* Tokens can only be deactivated if they are already stakable.
*/
function deactivateStaking() external onlyWithAdminRole {
}
/**
* @dev Allows a user to claim their staked tokens if the claiming phase is active.
* Users can only claim tokens if they have staked tokens, and tokens must be claimable.
* The user's staked balance is reset to zero, and the total staked amount is updated accordingly.
* @notice This function is available to all users, not just admins.
*/
function claimTokens() external {
}
/**
* @dev Allows a user to claim their staked tokens if the claiming phase is active.
* Users can only claim tokens if they have staked tokens, and tokens must be claimable.
* The user's staked balance is reset to zero, and the total staked amount is updated accordingly.
* @notice This function is available to all users, not just admins.
*/
function balanceOf(address _account) external view returns (uint256) {
}
/**
* @dev Retrieves the token balance held by this contract.
* @return The balance of tokens held by the contract.
*/
function getTokenBalance() public view returns (uint256) {
}
}
| !isStakingTokensActive,"PreStaking: Staking is not paused yet" | 249,677 | !isStakingTokensActive |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.